@pipeline-builder/pipeline-data 4.3.2 → 4.3.4

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"]}