@pipeline-builder/pipeline-data 4.3.3 → 4.3.5

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

@@ -1,27 +1,17 @@
-/**
- * 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';
+import { type Scheduler, type RemoteAuditAction } 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>;
+    /**
+     * The entity's manual-purge action (e.g. `pipeline.purge`), reused for the
+     * sweep's hard-deletes with `details.trigger: 'retention'`. Omitted for rows
+     * that are not user-facing records (pending attachment blobs and the like) —
+     * those purge unaudited.
+     */
+    auditAction?: RemoteAuditAction;
 }
 /**
  * The services that run a soft-delete purge. A closed union, not a `string`,

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

@@ -16,8 +16,12 @@
  * 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.
+ *
+ * Each tick is one audited job run: entities that name an `auditAction` get one
+ * event per tick that purged rows — system actor, the tick's `runId`, the count.
  */
-import { createLogger, createScheduler, envBool, envInt, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS } from '@pipeline-builder/api-core';
+import { randomUUID } from 'node:crypto';
+import { createLogger, createScheduler, envBool, envInt, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS, recordAudit, runWithAuditContext, SYSTEM_ACTOR_ID, SYSTEM_ORG_ID, } 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
@@ -37,6 +41,9 @@ export async function runSoftDeletePurge(entities, opts = {}, run) {
         logger.debug('Soft-delete purge disabled (SOFT_DELETE_PURGE_ENABLED=false)');
         return counts;
     }
+    // One id per tick: every audit event this run records carries it (as the
+    // job context's `runId` and in `details`), so a reviewer can regroup a sweep.
+    const runId = randomUUID();
     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.
@@ -44,7 +51,7 @@ export async function runSoftDeletePurge(entities, opts = {}, run) {
     // 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 () => {
+    return runWithAuditContext({ job: { jobId: 'soft-delete-purge', runId, trigger: 'schedule' } }, () => runWithTenantContext({ isSuperAdmin: true }, async () => {
         for (const entity of entities) {
             // Between entities: the leader lock was lost (another pod is taking over) or
             // we are shutting down. The remaining entities are picked up next tick —
@@ -76,12 +83,35 @@ export async function runSoftDeletePurge(entities, opts = {}, run) {
                     });
                 }
             }
-            if (total > 0)
+            if (total > 0) {
                 logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });
+                if (entity.auditAction)
+                    auditRetentionPurge(entity.auditAction, entity.name, total, runId);
+            }
             counts[entity.name] = total;
         }
         return counts;
