Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

Merge branch 'master' into umami-import

Edward Cuic070bfa32869
diff --cc docker-compose.yml
index 056a09075,39106f547..438bf49d8
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@@ -64,9 -56,17 +56,19 @@@ services
retries: 5
start_period: 10s
restart: unless-stopped
+ ports:
+ - "5432:5432"
+ redis:
+ image: redis:7-alpine
+ container_name: redis
+ ports:
+ - "127.0.0.1:6379:6379" # Only accessible locally
+ volumes:
+ - redis-data:/data
+ restart: unless-stopped
+ command: ["redis-server", "--appendonly", "yes"]
+
backend:
image: ghcr.io/rybbit-io/rybbit-backend:${IMAGE_TAG:-latest}
container_name: backend
diff --cc server/package-lock.json
index 3fe6b9b9a,24a7392b1..9026a9cb0
--- a/server/package-lock.json
+++ b/server/package-lock.json
@@@ -5957,42 -6068,60 +6184,96 @@@
],
"license": "MIT"
},
+ "node_modules/lodash.escaperegexp": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/lodash.escaperegexp/-/lodash.escaperegexp-4.1.2.tgz",
+ "integrity": "sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.groupby": {
+ "version": "4.6.0",
+ "resolved": "https://registry.npmjs.org/lodash.groupby/-/lodash.groupby-4.6.0.tgz",
+ "integrity": "sha512-5dcWxm23+VAoz+awKmBaiBvzox8+RqMgFhi7UvX9DHZr2HdxHXM/Wrf8cfKpsW37RNrvtPn6hSwNqurSILbmJw==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isfunction": {
+ "version": "3.0.9",
+ "resolved": "https://registry.npmjs.org/lodash.isfunction/-/lodash.isfunction-3.0.9.tgz",
+ "integrity": "sha512-AirXNj15uRIMMPihnkInB4i3NHeb4iBtNg9WRWuK2o31S+ePwwNmDPaTL3o7dTJ+VXNZim7rFs4rxN4YU1oUJw==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isnil": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/lodash.isnil/-/lodash.isnil-4.0.0.tgz",
+ "integrity": "sha512-up2Mzq3545mwVnMhTDMdfoG1OurpA/s5t88JmQX809eH3C8491iu2sfKhTfhQtKY78oPNhiaHJUpT/dUDAAtng==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isundefined": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/lodash.isundefined/-/lodash.isundefined-3.0.1.tgz",
+ "integrity": "sha512-MXB1is3s899/cD8jheYYE2V9qTHwKvt+npCwpD+1Sxm3Q3cECXCiYHjeHWXNwr6Q0SOBPrYUDxendrO6goVTEA==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.uniq": {
+ "version": "4.5.0",
+ "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
+ "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.defaults": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz",
+ "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.includes": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
+ "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isarguments": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz",
+ "integrity": "sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isboolean": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
+ "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isinteger": {
+ "version": "4.0.4",
+ "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz",
+ "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isnumber": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz",
+ "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isplainobject": {
+ "version": "4.0.6",
+ "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+ "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isstring": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz",
+ "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.once": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz",
+ "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==",
+ "license": "MIT"
+ },
"node_modules/loupe": {
"version": "3.1.3",
"resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.3.tgz",
@@@ -7985,17 -8159,48 +8350,60 @@@
"node": "*"
}
},
+ "node_modules/twilio": {
+ "version": "5.8.0",
+ "resolved": "https://registry.npmjs.org/twilio/-/twilio-5.8.0.tgz",
+ "integrity": "sha512-aJLBvI7ODLmFHI7ZYLBiMZKIdHuF9PrPeRM/GBMDg/AAzGXs4V8gEnNPHyTVThK0/8J48YHSqXMlQ+WJR5nxoQ==",
+ "license": "MIT",
+ "dependencies": {
+ "axios": "^1.11.0",
+ "dayjs": "^1.11.9",
+ "https-proxy-agent": "^5.0.0",
+ "jsonwebtoken": "^9.0.2",
+ "qs": "^6.9.4",
+ "scmp": "^2.1.0",
+ "xmlbuilder": "^13.0.2"
+ },
+ "engines": {
+ "node": ">=14.0"
+ }
+ },
+ "node_modules/twilio/node_modules/agent-base": {
+ "version": "6.0.2",
+ "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+ "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+ "license": "MIT",
+ "dependencies": {
+ "debug": "4"
+ },
+ "engines": {
+ "node": ">= 6.0.0"
+ }
+ },
+ "node_modules/twilio/node_modules/https-proxy-agent": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+ "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "6",
+ "debug": "4"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
++ },
+ "node_modules/type-fest": {
+ "version": "0.20.2",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+ "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+ "license": "(MIT OR CC0-1.0)",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
},
"node_modules/typescript": {
"version": "5.8.3",
diff --cc server/src/db/postgres/schema.ts
index 59e5b6f32,c5939d09d..ea6f77c05
--- a/server/src/db/postgres/schema.ts
+++ b/server/src/db/postgres/schema.ts
@@@ -9,9 -9,10 +9,12 @@@ import
foreignKey,
unique,
real,
+ check,
+ index,
+ bigint,
+ pgEnum,
} from "drizzle-orm/pg-core";
+ import { sql } from "drizzle-orm";
// User table
export const user = pgTable(
@@@ -263,43 -264,320 +266,361 @@@ export const telemetry = pgTable("telem
clickhouseSizeGb: real("clickhouse_size_gb").notNull(),
});
+ // Uptime monitor definitions
+ export const uptimeMonitors = pgTable(
+ "uptime_monitors",
+ {
+ id: serial("id").primaryKey().notNull(),
+ organizationId: text("organization_id")
+ .notNull()
+ .references(() => organization.id),
+ name: text("name"),
+ monitorType: text("monitor_type").notNull(), // 'http', 'tcp'
+
+ // Common settings
+ intervalSeconds: integer("interval_seconds").notNull(),
+ enabled: boolean("enabled").default(true),
+
+ // HTTP/HTTPS specific configuration
+ httpConfig: jsonb("http_config").$type<{
+ url: string;
+ method: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "PATCH";
+ headers?: Record<string, string>;
+ body?: string;
+ auth?: {
+ type: "none" | "basic" | "bearer" | "api_key" | "custom_header";
+ credentials?: {
+ username?: string;
+ password?: string;
+ token?: string;
+ headerName?: string;
+ headerValue?: string;
+ };
+ };
+ followRedirects?: boolean;
+ timeoutMs?: number;
+ ipVersion?: "any" | "ipv4" | "ipv6";
+ userAgent?: string;
+ }>(),
+
+ // TCP specific configuration
+ tcpConfig: jsonb("tcp_config").$type<{
+ host: string;
+ port: number;
+ timeoutMs?: number;
+ }>(),
+
+ // Validation rules
+ validationRules: jsonb("validation_rules").notNull().default([]).$type<
+ Array<
+ | {
+ type: "status_code";
+ operator: "equals" | "not_equals" | "in" | "not_in";
+ value: number | number[];
+ }
+ | {
+ type: "response_time";
+ operator: "less_than" | "greater_than";
+ value: number;
+ }
+ | {
+ type: "response_body_contains" | "response_body_not_contains";
+ value: string;
+ caseSensitive?: boolean;
+ }
+ | {
+ type: "header_exists";
+ header: string;
+ }
+ | {
+ type: "header_value";
+ header: string;
+ operator: "equals" | "contains";
+ value: string;
+ }
+ | {
+ type: "response_size";
+ operator: "less_than" | "greater_than";
+ value: number;
+ }
+ >
+ >(),
+
+ // Multi-region configuration
+ monitoringType: text("monitoring_type").default("local"), // 'local' or 'global'
+ selectedRegions: jsonb("selected_regions").default(["local"]).$type<string[]>(),
+
+ // Metadata
+ createdAt: timestamp("created_at", { mode: "string" }).defaultNow(),
+ updatedAt: timestamp("updated_at", { mode: "string" }).defaultNow(),
+ createdBy: text("created_by")
+ .notNull()
+ .references(() => user.id),
+ },
+ (table) => [
+ foreignKey({
+ columns: [table.organizationId],
+ foreignColumns: [organization.id],
+ name: "uptime_monitors_organization_id_organization_id_fk",
+ }),
+ foreignKey({
+ columns: [table.createdBy],
+ foreignColumns: [user.id],
+ name: "uptime_monitors_created_by_user_id_fk",
+ }),
+ ],
+ );
+
+ // Monitor status tracking
+ export const uptimeMonitorStatus = pgTable(
+ "uptime_monitor_status",
+ {
+ monitorId: integer("monitor_id")
+ .primaryKey()
+ .notNull()
+ .references(() => uptimeMonitors.id, { onDelete: "cascade" }),
+ lastCheckedAt: timestamp("last_checked_at", { mode: "string" }),
+ nextCheckAt: timestamp("next_check_at", { mode: "string" }),
+ currentStatus: text("current_status").default("unknown"), // 'up', 'down', 'unknown'
+ consecutiveFailures: integer("consecutive_failures").default(0),
+ consecutiveSuccesses: integer("consecutive_successes").default(0),
+ uptimePercentage24h: real("uptime_percentage_24h"),
+ uptimePercentage7d: real("uptime_percentage_7d"),
+ uptimePercentage30d: real("uptime_percentage_30d"),
+ averageResponseTime24h: real("average_response_time_24h"),
+ updatedAt: timestamp("updated_at", { mode: "string" }).defaultNow(),
+ },
+ (table) => [
+ foreignKey({
+ columns: [table.monitorId],
+ foreignColumns: [uptimeMonitors.id],
+ name: "uptime_monitor_status_monitor_id_uptime_monitors_id_fk",
+ }),
+ check("uptime_monitor_status_current_status_check", sql`current_status IN ('up', 'down', 'unknown')`),
+ check("uptime_monitor_status_uptime_24h_check", sql`uptime_percentage_24h >= 0 AND uptime_percentage_24h <= 100`),
+ check("uptime_monitor_status_uptime_7d_check", sql`uptime_percentage_7d >= 0 AND uptime_percentage_7d <= 100`),
+ check("uptime_monitor_status_uptime_30d_check", sql`uptime_percentage_30d >= 0 AND uptime_percentage_30d <= 100`),
+ index("uptime_monitor_status_updated_at_idx").on(table.updatedAt),
+ ],
+ );
+
+ // Alert configuration (scaffolding)
+ export const uptimeAlerts = pgTable(
+ "uptime_alerts",
+ {
+ id: serial("id").primaryKey().notNull(),
+ monitorId: integer("monitor_id")
+ .notNull()
+ .references(() => uptimeMonitors.id, { onDelete: "cascade" }),
+ alertType: text("alert_type").notNull(), // 'email', 'webhook', 'slack', etc.
+ alertConfig: jsonb("alert_config").notNull(), // Type-specific configuration
+ conditions: jsonb("conditions").notNull().$type<{
+ consecutiveFailures?: number;
+ responseTimeThresholdMs?: number;
+ uptimePercentageThreshold?: number;
+ }>(),
+ enabled: boolean("enabled").default(true),
+ createdAt: timestamp("created_at", { mode: "string" }).defaultNow(),
+ },
+ (table) => [
+ foreignKey({
+ columns: [table.monitorId],
+ foreignColumns: [uptimeMonitors.id],
+ name: "uptime_alerts_monitor_id_uptime_monitors_id_fk",
+ }),
+ ],
+ );
+
+ // Alert history (scaffolding)
+ export const uptimeAlertHistory = pgTable(
+ "uptime_alert_history",
+ {
+ id: serial("id").primaryKey().notNull(),
+ alertId: integer("alert_id")
+ .notNull()
+ .references(() => uptimeAlerts.id, { onDelete: "cascade" }),
+ monitorId: integer("monitor_id")
+ .notNull()
+ .references(() => uptimeMonitors.id, { onDelete: "cascade" }),
+ triggeredAt: timestamp("triggered_at", { mode: "string" }).defaultNow(),
+ resolvedAt: timestamp("resolved_at", { mode: "string" }),
+ alertData: jsonb("alert_data"), // Context about what triggered the alert
+ },
+ (table) => [
+ foreignKey({
+ columns: [table.alertId],
+ foreignColumns: [uptimeAlerts.id],
+ name: "uptime_alert_history_alert_id_uptime_alerts_id_fk",
+ }),
+ foreignKey({
+ columns: [table.monitorId],
+ foreignColumns: [uptimeMonitors.id],
+ name: "uptime_alert_history_monitor_id_uptime_monitors_id_fk",
+ }),
+ ],
+ );
+
+ // Agent regions for VPS-based monitoring
+ export const agentRegions = pgTable("agent_regions", {
+ code: text("code").primaryKey().notNull(), // Region code (e.g., 'us-east', 'europe')
+ name: text("name").notNull(), // Region display name
+ endpointUrl: text("endpoint_url").notNull(), // Agent endpoint URL
+ enabled: boolean("enabled").default(true),
+ lastHealthCheck: timestamp("last_health_check", { mode: "string" }),
+ isHealthy: boolean("is_healthy").default(true),
+ });
+
+ // Uptime incidents table
+ export const uptimeIncidents = pgTable(
+ "uptime_incidents",
+ {
+ id: serial("id").primaryKey().notNull(),
+ organizationId: text("organization_id")
+ .notNull()
+ .references(() => organization.id),
+ monitorId: integer("monitor_id")
+ .notNull()
+ .references(() => uptimeMonitors.id, { onDelete: "cascade" }),
+ region: text("region"), // Region where incident occurred
+
+ // Incident timing
+ startTime: timestamp("start_time", { mode: "string" }).notNull(),
+ endTime: timestamp("end_time", { mode: "string" }), // null if ongoing
+
+ // Status
+ status: text("status").notNull().default("active"), // 'active', 'acknowledged', 'resolved'
+
+ // Acknowledgement details
+ acknowledgedBy: text("acknowledged_by").references(() => user.id),
+ acknowledgedAt: timestamp("acknowledged_at", { mode: "string" }),
+
+ // Resolution details
+ resolvedBy: text("resolved_by").references(() => user.id),
+ resolvedAt: timestamp("resolved_at", { mode: "string" }),
+
+ // Error details
+ lastError: text("last_error"),
+ lastErrorType: text("last_error_type"),
+ failureCount: integer("failure_count").default(1),
+ createdAt: timestamp("created_at", { mode: "string" }).defaultNow(),
+ updatedAt: timestamp("updated_at", { mode: "string" }).defaultNow(),
+ },
+ (table) => [
+ foreignKey({
+ columns: [table.organizationId],
+ foreignColumns: [organization.id],
+ name: "uptime_incidents_organization_id_organization_id_fk",
+ }),
+ foreignKey({
+ columns: [table.monitorId],
+ foreignColumns: [uptimeMonitors.id],
+ name: "uptime_incidents_monitor_id_uptime_monitors_id_fk",
+ }),
+ foreignKey({
+ columns: [table.acknowledgedBy],
+ foreignColumns: [user.id],
+ name: "uptime_incidents_acknowledged_by_user_id_fk",
+ }),
+ foreignKey({
+ columns: [table.resolvedBy],
+ foreignColumns: [user.id],
+ name: "uptime_incidents_resolved_by_user_id_fk",
+ }),
+ ],
+ );
+
+ // Notification channels table
+ export const notificationChannels = pgTable(
+ "notification_channels",
+ {
+ id: serial("id").primaryKey().notNull(),
+ organizationId: text("organization_id")
+ .notNull()
+ .references(() => organization.id),
+ type: text("type").notNull(), // 'email', 'discord', 'slack', 'sms'
+ name: text("name").notNull(),
+ enabled: boolean("enabled").default(true),
+
+ // Channel-specific configuration
+ config: jsonb("config").notNull().$type<{
+ // Email config
+ email?: string;
+
+ // Discord config
+ webhookUrl?: string;
+
+ // Slack config
+ slackWebhookUrl?: string;
+ slackChannel?: string;
+
+ // SMS config (placeholder)
+ phoneNumber?: string;
+ provider?: string;
+ }>(),
+
+ // Monitor selection and notification settings
+ monitorIds: jsonb("monitor_ids").$type<number[] | null>(), // null = all monitors
+ triggerEvents: jsonb("trigger_events").notNull().default(["down", "recovery"]).$type<string[]>(), // 'down', 'recovery', 'degraded'
+ cooldownMinutes: integer("cooldown_minutes").default(5), // Minimum time between notifications
+ lastNotifiedAt: timestamp("last_notified_at", { mode: "string" }),
+
+ createdAt: timestamp("created_at", { mode: "string" }).defaultNow(),
+ updatedAt: timestamp("updated_at", { mode: "string" }).defaultNow(),
+ createdBy: text("created_by")
+ .notNull()
+ .references(() => user.id),
+ },
+ (table) => [
+ foreignKey({
+ columns: [table.organizationId],
+ foreignColumns: [organization.id],
+ name: "notification_channels_organization_id_organization_id_fk",
+ }),
+ foreignKey({
+ columns: [table.createdBy],
+ foreignColumns: [user.id],
+ name: "notification_channels_created_by_user_id_fk",
+ }),
+ ],
+ );
++
+const importSourceEnum = pgEnum("import_source_enum", [
+ "umami",
+]);
+
+const importStatusEnum = pgEnum("import_status_enum", [
+ "pending",
+ "processing",
+ "completed",
+ "failed",
+]);
+
+// Import status table for tracking data import progress
+export const importStatus = pgTable(
+ "import_status",
+ {
+ importId: text("import_id").primaryKey().notNull(),
+ siteId: integer("site_id").notNull(),
+ organizationId: text("organization_id").notNull(),
+ source: importSourceEnum("source").notNull(),
+ status: importStatusEnum("status").notNull().default("pending"),
+ importedEvents: integer("imported_events").notNull().default(0),
+ errorMessage: text("error_message"),
+ startedAt: timestamp("started_at", { mode: "string" }).notNull().defaultNow(),
+ completedAt: timestamp("completed_at", { mode: "string" }),
+ fileName: text("file_name").notNull(),
+ fileSize: bigint("file_size", { mode: "number" }).notNull(),
+ },
+ (table) => [
+ foreignKey({
+ columns: [table.siteId],
+ foreignColumns: [sites.siteId],
+ name: "import_status_site_id_sites_site_id_fk",
+ }),
+ foreignKey({
+ columns: [table.organizationId],
+ foreignColumns: [organization.id],
+ name: "import_status_organization_id_organization_id_fk",
+ }),
+ ]
+);
diff --cc server/src/index.ts
index 3539a6cb2,494eb98f5..92ea85809
--- a/server/src/index.ts
+++ b/server/src/index.ts
@@@ -73,12 -85,8 +86,13 @@@ import { siteConfig } from "./lib/siteC
import { trackEvent } from "./services/tracker/trackEvent.js";
// need to import telemetry service here to start it
import { telemetryService } from "./services/telemetryService.js";
+ import { uptimeService } from "./services/uptime/uptimeService.js";
import { extractSiteId, isSitePublic } from "./utils.js";
+import { importSiteData } from "./api/sites/importSiteData.js";
+import boss from "./db/postgres/boss.js";
+import { registerCsvParseWorker } from "./services/import/workers/csvParseWorker.js";
+import { registerDataInsertWorker } from "./services/import/workers/dataInsertWorker.js";
+import { getSiteImports } from "./api/sites/getSiteImports.js";
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
@@@ -333,14 -380,21 +397,26 @@@ const start = async () =>
telemetryService.startTelemetryCron();
+ await boss.start();
+ await registerCsvParseWorker();
+ await registerDataInsertWorker();
+
- // Start the server
+ // Start the server first
await server.listen({ port: 3001, host: "0.0.0.0" });
+ server.log.info("Server is listening on http://0.0.0.0:3001");
+
+ // Initialize uptime monitoring service in the background (non-blocking)
+ uptimeService
+ .initialize()
+ .then(() => {
+ server.log.info("Uptime monitoring service initialized successfully");
+ })
+ .catch((error) => {
+ server.log.error("Failed to initialize uptime service:", error);
+ // Continue running without uptime monitoring
+ });
} catch (err) {
+ await boss.stop();
server.log.error(err);
process.exit(1);
}