@pipeline-builder/pipeline-data 3.4.113 → 3.4.115

package/lib/api/soft-delete-sweep.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared soft-delete retention purge.
+ *
+ * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a
+ * `purge_after` deadline). This orchestrator runs one purge pass across a set
+ * of such entities, hard-deleting tombstones whose deadline has passed. It is
+ * the `run` callback a service hands to `createScheduler` (leader-locked), so
+ * only one pod sweeps at a time.
+ *
+ * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({
+ * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and
+ * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant
+ * context would see zero rows on those tables — and in production (`strict`
+ * mode) `withTenantTx` throws outright — so the scope is established here rather
+ * than left to the caller. This is a cross-tenant housekeeping job, not a
+ * per-org operation.
+ */
+import { type Scheduler } from '@pipeline-builder/api-core';
+/** The slice of a CrudService the sweep needs, plus a label for logs/metrics. */
+export interface PurgeableEntity {
+    /** Table/entity label (e.g. 'pipeline') for per-table logging. */
+    name: string;
+    /** Hard-delete up to `limit` expired tombstones; returns rows purged. */
+    purgeExpired(now: Date, limit?: number): Promise<number>;
+}
+export interface SoftDeletePurgeOptions {
+    /** Rows per batch per table (default 500). */
+    batchSize?: number;
+    /** Max batches per table per tick (default 20 → ≤ 10k/table/tick); the rest
+     *  is deferred to the next tick so a huge backlog can't blow the lock TTL. */
+    maxBatchesPerEntity?: number;
+}
+/** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging
+ *  (tombstones still accumulate + stay restorable; nothing is destroyed). */
+export declare function isSoftDeletePurgeEnabled(): boolean;
+/**
+ * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in
+ * batches until a batch returns `< batchSize` (drained) or the per-tick cap is
+ * hit (logged; continued next tick). Never throws — a failing entity is logged
+ * and the sweep moves on. Returns per-entity purged counts (also logged).
+ */
+export declare function runSoftDeletePurge(entities: PurgeableEntity[], opts?: SoftDeletePurgeOptions): Promise<Record<string, number>>;
+export interface SoftDeletePurgeSchedulerOptions extends SoftDeletePurgeOptions {
+    /** Service label for logs + the leader-lock key (e.g. 'pipeline', 'plugin'). */
+    service: string;
+    /** Entities to sweep — usually the service's own CrudService singletons. */
+    entities: PurgeableEntity[];
+}
+/**
+ * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete
+ * purge sweep for `entities` on a cadence. The caller `.start()`s it and wires
+ * `stop()` to SIGTERM. Returns null when purging is disabled.
+ *
+ * Env config:
+ *   SOFT_DELETE_PURGE_ENABLED           (default true; false ⇒ null, no sweep)
+ *   SOFT_DELETE_PURGE_INTERVAL_HOURS    (default 6)
+ *   SOFT_DELETE_PURGE_STARTUP_DELAY_MS  (default 120000 — 2 min settle)
+ *   SOFT_DELETE_PURGE_LOCK_TTL_MS       (default 900000 — 15 min; outlasts a
+ *                                        sweep, stays under the interval)
+ *
+ * A cross-pod leader lock (when Redis is configured) means only one replica
+ * sweeps per window; without Redis it runs on every pod — still safe, since the
+ * purge is a batched idempotent DELETE, just redundant.
+ */
+export declare function createSoftDeletePurgeScheduler(opts: SoftDeletePurgeSchedulerOptions): Scheduler | null;

package/lib/api/soft-delete-sweep.js

@@ -0,0 +1,114 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared soft-delete retention purge.
+ *
+ * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a
+ * `purge_after` deadline). This orchestrator runs one purge pass across a set
+ * of such entities, hard-deleting tombstones whose deadline has passed. It is
+ * the `run` callback a service hands to `createScheduler` (leader-locked), so
+ * only one pod sweeps at a time.
+ *
+ * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({
+ * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and
+ * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant
+ * context would see zero rows on those tables — and in production (`strict`
+ * mode) `withTenantTx` throws outright — so the scope is established here rather
+ * than left to the caller. This is a cross-tenant housekeeping job, not a
+ * per-org operation.
+ */
+import { createLogger, createScheduler, createEnvRedisLock } from '@pipeline-builder/api-core';
+import { runWithTenantContext } from '../database/tenancy.js';
+const logger = createLogger('soft-delete-sweep');
+/** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging
+ *  (tombstones still accumulate + stay restorable; nothing is destroyed). */
+export function isSoftDeletePurgeEnabled() {
+    return (process.env.SOFT_DELETE_PURGE_ENABLED ?? 'true').toLowerCase() !== 'false';
+}
+/**
+ * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in
+ * batches until a batch returns `< batchSize` (drained) or the per-tick cap is
+ * hit (logged; continued next tick). Never throws — a failing entity is logged
+ * and the sweep moves on. Returns per-entity purged counts (also logged).
+ */
+export async function runSoftDeletePurge(entities, opts = {}) {
+    const counts = {};
+    if (!isSoftDeletePurgeEnabled()) {
+        logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');
+        return counts;
+    }
+    const batchSize = opts.batchSize ?? 500;
+    const maxBatches = opts.maxBatchesPerEntity ?? 20;
+    // One `now` for the whole tick — rows that expire mid-sweep wait for the next.
+    const now = new Date();
+    // Establish a sysadmin scope so every `purgeExpired` (which routes through
+    // `withTenantTx`) bypasses RLS and spans all orgs. Without this, FORCE'd
+    // tables return zero rows and production `strict` mode throws.
+    return runWithTenantContext({ isSuperAdmin: true }, async () => {
+        for (const entity of entities) {
+            let total = 0;
+            for (let i = 0; i < maxBatches; i++) {
+                let purged;
+                try {
+                    purged = await entity.purgeExpired(now, batchSize);
+                }
+                catch (err) {
+                    logger.error('Purge batch failed', { entity: entity.name, error: String(err) });
+                    break;
+                }
+                total += purged;
+                if (purged < batchSize)
+                    break; // drained
+                if (i === maxBatches - 1) {
+                    logger.warn('Purge hit per-tick cap; remaining tombstones deferred to next tick', {
+                        entity: entity.name, purgedThisTick: total,
+                    });
+                }
+            }
+            if (total > 0)
+                logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });
+            counts[entity.name] = total;
+        }
+        return counts;
+    });
+}
+/**
+ * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete
+ * purge sweep for `entities` on a cadence. The caller `.start()`s it and wires
+ * `stop()` to SIGTERM. Returns null when purging is disabled.
+ *
+ * Env config:
+ *   SOFT_DELETE_PURGE_ENABLED           (default true; false ⇒ null, no sweep)
+ *   SOFT_DELETE_PURGE_INTERVAL_HOURS    (default 6)
+ *   SOFT_DELETE_PURGE_STARTUP_DELAY_MS  (default 120000 — 2 min settle)
+ *   SOFT_DELETE_PURGE_LOCK_TTL_MS       (default 900000 — 15 min; outlasts a
+ *                                        sweep, stays under the interval)
+ *
+ * A cross-pod leader lock (when Redis is configured) means only one replica
+ * sweeps per window; without Redis it runs on every pod — still safe, since the
+ * purge is a batched idempotent DELETE, just redundant.
+ */
+export function createSoftDeletePurgeScheduler(opts) {
+    if (!isSoftDeletePurgeEnabled()) {
+        logger.info('Soft-delete purge scheduler disabled (SOFT_DELETE_PURGE_ENABLED=false)', { service: opts.service });
+        return null;
+    }
+    const intervalMs = Math.max(1, Number.parseInt(process.env.SOFT_DELETE_PURGE_INTERVAL_HOURS ?? '6', 10) || 6) * 60 * 60 * 1000;
+    const startupDelayMs = Math.max(0, Number.parseInt(process.env.SOFT_DELETE_PURGE_STARTUP_DELAY_MS ?? '120000', 10) || 0);
+    const lockTtlMs = Math.max(1000, Number.parseInt(process.env.SOFT_DELETE_PURGE_LOCK_TTL_MS ?? '900000', 10) || 900000);
+    const lock = createEnvRedisLock();
+    logger.info('Soft-delete purge scheduler starting', {
+        service: opts.service,
+        entities: opts.entities.map((e) => e.name),
+        intervalHours: intervalMs / 3_600_000,
+        locked: !!lock,
+    });
+    return createScheduler({
+        name: `soft-delete-purge:${opts.service}`,
+        intervalMs,
+        startupDelayMs,
+        run: async () => { await runSoftDeletePurge(opts.entities, opts); },
+        ...(lock ? { lock: { redis: () => lock, key: `soft-delete-purge:${opts.service}:leader`, ttlMs: lockTtlMs } } : {}),
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"soft-delete-sweep.js","sourceRoot":"","sources":["../../src/api/soft-delete-sweep.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Shared soft-delete retention purge.\n *\n * Every {@link CrudService} entity soft-deletes (sets `deletedAt` + a\n * `purge_after` deadline). This orchestrator runs one purge pass across a set\n * of such entities, hard-deleting tombstones whose deadline has passed. It is\n * the `run` callback a service hands to `createScheduler` (leader-locked), so\n * only one pod sweeps at a time.\n *\n * Runs in an explicit **sysadmin tenant scope** (`runWithTenantContext({\n * isSuperAdmin: true })`) so the underlying `purgeExpired` spans every org and\n * bypasses RLS on FORCE'd tables (plugins/pipelines/etc.). A bare no-tenant\n * context would see zero rows on those tables — and in production (`strict`\n * mode) `withTenantTx` throws outright — so the scope is established here rather\n * than left to the caller. This is a cross-tenant housekeeping job, not a\n * per-org operation.\n */\n\nimport { createLogger, createScheduler, createEnvRedisLock, type Scheduler } from '@pipeline-builder/api-core';\nimport { runWithTenantContext } from '../database/tenancy.js';\n\nconst logger = createLogger('soft-delete-sweep');\n\n/** The slice of a CrudService the sweep needs, plus a label for logs/metrics. */\nexport interface PurgeableEntity {\n  /** Table/entity label (e.g. 'pipeline') for per-table logging. */\n  name: string;\n  /** Hard-delete up to `limit` expired tombstones; returns rows purged. */\n  purgeExpired(now: Date, limit?: number): Promise<number>;\n}\n\nexport interface SoftDeletePurgeOptions {\n  /** Rows per batch per table (default 500). */\n  batchSize?: number;\n  /** Max batches per table per tick (default 20 → ≤ 10k/table/tick); the rest\n   *  is deferred to the next tick so a huge backlog can't blow the lock TTL. */\n  maxBatchesPerEntity?: number;\n}\n\n/** Kill-switch: `SOFT_DELETE_PURGE_ENABLED=false` disables all hard-purging\n *  (tombstones still accumulate + stay restorable; nothing is destroyed). */\nexport function isSoftDeletePurgeEnabled(): boolean {\n  return (process.env.SOFT_DELETE_PURGE_ENABLED ?? 'true').toLowerCase() !== 'false';\n}\n\n/**\n * Run one purge sweep across `entities`. Loops each entity's `purgeExpired` in\n * batches until a batch returns `< batchSize` (drained) or the per-tick cap is\n * hit (logged; continued next tick). Never throws — a failing entity is logged\n * and the sweep moves on. Returns per-entity purged counts (also logged).\n */\nexport async function runSoftDeletePurge(\n  entities: PurgeableEntity[],\n  opts: SoftDeletePurgeOptions = {},\n): Promise<Record<string, number>> {\n  const counts: Record<string, number> = {};\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');\n    return counts;\n  }\n\n  const batchSize = opts.batchSize ?? 500;\n  const maxBatches = opts.maxBatchesPerEntity ?? 20;\n  // One `now` for the whole tick — rows that expire mid-sweep wait for the next.\n  const now = new Date();\n\n  // Establish a sysadmin scope so every `purgeExpired` (which routes through\n  // `withTenantTx`) bypasses RLS and spans all orgs. Without this, FORCE'd\n  // tables return zero rows and production `strict` mode throws.\n  return runWithTenantContext({ isSuperAdmin: true }, async () => {\n    for (const entity of entities) {\n      let total = 0;\n      for (let i = 0; i < maxBatches; i++) {\n        let purged: number;\n        try {\n          purged = await entity.purgeExpired(now, batchSize);\n        } catch (err) {\n          logger.error('Purge batch failed', { entity: entity.name, error: String(err) });\n          break;\n        }\n        total += purged;\n        if (purged < batchSize) break; // drained\n        if (i === maxBatches - 1) {\n          logger.warn('Purge hit per-tick cap; remaining tombstones deferred to next tick', {\n            entity: entity.name, purgedThisTick: total,\n          });\n        }\n      }\n      if (total > 0) logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });\n      counts[entity.name] = total;\n    }\n\n    return counts;\n  });\n}\n\n// -- Scheduler factory --------------------------------------------------------\n\nexport interface SoftDeletePurgeSchedulerOptions extends SoftDeletePurgeOptions {\n  /** Service label for logs + the leader-lock key (e.g. 'pipeline', 'plugin'). */\n  service: string;\n  /** Entities to sweep — usually the service's own CrudService singletons. */\n  entities: PurgeableEntity[];\n}\n\n/**\n * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete\n * purge sweep for `entities` on a cadence. The caller `.start()`s it and wires\n * `stop()` to SIGTERM. Returns null when purging is disabled.\n *\n * Env config:\n *   SOFT_DELETE_PURGE_ENABLED           (default true; false ⇒ null, no sweep)\n *   SOFT_DELETE_PURGE_INTERVAL_HOURS    (default 6)\n *   SOFT_DELETE_PURGE_STARTUP_DELAY_MS  (default 120000 — 2 min settle)\n *   SOFT_DELETE_PURGE_LOCK_TTL_MS       (default 900000 — 15 min; outlasts a\n *                                        sweep, stays under the interval)\n *\n * A cross-pod leader lock (when Redis is configured) means only one replica\n * sweeps per window; without Redis it runs on every pod — still safe, since the\n * purge is a batched idempotent DELETE, just redundant.\n */\nexport function createSoftDeletePurgeScheduler(opts: SoftDeletePurgeSchedulerOptions): Scheduler | null {\n  if (!isSoftDeletePurgeEnabled()) {\n    logger.info('Soft-delete purge scheduler disabled (SOFT_DELETE_PURGE_ENABLED=false)', { service: opts.service });\n    return null;\n  }\n\n  const intervalMs = Math.max(1, Number.parseInt(process.env.SOFT_DELETE_PURGE_INTERVAL_HOURS ?? '6', 10) || 6) * 60 * 60 * 1000;\n  const startupDelayMs = Math.max(0, Number.parseInt(process.env.SOFT_DELETE_PURGE_STARTUP_DELAY_MS ?? '120000', 10) || 0);\n  const lockTtlMs = Math.max(1000, Number.parseInt(process.env.SOFT_DELETE_PURGE_LOCK_TTL_MS ?? '900000', 10) || 900000);\n  const lock = createEnvRedisLock();\n\n  logger.info('Soft-delete purge scheduler starting', {\n    service: opts.service,\n    entities: opts.entities.map((e) => e.name),\n    intervalHours: intervalMs / 3_600_000,\n    locked: !!lock,\n  });\n\n  return createScheduler({\n    name: `soft-delete-purge:${opts.service}`,\n    intervalMs,\n    startupDelayMs,\n    run: async () => { await runSoftDeletePurge(opts.entities, opts); },\n    ...(lock ? { lock: { redis: () => lock, key: `soft-delete-purge:${opts.service}:leader`, ttlMs: lockTtlMs } } : {}),\n  });\n}\n"]}

package/lib/database/drizzle-schema.d.ts

@@ -707,6 +707,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "plugins";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -1133,6 +1150,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "pipelines";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -1559,6 +1593,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "pipeline_templates";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -1908,6 +1959,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "messages";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -2685,6 +2753,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "dashboards";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -3112,6 +3197,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "org_alert_destinations";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -3383,6 +3485,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "org_alert_rules";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -3654,6 +3773,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "compliance_policies";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;
@@ -4182,6 +4318,23 @@ export declare const schema: {
                 identity: undefined;
                 generated: undefined;
             }, {}, {}>;
+            purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+                name: "purge_after";
+                tableName: "compliance_rules";
+                dataType: "date";
+                columnType: "PgTimestamp";
+                data: Date;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
         };
         dialect: 'pg';
     }>;

package/lib/database/schema/alert.d.ts

@@ -254,6 +254,23 @@ export declare const orgAlertDestination: import("drizzle-orm/pg-core").PgTableW
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+            name: "purge_after";
+            tableName: "org_alert_destinations";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;
@@ -546,6 +563,23 @@ export declare const orgAlertRule: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+            name: "purge_after";
+            tableName: "org_alert_rules";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;

package/lib/database/schema/alert.js

@@ -53,7 +53,12 @@ export const orgAlertDestination = pgTable('org_alert_destinations', {
     /** Soft delete so we keep audit history of who-deleted-what. */
     deletedAt: timestamp('deleted_at', { withTimezone: true }),
     deletedBy: text('deleted_by'),
+    // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned
+    // rows once `purge_after` has passed (set on delete alongside deleted_at).
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
 }, (table) => ({
+    // Partial index over just the tombstones — drives the retention purge sweep.
+    purgeIdx: index('org_alert_destination_purge_idx').on(table.purgeAfter).where(sql `deleted_at IS NOT NULL`),
     // Per-org listing  the only access path.
     orgIdx: index('org_alert_destination_org_idx')
         .on(table.orgId, table.enabled),
@@ -108,7 +113,12 @@ export const orgAlertRule = pgTable('org_alert_rules', {
     /** Soft delete so we keep audit of who-deleted-what. */
     deletedAt: timestamp('deleted_at', { withTimezone: true }),
     deletedBy: text('deleted_by'),
+    // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned
+    // rows once `purge_after` has passed (set on delete alongside deleted_at).
+    purgeAfter: timestamp('purge_after', { withTimezone: true }),
 }, (table) => ({
+    // Partial index over just the tombstones — drives the retention purge sweep.
+    purgeIdx: index('org_alert_rule_purge_idx').on(table.purgeAfter).where(sql `deleted_at IS NOT NULL`),
     // Per-org listing + materializer's enabled-only scan.
     orgEnabledIdx: index('org_alert_rule_org_enabled_idx')
         .on(table.orgId, table.enabled),
@@ -117,4 +127,4 @@ export const orgAlertRule = pgTable('org_alert_rules', {
         .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"]}
+//# 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  // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned\n  // rows once `purge_after` has passed (set on delete alongside deleted_at).\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // Partial index over just the tombstones — drives the retention purge sweep.\n  purgeIdx: index('org_alert_destination_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\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  // Soft-delete purge deadline: the retention sweep hard-deletes tombstoned\n  // rows once `purge_after` has passed (set on delete alongside deleted_at).\n  purgeAfter: timestamp('purge_after', { withTimezone: true }),\n}, (table) => ({\n  // Partial index over just the tombstones — drives the retention purge sweep.\n  purgeIdx: index('org_alert_rule_purge_idx').on(table.purgeAfter).where(sql`deleted_at IS NOT NULL`),\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"]}

package/lib/database/schema/compliance.d.ts

@@ -301,6 +301,23 @@ export declare const compliancePolicy: import("drizzle-orm/pg-core").PgTableWith
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+            name: "purge_after";
+            tableName: "compliance_policies";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;
@@ -834,6 +851,23 @@ export declare const complianceRule: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        purgeAfter: import("drizzle-orm/pg-core").PgColumn<{
+            name: "purge_after";
+            tableName: "compliance_rules";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;