@pipeline-builder/pipeline-data 3.4.86 → 3.4.87

package/lib/database/schema/alert.js

@@ -0,0 +1,120 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { sql } from 'drizzle-orm';
+import { boolean, varchar, pgTable, text, timestamp, uuid, index, uniqueIndex } from 'drizzle-orm/pg-core';
+/**
+ * Per-org alert notification destination. Multi-tenant alerting routes
+ * Alertmanager webhooks to the platform; the platform looks the firing
+ * alert's `org_id` label up here and forwards to each enabled destination.
+ *
+ * Channels * - `slack`  `target` is the incoming-webhook URL
+ * - `webhook`  `target` is any HTTPS URL; the relay posts the
+ * Alertmanager v2 webhook payload verbatim
+ * - `in-app`  `target` ignored; surfaces as an in-app message via
+ * the existing `messages` table
+ *
+ * Secrets * - For `slack`/`webhook` channels, the URL itself is the secret. We don't
+ * log it on `dashboard.update` or surface the full URL on GET endpoints
+ * after write; just a masked preview (last 12 chars). Stored in clear
+ * text  same posture as `compliance_notification_preferences.webhook_url`
+ * and consistent with the rest of the app's secret handling for org-level
+ * integrations. If we add a KMS-encryption tier for any secret column,
+ * this is one of the first to migrate.
+ *
+ * @table org_alert_destinations
+ */
+export const orgAlertDestination = pgTable('org_alert_destinations', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    createdBy: text('created_by').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedBy: text('updated_by').notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    /** 'slack' | 'webhook' | 'in-app' | 'email'  kept stringly so future channels
+     * (PagerDuty, …) can be added without a schema migration. */
+    channel: varchar('channel', { length: 20 })
+        .$type()
+        .notNull(),
+    /** Channel-specific target. Slack/webhook: URL. Email: address. In-app: ignored. */
+    target: text('target').default('').notNull(),
+    /** Friendly label shown in the settings UI. */
+    label: varchar('label', { length: 100 }).notNull(),
+    /** Lowest severity that triggers this destination ('warning' = warning+critical,
+     * 'critical' = critical only). Mirrors Alertmanager severity ordering. */
+    minSeverity: varchar('min_severity', { length: 10 })
+        .$type()
+        .default('warning')
+        .notNull(),
+    enabled: boolean('enabled').default(true).notNull(),
+    /** Soft delete so we keep audit history of who-deleted-what. */
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+}, (table) => ({
+    // Per-org listing  the only access path.
+    orgIdx: index('org_alert_destination_org_idx')
+        .on(table.orgId, table.enabled),
+}));
+/**
+ *  Per-org alert rules authored by operators.
+ *
+ * Each row materializes into a `groups[].rules[]` entry in a Prometheus
+ * `rule_files` YAML. The materializer endpoint
+ * `GET /api/observability/alert-rules/materialized.yml` renders all enabled
+ * rules across all orgs (deleted=null) into one document; Prometheus polls
+ * or a sidecar copies it into the rules dir.
+ *
+ * Tenancy + safety * - `expr` is user-authored PromQL. The CRUD route enforces that the
+ * expression substring-contains `org_id="<orgId>"` so an operator can't
+ * write rules that fire on other orgs' metrics. This is a coarse gate
+ * (a malformed expression can still be syntactically wrong) but it
+ * closes the cross-tenant data leak. Real PromQL parsing + automatic
+ * org_id injection is a follow-on.
+ * - The materialized rule carries `labels.org_id = <orgId>` so the
+ * alertmanager-relay routes firing alerts to the right org's
+ * destinations (matches the alert-relay model).
+ *
+ * @table org_alert_rules
+ */
+export const orgAlertRule = pgTable('org_alert_rules', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    orgId: varchar('org_id', { length: 255 }).notNull(),
+    createdBy: text('created_by').notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+    updatedBy: text('updated_by').notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+    /** Operator-supplied rule name. Sanitized into a valid Prom alert name at
+     * materialization time (becomes `OrgRule_<orgId>_<slug>` to avoid name
+     * collisions across orgs). */
+    name: varchar('name', { length: 100 }).notNull(),
+    /** PromQL expression. MUST substring-contain `org_id="<orgId>"`. */
+    expr: text('expr').notNull(),
+    /** `for: 5m` style duration. Validated against Prom's duration regex. */
+    forDuration: varchar('for_duration', { length: 20 }).default('5m').notNull(),
+    /** 'warning' | 'critical'  matches the platform-wide severity ladder. */
+    severity: varchar('severity', { length: 20 })
+        .$type()
+        .default('warning')
+        .notNull(),
+    /** Alertmanager `summary` annotation. Supports `{{ $value }}`. */
+    summary: text('summary').notNull(),
+    /** Alertmanager `description` annotation. Optional; '' is fine. */
+    description: text('description').default('').notNull(),
+    /** Disabled rules don't materialize. Lets operators stage rules without firing. */
+    enabled: boolean('enabled').default(true).notNull(),
+    /** Soft delete so we keep audit of who-deleted-what. */
+    deletedAt: timestamp('deleted_at', { withTimezone: true }),
+    deletedBy: text('deleted_by'),
+}, (table) => ({
+    // Per-org listing + materializer's enabled-only scan.
+    orgEnabledIdx: index('org_alert_rule_org_enabled_idx')
+        .on(table.orgId, table.enabled),
+    // Unique within an org so operators can't accidentally clone a rule.
+    orgNameUq: uniqueIndex('org_alert_rule_org_name_uq')
+        .on(table.orgId, table.name)
+        .where(sql `deleted_at IS NULL`),
+}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alert.js","sourceRoot":"","sources":["../../../src/database/schema/alert.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { sql } from 'drizzle-orm';\nimport { boolean, varchar, pgTable, text, timestamp, uuid, index, uniqueIndex } from 'drizzle-orm/pg-core';\n\n/**\n * Per-org alert notification destination. Multi-tenant alerting routes\n * Alertmanager webhooks to the platform; the platform looks the firing\n * alert's `org_id` label up here and forwards to each enabled destination.\n *\n * Channels * - `slack`  `target` is the incoming-webhook URL\n * - `webhook`  `target` is any HTTPS URL; the relay posts the\n * Alertmanager v2 webhook payload verbatim\n * - `in-app`  `target` ignored; surfaces as an in-app message via\n * the existing `messages` table\n *\n * Secrets * - For `slack`/`webhook` channels, the URL itself is the secret. We don't\n * log it on `dashboard.update` or surface the full URL on GET endpoints\n * after write; just a masked preview (last 12 chars). Stored in clear\n * text  same posture as `compliance_notification_preferences.webhook_url`\n * and consistent with the rest of the app's secret handling for org-level\n * integrations. If we add a KMS-encryption tier for any secret column,\n * this is one of the first to migrate.\n *\n * @table org_alert_destinations\n */\nexport const orgAlertDestination = pgTable('org_alert_destinations', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n\n  createdBy: text('created_by').notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n  updatedBy: text('updated_by').notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true })\n    .defaultNow()\n    .notNull(),\n\n  /** 'slack' | 'webhook' | 'in-app' | 'email'  kept stringly so future channels\n   * (PagerDuty, …) can be added without a schema migration. */\n  channel: varchar('channel', { length: 20 })\n    .$type<'slack' | 'webhook' | 'in-app' | 'email'>()\n    .notNull(),\n  /** Channel-specific target. Slack/webhook: URL. Email: address. In-app: ignored. */\n  target: text('target').default('').notNull(),\n  /** Friendly label shown in the settings UI. */\n  label: varchar('label', { length: 100 }).notNull(),\n\n  /** Lowest severity that triggers this destination ('warning' = warning+critical,\n   * 'critical' = critical only). Mirrors Alertmanager severity ordering. */\n  minSeverity: varchar('min_severity', { length: 10 })\n    .$type<'warning' | 'critical'>()\n    .default('warning')\n    .notNull(),\n  enabled: boolean('enabled').default(true).notNull(),\n\n  /** Soft delete so we keep audit history of who-deleted-what. */\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n}, (table) => ({\n  // Per-org listing  the only access path.\n  orgIdx: index('org_alert_destination_org_idx')\n    .on(table.orgId, table.enabled),\n}));\n\n/**\n *  Per-org alert rules authored by operators.\n *\n * Each row materializes into a `groups[].rules[]` entry in a Prometheus\n * `rule_files` YAML. The materializer endpoint\n * `GET /api/observability/alert-rules/materialized.yml` renders all enabled\n * rules across all orgs (deleted=null) into one document; Prometheus polls\n * or a sidecar copies it into the rules dir.\n *\n * Tenancy + safety * - `expr` is user-authored PromQL. The CRUD route enforces that the\n * expression substring-contains `org_id=\"<orgId>\"` so an operator can't\n * write rules that fire on other orgs' metrics. This is a coarse gate\n * (a malformed expression can still be syntactically wrong) but it\n * closes the cross-tenant data leak. Real PromQL parsing + automatic\n * org_id injection is a follow-on.\n * - The materialized rule carries `labels.org_id = <orgId>` so the\n * alertmanager-relay routes firing alerts to the right org's\n * destinations (matches the alert-relay model).\n *\n * @table org_alert_rules\n */\nexport const orgAlertRule = pgTable('org_alert_rules', {\n  id: uuid('id').primaryKey().defaultRandom(),\n  orgId: varchar('org_id', { length: 255 }).notNull(),\n\n  createdBy: text('created_by').notNull(),\n  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),\n  updatedBy: text('updated_by').notNull(),\n  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),\n\n  /** Operator-supplied rule name. Sanitized into a valid Prom alert name at\n   * materialization time (becomes `OrgRule_<orgId>_<slug>` to avoid name\n   * collisions across orgs). */\n  name: varchar('name', { length: 100 }).notNull(),\n  /** PromQL expression. MUST substring-contain `org_id=\"<orgId>\"`. */\n  expr: text('expr').notNull(),\n  /** `for: 5m` style duration. Validated against Prom's duration regex. */\n  forDuration: varchar('for_duration', { length: 20 }).default('5m').notNull(),\n  /** 'warning' | 'critical'  matches the platform-wide severity ladder. */\n  severity: varchar('severity', { length: 20 })\n    .$type<'warning' | 'critical'>()\n    .default('warning')\n    .notNull(),\n  /** Alertmanager `summary` annotation. Supports `{{ $value }}`. */\n  summary: text('summary').notNull(),\n  /** Alertmanager `description` annotation. Optional; '' is fine. */\n  description: text('description').default('').notNull(),\n\n  /** Disabled rules don't materialize. Lets operators stage rules without firing. */\n  enabled: boolean('enabled').default(true).notNull(),\n\n  /** Soft delete so we keep audit of who-deleted-what. */\n  deletedAt: timestamp('deleted_at', { withTimezone: true }),\n  deletedBy: text('deleted_by'),\n}, (table) => ({\n  // Per-org listing + materializer's enabled-only scan.\n  orgEnabledIdx: index('org_alert_rule_org_enabled_idx')\n    .on(table.orgId, table.enabled),\n  // Unique within an org so operators can't accidentally clone a rule.\n  orgNameUq: uniqueIndex('org_alert_rule_org_name_uq')\n    .on(table.orgId, table.name)\n    .where(sql`deleted_at IS NULL`),\n}));\n\nexport type OrgAlertDestination = typeof orgAlertDestination.$inferSelect;\nexport type OrgAlertDestinationInsert = typeof orgAlertDestination.$inferInsert;\nexport type OrgAlertDestinationUpdate = Partial<Omit<OrgAlertDestinationInsert, 'id' | 'createdAt' | 'createdBy' | 'orgId'>>;\n"]}