@pipeline-builder/pipeline-data 4.1.15 → 4.1.17

package/lib/api/access-control-builder.d.ts

@@ -72,6 +72,18 @@ export interface BaseAccessFilter {
     viewerUserId?: string;
     viewerIsSuperAdmin?: boolean;
 }
+/** Per-entity tuning of {@link AccessControlQueryBuilder}. */
+export interface AccessControlOptions {
+    /**
+     * Whether the SYSTEM org's `public` rung reaches callers in other orgs (and
+     * anonymous callers). Default true: the system org's sample pipelines,
+     * templates and dashboards are visible from every org. Plugins set it false:
+     * since the plugin ecosystem the Official catalog reaches
+     * other orgs only as LISTINGS resolved through installs, never through
+     * `visibility = 'public'` on a `plugins` row.
+     */
+    systemCatalog?: boolean;
+}
 /**
  * Generic access control query builder for multi-tenant entities.
  *
@@ -86,7 +98,8 @@ export interface BaseAccessFilter {
  */
 export declare class AccessControlQueryBuilder<TSchema extends AccessControlSchema, TFilter extends BaseAccessFilter> {
     private schema;
-    constructor(schema: TSchema);
+    private options;
+    constructor(schema: TSchema, options?: AccessControlOptions);
     /**
      * Build the caller's visible slice of a catalog, from the three-rung
      * `visibility` ladder shared by every catalog entity.
@@ -103,6 +116,10 @@ export declare class AccessControlQueryBuilder<TSchema extends AccessControlSche
      * always see everything you are entitled to, or a freshly-created private row
      * would vanish from its own author's listing.
      *
+     * An entity can drop the system-org branch with `systemCatalog: false`
+     * ({@link AccessControlOptions}): plugins do, so a system-org plugin reaches
+     * other orgs only as an Official listing.
+     *
      * An explicit `visibility` filter NARROWS within that set, never widens it —
      * so `?visibility=public` still surfaces the system-org catalog.
      *

package/lib/api/access-control-builder.js

@@ -103,8 +103,10 @@ const NO_ROWS = sql `false`;
  */
 export class AccessControlQueryBuilder {
     schema;
-    constructor(schema) {
+    options;
+    constructor(schema, options = {}) {
         this.schema = schema;
+        this.options = options;
     }
     /**
      * Build the caller's visible slice of a catalog, from the three-rung
@@ -122,6 +124,10 @@ export class AccessControlQueryBuilder {
      * always see everything you are entitled to, or a freshly-created private row
      * would vanish from its own author's listing.
      *
+     * An entity can drop the system-org branch with `systemCatalog: false`
+     * ({@link AccessControlOptions}): plugins do, so a system-org plugin reaches
+     * other orgs only as an Official listing.
+     *
      * An explicit `visibility` filter NARROWS within that set, never widens it —
      * so `?visibility=public` still surfaces the system-org catalog.
      *
@@ -138,8 +144,12 @@ export class AccessControlQueryBuilder {
     buildAccessControl(filter, orgId, parentOrgId) {
         const conditions = [];
         const requested = filter.visibility;
+        const systemCatalog = this.options.systemCatalog !== false;
         if (!orgId) {
-            // No org context — only the system org's public catalog.
+            // No org context — only the system org's public catalog (nothing at all
+            // for an entity without one).
+            if (!systemCatalog)
+                return [NO_ROWS];
             conditions.push(eq(this.schema.orgId, SYSTEM_ORG_ID));
             conditions.push(eq(this.schema.visibility, 'public'));
             // An anonymous caller asking for a narrower rung gets nothing, rather than
@@ -155,11 +165,14 @@ export class AccessControlQueryBuilder {
             ? eq(this.schema.orgId, normalizedOrgId)
             : and(eq(this.schema.orgId, normalizedOrgId), or(ne(this.schema.visibility, 'private'), ownDraftsOnly));
         // Rows from OTHER orgs are only ever visible at the `public` rung.
-        const otherOrgScopes = [eq(this.schema.orgId, SYSTEM_ORG_ID)];
+        const otherOrgScopes = [];
+        if (systemCatalog)
+            otherOrgScopes.push(eq(this.schema.orgId, SYSTEM_ORG_ID));
         if (parentOrgId)
             otherOrgScopes.push(eq(this.schema.orgId, parentOrgId.toLowerCase()));
-        const otherOrgsPublic = and(eq(this.schema.visibility, 'public'), or(...otherOrgScopes));
-        conditions.push(or(ownOrg, otherOrgsPublic));
+        conditions.push(otherOrgScopes.length > 0
+            ? or(ownOrg, and(eq(this.schema.visibility, 'public'), or(...otherOrgScopes)))
+            : ownOrg);
         if (requested !== undefined)
             conditions.push(eq(this.schema.visibility, requested));
         return conditions;
@@ -208,4 +221,4 @@ export class AccessControlQueryBuilder {
         return conditions;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"access-control-builder.js","sourceRoot":"","sources":["../../src/api/access-control-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport { and, eq, ne, or, sql, SQL } from 'drizzle-orm';\nimport type { AnyColumn } from 'drizzle-orm/column';\n\nconst FULL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * Escape SQL LIKE wildcard characters to prevent wildcard injection.\n * Replaces `%` → `\\\\%`, `_` → `\\\\_`, and `\\\\` → `\\\\\\\\`.\n */\nexport function escapeLikeWildcards(str: string): string {\n  return str.replace(/\\\\/g, '\\\\\\\\').replace(/%/g, '\\\\%').replace(/_/g, '\\\\_');\n}\n\n/**\n * Build a condition that checks if a JSONB text array column contains a keyword (case-insensitive).\n * Used for keywords/tags filtering on pipelines, plugins, and compliance rules.\n */\nexport function buildJsonbKeywordCondition(column: AnyColumn, keyword: string): SQL {\n  const escaped = escapeLikeWildcards(keyword.toLowerCase());\n  return sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(${column}) AS el WHERE lower(el) LIKE ${'%' + escaped + '%'})`;\n}\n\n/**\n * Parse boolean filter value from string or boolean\n */\nexport function parseBooleanFilter(value: unknown): boolean {\n  if (typeof value === 'boolean') return value;\n  if (typeof value === 'string') return value === 'true';\n  return Boolean(value);\n}\n\n/**\n * Normalize string filter value to lowercase\n */\nexport function normalizeStringFilter(value: unknown): string {\n  return typeof value === 'string' ? value.toLowerCase() : String(value).toLowerCase();\n}\n\n/**\n * Build an ID predicate with UUID prefix matching.\n *\n * - Full UUID → exact match\n * - Partial UUID → prefix match via `LIKE` (a list-search affordance)\n * - Absent → `null` (no predicate)\n *\n * Standalone so entities that DON'T use {@link AccessControlQueryBuilder}'s\n * access control (e.g. pipeline templates, which carry their own three-rung\n * visibility ladder) still share one id-matching implementation.\n */\nexport function buildIdCondition(idColumn: AnyColumn, id: unknown): SQL | null {\n  if (id === undefined || id === null) return null;\n\n  // `BaseAccessFilter.id` is declared `string | string[]`, so honour the array\n  // form: match ANY of the ids, each with the same exact-vs-prefix semantics as\n  // a single value. `String(['a','b'])` would otherwise produce `LIKE 'a,b%'`\n  // and silently return zero rows — a trap for the first caller to pass one.\n  if (Array.isArray(id)) {\n    const parts = id\n      .map((one) => buildIdCondition(idColumn, one))\n      .filter((c): c is SQL => c !== null);\n    if (parts.length === 0) return null;\n    return parts.length === 1 ? parts[0] : (or(...parts) as SQL);\n  }\n\n  const idString = String(id).toLowerCase();\n  if (FULL_UUID.test(idString)) {\n    return eq(idColumn, idString);\n  }\n  // Escape SQL LIKE wildcards to prevent wildcard injection\n  const escaped = escapeLikeWildcards(idString);\n  return sql`${idColumn}::text LIKE ${escaped + '%'} ESCAPE '\\\\'`;\n}\n\n/**\n * Build the `isDefault` / `isActive` predicates shared by every catalog entity.\n * `isActive` defaults to true so soft-deleted rows stay out of normal reads.\n * Standalone for the same reason as {@link buildIdCondition}.\n */\nexport function buildBooleanConditions(\n  columns: { isDefault: AnyColumn; isActive: AnyColumn },\n  filter: { isDefault?: unknown; isActive?: unknown },\n): SQL[] {\n  const conditions: SQL[] = [];\n\n  if (filter.isDefault !== undefined) {\n    conditions.push(eq(columns.isDefault, parseBooleanFilter(filter.isDefault)));\n  }\n\n  if (filter.isActive !== undefined) {\n    conditions.push(eq(columns.isActive, parseBooleanFilter(filter.isActive)));\n  } else {\n    // Default to active records only to exclude soft-deleted entities\n    conditions.push(eq(columns.isActive, true));\n  }\n\n  return conditions;\n}\n\n/**\n * Schema table interface for access control queries. Every catalog entity\n * carries the same five columns, which is what lets ONE predicate serve\n * pipelines, plugins and templates alike.\n */\nexport interface AccessControlSchema {\n  id: AnyColumn;\n  orgId: AnyColumn;\n  /** Three-rung sharing ladder — see api-core's `Visibility`. */\n  visibility: AnyColumn;\n  /** Author. Owns the `private` rung. */\n  createdBy: AnyColumn;\n  isDefault: AnyColumn;\n  isActive: AnyColumn;\n}\n\n/**\n * Base filter interface with common access control fields.\n *\n * `viewerUserId` / `viewerIsSuperAdmin` are SERVER-SET (stamped from the request's\n * tenant context by `withViewerContext`), never client-supplied — see\n * `viewer-context.ts` for why the tenant context is the channel.\n */\nexport interface BaseAccessFilter {\n  id?: string | string[];\n  visibility?: string;\n  isDefault?: boolean | string;\n  isActive?: boolean | string;\n  viewerUserId?: string;\n  viewerIsSuperAdmin?: boolean;\n}\n\n/** Fail-closed predicate: matches no rows. */\nconst NO_ROWS: SQL = sql`false`;\n\n/**\n * Generic access control query builder for multi-tenant entities.\n *\n * Consolidates duplicate access control logic shared across pipeline and plugin queries.\n * Handles:\n * - Multi-tenant access control (public/private/org-and-public)\n * - UUID prefix matching for ID filters\n * - Boolean field normalization\n *\n * @typeParam TSchema - Schema table type with access control fields\n * @typeParam TFilter - Filter type extending BaseAccessFilter\n */\nexport class AccessControlQueryBuilder<\n  TSchema extends AccessControlSchema,\n  TFilter extends BaseAccessFilter,\n> {\n  constructor(\n    private schema: TSchema,\n  ) {}\n\n  /**\n   * Build the caller's visible slice of a catalog, from the three-rung\n   * `visibility` ladder shared by every catalog entity.\n   *\n   * Effective read set for a caller in org `O` as user `V` whose parent org is `P`:\n   *\n   *   (org_id = O AND (visibility <> 'private' OR created_by = V))\n   *   OR (visibility = 'public' AND (org_id = 'system' OR org_id = P))\n   *\n   * i.e. your own org's shared rungs plus your own drafts, widened by the system\n   * org's public catalog (the standing \"system-org content is visible from every\n   * org\" rule) and — for a team — its parent's public rows. The `public`-only\n   * restriction applies solely to those OTHER orgs' rows; within your own org you\n   * always see everything you are entitled to, or a freshly-created private row\n   * would vanish from its own author's listing.\n   *\n   * An explicit `visibility` filter NARROWS within that set, never widens it —\n   * so `?visibility=public` still surfaces the system-org catalog.\n   *\n   * Fails CLOSED on both axes: no `orgId` (anonymous) ⇒ system-org public only;\n   * no `viewerUserId` ⇒ the private rung matches nothing rather than everything.\n   * `viewerIsSuperAdmin` lifts the private rung only — a platform operator\n   * administers the whole catalog.\n   *\n   * @param filter - Filter criteria\n   * @param orgId - User's organization ID (optional)\n   * @param parentOrgId - Parent org ID when the caller is a team (optional)\n   * @returns Array of SQL conditions for access control\n   */\n  protected buildAccessControl(filter: Partial<TFilter>, orgId?: string, parentOrgId?: string): SQL[] {\n    const conditions: SQL[] = [];\n    const requested = filter.visibility;\n\n    if (!orgId) {\n      // No org context — only the system org's public catalog.\n      conditions.push(eq(this.schema.orgId, SYSTEM_ORG_ID));\n      conditions.push(eq(this.schema.visibility, 'public'));\n      // An anonymous caller asking for a narrower rung gets nothing, rather than\n      // having the narrowing silently ignored.\n      if (requested !== undefined && requested !== 'public') conditions.push(NO_ROWS);\n      return conditions;\n    }\n\n    const normalizedOrgId = orgId.toLowerCase();\n\n    // Own-org rows: everything EXCEPT other people's private drafts.\n    const ownDraftsOnly = filter.viewerUserId ? eq(this.schema.createdBy, filter.viewerUserId) : NO_ROWS;\n    const ownOrg = filter.viewerIsSuperAdmin\n      ? eq(this.schema.orgId, normalizedOrgId)\n      : and(eq(this.schema.orgId, normalizedOrgId), or(ne(this.schema.visibility, 'private'), ownDraftsOnly)!)!;\n\n    // Rows from OTHER orgs are only ever visible at the `public` rung.\n    const otherOrgScopes = [eq(this.schema.orgId, SYSTEM_ORG_ID)];\n    if (parentOrgId) otherOrgScopes.push(eq(this.schema.orgId, parentOrgId.toLowerCase()));\n    const otherOrgsPublic = and(eq(this.schema.visibility, 'public'), or(...otherOrgScopes)!)!;\n\n    conditions.push(or(ownOrg, otherOrgsPublic)!);\n\n    if (requested !== undefined) conditions.push(eq(this.schema.visibility, requested));\n\n    return conditions;\n  }\n\n  /**\n   * Build ID filter with UUID prefix matching support\n   *\n   * - Full UUID: Exact match\n   * - Partial UUID: Prefix match using SQL LIKE\n   *\n   * @param id - ID filter value (full or partial UUID)\n   * @returns SQL condition or null if no ID filter\n   */\n  protected buildIdFilter(id: unknown): SQL | null {\n    return buildIdCondition(this.schema.id, id);\n  }\n\n  /**\n   * Build boolean field conditions (isDefault, isActive)\n   *\n   * @param filter - Filter criteria\n   * @returns Array of SQL conditions for boolean fields\n   */\n  protected buildBooleanFilters(filter: Partial<TFilter>): SQL[] {\n    return buildBooleanConditions(this.schema, filter);\n  }\n\n  /**\n   * Build all common conditions (access control + ID + booleans)\n   *\n   * This combines all the generic filters that apply to any access-controlled entity.\n   * Subclasses should call this and add entity-specific conditions.\n   *\n   * @param filter - Filter criteria\n   * @param orgId - User's organization ID (optional — falls back to system-public-only)\n   * @returns Array of SQL conditions\n   */\n  public buildCommonConditions(filter: Partial<TFilter>, orgId?: string, parentOrgId?: string): SQL[] {\n    const conditions: SQL[] = [];\n\n    // Access control (multi-tenant) — handles visibility internally\n    conditions.push(...this.buildAccessControl(filter, orgId, parentOrgId));\n\n    // ID filter with prefix matching\n    const idCondition = this.buildIdFilter(filter.id);\n    if (idCondition) conditions.push(idCondition);\n\n    // Boolean filters\n    conditions.push(...this.buildBooleanFilters(filter));\n\n    return conditions;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"access-control-builder.js","sourceRoot":"","sources":["../../src/api/access-control-builder.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { SYSTEM_ORG_ID } from '@pipeline-builder/api-core';\nimport { and, eq, ne, or, sql, SQL } from 'drizzle-orm';\nimport type { AnyColumn } from 'drizzle-orm/column';\n\nconst FULL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * Escape SQL LIKE wildcard characters to prevent wildcard injection.\n * Replaces `%` → `\\\\%`, `_` → `\\\\_`, and `\\\\` → `\\\\\\\\`.\n */\nexport function escapeLikeWildcards(str: string): string {\n  return str.replace(/\\\\/g, '\\\\\\\\').replace(/%/g, '\\\\%').replace(/_/g, '\\\\_');\n}\n\n/**\n * Build a condition that checks if a JSONB text array column contains a keyword (case-insensitive).\n * Used for keywords/tags filtering on pipelines, plugins, and compliance rules.\n */\nexport function buildJsonbKeywordCondition(column: AnyColumn, keyword: string): SQL {\n  const escaped = escapeLikeWildcards(keyword.toLowerCase());\n  return sql`EXISTS (SELECT 1 FROM jsonb_array_elements_text(${column}) AS el WHERE lower(el) LIKE ${'%' + escaped + '%'})`;\n}\n\n/**\n * Parse boolean filter value from string or boolean\n */\nexport function parseBooleanFilter(value: unknown): boolean {\n  if (typeof value === 'boolean') return value;\n  if (typeof value === 'string') return value === 'true';\n  return Boolean(value);\n}\n\n/**\n * Normalize string filter value to lowercase\n */\nexport function normalizeStringFilter(value: unknown): string {\n  return typeof value === 'string' ? value.toLowerCase() : String(value).toLowerCase();\n}\n\n/**\n * Build an ID predicate with UUID prefix matching.\n *\n * - Full UUID → exact match\n * - Partial UUID → prefix match via `LIKE` (a list-search affordance)\n * - Absent → `null` (no predicate)\n *\n * Standalone so entities that DON'T use {@link AccessControlQueryBuilder}'s\n * access control (e.g. pipeline templates, which carry their own three-rung\n * visibility ladder) still share one id-matching implementation.\n */\nexport function buildIdCondition(idColumn: AnyColumn, id: unknown): SQL | null {\n  if (id === undefined || id === null) return null;\n\n  // `BaseAccessFilter.id` is declared `string | string[]`, so honour the array\n  // form: match ANY of the ids, each with the same exact-vs-prefix semantics as\n  // a single value. `String(['a','b'])` would otherwise produce `LIKE 'a,b%'`\n  // and silently return zero rows — a trap for the first caller to pass one.\n  if (Array.isArray(id)) {\n    const parts = id\n      .map((one) => buildIdCondition(idColumn, one))\n      .filter((c): c is SQL => c !== null);\n    if (parts.length === 0) return null;\n    return parts.length === 1 ? parts[0] : (or(...parts) as SQL);\n  }\n\n  const idString = String(id).toLowerCase();\n  if (FULL_UUID.test(idString)) {\n    return eq(idColumn, idString);\n  }\n  // Escape SQL LIKE wildcards to prevent wildcard injection\n  const escaped = escapeLikeWildcards(idString);\n  return sql`${idColumn}::text LIKE ${escaped + '%'} ESCAPE '\\\\'`;\n}\n\n/**\n * Build the `isDefault` / `isActive` predicates shared by every catalog entity.\n * `isActive` defaults to true so soft-deleted rows stay out of normal reads.\n * Standalone for the same reason as {@link buildIdCondition}.\n */\nexport function buildBooleanConditions(\n  columns: { isDefault: AnyColumn; isActive: AnyColumn },\n  filter: { isDefault?: unknown; isActive?: unknown },\n): SQL[] {\n  const conditions: SQL[] = [];\n\n  if (filter.isDefault !== undefined) {\n    conditions.push(eq(columns.isDefault, parseBooleanFilter(filter.isDefault)));\n  }\n\n  if (filter.isActive !== undefined) {\n    conditions.push(eq(columns.isActive, parseBooleanFilter(filter.isActive)));\n  } else {\n    // Default to active records only to exclude soft-deleted entities\n    conditions.push(eq(columns.isActive, true));\n  }\n\n  return conditions;\n}\n\n/**\n * Schema table interface for access control queries. Every catalog entity\n * carries the same five columns, which is what lets ONE predicate serve\n * pipelines, plugins and templates alike.\n */\nexport interface AccessControlSchema {\n  id: AnyColumn;\n  orgId: AnyColumn;\n  /** Three-rung sharing ladder — see api-core's `Visibility`. */\n  visibility: AnyColumn;\n  /** Author. Owns the `private` rung. */\n  createdBy: AnyColumn;\n  isDefault: AnyColumn;\n  isActive: AnyColumn;\n}\n\n/**\n * Base filter interface with common access control fields.\n *\n * `viewerUserId` / `viewerIsSuperAdmin` are SERVER-SET (stamped from the request's\n * tenant context by `withViewerContext`), never client-supplied — see\n * `viewer-context.ts` for why the tenant context is the channel.\n */\nexport interface BaseAccessFilter {\n  id?: string | string[];\n  visibility?: string;\n  isDefault?: boolean | string;\n  isActive?: boolean | string;\n  viewerUserId?: string;\n  viewerIsSuperAdmin?: boolean;\n}\n\n/** Fail-closed predicate: matches no rows. */\nconst NO_ROWS: SQL = sql`false`;\n\n/** Per-entity tuning of {@link AccessControlQueryBuilder}. */\nexport interface AccessControlOptions {\n  /**\n   * Whether the SYSTEM org's `public` rung reaches callers in other orgs (and\n   * anonymous callers). Default true: the system org's sample pipelines,\n   * templates and dashboards are visible from every org. Plugins set it false:\n   * since the plugin ecosystem the Official catalog reaches\n   * other orgs only as LISTINGS resolved through installs, never through\n   * `visibility = 'public'` on a `plugins` row.\n   */\n  systemCatalog?: boolean;\n}\n\n/**\n * Generic access control query builder for multi-tenant entities.\n *\n * Consolidates duplicate access control logic shared across pipeline and plugin queries.\n * Handles:\n * - Multi-tenant access control (public/private/org-and-public)\n * - UUID prefix matching for ID filters\n * - Boolean field normalization\n *\n * @typeParam TSchema - Schema table type with access control fields\n * @typeParam TFilter - Filter type extending BaseAccessFilter\n */\nexport class AccessControlQueryBuilder<\n  TSchema extends AccessControlSchema,\n  TFilter extends BaseAccessFilter,\n> {\n  constructor(\n    private schema: TSchema,\n    private options: AccessControlOptions = {},\n  ) {}\n\n  /**\n   * Build the caller's visible slice of a catalog, from the three-rung\n   * `visibility` ladder shared by every catalog entity.\n   *\n   * Effective read set for a caller in org `O` as user `V` whose parent org is `P`:\n   *\n   *   (org_id = O AND (visibility <> 'private' OR created_by = V))\n   *   OR (visibility = 'public' AND (org_id = 'system' OR org_id = P))\n   *\n   * i.e. your own org's shared rungs plus your own drafts, widened by the system\n   * org's public catalog (the standing \"system-org content is visible from every\n   * org\" rule) and — for a team — its parent's public rows. The `public`-only\n   * restriction applies solely to those OTHER orgs' rows; within your own org you\n   * always see everything you are entitled to, or a freshly-created private row\n   * would vanish from its own author's listing.\n   *\n   * An entity can drop the system-org branch with `systemCatalog: false`\n   * ({@link AccessControlOptions}): plugins do, so a system-org plugin reaches\n   * other orgs only as an Official listing.\n   *\n   * An explicit `visibility` filter NARROWS within that set, never widens it —\n   * so `?visibility=public` still surfaces the system-org catalog.\n   *\n   * Fails CLOSED on both axes: no `orgId` (anonymous) ⇒ system-org public only;\n   * no `viewerUserId` ⇒ the private rung matches nothing rather than everything.\n   * `viewerIsSuperAdmin` lifts the private rung only — a platform operator\n   * administers the whole catalog.\n   *\n   * @param filter - Filter criteria\n   * @param orgId - User's organization ID (optional)\n   * @param parentOrgId - Parent org ID when the caller is a team (optional)\n   * @returns Array of SQL conditions for access control\n   */\n  protected buildAccessControl(filter: Partial<TFilter>, orgId?: string, parentOrgId?: string): SQL[] {\n    const conditions: SQL[] = [];\n    const requested = filter.visibility;\n\n    const systemCatalog = this.options.systemCatalog !== false;\n\n    if (!orgId) {\n      // No org context — only the system org's public catalog (nothing at all\n      // for an entity without one).\n      if (!systemCatalog) return [NO_ROWS];\n      conditions.push(eq(this.schema.orgId, SYSTEM_ORG_ID));\n      conditions.push(eq(this.schema.visibility, 'public'));\n      // An anonymous caller asking for a narrower rung gets nothing, rather than\n      // having the narrowing silently ignored.\n      if (requested !== undefined && requested !== 'public') conditions.push(NO_ROWS);\n      return conditions;\n    }\n\n    const normalizedOrgId = orgId.toLowerCase();\n\n    // Own-org rows: everything EXCEPT other people's private drafts.\n    const ownDraftsOnly = filter.viewerUserId ? eq(this.schema.createdBy, filter.viewerUserId) : NO_ROWS;\n    const ownOrg = filter.viewerIsSuperAdmin\n      ? eq(this.schema.orgId, normalizedOrgId)\n      : and(eq(this.schema.orgId, normalizedOrgId), or(ne(this.schema.visibility, 'private'), ownDraftsOnly)!)!;\n\n    // Rows from OTHER orgs are only ever visible at the `public` rung.\n    const otherOrgScopes: SQL[] = [];\n    if (systemCatalog) otherOrgScopes.push(eq(this.schema.orgId, SYSTEM_ORG_ID));\n    if (parentOrgId) otherOrgScopes.push(eq(this.schema.orgId, parentOrgId.toLowerCase()));\n    conditions.push(otherOrgScopes.length > 0\n      ? or(ownOrg, and(eq(this.schema.visibility, 'public'), or(...otherOrgScopes)!)!)!\n      : ownOrg);\n\n    if (requested !== undefined) conditions.push(eq(this.schema.visibility, requested));\n\n    return conditions;\n  }\n\n  /**\n   * Build ID filter with UUID prefix matching support\n   *\n   * - Full UUID: Exact match\n   * - Partial UUID: Prefix match using SQL LIKE\n   *\n   * @param id - ID filter value (full or partial UUID)\n   * @returns SQL condition or null if no ID filter\n   */\n  protected buildIdFilter(id: unknown): SQL | null {\n    return buildIdCondition(this.schema.id, id);\n  }\n\n  /**\n   * Build boolean field conditions (isDefault, isActive)\n   *\n   * @param filter - Filter criteria\n   * @returns Array of SQL conditions for boolean fields\n   */\n  protected buildBooleanFilters(filter: Partial<TFilter>): SQL[] {\n    return buildBooleanConditions(this.schema, filter);\n  }\n\n  /**\n   * Build all common conditions (access control + ID + booleans)\n   *\n   * This combines all the generic filters that apply to any access-controlled entity.\n   * Subclasses should call this and add entity-specific conditions.\n   *\n   * @param filter - Filter criteria\n   * @param orgId - User's organization ID (optional — falls back to system-public-only)\n   * @returns Array of SQL conditions\n   */\n  public buildCommonConditions(filter: Partial<TFilter>, orgId?: string, parentOrgId?: string): SQL[] {\n    const conditions: SQL[] = [];\n\n    // Access control (multi-tenant) — handles visibility internally\n    conditions.push(...this.buildAccessControl(filter, orgId, parentOrgId));\n\n    // ID filter with prefix matching\n    const idCondition = this.buildIdFilter(filter.id);\n    if (idCondition) conditions.push(idCondition);\n\n    // Boolean filters\n    conditions.push(...this.buildBooleanFilters(filter));\n\n    return conditions;\n  }\n}\n"]}

package/lib/api/crud-service.d.ts

@@ -66,15 +66,47 @@ export interface PaginatedResult<T> {
  *  soft-delete paths (e.g. platform's hand-rolled dashboard/alert services)
  *  stamp `purge_after` with the SAME window the CrudService entities use. */
 export declare function softDeleteRetentionMs(): number;
+/**
+ * Abstract CRUD service with multi-tenant access control and pagination.
+ *
+ * Subclasses bind to a specific Drizzle table by implementing `schema`,
+ * `buildConditions`, `getSortColumn`, and the org/project-column accessors.
+ *
+ * @typeParam TEntity - Entity type extending BaseEntity
+ * @typeParam TFilter - Filter type for query parameters
+ * @typeParam TInsert - Insert DTO type
+ * @typeParam TUpdate - Update DTO type
+ *
+ * **A note on the type casts.** Drizzle's row types are inferred from
+ * `pgTable(...)` and don't generically narrow through the abstract `schema`
+ * getter, so the base class casts query results to `TEntity` and back. The
+ * cast is *not* a runtime safety guarantee — it relies on each subclass
+ * passing the matching entity type. Org-scoping is enforced by every
+ * subclass's `buildConditions` injecting `WHERE org_id = $1`; this class
+ * does not add that filter itself.
+ *
+ * **Error policy.** Errors propagate up to the route-level handler
+ * (`withRoute`); no catch-and-swallow here.
+ *
+ * @example
+ * ```typescript
+ * class PipelineService extends CrudService<Pipeline, PipelineFilter, PipelineInsert, PipelineUpdate> {
+ *   protected get schema() { return schema.pipeline; }
+ *   protected buildConditions(filter, orgId) { return buildPipelineConditions(filter, orgId); }
+ *   protected getSortColumn(sortBy) { return Object.hasOwn(sortColumnMap, sortBy) ? sortColumnMap[sortBy] : null; }
+ *   protected getProjectColumn() { return schema.pipeline.project; }
+ *   protected getOrgColumn() { return schema.pipeline.orgId; }
+ * }
+ * ```
+ */
 export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, TInsert, TUpdate> {
     /** Drizzle schema table for this entity */
     protected abstract get schema(): PgTable;
     /**
      * Typed column view of {@link schema}. `PgTable` exposes no static columns, so
-     * the base class previously reached for `(this.schema as any).id` etc. at each
-     * use; centralize that single unavoidable cast here so callers get structured,
-     * typed access instead. `visibility` is optional (not every entity has it)
-     * and the index signature covers dynamic sparse-fieldset column lookup.
+     * this is the single unavoidable cast for column access. `visibility` is
+     * optional (not every entity has it) and the index signature covers dynamic
+     * sparse-fieldset column lookup.
      */
     private get cols();
     /**
@@ -102,6 +134,16 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
      *  hierarchy) — same opt-in semantics as `find`/`findPaginated`. Omitted by the
      *  write path (`writeConditions`), which must stay own-org scoped. */
     private idConditions;
+    /**
+     * Excludes soft-deleted tombstones on entities with a `deletedAt` column. The
+     * by-id filter deliberately skips the `isActive` default (a deactivated row is
+     * still readable by id), so without this a tombstone would be readable and —
+     * through `update` — half-revivable (`isActive` flipped back while
+     * `deletedAt`/`purgeAfter` stay set, so the sweep later purges a row the UI
+     * shows as live). Tombstones are reached only via the dedicated
+     * restore/purge/findDeleted paths.
+     */
+    private notTombstoned;
     /**
      * Conditions for a MUTATION (update/delete) of a single entity.
      *
@@ -117,6 +159,25 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
      *  `schema` is typed `PgTable` (no static `.id`), so cast — same pattern the
      *  sort/default helpers use for column access. */
     private exactIdCondition;
+    /** The actor stamped on a write: the caller, or the system actor for background work. */
+    private actor;
+    /**
+     * The one cast point for `.set()` / `.values()` / `.select()` shapes. The base class writes
+     * the shared columns (`updatedBy`, `deletedAt`, …) through the abstract
+     * `PgTable`, whose insert/update types can't prove those columns exist.
+     */
+    private row;
+    /** Run a lifecycle hook best-effort: a failure is logged, never thrown. */
+    private runHook;
+    /** The columns a soft-delete stamps, including the purge deadline. */
+    private tombstoneSet;
+    /**
+     * Hard-delete up to `limit` rows matching `conditions` in one transaction:
+     * dependents are torn down first by `onBeforePurge` in the SAME tx (a
+     * FK-blocking child can't strand the parent; a throw aborts the batch), then
+     * `onAfterPurge` handles external side-effects best-effort. Returns the ids.
+     */
+    private purgeWhere;
     /** Called after a new entity is created */
     protected onAfterCreate(_entity: TEntity, _userId: string): Promise<void>;
     /** Called after an entity is updated */
@@ -171,10 +232,18 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
      * @param orgId - User's organization ID (optional — omit for anonymous/system-public-only access)
      */
     find(filter: Partial<TFilter>, orgId?: string, parentOrgId?: string): Promise<TEntity[]>;
+    /**
+     * ORDER BY for {@link findFirst}, so "take one" is deterministic rather than
+     * whatever row the planner meets first: the default row, then the newest,
+     * then id as the final tiebreak. Services override it to rank by their own
+     * notion of "best match" (plugins: own org first, then semver).
+     */
+    protected findFirstOrderBy(_filter: Partial<TFilter>, _orgId?: string, _parentOrgId?: string): SQL[];
     /**
      * Find the FIRST entity matching `filter` — a bounded (`LIMIT 1`) variant of
      * `find` for the "match by filter, take one" read paths (e.g. `GET /find`), so
-     * they don't `SELECT` every matching org row just to return `[0]`.
+     * they don't `SELECT` every matching org row just to return `[0]`. Ranked by
+     * {@link findFirstOrderBy}.
      */
     findFirst(filter: Partial<TFilter>, orgId?: string, parentOrgId?: string): Promise<TEntity | null>;
     /**
@@ -218,9 +287,8 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
      */
     findById(id: string, orgId?: string, parentOrgId?: string): Promise<TEntity | null>;
     /**
-     * Defense-in-depth tenant stamp. RLS is in owner-bypass mode, so the app layer
-     * is the only tenant gate on writes. A NON-sysadmin caller may only write into
-     * its OWN org, so pin the row to the trusted tenant-context org.
+     * Defense-in-depth tenant stamp alongside RLS: a NON-sysadmin caller may only
+     * write into its OWN org, so pin the row to the trusted tenant-context org.
      *
      * The stamp fires whenever the payload's `orgId` differs from the context org —
      * which covers BOTH a forged/mismatched `data.orgId` AND an ABSENT one. The
@@ -271,15 +339,8 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
     bulkDelete(ids: string[], orgId: string, userId: string, 
     /**
      * The caller's authority on the three-rung `visibility` ladder. Omit (or
-     * pass `isSystemAdmin: true`) for an unrestricted delete.
-     *
-     * This used to be a `restrictToPrivate` boolean that narrowed to
-     * `visibility = 'private'`. That encoded the OLD two-state model: since
-     * `resolveVisibility` defaults pipelines and plugins to `org`, and
-     * single-row delete allows an `org` row with plain `:write`, bulk delete
-     * 403'd the normal case — an org admin could delete a pipeline one at a
-     * time but not in bulk. The rungs enforced here mirror
-     * `requireVisibilityWriteAccess` exactly:
+     * pass `isSystemAdmin: true`) for an unrestricted delete. The rungs mirror
+     * `requireVisibilityWriteAccess` exactly, so bulk and single-row delete agree:
      *   - `private` → author only (`createdBy === userId`)
      *   - `org`     → any member of the org (plain `:write`)
      *   - `public`  → requires the entity's publish permission
@@ -288,19 +349,6 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
         isSystemAdmin: boolean;
         canPublish: boolean;
     }): Promise<TEntity[]>;
-    /**
-     * Restore a soft-deleted (tombstoned) entity: clear `isActive`/`deletedAt`/
-     * `deletedBy`/`purgeAfter` so it reappears in normal reads.
-     *
-     * Matches ONLY a genuine tombstone — `isActive = false` AND `deletedAt IS NOT
-     * NULL` — so a merely *deactivated* row (isActive=false, no deletedAt) is never
-     * silently "restored". Pinned to the caller's own org (orgId-less sysadmin
-     * context spans orgs, matching delete/update). Returns null when there is no
-     * such tombstone (already active, purged, or unknown) so the route can 404.
-     * A unique-key collision (a live row already holds the key) surfaces as the
-     * driver's unique-violation for the route to map to 409 — in practice the
-     * tombstone IS the key holder, so this is defensive.
-     */
     /** Conditions matching a GENUINE tombstone (`isActive=false` AND `deletedAt IS
      *  NOT NULL`), optionally pinned to `id` and/or `orgId`. Single source of truth
      *  for restore/findDeletedById/findDeleted so the "what is a tombstone" rule
@@ -309,12 +357,9 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
     /**
      * The `private` rung, for TOMBSTONE reads and restore.
      *
-     * Deleting a row does not declassify it. These conditions carried only
-     * `isActive=false + deletedAt IS NOT NULL + org_id = O`, so the "recently
-     * deleted" list handed every member of an org the tombstones of everyone
-     * else's PRIVATE pipelines, plugins and templates — rows the very same member
-     * could not read one second before they were deleted. `restore` shared the
-     * clause, so they could also bring one back.
+     * Deleting a row does not declassify it: without this, the "recently
+     * deleted" list (and restore) would expose other members' PRIVATE rows that
+     * the same viewer could not read before they were deleted.
      *
      * Mirrors the live read ladder (`visibility <> 'private' OR created_by = V`)
      * rather than the delete ladder: this gates who may SEE a tombstone, and a
@@ -327,6 +372,19 @@ export declare abstract class CrudService<TEntity extends BaseEntity, TFilter, T
      * it runs org-wide under a sysadmin scope and must reach every tombstone.
      */
     private tombstoneVisibilityConditions;
+    /**
+     * Restore a soft-deleted (tombstoned) entity: clear `isActive`/`deletedAt`/
+     * `deletedBy`/`purgeAfter` so it reappears in normal reads.
+     *
+     * Matches ONLY a genuine tombstone — `isActive = false` AND `deletedAt IS NOT
+     * NULL` — so a merely *deactivated* row (isActive=false, no deletedAt) is never
+     * silently "restored". Pinned to the caller's own org (orgId-less sysadmin
+     * context spans orgs, matching delete/update). Returns null when there is no
+     * such tombstone (already active, purged, or unknown) so the route can 404.
+     * A unique-key collision (a live row already holds the key) surfaces as the
+     * driver's unique-violation for the route to map to 409 — in practice the
+     * tombstone IS the key holder, so this is defensive.
+     */
     restore(id: string, orgId: string, userId: string): Promise<TEntity | null>;
     /**
      * Read a soft-deleted entity by id (the inverse of the default `isActive=true`