-    });
+    }));
+}
+/**
+ * The audit event for one entity's hard-deletes in one tick. A cross-tenant
+ * system job, so it is attributed to the system actor in the system org;
+ * `targetType` is the entity and there is no single `targetId`. Never throws —
+ * an unbound audit client (a wiring bug) is logged, and the sweep carries on.
+ */
+function auditRetentionPurge(action, entity, count, runId) {
+    try {
+        recordAudit({
+            action,
+            actorId: SYSTEM_ACTOR_ID,
+            orgId: SYSTEM_ORG_ID,
+            targetType: entity,
+            details: { trigger: 'retention', runId, count },
+        });
+    }
+    catch (err) {
+        logger.error('Retention purge audit not recorded', { entity, count, error: String(err) });
+    }
 }
 /**
  * Build (but do NOT start) a leader-locked scheduler that runs the soft-delete
@@ -120,4 +150,4 @@ export function createSoftDeletePurgeScheduler(opts) {
         lock: { key: leaderLockKey(opts.service, 'soft-delete-purge'), 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, envBool, envInt, type Scheduler, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS } 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\n/**\n * The services that run a soft-delete purge. A closed union, not a `string`,\n * because the value becomes the LOCK KEY: two services passing the same string\n * would silently share one lock, and whichever lost it would simply never sweep —\n * a typo that stops a purge with no error anywhere.\n */\nexport type SoftDeleteSweepService = 'pipeline' | 'plugin' | 'message' | 'compliance' | 'platform' | 'reporting';\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 envBool('SOFT_DELETE_PURGE_ENABLED', true);\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  run?: { signal: AbortSignal },\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      // Between entities: the leader lock was lost (another pod is taking over) or\n      // we are shutting down. The remaining entities are picked up next tick —\n      // their tombstones are still expired — and stopping lets the lock go.\n      if (run?.signal.aborted) {\n        logger.info('Soft-delete purge stopping early', { reason: String(run.signal.reason ?? 'aborted'), atEntity: entity.name });\n        break;\n      }\n      let total = 0;\n      for (let i = 0; i < maxBatches; i++) {\n        // Also between BATCHES: one entity with a large backlog can run for many\n        // batches, which is exactly the case a TTL used to have to cover.\n        if (run?.signal.aborted) break;\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: SoftDeleteSweepService;\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 = envInt('SOFT_DELETE_PURGE_INTERVAL_HOURS', 6, { min: 1 }) * 60 * 60 * 1000;\n  const startupDelayMs = envInt('SOFT_DELETE_PURGE_STARTUP_DELAY_MS', 120_000, { min: 0 });\n  const lockTtlMs = envInt('SOFT_DELETE_PURGE_LOCK_TTL_MS', DEFAULT_LEADER_LOCK_TTL_MS, { min: 1000 });\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  });\n\n  return createScheduler({\n    name: `soft-delete-purge:${opts.service}`,\n    intervalMs,\n    startupDelayMs,\n    run: async (run) => { await runSoftDeletePurge(opts.entities, opts, run); },\n    lock: { key: leaderLockKey(opts.service, 'soft-delete-purge'), ttlMs: lockTtlMs },\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"soft-delete-sweep.js","sourceRoot":"","sources":["../../src/api/soft-delete-sweep.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EACL,YAAY,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAkB,aAAa,EAAE,0BAA0B,EACzG,WAAW,EAAE,mBAAmB,EAAE,eAAe,EAAE,aAAa,GACjE,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,MAAM,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAiCjD;6EAC6E;AAC7E,MAAM,UAAU,wBAAwB;IACtC,OAAO,OAAO,CAAC,2BAA2B,EAAE,IAAI,CAAC,CAAC;AACpD,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,QAA2B,EAC3B,IAAI,GAA2B,EAAE,EACjC,GAA6B;IAE7B,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC;QAChC,MAAM,CAAC,KAAK,CAAC,8DAA8D,CAAC,CAAC;QAC7E,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,yEAAyE;IACzE,8EAA8E;IAC9E,MAAM,KAAK,GAAG,UAAU,EAAE,CAAC;IAC3B,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,GAAG,CAAC;IACxC,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,IAAI,EAAE,CAAC;IAClD,+EAA+E;IAC/E,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;IAEvB,2EAA2E;IAC3E,yEAAyE;IACzE,+DAA+D;IAC/D,OAAO,mBAAmB,CAAC,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,oBAAoB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,KAAK,IAAI,EAAE;QAC5J,KAAK,MAAM,MAAM,IAAI,QAAQ,EAAE,CAAC;YAC9B,6EAA6E;YAC7E,yEAAyE;YACzE,sEAAsE;YACtE,IAAI,GAAG,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;gBACxB,MAAM,CAAC,IAAI,CAAC,kCAAkC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,IAAI,SAAS,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;gBAC3H,MAAM;YACR,CAAC;YACD,IAAI,KAAK,GAAG,CAAC,CAAC;YACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;gBACpC,yEAAyE;gBACzE,kEAAkE;gBAClE,IAAI,GAAG,EAAE,MAAM,CAAC,OAAO;oBAAE,MAAM;gBAC/B,IAAI,MAAc,CAAC;gBACnB,IAAI,CAAC;oBACH,MAAM,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;gBACrD,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBAChF,MAAM;gBACR,CAAC;gBACD,KAAK,IAAI,MAAM,CAAC;gBAChB,IAAI,MAAM,GAAG,SAAS;oBAAE,MAAM,CAAC,UAAU;gBACzC,IAAI,CAAC,KAAK,UAAU,GAAG,CAAC,EAAE,CAAC;oBACzB,MAAM,CAAC,IAAI,CAAC,oEAAoE,EAAE;wBAChF,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK;qBAC3C,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YACD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBACd,MAAM,CAAC,IAAI,CAAC,kCAAkC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;gBACvF,IAAI,MAAM,CAAC,WAAW;oBAAE,mBAAmB,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;YAC7F,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAC9B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CAAC,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,MAAyB,EAAE,MAAc,EAAE,KAAa,EAAE,KAAa;IAClG,IAAI,CAAC;QACH,WAAW,CAAC;YACV,MAAM;YACN,OAAO,EAAE,eAAe;YACxB,KAAK,EAAE,aAAa;YACpB,UAAU,EAAE,MAAM;YAClB,OAAO,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE;SAChD,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC5F,CAAC;AACH,CAAC;AAWD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,8BAA8B,CAAC,IAAqC;IAClF,IAAI,CAAC,wBAAwB,EAAE,EAAE,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,wEAAwE,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QACjH,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,CAAC,kCAAkC,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC9F,MAAM,cAAc,GAAG,MAAM,CAAC,oCAAoC,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;IACzF,MAAM,SAAS,GAAG,MAAM,CAAC,+BAA+B,EAAE,0BAA0B,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;IAErG,MAAM,CAAC,IAAI,CAAC,sCAAsC,EAAE;QAClD,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QAC1C,aAAa,EAAE,UAAU,GAAG,SAAS;KACtC,CAAC,CAAC;IAEH,OAAO,eAAe,CAAC;QACrB,IAAI,EAAE,qBAAqB,IAAI,CAAC,OAAO,EAAE;QACzC,UAAU;QACV,cAAc;QACd,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QAC3E,IAAI,EAAE,EAAE,GAAG,EAAE,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,mBAAmB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE;KAClF,CAAC,CAAC;AACL,CAAC","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 * Each tick is one audited job run: entities that name an `auditAction` get one\n * event per tick that purged rows — system actor, the tick's `runId`, the count.\n */\n\nimport { randomUUID } from 'node:crypto';\nimport {\n  createLogger, createScheduler, envBool, envInt, type Scheduler, leaderLockKey, DEFAULT_LEADER_LOCK_TTL_MS,\n  recordAudit, runWithAuditContext, SYSTEM_ACTOR_ID, SYSTEM_ORG_ID, type RemoteAuditAction,\n} 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   * The entity's manual-purge action (e.g. `pipeline.purge`), reused for the\n   * sweep's hard-deletes with `details.trigger: 'retention'`. Omitted for rows\n   * that are not user-facing records (pending attachment blobs and the like) —\n   * those purge unaudited.\n   */\n  auditAction?: RemoteAuditAction;\n}\n\n/**\n * The services that run a soft-delete purge. A closed union, not a `string`,\n * because the value becomes the LOCK KEY: two services passing the same string\n * would silently share one lock, and whichever lost it would simply never sweep —\n * a typo that stops a purge with no error anywhere.\n */\nexport type SoftDeleteSweepService = 'pipeline' | 'plugin' | 'message' | 'compliance' | 'platform' | 'reporting';\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 envBool('SOFT_DELETE_PURGE_ENABLED', true);\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  run?: { signal: AbortSignal },\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  // One id per tick: every audit event this run records carries it (as the\n  // job context's `runId` and in `details`), so a reviewer can regroup a sweep.\n  const runId = randomUUID();\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 runWithAuditContext({ job: { jobId: 'soft-delete-purge', runId, trigger: 'schedule' } }, () => runWithTenantContext({ isSuperAdmin: true }, async () => {\n    for (const entity of entities) {\n      // Between entities: the leader lock was lost (another pod is taking over) or\n      // we are shutting down. The remaining entities are picked up next tick —\n      // their tombstones are still expired — and stopping lets the lock go.\n      if (run?.signal.aborted) {\n        logger.info('Soft-delete purge stopping early', { reason: String(run.signal.reason ?? 'aborted'), atEntity: entity.name });\n        break;\n      }\n      let total = 0;\n      for (let i = 0; i < maxBatches; i++) {\n        // Also between BATCHES: one entity with a large backlog can run for many\n        // batches, which is exactly the case a TTL used to have to cover.\n        if (run?.signal.aborted) break;\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) {\n        logger.info('Purged expired soft-deleted rows', { entity: entity.name, count: total });\n        if (entity.auditAction) auditRetentionPurge(entity.auditAction, entity.name, total, runId);\n      }\n      counts[entity.name] = total;\n    }\n\n    return counts;\n  }));\n}\n\n/**\n * The audit event for one entity's hard-deletes in one tick. A cross-tenant\n * system job, so it is attributed to the system actor in the system org;\n * `targetType` is the entity and there is no single `targetId`. Never throws —\n * an unbound audit client (a wiring bug) is logged, and the sweep carries on.\n */\nfunction auditRetentionPurge(action: RemoteAuditAction, entity: string, count: number, runId: string): void {\n  try {\n    recordAudit({\n      action,\n      actorId: SYSTEM_ACTOR_ID,\n      orgId: SYSTEM_ORG_ID,\n      targetType: entity,\n      details: { trigger: 'retention', runId, count },\n    });\n  } catch (err) {\n    logger.error('Retention purge audit not recorded', { entity, count, error: String(err) });\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: SoftDeleteSweepService;\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 = envInt('SOFT_DELETE_PURGE_INTERVAL_HOURS', 6, { min: 1 }) * 60 * 60 * 1000;\n  const startupDelayMs = envInt('SOFT_DELETE_PURGE_STARTUP_DELAY_MS', 120_000, { min: 0 });\n  const lockTtlMs = envInt('SOFT_DELETE_PURGE_LOCK_TTL_MS', DEFAULT_LEADER_LOCK_TTL_MS, { min: 1000 });\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  });\n\n  return createScheduler({\n    name: `soft-delete-purge:${opts.service}`,\n    intervalMs,\n    startupDelayMs,\n    run: async (run) => { await runSoftDeletePurge(opts.entities, opts, run); },\n    lock: { key: leaderLockKey(opts.service, 'soft-delete-purge'), ttlMs: lockTtlMs },\n  });\n}\n"]}

