@pipeline-builder/pipeline-data 0.0.1

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,124 @@
+// 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, closeLeaderLock } 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,
+    });
+    const scheduler = 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 } } : {}),
+    });
+    if (!lock)
+        return scheduler;
+    // Own the leader-lock Redis client's lifecycle: `stop()` (wired to the
+    // service's runServer onShutdown) also closes the connection so it can't keep
+    // the process from exiting cleanly. Per-cycle lock acquire/release is handled
+    // by withLeaderLock; this is just connection teardown.
+    return {
+        start: () => scheduler.start(),
+        stop: () => { scheduler.stop(); void closeLeaderLock(lock); },
+    };
+}
+//# 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, closeLeaderLock, 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  const scheduler = 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  if (!lock) return scheduler;\n\n  // Own the leader-lock Redis client's lifecycle: `stop()` (wired to the\n  // service's runServer onShutdown) also closes the connection so it can't keep\n  // the process from exiting cleanly. Per-cycle lock acquire/release is handled\n  // by withLeaderLock; this is just connection teardown.\n  return {\n    start: () => scheduler.start(),\n    stop: () => { scheduler.stop(); void closeLeaderLock(lock); },\n  };\n}\n"]}

package/lib/api/viewer-context.d.ts

@@ -0,0 +1,29 @@
+/** The viewer fields a per-user predicate reads off a filter. */
+export interface ViewerScopedFilter {
+    /** Caller's user id. Compared against the row's per-user column. */
+    readonly viewerUserId?: string;
+    /** Whether the caller is a platform super-admin (sees every rung). */
+    readonly viewerIsSuperAdmin?: boolean;
+}
+/** The current request's user id, or `undefined` outside a tenant scope. */
+export declare function currentViewerUserId(): string | undefined;
+/**
+ * Stamp the request's viewer identity onto a filter.
+ *
+ * An EXPLICIT value on the filter always wins, so a caller that deliberately
+ * scopes to a specific user (or a test that fixes the viewer) stays expressible;
+ * the context only fills what the caller left blank.
+ *
+ * Safe against `CrudService.runRead`'s sysadmin widening (the parent-org read
+ * path, which re-enters the context with `isSuperAdmin: true`): conditions are
+ * always built BEFORE that scope is entered, so the stamp reflects the real
+ * caller, never the widened one.
+ *
+ * @example
+ * ```typescript
+ * protected buildConditions(filter, orgId, parentOrgId) {
+ *   return buildXConditions(withViewerContext(filter), orgId, parentOrgId);
+ * }
+ * ```
+ */
+export declare function withViewerContext<F extends ViewerScopedFilter>(filter: Partial<F>): Partial<F>;

package/lib/api/viewer-context.js

@@ -0,0 +1,63 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Viewer identity for app-layer predicates that carry a PER-USER rung.
+ *
+ * Most visibility predicates are org-grained, which RLS and the shared
+ * access-control builder already express. Two entities need finer grain:
+ *
+ *  - **pipeline templates** — the `private` rung is author-only (`created_by`)
+ *  - **messages** — a per-user targeted row (`recipient_user_id`) is visible
+ *    only to its target, not to everyone in the recipient org
+ *
+ * Both need to know WHO is asking, and neither can get it from `CrudService`'s
+ * signatures: `writeConditions` (update/delete) builds the read clause from a
+ * bare `{ id }` filter and has nowhere to pass a viewer. Hand-threading the
+ * viewer through every call site is the alternative, and it fails in practice —
+ * it produces parallel `find*Visible*` methods and silently drops the viewer at
+ * whichever call site forgets it (an org member then reads a row addressed to
+ * someone else).
+ *
+ * So the viewer travels the same trusted, request-scoped channel as the org
+ * stamp: `TenantContext`, set once at the request boundary from the validated
+ * JWT. A service opts in by stamping it in ONE place — its `buildConditions`
+ * override, which every read and write funnels through, including direct
+ * `this.buildConditions(...)` calls.
+ *
+ * Fails CLOSED everywhere: no tenant scope (background jobs, migrations, the
+ * retention sweep) means no viewer, and a viewer-less predicate must match
+ * nothing on the per-user rung rather than matching everything.
+ */
+import { getTenantContext } from '../database/tenancy.js';
+/** The current request's user id, or `undefined` outside a tenant scope. */
+export function currentViewerUserId() {
+    return getTenantContext()?.userId;
+}
+/**
+ * Stamp the request's viewer identity onto a filter.
+ *
+ * An EXPLICIT value on the filter always wins, so a caller that deliberately
+ * scopes to a specific user (or a test that fixes the viewer) stays expressible;
+ * the context only fills what the caller left blank.
+ *
+ * Safe against `CrudService.runRead`'s sysadmin widening (the parent-org read
+ * path, which re-enters the context with `isSuperAdmin: true`): conditions are
+ * always built BEFORE that scope is entered, so the stamp reflects the real
+ * caller, never the widened one.
+ *
+ * @example
+ * ```typescript
+ * protected buildConditions(filter, orgId, parentOrgId) {
+ *   return buildXConditions(withViewerContext(filter), orgId, parentOrgId);
+ * }
+ * ```
+ */
+export function withViewerContext(filter) {
+    const ctx = getTenantContext();
+    return {
+        ...filter,
+        viewerUserId: filter.viewerUserId ?? ctx?.userId,
+        viewerIsSuperAdmin: filter.viewerIsSuperAdmin ?? ctx?.isSuperAdmin ?? false,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,263 @@
+import type { Visibility } from '@pipeline-builder/api-core';
+/**
+ * Base filter interface containing common filter properties shared across all entity types.
+ *
+ * @example
+ * ```typescript
+ * const filter: CommonFilter = {
+ *   id: '123',
+ *   orgId: 'my-org',
+ *   visibility: 'public',
+ *   isDefault: true,
+ *   isActive: true
+ * };
+ * ```
+ */
+export interface CommonFilter {
+    /**
+     * Unique identifier for the entity
+     * Can be a single ID or array of IDs for batch filtering
+     */
+    readonly id?: string | string[];
+    /** Caller's user id, matched against the entity's per-user column. */
+    readonly viewerUserId?: string;
+    /** Whether the caller is a platform super-admin (sees every rung). */
+    readonly viewerIsSuperAdmin?: boolean;
+    /**
+     * Organization identifier to filter entities by organization
+     * Can be a single org ID or array for multi-org filtering
+     */
+    readonly orgId?: string | string[];
+    /**
+     * Narrow to one rung of the shared three-rung sharing ladder. Applied WITHIN
+     * what the caller can already see — never widens it.
+     * @see Visibility
+     */
+    readonly visibility?: Visibility | string;
+    /**
+     * Filter by default status
+     * - true: Only default entities
+     * - false: Only non-default entities
+     * - undefined: All entities
+     */
+    readonly isDefault?: boolean;
+    /**
+     * Filter by active/inactive status
+     * - true: Only active entities
+     * - false: Only inactive entities
+     * - undefined: All entities
+     */
+    readonly isActive?: boolean;
+    /**
+     * Number of results to return
+     * @minimum 1
+     * @maximum 1000
+     */
+    readonly limit?: number;
+    /**
+     * Number of results to skip (for pagination)
+     * @minimum 0
+     */
+    readonly offset?: number;
+    /**
+     * Sort field and direction
+     * @example "name:asc", "createdAt:desc"
+     */
+    readonly sort?: string;
+    /**
+     * Filter by catalog owner (developer-portal "my services" view).
+     * Matches the entity's `ownerId` exactly (a user id or team id).
+     * Only applied by builders for entities that carry an owner column
+     * (pipelines, plugins); ignored elsewhere.
+     */
+    readonly ownerId?: string;
+    /**
+     * Filter by lifecycle stage (experimental | production | deprecated).
+     * Only applied by builders for entities that carry a lifecycle column.
+     */
+    readonly lifecycle?: string;
+}
+/**
+ * Filter interface for plugin-specific properties.
+ * Extends CommonFilter to include plugin-related filter options.
+ *
+ * @example
+ * ```typescript
+ * const filter: PluginFilter = {
+ *   name: 'nodejs-build',
+ *   version: '1.0.0',
+ *   isActive: true
+ * };
+ * ```
+ */
+export interface PluginFilter extends CommonFilter {
+    /**
+     * Plugin name to filter by
+     */
+    readonly name?: string;
+    /**
+     * Plugin version to filter by
+     * Supports semantic versioning
+     * @example "1.0.0", "^2.0.0", "~1.2.3"
+     */
+    readonly version?: string;
+    /**
+     * Keyword to search within the keywords JSONB array (case-insensitive contains)
+     */
+    readonly keyword?: string;
+    /**
+     * Plugin category to filter by
+     * @example "language", "security", "testing"
+     */
+    readonly category?: string;
+}
+/**
+ * Filter interface for pipeline-specific properties.
+ * Extends CommonFilter to include pipeline-related filter options.
+ *
+ * @example
+ * ```typescript
+ * const filter: PipelineFilter = {
+ *   project: 'my-app',
+ *   organization: 'my-org',
+ *   pipelineName: 'my-pipeline',
+ *   isActive: true
+ * };
+ * ```
+ */
+export interface PipelineFilter extends CommonFilter {
+    /**
+     * Project name associated with the pipeline
+     */
+    readonly project?: string;
+    /**
+     * Organization name associated with the pipeline
+     */
+    readonly organization?: string;
+    /**
+     * Pipeline name to filter by
+     */
+    readonly pipelineName?: string;
+    /**
+     * Keyword to search within the keywords JSONB array (case-insensitive contains)
+     */
+    readonly keyword?: string;
+}
+/** Filter interface for pipeline-template queries (golden-path catalog). */
+export interface PipelineTemplateFilter extends CommonFilter {
+    /** Template name (case-insensitive contains). */
+    readonly name?: string;
+    /** Category to filter by (e.g. 'language', 'general'). */
+    readonly category?: string;
+    /** Keyword search within the keywords JSONB array. */
+    readonly keyword?: string;
+}
+/**
+ * Filter interface for message-specific properties.
+ * Extends CommonFilter to include message-related filter options.
+ */
+export interface MessageFilter extends CommonFilter {
+    /**
+     * Thread ID to filter by (for fetching thread replies).
+     * Pass `null` to filter for root messages only (threadId IS NULL).
+     */
+    readonly threadId?: string | null;
+    /**
+     * Recipient organization ID to filter by
+     * Use '*' for broadcast announcements
+     */
+    readonly recipientOrgId?: string;
+    /**
+     * Recipient user ID to filter by (per-user targeting within the recipient
+     * org). Pass `null` to match org-wide messages only (recipient_user_id IS
+     * NULL). Rarely set directly by callers — see `viewerUserId` for the
+     * visibility-scoping variant.
+     */
+    readonly recipientUserId?: string | null;
+    /**
+     * Message type filter
+     */
+    readonly messageType?: 'announcement' | 'conversation';
+    /**
+     * Filter by priority level
+     */
+    readonly priority?: 'normal' | 'high' | 'urgent';
+    /**
+     * Channel/inbox-bucket filter (e.g. 'support', 'help'). Matches rows
+     * exactly; pass null to match channel IS NULL (org-to-org messages).
+     */
+    readonly channel?: string | null;
+    /**
+     * Filter by read state for the requesting org.
+     * Implemented as a JSONB key-existence check against `messages.read_by`
+     * (a `{ [orgId]: isoTimestamp }` map), using the orgId passed to
+     * `buildMessageConditions`.
+     * - true  → only messages the org has read (orgId key exists in read_by)
+     * - false → only messages the org has NOT read
+     * - undefined → no read-state filter
+     */
+    readonly isRead?: boolean;
+    /**
+     * Free-text inbox search. Case-insensitive substring match against the
+     * message `subject` OR `content` (LIKE wildcards in the term are escaped, so a
+     * literal `%`/`_` matches itself). Applied on top of the visibility scope, so
+     * it never widens what the caller can see.
+     */
+    readonly search?: string;
+}
+/**
+ * Filter for compliance policies.
+ */
+export interface CompliancePolicyFilter extends CommonFilter {
+    readonly name?: string;
+    readonly isTemplate?: boolean;
+}
+/**
+ * Filter for compliance rules.
+ */
+export interface ComplianceRuleFilter extends CommonFilter {
+    readonly name?: string;
+    readonly policyId?: string;
+    readonly target?: 'plugin' | 'pipeline';
+    readonly field?: string;
+    readonly severity?: 'warning' | 'error' | 'critical';
+    readonly scope?: 'org' | 'published';
+    readonly tag?: string;
+}
+/**
+ * Filter for compliance exemptions.
+ */
+export interface ComplianceExemptionFilter {
+    readonly orgId?: string;
+    readonly ruleId?: string;
+    readonly entityType?: 'plugin' | 'pipeline';
+    readonly entityId?: string;
+    readonly status?: 'pending' | 'approved' | 'rejected' | 'expired';
+    readonly limit?: number;
+    readonly offset?: number;
+}
+/**
+ * Filter for compliance audit log entries.
+ */
+export interface ComplianceAuditFilter {
+    readonly orgId?: string;
+    readonly target?: 'plugin' | 'pipeline';
+    readonly action?: string;
+    readonly result?: 'pass' | 'warn' | 'block';
+    readonly scanId?: string;
+    readonly dateFrom?: string;
+    readonly dateTo?: string;
+    readonly limit?: number;
+    readonly offset?: number;
+}
+/**
+ * Filter for compliance scans.
+ */
+export interface ComplianceScanFilter {
+    readonly orgId?: string;
+    readonly target?: 'plugin' | 'pipeline' | 'all';
+    readonly status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    readonly triggeredBy?: 'manual' | 'scheduled' | 'rule-change' | 'rule-dry-run';
+    readonly limit?: number;
+    readonly offset?: number;
+}

package/lib/core/query-filters.js

@@ -0,0 +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   * Plugin version to filter by\n   * Supports semantic versioning\n   * @example \"1.0.0\", \"^2.0.0\", \"~1.2.3\"\n   */\n  readonly version?: string;\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"]}