package/lib/api/version-references.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Which pipelines still REFERENCE a plugin version or image — the one rule every
+ * removal path asks before it deletes anything: an org plugin delete (forced or
+ * not), a bulk delete, a tombstone purge (manual or the retention sweep), the
+ * image registry's age GC, the listing image GC.
+ *
+ * THE RULE: a version (or its image) that any pipeline references cannot be
+ * deleted until no pipeline does — whatever its vulnerability state. A
+ * vulnerable image is the WORST thing to delete out from under a pipeline: the
+ * next run fails to pull, and the owners learn about the CVE from an outage.
+ * Vulnerability consequences are graded warnings and notifications, never removal.
+ *
+ * A reference is any of:
+ *  - `declared` — a LIVE pipeline's config resolves to it (`pipeline_plugin_resolution`);
+ *  - `deployed` — a pipeline's last deploy recorded it (`pipeline_step_manifests`),
+ *    INCLUDING a soft-deleted pipeline: its CodePipeline still runs the image;
+ *  - `exposure` — an open DEPLOYED exposure still names it (the same "still runs
+ *    it" fact, kept when a manifest is gone).
+ *
+ * Matched by image digest when the version has one (a team running its parent's
+ * plugin, or another org's install, pins the same digest), else by name +
+ * version within the owner org and its teams.
+ */
+import { type SQL } from 'drizzle-orm';
+/** A version / image whose references are wanted. */
+export interface VersionReferenceTarget {
+    pluginName: string;
+    pluginVersion: string;
+    imageDigest?: string | null;
+    /** The owning org of an org plugin (its teams count too); omitted for a listing version. */
+    ownerOrgId?: string | null;
+    /** The listing's publisher handle (a listing version); null/omitted for an org plugin. */
+    publisher?: string | null;
+}
+/** One pipeline referencing a version. */
+export interface VersionReference {
+    pipelineId: string;
+    pipelineName: string | null;
+    orgId: string;
+    source: 'declared' | 'deployed' | 'exposure';
+    /** The pipeline is soft-deleted (still deployed: its manifest or exposure remains). */
+    pipelineDeleted: boolean;
+    steps: string[];
+}
+/**
+ * The SQL predicate "some pipeline references this row's image / version", over
+ * a `plugins`-shaped row's columns — the purge guard's form of
+ * {@link findVersionReferences} (same three sources, same matching).
+ */
+export declare function versionReferencedPredicate(cols: {
+    digest: SQL;
+    name: SQL;
+    version: SQL;
+    orgId: SQL;
+}): SQL;
+/**
+ * Every pipeline referencing `target` (see the module doc), across orgs — so it
+ * must run with a scope that can read every org's rows (elevated). The result
+ * names other orgs' pipelines; callers show the OWNER only counts and its own
+ * org's pipelines, and notify each referencing org about its own.
+ */
+export declare function findVersionReferences(target: VersionReferenceTarget): Promise<VersionReference[]>;
+/** Distinct pipelines among `refs` (a pipeline both declared and deployed counts once). */
+export declare function distinctPipelines(refs: readonly VersionReference[]): Array<{
+    pipelineId: string;
+    pipelineName: string | null;
+    orgId: string;
+    sources: string[];
+    pipelineDeleted: boolean;
+    steps: string[];
+}>;
+/**
+ * The image digests an org's namespace still needs: every `plugins` row's
+ * digest (active, inactive or soft-deleted — a tombstone is restorable until
+ * purged, and the purge itself is guarded) plus every digest a pipeline of the
+ * org or its teams declares, runs or has an open deployed exposure on. What the
+ * image registry's age GC consults before deleting anything in `org-<id>/*`.
+ * Elevated read.
+ */
+export declare function orgImageDigestsInUse(orgId: string): Promise<string[]>;

package/lib/api/version-references.js

@@ -0,0 +1,135 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Which pipelines still REFERENCE a plugin version or image — the one rule every
+ * removal path asks before it deletes anything: an org plugin delete (forced or
+ * not), a bulk delete, a tombstone purge (manual or the retention sweep), the
+ * image registry's age GC, the listing image GC.
+ *
+ * THE RULE: a version (or its image) that any pipeline references cannot be
+ * deleted until no pipeline does — whatever its vulnerability state. A
+ * vulnerable image is the WORST thing to delete out from under a pipeline: the
+ * next run fails to pull, and the owners learn about the CVE from an outage.
+ * Vulnerability consequences are graded warnings and notifications, never removal.
+ *
+ * A reference is any of:
+ *  - `declared` — a LIVE pipeline's config resolves to it (`pipeline_plugin_resolution`);
+ *  - `deployed` — a pipeline's last deploy recorded it (`pipeline_step_manifests`),
+ *    INCLUDING a soft-deleted pipeline: its CodePipeline still runs the image;
+ *  - `exposure` — an open DEPLOYED exposure still names it (the same "still runs
+ *    it" fact, kept when a manifest is gone).
+ *
+ * Matched by image digest when the version has one (a team running its parent's
+ * plugin, or another org's install, pins the same digest), else by name +
+ * version within the owner org and its teams.
+ */
+import { sql } from 'drizzle-orm';
+import { executeRows } from '../database/pg-result.js';
+import { withTenantTx } from '../database/tenancy.js';
+/**
+ * The SQL predicate "some pipeline references this row's image / version", over
+ * a `plugins`-shaped row's columns — the purge guard's form of
+ * {@link findVersionReferences} (same three sources, same matching).
+ */
+export function versionReferencedPredicate(cols) {
+    return sql `(
+    (${cols.digest} IS NOT NULL AND (
+      EXISTS (SELECT 1 FROM pipeline_step_manifests m WHERE m.image_digest = ${cols.digest})
+      OR EXISTS (SELECT 1 FROM pipeline_plugin_resolution r JOIN pipelines p ON p.id::text = r.pipeline_id AND p.deleted_at IS NULL
+                  WHERE r.resolved_digest = ${cols.digest})
+      OR EXISTS (SELECT 1 FROM plugin_vuln_exposure e WHERE e.image_digest = ${cols.digest} AND e.source = 'deployed' AND e.fixed_at IS NULL)))
+    OR (${cols.digest} IS NULL AND (
+      EXISTS (SELECT 1 FROM pipeline_step_manifests m WHERE m.plugin_name = ${cols.name} AND m.plugin_version = ${cols.version}
+                AND m.plugin_publisher IS NULL AND lower(m.org_id) = lower(${cols.orgId}))
+      OR EXISTS (SELECT 1 FROM pipeline_plugin_resolution r JOIN pipelines p ON p.id::text = r.pipeline_id AND p.deleted_at IS NULL
+                  WHERE r.plugin_name = ${cols.name} AND r.resolved_version = ${cols.version} AND r.plugin_publisher IS NULL
+                    AND (lower(r.org_id) = lower(${cols.orgId}) OR lower(r.root_org_id) = lower(${cols.orgId})))))
+  )`;
+}
+/**
+ * Every pipeline referencing `target` (see the module doc), across orgs — so it
+ * must run with a scope that can read every org's rows (elevated). The result
+ * names other orgs' pipelines; callers show the OWNER only counts and its own
+ * org's pipelines, and notify each referencing org about its own.
+ */
+export async function findVersionReferences(target) {
+    const digest = target.imageDigest ?? null;
+    const owner = target.ownerOrgId?.toLowerCase() ?? null;
+    const declaredMatch = digest
+        ? sql `r.resolved_digest = ${digest}`
+        : sql `r.plugin_name = ${target.pluginName} AND r.resolved_version = ${target.pluginVersion}
+          AND ${target.publisher ? sql `r.plugin_publisher = ${target.publisher}` : sql `r.plugin_publisher IS NULL AND (lower(r.org_id) = ${owner} OR lower(r.root_org_id) = ${owner})`}`;
+    const deployedMatch = digest
+        ? sql `m.image_digest = ${digest}`
+        : sql `m.plugin_name = ${target.pluginName} AND m.plugin_version = ${target.pluginVersion}
+          AND ${target.publisher ? sql `m.plugin_publisher = ${target.publisher}` : sql `m.plugin_publisher IS NULL AND lower(m.org_id) = ${owner}`}`;
+    const exposureMatch = digest
+        ? sql `e.image_digest = ${digest}`
+        : sql `e.plugin_name = ${target.pluginName} AND e.plugin_version = ${target.pluginVersion}
+          AND ${target.publisher ? sql `e.plugin_publisher = ${target.publisher}` : sql `e.plugin_publisher IS NULL AND lower(e.org_id) = ${owner}`}`;
+    const rows = await withTenantTx((tx) => executeRows(tx, sql `
+    SELECT x.pipeline_id, x.org_id, x.source, p.pipeline_name, (p.id IS NULL OR p.deleted_at IS NOT NULL) AS deleted,
+           array_agg(DISTINCT x.step) FILTER (WHERE x.step IS NOT NULL) AS steps
+      FROM (
+        SELECT r.pipeline_id, r.org_id, 'declared' AS source,
+               CASE WHEN r.stage_name = 'synth' AND r.step_name = 'synth' THEN 'synth' ELSE r.stage_name || '/' || r.step_name END AS step
+          FROM pipeline_plugin_resolution r
+          JOIN pipelines lp ON lp.id::text = r.pipeline_id AND lp.deleted_at IS NULL
+         WHERE ${declaredMatch}
+        UNION ALL
+        SELECT m.pipeline_id::text, m.org_id, 'deployed', m.stage_name || '/' || m.action_name
+          FROM pipeline_step_manifests m WHERE ${deployedMatch}
+        UNION ALL
+        SELECT e.pipeline_id, e.org_id, 'exposure', NULL
+          FROM plugin_vuln_exposure e WHERE ${exposureMatch} AND e.source = 'deployed' AND e.fixed_at IS NULL
+      ) x
+      LEFT JOIN pipelines p ON p.id::text = x.pipeline_id
+     GROUP BY x.pipeline_id, x.org_id, x.source, p.pipeline_name, p.id, p.deleted_at
+     ORDER BY x.org_id, x.pipeline_id, x.source
+  `));
+    return rows.map((r) => ({
+        pipelineId: r.pipeline_id,
+        pipelineName: r.pipeline_name ?? null,
+        orgId: r.org_id,
+        source: r.source,
+        pipelineDeleted: r.deleted === true,
+        steps: r.steps ?? [],
+    }));
+}
+/** Distinct pipelines among `refs` (a pipeline both declared and deployed counts once). */
+export function distinctPipelines(refs) {
+    const byId = new Map();
+    for (const r of refs) {
+        const e = byId.get(r.pipelineId) ?? { pipelineId: r.pipelineId, pipelineName: r.pipelineName, orgId: r.orgId, sources: [], pipelineDeleted: r.pipelineDeleted, steps: [] };
+        if (!e.sources.includes(r.source))
+            e.sources.push(r.source);
+        e.steps = [...new Set([...e.steps, ...r.steps])];
+        byId.set(r.pipelineId, e);
+    }
+    return [...byId.values()];
+}
+/**
+ * The image digests an org's namespace still needs: every `plugins` row's
+ * digest (active, inactive or soft-deleted — a tombstone is restorable until
+ * purged, and the purge itself is guarded) plus every digest a pipeline of the
+ * org or its teams declares, runs or has an open deployed exposure on. What the
+ * image registry's age GC consults before deleting anything in `org-<id>/*`.
+ * Elevated read.
+ */
+export async function orgImageDigestsInUse(orgId) {
+    const org = orgId.toLowerCase();
+    const rows = await withTenantTx((tx) => executeRows(tx, sql `
+    SELECT DISTINCT d FROM (
+      SELECT image_digest AS d FROM plugins WHERE lower(org_id) = ${org} AND image_digest IS NOT NULL
+      UNION SELECT r.resolved_digest FROM pipeline_plugin_resolution r
+              WHERE r.resolved_digest IS NOT NULL AND (lower(r.org_id) = ${org} OR lower(r.root_org_id) = ${org})
+      UNION SELECT m.image_digest FROM pipeline_step_manifests m
+              WHERE m.image_digest IS NOT NULL AND m.image_digest IN (SELECT image_digest FROM plugins WHERE lower(org_id) = ${org} AND image_digest IS NOT NULL)
+      UNION SELECT m.image_digest FROM pipeline_step_manifests m WHERE m.image_digest IS NOT NULL AND lower(m.org_id) = ${org}
+      UNION SELECT e.image_digest FROM plugin_vuln_exposure e
+              WHERE e.image_digest IS NOT NULL AND e.source = 'deployed' AND e.fixed_at IS NULL AND lower(e.org_id) = ${org}
+    ) x WHERE d IS NOT NULL
+  `));
+    return rows.map((r) => r.d);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version-references.js","sourceRoot":"","sources":["../../src/api/version-references.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Which pipelines still REFERENCE a plugin version or image — the one rule every\n * removal path asks before it deletes anything: an org plugin delete (forced or\n * not), a bulk delete, a tombstone purge (manual or the retention sweep), the\n * image registry's age GC, the listing image GC.\n *\n * THE RULE: a version (or its image) that any pipeline references cannot be\n * deleted until no pipeline does — whatever its vulnerability state. A\n * vulnerable image is the WORST thing to delete out from under a pipeline: the\n * next run fails to pull, and the owners learn about the CVE from an outage.\n * Vulnerability consequences are graded warnings and notifications, never removal.\n *\n * A reference is any of:\n *  - `declared` — a LIVE pipeline's config resolves to it (`pipeline_plugin_resolution`);\n *  - `deployed` — a pipeline's last deploy recorded it (`pipeline_step_manifests`),\n *    INCLUDING a soft-deleted pipeline: its CodePipeline still runs the image;\n *  - `exposure` — an open DEPLOYED exposure still names it (the same \"still runs\n *    it\" fact, kept when a manifest is gone).\n *\n * Matched by image digest when the version has one (a team running its parent's\n * plugin, or another org's install, pins the same digest), else by name +\n * version within the owner org and its teams.\n */\n\nimport { sql, type SQL } from 'drizzle-orm';\nimport { executeRows } from '../database/pg-result.js';\nimport { withTenantTx } from '../database/tenancy.js';\n\n/** A version / image whose references are wanted. */\nexport interface VersionReferenceTarget {\n  pluginName: string;\n  pluginVersion: string;\n  imageDigest?: string | null;\n  /** The owning org of an org plugin (its teams count too); omitted for a listing version. */\n  ownerOrgId?: string | null;\n  /** The listing's publisher handle (a listing version); null/omitted for an org plugin. */\n  publisher?: string | null;\n}\n\n/** One pipeline referencing a version. */\nexport interface VersionReference {\n  pipelineId: string;\n  pipelineName: string | null;\n  orgId: string;\n  source: 'declared' | 'deployed' | 'exposure';\n  /** The pipeline is soft-deleted (still deployed: its manifest or exposure remains). */\n  pipelineDeleted: boolean;\n  steps: string[];\n}\n\n/**\n * The SQL predicate \"some pipeline references this row's image / version\", over\n * a `plugins`-shaped row's columns — the purge guard's form of\n * {@link findVersionReferences} (same three sources, same matching).\n */\nexport function versionReferencedPredicate(cols: { digest: SQL; name: SQL; version: SQL; orgId: SQL }): SQL {\n  return sql`(\n    (${cols.digest} IS NOT NULL AND (\n      EXISTS (SELECT 1 FROM pipeline_step_manifests m WHERE m.image_digest = ${cols.digest})\n      OR EXISTS (SELECT 1 FROM pipeline_plugin_resolution r JOIN pipelines p ON p.id::text = r.pipeline_id AND p.deleted_at IS NULL\n                  WHERE r.resolved_digest = ${cols.digest})\n      OR EXISTS (SELECT 1 FROM plugin_vuln_exposure e WHERE e.image_digest = ${cols.digest} AND e.source = 'deployed' AND e.fixed_at IS NULL)))\n    OR (${cols.digest} IS NULL AND (\n      EXISTS (SELECT 1 FROM pipeline_step_manifests m WHERE m.plugin_name = ${cols.name} AND m.plugin_version = ${cols.version}\n                AND m.plugin_publisher IS NULL AND lower(m.org_id) = lower(${cols.orgId}))\n      OR EXISTS (SELECT 1 FROM pipeline_plugin_resolution r JOIN pipelines p ON p.id::text = r.pipeline_id AND p.deleted_at IS NULL\n                  WHERE r.plugin_name = ${cols.name} AND r.resolved_version = ${cols.version} AND r.plugin_publisher IS NULL\n                    AND (lower(r.org_id) = lower(${cols.orgId}) OR lower(r.root_org_id) = lower(${cols.orgId})))))\n  )`;\n}\n\n/**\n * Every pipeline referencing `target` (see the module doc), across orgs — so it\n * must run with a scope that can read every org's rows (elevated). The result\n * names other orgs' pipelines; callers show the OWNER only counts and its own\n * org's pipelines, and notify each referencing org about its own.\n */\nexport async function findVersionReferences(target: VersionReferenceTarget): Promise<VersionReference[]> {\n  const digest = target.imageDigest ?? null;\n  const owner = target.ownerOrgId?.toLowerCase() ?? null;\n  const declaredMatch = digest\n    ? sql`r.resolved_digest = ${digest}`\n    : sql`r.plugin_name = ${target.pluginName} AND r.resolved_version = ${target.pluginVersion}\n          AND ${target.publisher ? sql`r.plugin_publisher = ${target.publisher}` : sql`r.plugin_publisher IS NULL AND (lower(r.org_id) = ${owner} OR lower(r.root_org_id) = ${owner})`}`;\n  const deployedMatch = digest\n    ? sql`m.image_digest = ${digest}`\n    : sql`m.plugin_name = ${target.pluginName} AND m.plugin_version = ${target.pluginVersion}\n          AND ${target.publisher ? sql`m.plugin_publisher = ${target.publisher}` : sql`m.plugin_publisher IS NULL AND lower(m.org_id) = ${owner}`}`;\n  const exposureMatch = digest\n    ? sql`e.image_digest = ${digest}`\n    : sql`e.plugin_name = ${target.pluginName} AND e.plugin_version = ${target.pluginVersion}\n          AND ${target.publisher ? sql`e.plugin_publisher = ${target.publisher}` : sql`e.plugin_publisher IS NULL AND lower(e.org_id) = ${owner}`}`;\n  const rows = await withTenantTx((tx) => executeRows<{ pipeline_id: string; org_id: string; source: VersionReference['source']; pipeline_name: string | null; deleted: boolean; steps: string[] | null }>(tx, sql`\n    SELECT x.pipeline_id, x.org_id, x.source, p.pipeline_name, (p.id IS NULL OR p.deleted_at IS NOT NULL) AS deleted,\n           array_agg(DISTINCT x.step) FILTER (WHERE x.step IS NOT NULL) AS steps\n      FROM (\n        SELECT r.pipeline_id, r.org_id, 'declared' AS source,\n               CASE WHEN r.stage_name = 'synth' AND r.step_name = 'synth' THEN 'synth' ELSE r.stage_name || '/' || r.step_name END AS step\n          FROM pipeline_plugin_resolution r\n          JOIN pipelines lp ON lp.id::text = r.pipeline_id AND lp.deleted_at IS NULL\n         WHERE ${declaredMatch}\n        UNION ALL\n        SELECT m.pipeline_id::text, m.org_id, 'deployed', m.stage_name || '/' || m.action_name\n          FROM pipeline_step_manifests m WHERE ${deployedMatch}\n        UNION ALL\n        SELECT e.pipeline_id, e.org_id, 'exposure', NULL\n          FROM plugin_vuln_exposure e WHERE ${exposureMatch} AND e.source = 'deployed' AND e.fixed_at IS NULL\n      ) x\n      LEFT JOIN pipelines p ON p.id::text = x.pipeline_id\n     GROUP BY x.pipeline_id, x.org_id, x.source, p.pipeline_name, p.id, p.deleted_at\n     ORDER BY x.org_id, x.pipeline_id, x.source\n  `));\n  return rows.map((r) => ({\n    pipelineId: r.pipeline_id,\n    pipelineName: r.pipeline_name ?? null,\n    orgId: r.org_id,\n    source: r.source,\n    pipelineDeleted: r.deleted === true,\n    steps: r.steps ?? [],\n  }));\n}\n\n/** Distinct pipelines among `refs` (a pipeline both declared and deployed counts once). */\nexport function distinctPipelines(refs: readonly VersionReference[]): Array<{ pipelineId: string; pipelineName: string | null; orgId: string; sources: string[]; pipelineDeleted: boolean; steps: string[] }> {\n  const byId = new Map<string, { pipelineId: string; pipelineName: string | null; orgId: string; sources: string[]; pipelineDeleted: boolean; steps: string[] }>();\n  for (const r of refs) {\n    const e = byId.get(r.pipelineId) ?? { pipelineId: r.pipelineId, pipelineName: r.pipelineName, orgId: r.orgId, sources: [], pipelineDeleted: r.pipelineDeleted, steps: [] };\n    if (!e.sources.includes(r.source)) e.sources.push(r.source);\n    e.steps = [...new Set([...e.steps, ...r.steps])];\n    byId.set(r.pipelineId, e);\n  }\n  return [...byId.values()];\n}\n\n/**\n * The image digests an org's namespace still needs: every `plugins` row's\n * digest (active, inactive or soft-deleted — a tombstone is restorable until\n * purged, and the purge itself is guarded) plus every digest a pipeline of the\n * org or its teams declares, runs or has an open deployed exposure on. What the\n * image registry's age GC consults before deleting anything in `org-<id>/*`.\n * Elevated read.\n */\nexport async function orgImageDigestsInUse(orgId: string): Promise<string[]> {\n  const org = orgId.toLowerCase();\n  const rows = await withTenantTx((tx) => executeRows<{ d: string }>(tx, sql`\n    SELECT DISTINCT d FROM (\n      SELECT image_digest AS d FROM plugins WHERE lower(org_id) = ${org} AND image_digest IS NOT NULL\n      UNION SELECT r.resolved_digest FROM pipeline_plugin_resolution r\n              WHERE r.resolved_digest IS NOT NULL AND (lower(r.org_id) = ${org} OR lower(r.root_org_id) = ${org})\n      UNION SELECT m.image_digest FROM pipeline_step_manifests m\n              WHERE m.image_digest IS NOT NULL AND m.image_digest IN (SELECT image_digest FROM plugins WHERE lower(org_id) = ${org} AND image_digest IS NOT NULL)\n      UNION SELECT m.image_digest FROM pipeline_step_manifests m WHERE m.image_digest IS NOT NULL AND lower(m.org_id) = ${org}\n      UNION SELECT e.image_digest FROM plugin_vuln_exposure e\n              WHERE e.image_digest IS NOT NULL AND e.source = 'deployed' AND e.fixed_at IS NULL AND lower(e.org_id) = ${org}\n    ) x WHERE d IS NOT NULL\n  `));\n  return rows.map((r) => r.d);\n}\n"]}

package/lib/core/query-filters.d.ts

@@ -117,9 +117,9 @@ export interface PluginFilter extends CommonFilter {
     /** Exclude yanked versions (resolution without a version spec). Internal. */
     readonly excludeYanked?: boolean;
     /**
-     * Exclude versions the nightly rescan flagged (`scan_flagged_at` set) —
-     * resolution of a range / the default while `PLUGIN_BLOCK_ON_NEW_CRITICAL`
-     * is on. Internal.
+     * Exclude versions the nightly rescan flagged (`scan_flagged_at` set) — the
+     * lookup's "newest unflagged version to move to" suggestion. Never applied to
+     * what a reference RESOLVES to: vulnerability state does not skip versions. Internal.
      */
     readonly excludeScanFlagged?: boolean;
     /**

package/lib/core/query-filters.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-filters.js","sourceRoot":"","sources":["../../src/core/query-filters.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Visibility } from '@pipeline-builder/api-core';\n\n/**\n * Base filter interface containing common filter properties shared across all entity types.\n *\n * @example\n * ```typescript\n * const filter: CommonFilter = {\n *   id: '123',\n *   orgId: 'my-org',\n *   visibility: 'public',\n *   isDefault: true,\n *   isActive: true\n * };\n * ```\n */\nexport interface CommonFilter {\n  /**\n   * Unique identifier for the entity\n   * Can be a single ID or array of IDs for batch filtering\n   */\n  readonly id?: string | string[];\n\n  // --- Viewer context (server-set, NEVER client-supplied) ---------------------\n  // Only entities whose visibility predicate has a PER-USER rung read these —\n  // pipeline templates (`private` is author-only) and messages (a per-user\n  // targeted row is visible only to its target). Their services stamp them from\n  // the request's `TenantContext` via `withViewerContext`, so no route or query\n  // string can inject them. Everything else ignores them.\n  //\n  // Both fail CLOSED when absent: no viewer means the per-user rung matches\n  // NOTHING, never everything.\n\n  /** Caller's user id, matched against the entity's per-user column. */\n  readonly viewerUserId?: string;\n  /** Whether the caller is a platform super-admin (sees every rung). */\n  readonly viewerIsSuperAdmin?: boolean;\n\n  /**\n   * Organization identifier to filter entities by organization\n   * Can be a single org ID or array for multi-org filtering\n   */\n  readonly orgId?: string | string[];\n\n  /**\n   * Narrow to one rung of the shared three-rung sharing ladder. Applied WITHIN\n   * what the caller can already see — never widens it.\n   * @see Visibility\n   */\n  readonly visibility?: Visibility | string;\n\n  /**\n   * Filter by default status\n   * - true: Only default entities\n   * - false: Only non-default entities\n   * - undefined: All entities\n   */\n  readonly isDefault?: boolean;\n\n  /**\n   * Filter by active/inactive status\n   * - true: Only active entities\n   * - false: Only inactive entities\n   * - undefined: All entities\n   */\n  readonly isActive?: boolean;\n\n  /**\n   * Number of results to return\n   * @minimum 1\n   * @maximum 1000\n   */\n  readonly limit?: number;\n\n  /**\n   * Number of results to skip (for pagination)\n   * @minimum 0\n   */\n  readonly offset?: number;\n\n  /**\n   * Sort field and direction\n   * @example \"name:asc\", \"createdAt:desc\"\n   */\n  readonly sort?: string;\n\n  /**\n   * Filter by catalog owner (developer-portal \"my services\" view).\n   * Matches the entity's `ownerId` exactly (a user id or team id).\n   * Only applied by builders for entities that carry an owner column\n   * (pipelines, plugins); ignored elsewhere.\n   */\n  readonly ownerId?: string;\n\n  /**\n   * Filter by lifecycle stage (experimental | production | deprecated).\n   * Only applied by builders for entities that carry a lifecycle column.\n   */\n  readonly lifecycle?: string;\n}\n\n/**\n * Filter interface for plugin-specific properties.\n * Extends CommonFilter to include plugin-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PluginFilter = {\n *   name: 'nodejs-build',\n *   version: '1.0.0',\n *   isActive: true\n * };\n * ```\n */\nexport interface PluginFilter extends CommonFilter {\n  /**\n   * Plugin name to filter by\n   */\n  readonly name?: string;\n\n  /**\n   * How `name` matches: `contains` (default — case-insensitive substring, for\n   * list/search) or `exact` (resolution — the lookup path). Internal: not in\n   * the public filter schema.\n   */\n  readonly nameMatch?: 'exact' | 'contains';\n\n  /**\n   * Publisher handle of an installed listing to resolve through.\n   * Lookup only: a `plugins` row query ignores it (the resolver routes a\n   * qualified reference to the listing, never to an org's own rows).\n   */\n  readonly publisher?: string;\n\n  /**\n   * Plugin version spec: exact (`1.2.3`), caret (`^1.2.3`), tilde (`~1.2.3`),\n   * partial (`1`, `1.2`, `1.x`) or `latest` — see semver-range.ts. A range never\n   * matches a yanked version.\n   * @example \"1.0.0\", \"^2.0.0\", \"~1.2.3\", \"latest\"\n   */\n  readonly version?: string;\n\n  /** Exclude yanked versions (resolution without a version spec). Internal. */\n  readonly excludeYanked?: boolean;\n\n  /**\n   * Exclude versions the nightly rescan flagged (`scan_flagged_at` set) —\n   * resolution of a range / the default while `PLUGIN_BLOCK_ON_NEW_CRITICAL`\n   * is on. Internal.\n   */\n  readonly excludeScanFlagged?: boolean;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n\n  /**\n   * Plugin category to filter by\n   * @example \"language\", \"security\", \"testing\"\n   */\n  readonly category?: string;\n}\n\n/**\n * Filter interface for pipeline-specific properties.\n * Extends CommonFilter to include pipeline-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PipelineFilter = {\n *   project: 'my-app',\n *   organization: 'my-org',\n *   pipelineName: 'my-pipeline',\n *   isActive: true\n * };\n * ```\n */\nexport interface PipelineFilter extends CommonFilter {\n  /**\n   * Project name associated with the pipeline\n   */\n  readonly project?: string;\n\n  /**\n   * Organization name associated with the pipeline\n   */\n  readonly organization?: string;\n\n  /**\n   * Pipeline name to filter by\n   */\n  readonly pipelineName?: string;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n}\n\n/** Filter interface for pipeline-template queries (golden-path catalog). */\nexport interface PipelineTemplateFilter extends CommonFilter {\n  /** Template name (case-insensitive contains). */\n  readonly name?: string;\n  /** Category to filter by (e.g. 'language', 'general'). */\n  readonly category?: string;\n  /** Keyword search within the keywords JSONB array. */\n  readonly keyword?: string;\n  // Sharing rung + viewer context are inherited from CommonFilter.\n}\n\n/**\n * Filter interface for message-specific properties.\n * Extends CommonFilter to include message-related filter options.\n */\nexport interface MessageFilter extends CommonFilter {\n  /**\n   * Thread ID to filter by (for fetching thread replies).\n   * Pass `null` to filter for root messages only (threadId IS NULL).\n   */\n  readonly threadId?: string | null;\n\n  /**\n   * Recipient organization ID to filter by\n   * Use '*' for broadcast announcements\n   */\n  readonly recipientOrgId?: string;\n\n  /**\n   * Recipient user ID to filter by (per-user targeting within the recipient\n   * org). Pass `null` to match org-wide messages only (recipient_user_id IS\n   * NULL). Rarely set directly by callers — see `viewerUserId` for the\n   * visibility-scoping variant.\n   */\n  readonly recipientUserId?: string | null;\n\n  // NOTE: the VIEWER's user id (`viewerUserId`) is inherited from CommonFilter.\n  // For messages it is NOT a column filter: when present, the recipient-side\n  // branch in `buildMessageConditions` widens to include rows targeted at this\n  // user (recipient_user_id = viewerUserId) ALONGSIDE org-wide ones\n  // (recipient_user_id IS NULL). When absent, only org-wide recipient rows are\n  // visible, so a user-targeted message stays private to its target, the sender,\n  // and the system org. MessageService stamps it from the tenant context.\n\n  /**\n   * Message type filter\n   */\n  readonly messageType?: 'announcement' | 'conversation';\n\n  /**\n   * Filter by priority level\n   */\n  readonly priority?: 'normal' | 'high' | 'urgent';\n\n  /**\n   * Channel/inbox-bucket filter (e.g. 'support', 'help'). Matches rows\n   * exactly; pass null to match channel IS NULL (org-to-org messages).\n   */\n  readonly channel?: string | null;\n\n  /**\n   * Filter by read state for the requesting org.\n   * Implemented as a JSONB key-existence check against `messages.read_by`\n   * (a `{ [orgId]: isoTimestamp }` map), using the orgId passed to\n   * `buildMessageConditions`.\n   * - true  → only messages the org has read (orgId key exists in read_by)\n   * - false → only messages the org has NOT read\n   * - undefined → no read-state filter\n   */\n  readonly isRead?: boolean;\n\n  /**\n   * Free-text inbox search. Case-insensitive substring match against the\n   * message `subject` OR `content` (LIKE wildcards in the term are escaped, so a\n   * literal `%`/`_` matches itself). Applied on top of the visibility scope, so\n   * it never widens what the caller can see.\n   */\n  readonly search?: string;\n}\n\n// ========================================\n// Compliance Filters\n// ========================================\n\n/**\n * Filter for compliance policies.\n */\nexport interface CompliancePolicyFilter extends CommonFilter {\n  readonly name?: string;\n  readonly isTemplate?: boolean;\n}\n\n/**\n * Filter for compliance rules.\n */\nexport interface ComplianceRuleFilter extends CommonFilter {\n  readonly name?: string;\n  readonly policyId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly field?: string;\n  readonly severity?: 'warning' | 'error' | 'critical';\n  readonly scope?: 'org' | 'published';\n  readonly tag?: string;\n}\n\n/**\n * Filter for compliance exemptions.\n */\nexport interface ComplianceExemptionFilter {\n  readonly orgId?: string;\n  readonly ruleId?: string;\n  readonly entityType?: 'plugin' | 'pipeline';\n  readonly entityId?: string;\n  readonly status?: 'pending' | 'approved' | 'rejected' | 'expired';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance audit log entries.\n */\nexport interface ComplianceAuditFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly action?: string;\n  readonly result?: 'pass' | 'warn' | 'block';\n  readonly scanId?: string;\n  readonly dateFrom?: string;\n  readonly dateTo?: string;\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance scans.\n */\nexport interface ComplianceScanFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline' | 'all';\n  readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';\n  readonly triggeredBy?: 'manual' | 'scheduled' | 'rule-change' | 'rule-dry-run';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-filters.js","sourceRoot":"","sources":["../../src/core/query-filters.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Visibility } from '@pipeline-builder/api-core';\n\n/**\n * Base filter interface containing common filter properties shared across all entity types.\n *\n * @example\n * ```typescript\n * const filter: CommonFilter = {\n *   id: '123',\n *   orgId: 'my-org',\n *   visibility: 'public',\n *   isDefault: true,\n *   isActive: true\n * };\n * ```\n */\nexport interface CommonFilter {\n  /**\n   * Unique identifier for the entity\n   * Can be a single ID or array of IDs for batch filtering\n   */\n  readonly id?: string | string[];\n\n  // --- Viewer context (server-set, NEVER client-supplied) ---------------------\n  // Only entities whose visibility predicate has a PER-USER rung read these —\n  // pipeline templates (`private` is author-only) and messages (a per-user\n  // targeted row is visible only to its target). Their services stamp them from\n  // the request's `TenantContext` via `withViewerContext`, so no route or query\n  // string can inject them. Everything else ignores them.\n  //\n  // Both fail CLOSED when absent: no viewer means the per-user rung matches\n  // NOTHING, never everything.\n\n  /** Caller's user id, matched against the entity's per-user column. */\n  readonly viewerUserId?: string;\n  /** Whether the caller is a platform super-admin (sees every rung). */\n  readonly viewerIsSuperAdmin?: boolean;\n\n  /**\n   * Organization identifier to filter entities by organization\n   * Can be a single org ID or array for multi-org filtering\n   */\n  readonly orgId?: string | string[];\n\n  /**\n   * Narrow to one rung of the shared three-rung sharing ladder. Applied WITHIN\n   * what the caller can already see — never widens it.\n   * @see Visibility\n   */\n  readonly visibility?: Visibility | string;\n\n  /**\n   * Filter by default status\n   * - true: Only default entities\n   * - false: Only non-default entities\n   * - undefined: All entities\n   */\n  readonly isDefault?: boolean;\n\n  /**\n   * Filter by active/inactive status\n   * - true: Only active entities\n   * - false: Only inactive entities\n   * - undefined: All entities\n   */\n  readonly isActive?: boolean;\n\n  /**\n   * Number of results to return\n   * @minimum 1\n   * @maximum 1000\n   */\n  readonly limit?: number;\n\n  /**\n   * Number of results to skip (for pagination)\n   * @minimum 0\n   */\n  readonly offset?: number;\n\n  /**\n   * Sort field and direction\n   * @example \"name:asc\", \"createdAt:desc\"\n   */\n  readonly sort?: string;\n\n  /**\n   * Filter by catalog owner (developer-portal \"my services\" view).\n   * Matches the entity's `ownerId` exactly (a user id or team id).\n   * Only applied by builders for entities that carry an owner column\n   * (pipelines, plugins); ignored elsewhere.\n   */\n  readonly ownerId?: string;\n\n  /**\n   * Filter by lifecycle stage (experimental | production | deprecated).\n   * Only applied by builders for entities that carry a lifecycle column.\n   */\n  readonly lifecycle?: string;\n}\n\n/**\n * Filter interface for plugin-specific properties.\n * Extends CommonFilter to include plugin-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PluginFilter = {\n *   name: 'nodejs-build',\n *   version: '1.0.0',\n *   isActive: true\n * };\n * ```\n */\nexport interface PluginFilter extends CommonFilter {\n  /**\n   * Plugin name to filter by\n   */\n  readonly name?: string;\n\n  /**\n   * How `name` matches: `contains` (default — case-insensitive substring, for\n   * list/search) or `exact` (resolution — the lookup path). Internal: not in\n   * the public filter schema.\n   */\n  readonly nameMatch?: 'exact' | 'contains';\n\n  /**\n   * Publisher handle of an installed listing to resolve through.\n   * Lookup only: a `plugins` row query ignores it (the resolver routes a\n   * qualified reference to the listing, never to an org's own rows).\n   */\n  readonly publisher?: string;\n\n  /**\n   * Plugin version spec: exact (`1.2.3`), caret (`^1.2.3`), tilde (`~1.2.3`),\n   * partial (`1`, `1.2`, `1.x`) or `latest` — see semver-range.ts. A range never\n   * matches a yanked version.\n   * @example \"1.0.0\", \"^2.0.0\", \"~1.2.3\", \"latest\"\n   */\n  readonly version?: string;\n\n  /** Exclude yanked versions (resolution without a version spec). Internal. */\n  readonly excludeYanked?: boolean;\n\n  /**\n   * Exclude versions the nightly rescan flagged (`scan_flagged_at` set) — the\n   * lookup's \"newest unflagged version to move to\" suggestion. Never applied to\n   * what a reference RESOLVES to: vulnerability state does not skip versions. Internal.\n   */\n  readonly excludeScanFlagged?: boolean;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n\n  /**\n   * Plugin category to filter by\n   * @example \"language\", \"security\", \"testing\"\n   */\n  readonly category?: string;\n}\n\n/**\n * Filter interface for pipeline-specific properties.\n * Extends CommonFilter to include pipeline-related filter options.\n *\n * @example\n * ```typescript\n * const filter: PipelineFilter = {\n *   project: 'my-app',\n *   organization: 'my-org',\n *   pipelineName: 'my-pipeline',\n *   isActive: true\n * };\n * ```\n */\nexport interface PipelineFilter extends CommonFilter {\n  /**\n   * Project name associated with the pipeline\n   */\n  readonly project?: string;\n\n  /**\n   * Organization name associated with the pipeline\n   */\n  readonly organization?: string;\n\n  /**\n   * Pipeline name to filter by\n   */\n  readonly pipelineName?: string;\n\n  /**\n   * Keyword to search within the keywords JSONB array (case-insensitive contains)\n   */\n  readonly keyword?: string;\n}\n\n/** Filter interface for pipeline-template queries (golden-path catalog). */\nexport interface PipelineTemplateFilter extends CommonFilter {\n  /** Template name (case-insensitive contains). */\n  readonly name?: string;\n  /** Category to filter by (e.g. 'language', 'general'). */\n  readonly category?: string;\n  /** Keyword search within the keywords JSONB array. */\n  readonly keyword?: string;\n  // Sharing rung + viewer context are inherited from CommonFilter.\n}\n\n/**\n * Filter interface for message-specific properties.\n * Extends CommonFilter to include message-related filter options.\n */\nexport interface MessageFilter extends CommonFilter {\n  /**\n   * Thread ID to filter by (for fetching thread replies).\n   * Pass `null` to filter for root messages only (threadId IS NULL).\n   */\n  readonly threadId?: string | null;\n\n  /**\n   * Recipient organization ID to filter by\n   * Use '*' for broadcast announcements\n   */\n  readonly recipientOrgId?: string;\n\n  /**\n   * Recipient user ID to filter by (per-user targeting within the recipient\n   * org). Pass `null` to match org-wide messages only (recipient_user_id IS\n   * NULL). Rarely set directly by callers — see `viewerUserId` for the\n   * visibility-scoping variant.\n   */\n  readonly recipientUserId?: string | null;\n\n  // NOTE: the VIEWER's user id (`viewerUserId`) is inherited from CommonFilter.\n  // For messages it is NOT a column filter: when present, the recipient-side\n  // branch in `buildMessageConditions` widens to include rows targeted at this\n  // user (recipient_user_id = viewerUserId) ALONGSIDE org-wide ones\n  // (recipient_user_id IS NULL). When absent, only org-wide recipient rows are\n  // visible, so a user-targeted message stays private to its target, the sender,\n  // and the system org. MessageService stamps it from the tenant context.\n\n  /**\n   * Message type filter\n   */\n  readonly messageType?: 'announcement' | 'conversation';\n\n  /**\n   * Filter by priority level\n   */\n  readonly priority?: 'normal' | 'high' | 'urgent';\n\n  /**\n   * Channel/inbox-bucket filter (e.g. 'support', 'help'). Matches rows\n   * exactly; pass null to match channel IS NULL (org-to-org messages).\n   */\n  readonly channel?: string | null;\n\n  /**\n   * Filter by read state for the requesting org.\n   * Implemented as a JSONB key-existence check against `messages.read_by`\n   * (a `{ [orgId]: isoTimestamp }` map), using the orgId passed to\n   * `buildMessageConditions`.\n   * - true  → only messages the org has read (orgId key exists in read_by)\n   * - false → only messages the org has NOT read\n   * - undefined → no read-state filter\n   */\n  readonly isRead?: boolean;\n\n  /**\n   * Free-text inbox search. Case-insensitive substring match against the\n   * message `subject` OR `content` (LIKE wildcards in the term are escaped, so a\n   * literal `%`/`_` matches itself). Applied on top of the visibility scope, so\n   * it never widens what the caller can see.\n   */\n  readonly search?: string;\n}\n\n// ========================================\n// Compliance Filters\n// ========================================\n\n/**\n * Filter for compliance policies.\n */\nexport interface CompliancePolicyFilter extends CommonFilter {\n  readonly name?: string;\n  readonly isTemplate?: boolean;\n}\n\n/**\n * Filter for compliance rules.\n */\nexport interface ComplianceRuleFilter extends CommonFilter {\n  readonly name?: string;\n  readonly policyId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly field?: string;\n  readonly severity?: 'warning' | 'error' | 'critical';\n  readonly scope?: 'org' | 'published';\n  readonly tag?: string;\n}\n\n/**\n * Filter for compliance exemptions.\n */\nexport interface ComplianceExemptionFilter {\n  readonly orgId?: string;\n  readonly ruleId?: string;\n  readonly entityType?: 'plugin' | 'pipeline';\n  readonly entityId?: string;\n  readonly status?: 'pending' | 'approved' | 'rejected' | 'expired';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance audit log entries.\n */\nexport interface ComplianceAuditFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline';\n  readonly action?: string;\n  readonly result?: 'pass' | 'warn' | 'block';\n  readonly scanId?: string;\n  readonly dateFrom?: string;\n  readonly dateTo?: string;\n  readonly limit?: number;\n  readonly offset?: number;\n}\n\n/**\n * Filter for compliance scans.\n */\nexport interface ComplianceScanFilter {\n  readonly orgId?: string;\n  readonly target?: 'plugin' | 'pipeline' | 'all';\n  readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';\n  readonly triggeredBy?: 'manual' | 'scheduled' | 'rule-change' | 'rule-dry-run';\n  readonly limit?: number;\n  readonly offset?: number;\n}\n"]}