@pipeline-builder/api-core 4.1.13 → 4.1.15

package/lib/helpers/org-hierarchy.js

@@ -15,9 +15,8 @@
  *   - {@link isAncestorOrgWith}      — UP: is A an ancestor of B?
  *   - {@link expandOrgScopeWith}     — DOWN: self + all descendant org ids.
  *
- * Every org is flat today (`parentOrgId` null on all rows), so lineage resolves
- * to `{ rootOrgId: self }` and scope to `[self]` — i.e. these are no-ops until
- * orgs get parents.
+ * A root org (`parentOrgId` null) resolves to `{ rootOrgId: self }` and scope
+ * `[self]`.
  */
 /** Hard ceiling on ancestry/descendant traversal — cycle + abuse guard. */
 export const MAX_ORG_DEPTH = 16;
@@ -56,6 +55,27 @@ export function createOrgIdCaster(ObjectIdCtor) {
         return isObjectIdHex(idStr) ? new ObjectIdCtor(idStr) : idStr;
     };
 }
+/**
+ * The parent/children lookups over a service's own `organizations` model, for
+ * the `*With` traversals below. `getChildOrgIds` returns LIVE children only (a
+ * soft-deleted team leaves every downward scope); `getParentOrgId` does not
+ * filter, so a deleted team still resolves through its parent.
+ */
+export function createMongoOrgHierarchy(Model, toOrgId) {
+    return {
+        async getParentOrgId(orgId) {
+            const org = await Model.findById(toOrgId(orgId)).select('parentOrgId').lean();
+            return toOrgIdString(org?.parentOrgId);
+        },
+        async getChildOrgIds(frontier) {
+            // `deletedAt: null` matches both an explicit null and an absent field.
+            const children = await Model.find({ parentOrgId: { $in: frontier }, deletedAt: null }).select('_id').lean();
+            return children
+                .map((c) => toOrgIdString(c._id))
+                .filter((id) => !!id);
+        },
+    };
+}
 /**
  * Walk `parentOrgId` from `orgId` up to the root. Returns the direct parent (if
  * any) and the root org id (the input itself when the org has no parent). On a
@@ -85,6 +105,27 @@ export async function resolveOrgLineageWith(orgId, getParent) {
 export async function resolveRootOrgIdWith(orgId, getParent) {
     return (await resolveOrgLineageWith(orgId, getParent)).rootOrgId;
 }
+/**
+ * Fail-CLOSED variant of {@link resolveRootOrgIdWith}: returns `null` when the
+ * root can't be proven — a cycle or a chain deeper than {@link MAX_ORG_DEPTH} —
+ * instead of treating the last reached id as the root. Lookup errors propagate.
+ * For callers where a wrong root is worse than no answer (e.g. a retention purge
+ * that would otherwise apply a team's shorter default window).
+ */
+export async function resolveRootOrgIdStrict(orgId, getParent) {
+    const seen = new Set([orgId]);
+    let currentId = orgId;
+    for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {
+        const parent = toOrgIdString(await getParent(currentId));
+        if (!parent || parent === currentId)
+            return currentId;
+        if (seen.has(parent))
+            return null;
+        seen.add(parent);
+        currentId = parent;
+    }
+    return null;
+}
 /**
  * True when `ancestorOrgId` is an ancestor of `candidateOrgId` — i.e.
  * `candidateOrgId` lives somewhere in the subtree rooted at `ancestorOrgId`.
@@ -135,4 +176,4 @@ export async function expandOrgScopeWith(orgId, getChildren) {
     }
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy traversal (org-team-hierarchy proposal).\n *\n * A \"team\" is an organization whose `parentOrgId` points at another org; a root\n * org has `parentOrgId = null`. These helpers walk that single self-referential\n * column, but hold **no database dependency** of their own: each takes a query\n * callback so every service (platform, quota, …) can share the cycle-safe,\n * depth-capped traversal logic while reading its own Mongoose model with its own\n * `_id` casting rules.\n *\n *   - {@link resolveOrgLineageWith} — UP: direct parent + root of the chain.\n *   - {@link resolveRootOrgIdWith}   — UP: just the root id.\n *   - {@link isAncestorOrgWith}      — UP: is A an ancestor of B?\n *   - {@link expandOrgScopeWith}     — DOWN: self + all descendant org ids.\n *\n * Every org is flat today (`parentOrgId` null on all rows), so lineage resolves\n * to `{ rootOrgId: self }` and scope to `[self]` — i.e. these are no-ops until\n * orgs get parents.\n */\n\n/** Hard ceiling on ancestry/descendant traversal — cycle + abuse guard. */\nexport const MAX_ORG_DEPTH = 16;\n\n/** Fetch an org's direct `parentOrgId`, or undefined for a root/missing org. */\nexport type GetParentOrgId = (orgId: string) => Promise<string | undefined>;\n\n/** Fetch the direct child org ids of every org in `frontier` (one round of BFS). */\nexport type GetChildOrgIds = (frontier: string[]) => Promise<string[]>;\n\n/** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */\nexport function toOrgIdString(v: unknown): string | undefined {\n  if (v === null || v === undefined) return undefined;\n  const s = String(v);\n  return s && s !== 'null' && s !== 'undefined' ? s : undefined;\n}\n\n/** True when `id` is a 24-character hex string — i.e. castable to an ObjectId. */\nfunction isObjectIdHex(id: string): boolean {\n  return id.length === 24 && /^[0-9a-fA-F]{24}$/.test(id);\n}\n\n/**\n * Build the org-id cast the Mongo-backed services use on every `_id` lookup.\n *\n * Platform writes ObjectId `_id`s into the shared `organizations` collection,\n * while the well-known `'system'` org (and `parentOrgId`, still a String column)\n * are plain strings — so a 24-hex id arriving from a route param / JWT claim /\n * cross-service payload must be cast or `findById('<24hex>')` never matches.\n *\n * Platform and quota each had their OWN `toOrgId` with a different signature\n * (`string | string[]` vs `string`), which is exactly the drift this removes:\n * the logic and the signature live here once, and each service supplies only\n * its mongoose `Types.ObjectId` constructor. api-core cannot import mongoose\n * itself (it is not — and should not become — an api-core dependency), so the\n * constructor is injected rather than imported.\n *\n * @example\n * export const toOrgId = createOrgIdCaster(mongoose.Types.ObjectId);\n */\nexport function createOrgIdCaster<T>(\n  ObjectIdCtor: new (hex: string) => T,\n): (id: string | string[]) => string | T {\n  return (id) => {\n    const idStr = Array.isArray(id) ? id[0] : id;\n    return isObjectIdHex(idStr) ? new ObjectIdCtor(idStr) : idStr;\n  };\n}\n\nexport interface OrgLineage {\n  /** The org's direct parent id, or `undefined` when it's a root org. */\n  parentOrgId?: string;\n  /** Top of the ancestry chain. Equals the input `orgId` for a root org. */\n  rootOrgId: string;\n}\n\n/**\n * Walk `parentOrgId` from `orgId` up to the root. Returns the direct parent (if\n * any) and the root org id (the input itself when the org has no parent). On a\n * detected cycle, a missing org, or the depth cap, traversal stops and the last\n * reached id is treated as the root.\n */\nexport async function resolveOrgLineageWith(orgId: string, getParent: GetParentOrgId): Promise<OrgLineage> {\n  const seen = new Set<string>([orgId]);\n  let currentId = orgId;\n  let parentOrgId: string | undefined;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) break; // currentId is the root\n    // Record the direct parent only when it isn't a self-loop, so a malformed\n    // A→A org isn't reported as its own parent.\n    if (depth === 0 && parent !== orgId) parentOrgId = parent;\n    if (seen.has(parent)) break; // cycle — treat currentId as the root\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return { rootOrgId: currentId, ...(parentOrgId && { parentOrgId }) };\n}\n\n/** Walk `parentOrgId` up to the root and return just the root id. */\nexport async function resolveRootOrgIdWith(orgId: string, getParent: GetParentOrgId): Promise<string> {\n  return (await resolveOrgLineageWith(orgId, getParent)).rootOrgId;\n}\n\n/**\n * True when `ancestorOrgId` is an ancestor of `candidateOrgId` — i.e.\n * `candidateOrgId` lives somewhere in the subtree rooted at `ancestorOrgId`.\n * Walks `candidateOrgId`'s parent chain upward, depth-capped and cycle-safe.\n * Returns `false` when the two are equal (an org is not its own ancestor) or\n * unrelated.\n */\nexport async function isAncestorOrgWith(\n  ancestorOrgId: string,\n  candidateOrgId: string,\n  getParent: GetParentOrgId,\n): Promise<boolean> {\n  if (ancestorOrgId === candidateOrgId) return false;\n\n  const seen = new Set<string>([candidateOrgId]);\n  let currentId = candidateOrgId;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) return false; // reached a root without matching\n    if (parent === ancestorOrgId) return true;\n    if (seen.has(parent)) return false; // cycle\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return false;\n}\n\n/**\n * Expand `orgId` to itself plus every descendant org id (breadth-first over\n * `parentOrgId`). This is the scope a parent org \"sees\" for visibility and\n * analytics rollups: `[self, ...descendants]`. Returns `[orgId]` when the org\n * has no children. Cycle-safe and depth-capped.\n */\nexport async function expandOrgScopeWith(orgId: string, getChildren: GetChildOrgIds): Promise<string[]> {\n  const result: string[] = [orgId];\n  const seen = new Set<string>([orgId]);\n  let frontier: string[] = [orgId];\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH && frontier.length > 0; depth++) {\n    const children = await getChildren(frontier);\n    const next: string[] = [];\n    for (const raw of children) {\n      const id = toOrgIdString(raw);\n      if (!id || seen.has(id)) continue;\n      seen.add(id);\n      result.push(id);\n      next.push(id);\n    }\n    frontier = next;\n  }\n\n  return result;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Org → team hierarchy traversal (org-team-hierarchy proposal).\n *\n * A \"team\" is an organization whose `parentOrgId` points at another org; a root\n * org has `parentOrgId = null`. These helpers walk that single self-referential\n * column, but hold **no database dependency** of their own: each takes a query\n * callback so every service (platform, quota, …) can share the cycle-safe,\n * depth-capped traversal logic while reading its own Mongoose model with its own\n * `_id` casting rules.\n *\n *   - {@link resolveOrgLineageWith} — UP: direct parent + root of the chain.\n *   - {@link resolveRootOrgIdWith}   — UP: just the root id.\n *   - {@link isAncestorOrgWith}      — UP: is A an ancestor of B?\n *   - {@link expandOrgScopeWith}     — DOWN: self + all descendant org ids.\n *\n * A root org (`parentOrgId` null) resolves to `{ rootOrgId: self }` and scope\n * `[self]`.\n */\n\n/** Hard ceiling on ancestry/descendant traversal — cycle + abuse guard. */\nexport const MAX_ORG_DEPTH = 16;\n\n/** Fetch an org's direct `parentOrgId`, or undefined for a root/missing org. */\nexport type GetParentOrgId = (orgId: string) => Promise<string | undefined>;\n\n/** Fetch the direct child org ids of every org in `frontier` (one round of BFS). */\nexport type GetChildOrgIds = (frontier: string[]) => Promise<string[]>;\n\n/** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */\nexport function toOrgIdString(v: unknown): string | undefined {\n  if (v === null || v === undefined) return undefined;\n  const s = String(v);\n  return s && s !== 'null' && s !== 'undefined' ? s : undefined;\n}\n\n/** True when `id` is a 24-character hex string — i.e. castable to an ObjectId. */\nfunction isObjectIdHex(id: string): boolean {\n  return id.length === 24 && /^[0-9a-fA-F]{24}$/.test(id);\n}\n\n/**\n * Build the org-id cast the Mongo-backed services use on every `_id` lookup.\n *\n * Platform writes ObjectId `_id`s into the shared `organizations` collection,\n * while the well-known `'system'` org (and `parentOrgId`, still a String column)\n * are plain strings — so a 24-hex id arriving from a route param / JWT claim /\n * cross-service payload must be cast or `findById('<24hex>')` never matches.\n *\n * Platform and quota each had their OWN `toOrgId` with a different signature\n * (`string | string[]` vs `string`), which is exactly the drift this removes:\n * the logic and the signature live here once, and each service supplies only\n * its mongoose `Types.ObjectId` constructor. api-core cannot import mongoose\n * itself (it is not — and should not become — an api-core dependency), so the\n * constructor is injected rather than imported.\n *\n * @example\n * export const toOrgId = createOrgIdCaster(mongoose.Types.ObjectId);\n */\nexport function createOrgIdCaster<T>(\n  ObjectIdCtor: new (hex: string) => T,\n): (id: string | string[]) => string | T {\n  return (id) => {\n    const idStr = Array.isArray(id) ? id[0] : id;\n    return isObjectIdHex(idStr) ? new ObjectIdCtor(idStr) : idStr;\n  };\n}\n\n/**\n * The slice of a Mongoose `Organization` model the hierarchy callbacks read.\n * Structural (api-core has no mongoose dependency); `select().lean()` chains as\n * mongoose queries do.\n */\nexport interface OrgHierarchyModel {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  findById(id: any): { select(fields: string): { lean(): PromiseLike<unknown> } };\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  find(filter: any): { select(fields: string): { lean(): PromiseLike<unknown[]> } };\n}\n\n/**\n * The parent/children lookups over a service's own `organizations` model, for\n * the `*With` traversals below. `getChildOrgIds` returns LIVE children only (a\n * soft-deleted team leaves every downward scope); `getParentOrgId` does not\n * filter, so a deleted team still resolves through its parent.\n */\nexport function createMongoOrgHierarchy(\n  Model: OrgHierarchyModel,\n  toOrgId: (id: string) => unknown,\n): { getParentOrgId: GetParentOrgId; getChildOrgIds: GetChildOrgIds } {\n  return {\n    async getParentOrgId(orgId) {\n      const org = await Model.findById(toOrgId(orgId)).select('parentOrgId').lean();\n      return toOrgIdString((org as { parentOrgId?: unknown } | null)?.parentOrgId);\n    },\n    async getChildOrgIds(frontier) {\n      // `deletedAt: null` matches both an explicit null and an absent field.\n      const children = await Model.find({ parentOrgId: { $in: frontier }, deletedAt: null }).select('_id').lean();\n      return children\n        .map((c) => toOrgIdString((c as { _id?: unknown })._id))\n        .filter((id): id is string => !!id);\n    },\n  };\n}\n\nexport interface OrgLineage {\n  /** The org's direct parent id, or `undefined` when it's a root org. */\n  parentOrgId?: string;\n  /** Top of the ancestry chain. Equals the input `orgId` for a root org. */\n  rootOrgId: string;\n}\n\n/**\n * Walk `parentOrgId` from `orgId` up to the root. Returns the direct parent (if\n * any) and the root org id (the input itself when the org has no parent). On a\n * detected cycle, a missing org, or the depth cap, traversal stops and the last\n * reached id is treated as the root.\n */\nexport async function resolveOrgLineageWith(orgId: string, getParent: GetParentOrgId): Promise<OrgLineage> {\n  const seen = new Set<string>([orgId]);\n  let currentId = orgId;\n  let parentOrgId: string | undefined;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) break; // currentId is the root\n    // Record the direct parent only when it isn't a self-loop, so a malformed\n    // A→A org isn't reported as its own parent.\n    if (depth === 0 && parent !== orgId) parentOrgId = parent;\n    if (seen.has(parent)) break; // cycle — treat currentId as the root\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return { rootOrgId: currentId, ...(parentOrgId && { parentOrgId }) };\n}\n\n/** Walk `parentOrgId` up to the root and return just the root id. */\nexport async function resolveRootOrgIdWith(orgId: string, getParent: GetParentOrgId): Promise<string> {\n  return (await resolveOrgLineageWith(orgId, getParent)).rootOrgId;\n}\n\n/**\n * Fail-CLOSED variant of {@link resolveRootOrgIdWith}: returns `null` when the\n * root can't be proven — a cycle or a chain deeper than {@link MAX_ORG_DEPTH} —\n * instead of treating the last reached id as the root. Lookup errors propagate.\n * For callers where a wrong root is worse than no answer (e.g. a retention purge\n * that would otherwise apply a team's shorter default window).\n */\nexport async function resolveRootOrgIdStrict(orgId: string, getParent: GetParentOrgId): Promise<string | null> {\n  const seen = new Set<string>([orgId]);\n  let currentId = orgId;\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent || parent === currentId) return currentId;\n    if (seen.has(parent)) return null;\n    seen.add(parent);\n    currentId = parent;\n  }\n  return null;\n}\n\n/**\n * True when `ancestorOrgId` is an ancestor of `candidateOrgId` — i.e.\n * `candidateOrgId` lives somewhere in the subtree rooted at `ancestorOrgId`.\n * Walks `candidateOrgId`'s parent chain upward, depth-capped and cycle-safe.\n * Returns `false` when the two are equal (an org is not its own ancestor) or\n * unrelated.\n */\nexport async function isAncestorOrgWith(\n  ancestorOrgId: string,\n  candidateOrgId: string,\n  getParent: GetParentOrgId,\n): Promise<boolean> {\n  if (ancestorOrgId === candidateOrgId) return false;\n\n  const seen = new Set<string>([candidateOrgId]);\n  let currentId = candidateOrgId;\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {\n    const parent = toOrgIdString(await getParent(currentId));\n    if (!parent) return false; // reached a root without matching\n    if (parent === ancestorOrgId) return true;\n    if (seen.has(parent)) return false; // cycle\n    seen.add(parent);\n    currentId = parent;\n  }\n\n  return false;\n}\n\n/**\n * Expand `orgId` to itself plus every descendant org id (breadth-first over\n * `parentOrgId`). This is the scope a parent org \"sees\" for visibility and\n * analytics rollups: `[self, ...descendants]`. Returns `[orgId]` when the org\n * has no children. Cycle-safe and depth-capped.\n */\nexport async function expandOrgScopeWith(orgId: string, getChildren: GetChildOrgIds): Promise<string[]> {\n  const result: string[] = [orgId];\n  const seen = new Set<string>([orgId]);\n  let frontier: string[] = [orgId];\n\n  for (let depth = 0; depth < MAX_ORG_DEPTH && frontier.length > 0; depth++) {\n    const children = await getChildren(frontier);\n    const next: string[] = [];\n    for (const raw of children) {\n      const id = toOrgIdString(raw);\n      if (!id || seen.has(id)) continue;\n      seen.add(id);\n      result.push(id);\n      next.push(id);\n    }\n    frontier = next;\n  }\n\n  return result;\n}\n"]}

package/lib/helpers/restore-helpers.d.ts

@@ -13,37 +13,57 @@ export interface RestorableService<T extends RestorableEntity> {
     findDeletedById(id: string, orgId?: string): Promise<T | null>;
     restore(id: string, orgId: string, userId: string): Promise<T | null>;
 }
-/**
- * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load
- * the own-org tombstone, gate it on the visibility ladder (parity with delete),
- * restore, and 404 on miss. Returns `{ existing, restored }` on success,
- * or `null` when it has ALREADY sent a response (400/404/403) — the caller then
- * does the entity-specific audit + response. DRYs the near-identical
- * pipeline / plugin / pipeline_template restore routes (which differ only in
- * service, audit action, and response shaping).
- */
-export declare function loadAndRestore<T extends RestorableEntity>(req: Request, res: Response, orgId: string, userId: string, service: RestorableService<T>, label: string, publishPermission: Permission): Promise<{
-    existing: T;
-    restored: T;
-} | null>;
 /** The slice of a service a purge route uses (satisfied by any CrudService). */
 export interface PurgeableService<T extends RestorableEntity> {
     findDeletedById(id: string, orgId?: string): Promise<T | null>;
     purgeById(id: string, orgId?: string): Promise<string | null>;
 }
 /**
- * Shared skeleton for an entity PURGE route: extract `:id`, load the own-org
- * tombstone, gate it on the visibility ladder (parity with
- * delete/restore), then permanently hard-delete it — but ONLY when it is a
- * genuine tombstone (a live/active row loads as `null` here and 404s, so purge
- * can never hard-delete a live row). Returns `{ existing, purgedId }` on success
- * (the caller emits the entity-specific audit off `existing`), or `null` when it
- * has ALREADY sent a response (400/404/403). Step-up is the ROUTE's job: the
- * pipeline, template and plugin services mount purge behind `requireStepUp`
- * (sharing restore's chain so one token isn't consumed twice). DRYs the near-identical
- * pipeline / pipeline_template purge routes.
+ * Decides whether the caller may restore/purge the loaded tombstone. Returns
+ * false after it has ANSWERED the request (403). Load-bearing: the tombstone
+ * load is org-scoped, not visibility-scoped, so this is what stops a colleague
+ * resurrecting (or destroying) someone else's draft.
+ */
+export type TombstoneAuthorizer<T> = (existing: T, req: Request, res: Response) => boolean;
+export type TombstoneRouteOptions<T extends RestorableEntity> = {
+    orgId: string;
+    userId: string;
+    /** User-facing entity noun for the 400/404 messages ('Pipeline', 'Rule', …). */
+    label: string;
+    /**
+     * The org the tombstone load and the mutation are pinned to. Defaults to
+     * `orgId`; `undefined` spans orgs (system-admin moderation).
+     */
+    scopeOrgId?: string | undefined;
+} & (
+/** Same authority as delete on the visibility ladder: `publishPermission`
+ *  for a public row, authorship for a private one. */
+{
+    publishPermission: Permission;
+    authorize?: undefined;
+} | {
+    authorize: TombstoneAuthorizer<T>;
+    publishPermission?: undefined;
+});
+/**
+ * Shared skeleton for a step-up-gated entity RESTORE route: extract `:id`, load
+ * the tombstone, authorize it, restore, and 404 on miss. Returns
+ * `{ existing, restored }` on success, or `null` when it has ALREADY sent a
+ * response (400/404/403) — the caller then does the entity-specific audit +
+ * response. Step-up is the route's job.
+ */
+export declare function loadAndRestore<T extends RestorableEntity>(req: Request, res: Response, service: RestorableService<T>, opts: TombstoneRouteOptions<T>): Promise<{
+    existing: T;
+    restored: T;
+} | null>;
+/**
+ * Shared skeleton for an entity PURGE route: the same load + authorization as
+ * restore, then a permanent hard-delete via the retention sweep's single-id
+ * purge (same tombstone match + dependent-teardown hooks). Returns
+ * `{ existing, purgedId }` (the caller audits off `existing`), or `null` when it
+ * has ALREADY sent a response. Step-up is the route's job.
  */
-export declare function loadAndPurge<T extends RestorableEntity>(req: Request, res: Response, orgId: string, service: PurgeableService<T>, label: string, publishPermission: Permission, userId: string): Promise<{
+export declare function loadAndPurge<T extends RestorableEntity>(req: Request, res: Response, service: PurgeableService<T>, opts: TombstoneRouteOptions<T>): Promise<{
     existing: T;
     purgedId: string;
 } | null>;

package/lib/helpers/restore-helpers.js

@@ -5,74 +5,63 @@ import { sendEntityNotFound } from './crud-helpers.js';
 import { ErrorCode } from '../types/error-codes.js';
 import { getParam } from '../utils/params.js';
 import { sendBadRequest } from '../utils/response.js';
-/**
- * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load
- * the own-org tombstone, gate it on the visibility ladder (parity with delete),
- * restore, and 404 on miss. Returns `{ existing, restored }` on success,
- * or `null` when it has ALREADY sent a response (400/404/403) — the caller then
- * does the entity-specific audit + response. DRYs the near-identical
- * pipeline / plugin / pipeline_template restore routes (which differ only in
- * service, audit action, and response shaping).
- */
-export async function loadAndRestore(req, res, orgId, userId, service, label, publishPermission) {
+/** Shared prelude: `:id` → own-scope tombstone → authorization. `null` = answered. */
+async function loadTombstone(req, res, service, opts) {
     const id = getParam(req.params, 'id');
     if (!id) {
-        sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);
+        sendBadRequest(res, `${opts.label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);
         return null;
     }
-    // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404.
-    const existing = await service.findDeletedById(id, orgId);
+    const scope = 'scopeOrgId' in opts ? opts.scopeOrgId : opts.orgId;
+    // A live row / unknown id / already-purged → 404, so a currently-active entity
+    // is never restored or hard-deleted through these paths.
+    const existing = await service.findDeletedById(id, scope);
     if (!existing) {
-        sendEntityNotFound(res, label);
+        sendEntityNotFound(res, opts.label);
         return null;
     }
-    // Same ladder authority as delete: `:publish` for a public row, authorship for
-    // a private one. Load-bearing here — the tombstone load is org-scoped, not
-    // visibility-scoped, so this is what stops a colleague resurrecting a draft.
-    if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission))
-        return null;
-    const restored = await service.restore(id, orgId, userId || 'system');
-    if (!restored) {
-        sendEntityNotFound(res, label);
+    const allowed = opts.authorize
+        ? opts.authorize(existing, req, res)
+        : requireVisibilityWriteAccess(req, res, existing, opts.userId, opts.publishPermission);
+    if (!allowed)
         return null;
-    }
-    return { existing, restored };
+    return { id, existing, scope };
 }
 /**
- * Shared skeleton for an entity PURGE route: extract `:id`, load the own-org
- * tombstone, gate it on the visibility ladder (parity with
- * delete/restore), then permanently hard-delete it — but ONLY when it is a
- * genuine tombstone (a live/active row loads as `null` here and 404s, so purge
- * can never hard-delete a live row). Returns `{ existing, purgedId }` on success
- * (the caller emits the entity-specific audit off `existing`), or `null` when it
- * has ALREADY sent a response (400/404/403). Step-up is the ROUTE's job: the
- * pipeline, template and plugin services mount purge behind `requireStepUp`
- * (sharing restore's chain so one token isn't consumed twice). DRYs the near-identical
- * pipeline / pipeline_template purge routes.
+ * Shared skeleton for a step-up-gated entity RESTORE route: extract `:id`, load
+ * the tombstone, authorize it, restore, and 404 on miss. Returns
+ * `{ existing, restored }` on success, or `null` when it has ALREADY sent a
+ * response (400/404/403) — the caller then does the entity-specific audit +
+ * response. Step-up is the route's job.
  */
-export async function loadAndPurge(req, res, orgId, service, label, publishPermission, userId) {
-    const id = getParam(req.params, 'id');
-    if (!id) {
-        sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);
+export async function loadAndRestore(req, res, service, opts) {
+    const loaded = await loadTombstone(req, res, service, opts);
+    if (!loaded)
         return null;
-    }
-    // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404,
-    // so a currently-active entity is never hard-deleted through this path.
-    const existing = await service.findDeletedById(id, orgId);
-    if (!existing) {
-        sendEntityNotFound(res, label);
+    const restored = await service.restore(loaded.id, loaded.scope ?? '', opts.userId);
+    if (!restored) {
+        sendEntityNotFound(res, opts.label);
         return null;
     }
-    // Same ladder authority as delete/restore (see loadAndRestore).
-    if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission))
+    return { existing: loaded.existing, restored };
+}
+/**
+ * Shared skeleton for an entity PURGE route: the same load + authorization as
+ * restore, then a permanent hard-delete via the retention sweep's single-id
+ * purge (same tombstone match + dependent-teardown hooks). Returns
+ * `{ existing, purgedId }` (the caller audits off `existing`), or `null` when it
+ * has ALREADY sent a response. Step-up is the route's job.
+ */
+export async function loadAndPurge(req, res, service, opts) {
+    const loaded = await loadTombstone(req, res, service, opts);
+    if (!loaded)
         return null;
-    // Reuse the retention sweep's single-id hard-delete (same tombstone match +
-    // dependent-teardown hooks). Returns null on a race (already purged) → 404.
-    const purgedId = await service.purgeById(id, orgId);
+    // Null on a race (already purged) → 404.
+    const purgedId = await service.purgeById(loaded.id, loaded.scope ?? '');
     if (!purgedId) {
-        sendEntityNotFound(res, label);
+        sendEntityNotFound(res, opts.label);
         return null;
     }
-    return { existing, purgedId };
+    return { existing: loaded.existing, purgedId };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restore-helpers.js","sourceRoot":"","sources":["../../src/helpers/restore-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\nimport { requireVisibilityWriteAccess } from './access-helpers.js';\nimport { sendEntityNotFound } from './crud-helpers.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { Permission } from '../types/permissions.js';\nimport { getParam } from '../utils/params.js';\nimport { sendBadRequest } from '../utils/response.js';\n\n/** Minimal shape a restore route needs from the entity it restores. */\nexport interface RestorableEntity {\n  orgId: string;\n  /** Rung the tombstone sat at — drives the restore/purge authority check. */\n  visibility?: string;\n  /** Author — the only non-admin who may restore/purge a `private` row. */\n  createdBy?: string;\n}\n\n/** The slice of a service a restore route uses (satisfied by any CrudService). */\nexport interface RestorableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  restore(id: string, orgId: string, userId: string): Promise<T | null>;\n}\n\n/**\n * Shared skeleton for a step-up-gated entity restore route: extract `:id`, load\n * the own-org tombstone, gate it on the visibility ladder (parity with delete),\n * restore, and 404 on miss. Returns `{ existing, restored }` on success,\n * or `null` when it has ALREADY sent a response (400/404/403) — the caller then\n * does the entity-specific audit + response. DRYs the near-identical\n * pipeline / plugin / pipeline_template restore routes (which differ only in\n * service, audit action, and response shaping).\n */\nexport async function loadAndRestore<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  orgId: string,\n  userId: string,\n  service: RestorableService<T>,\n  label: string,\n  publishPermission: Permission,\n): Promise<{ existing: T; restored: T } | null> {\n  const id = getParam(req.params, 'id');\n  if (!id) {\n    sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);\n    return null;\n  }\n\n  // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404.\n  const existing = await service.findDeletedById(id, orgId);\n  if (!existing) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  // Same ladder authority as delete: `:publish` for a public row, authorship for\n  // a private one. Load-bearing here — the tombstone load is org-scoped, not\n  // visibility-scoped, so this is what stops a colleague resurrecting a draft.\n  if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission)) return null;\n\n  const restored = await service.restore(id, orgId, userId || 'system');\n  if (!restored) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  return { existing, restored };\n}\n\n/** The slice of a service a purge route uses (satisfied by any CrudService). */\nexport interface PurgeableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  purgeById(id: string, orgId?: string): Promise<string | null>;\n}\n\n/**\n * Shared skeleton for an entity PURGE route: extract `:id`, load the own-org\n * tombstone, gate it on the visibility ladder (parity with\n * delete/restore), then permanently hard-delete it — but ONLY when it is a\n * genuine tombstone (a live/active row loads as `null` here and 404s, so purge\n * can never hard-delete a live row). Returns `{ existing, purgedId }` on success\n * (the caller emits the entity-specific audit off `existing`), or `null` when it\n * has ALREADY sent a response (400/404/403). Step-up is the ROUTE's job: the\n * pipeline, template and plugin services mount purge behind `requireStepUp`\n * (sharing restore's chain so one token isn't consumed twice). DRYs the near-identical\n * pipeline / pipeline_template purge routes.\n */\nexport async function loadAndPurge<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  orgId: string,\n  service: PurgeableService<T>,\n  label: string,\n  publishPermission: Permission,\n  userId: string,\n): Promise<{ existing: T; purgedId: string } | null> {\n  const id = getParam(req.params, 'id');\n  if (!id) {\n    sendBadRequest(res, `${label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);\n    return null;\n  }\n\n  // Load the TOMBSTONE (own-org). A live row / unknown id / already-purged → 404,\n  // so a currently-active entity is never hard-deleted through this path.\n  const existing = await service.findDeletedById(id, orgId);\n  if (!existing) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  // Same ladder authority as delete/restore (see loadAndRestore).\n  if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission)) return null;\n\n  // Reuse the retention sweep's single-id hard-delete (same tombstone match +\n  // dependent-teardown hooks). Returns null on a race (already purged) → 404.\n  const purgedId = await service.purgeById(id, orgId);\n  if (!purgedId) {\n    sendEntityNotFound(res, label);\n    return null;\n  }\n\n  return { existing, purgedId };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restore-helpers.js","sourceRoot":"","sources":["../../src/helpers/restore-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\nimport { requireVisibilityWriteAccess } from './access-helpers.js';\nimport { sendEntityNotFound } from './crud-helpers.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport type { Permission } from '../types/permissions.js';\nimport { getParam } from '../utils/params.js';\nimport { sendBadRequest } from '../utils/response.js';\n\n/** Minimal shape a restore route needs from the entity it restores. */\nexport interface RestorableEntity {\n  orgId: string;\n  /** Rung the tombstone sat at — drives the restore/purge authority check. */\n  visibility?: string;\n  /** Author — the only non-admin who may restore/purge a `private` row. */\n  createdBy?: string;\n}\n\n/** The slice of a service a restore route uses (satisfied by any CrudService). */\nexport interface RestorableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  restore(id: string, orgId: string, userId: string): Promise<T | null>;\n}\n\n/** The slice of a service a purge route uses (satisfied by any CrudService). */\nexport interface PurgeableService<T extends RestorableEntity> {\n  findDeletedById(id: string, orgId?: string): Promise<T | null>;\n  purgeById(id: string, orgId?: string): Promise<string | null>;\n}\n\n/**\n * Decides whether the caller may restore/purge the loaded tombstone. Returns\n * false after it has ANSWERED the request (403). Load-bearing: the tombstone\n * load is org-scoped, not visibility-scoped, so this is what stops a colleague\n * resurrecting (or destroying) someone else's draft.\n */\nexport type TombstoneAuthorizer<T> = (existing: T, req: Request, res: Response) => boolean;\n\nexport type TombstoneRouteOptions<T extends RestorableEntity> = {\n  orgId: string;\n  userId: string;\n  /** User-facing entity noun for the 400/404 messages ('Pipeline', 'Rule', …). */\n  label: string;\n  /**\n   * The org the tombstone load and the mutation are pinned to. Defaults to\n   * `orgId`; `undefined` spans orgs (system-admin moderation).\n   */\n  scopeOrgId?: string | undefined;\n} & (\n  /** Same authority as delete on the visibility ladder: `publishPermission`\n   *  for a public row, authorship for a private one. */\n  | { publishPermission: Permission; authorize?: undefined }\n  | { authorize: TombstoneAuthorizer<T>; publishPermission?: undefined }\n);\n\n/** Shared prelude: `:id` → own-scope tombstone → authorization. `null` = answered. */\nasync function loadTombstone<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  service: { findDeletedById(id: string, orgId?: string): Promise<T | null> },\n  opts: TombstoneRouteOptions<T>,\n): Promise<{ id: string; existing: T; scope: string | undefined } | null> {\n  const id = getParam(req.params, 'id');\n  if (!id) {\n    sendBadRequest(res, `${opts.label} ID is required.`, ErrorCode.MISSING_REQUIRED_FIELD);\n    return null;\n  }\n  const scope = 'scopeOrgId' in opts ? opts.scopeOrgId : opts.orgId;\n\n  // A live row / unknown id / already-purged → 404, so a currently-active entity\n  // is never restored or hard-deleted through these paths.\n  const existing = await service.findDeletedById(id, scope);\n  if (!existing) {\n    sendEntityNotFound(res, opts.label);\n    return null;\n  }\n\n  const allowed = opts.authorize\n    ? opts.authorize(existing, req, res)\n    : requireVisibilityWriteAccess(req, res, existing, opts.userId, opts.publishPermission);\n  if (!allowed) return null;\n  return { id, existing, scope };\n}\n\n/**\n * Shared skeleton for a step-up-gated entity RESTORE route: extract `:id`, load\n * the tombstone, authorize it, restore, and 404 on miss. Returns\n * `{ existing, restored }` on success, or `null` when it has ALREADY sent a\n * response (400/404/403) — the caller then does the entity-specific audit +\n * response. Step-up is the route's job.\n */\nexport async function loadAndRestore<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  service: RestorableService<T>,\n  opts: TombstoneRouteOptions<T>,\n): Promise<{ existing: T; restored: T } | null> {\n  const loaded = await loadTombstone(req, res, service, opts);\n  if (!loaded) return null;\n\n  const restored = await service.restore(loaded.id, loaded.scope ?? '', opts.userId);\n  if (!restored) {\n    sendEntityNotFound(res, opts.label);\n    return null;\n  }\n  return { existing: loaded.existing, restored };\n}\n\n/**\n * Shared skeleton for an entity PURGE route: the same load + authorization as\n * restore, then a permanent hard-delete via the retention sweep's single-id\n * purge (same tombstone match + dependent-teardown hooks). Returns\n * `{ existing, purgedId }` (the caller audits off `existing`), or `null` when it\n * has ALREADY sent a response. Step-up is the route's job.\n */\nexport async function loadAndPurge<T extends RestorableEntity>(\n  req: Request,\n  res: Response,\n  service: PurgeableService<T>,\n  opts: TombstoneRouteOptions<T>,\n): Promise<{ existing: T; purgedId: string } | null> {\n  const loaded = await loadTombstone(req, res, service, opts);\n  if (!loaded) return null;\n\n  // Null on a race (already purged) → 404.\n  const purgedId = await service.purgeById(loaded.id, loaded.scope ?? '');\n  if (!purgedId) {\n    sendEntityNotFound(res, opts.label);\n    return null;\n  }\n  return { existing: loaded.existing, purgedId };\n}\n"]}

package/lib/helpers/sse-helpers.d.ts

@@ -6,22 +6,44 @@ import type { Request, Response } from 'express';
  * `X-Accel-Buffering: no` (disable nginx buffering) block.
  */
 export declare function writeSseHeaders(res: Response): void;
+/** The slice of an Express/Node response needed to observe a client disconnect. */
+interface ClosableResponse {
+    on(event: 'close', listener: () => void): unknown;
+    readonly writableFinished: boolean;
+}
 /**
- * Set SSE response headers and flush.
- * Returns an `aborted()` function to check if the client disconnected.
+ * An AbortSignal that fires when the client disconnects before the response
+ * finished — cancels a provider call (avoids wasted spend) and tells the route
+ * to stop writing.
  *
  * Disconnect is detected on the RESPONSE: `res` emits 'close' when the
  * underlying connection goes away, and `writableFinished` tells an early close
  * (client gone) from the normal close after `res.end()`. The request's own
  * 'close' is not a disconnect signal — on current Node it fires once the request
- * BODY has been consumed, which for a POST stream happens before this listener
- * is attached, so a disconnect was never observed.
+ * BODY has been consumed (express.json() does that before the handler runs), so
+ * a disconnect would never be observed.
  */
-export declare function initSSEStream(_req: Request, res: Response, timeoutMs: number): {
-    aborted: () => boolean;
-};
+export declare function clientAbortSignal(res: ClosableResponse): AbortSignal;
+/** An open SSE response. */
+export interface SseStream {
+    /** Aborted when the client disconnects before the stream finished. */
+    readonly signal: AbortSignal;
+    /** True once the client has disconnected. */
+    aborted(): boolean;
+    /** Write one `data:` frame carrying `event` as JSON. A no-op after a disconnect. */
+    send(event: unknown): void;
+    /** Write the terminal `data: [DONE]` frame (preceded by `event`, when given).
+     *  A no-op after a disconnect. The caller still ends the response. */
+    done(event?: unknown): void;
+}
+/**
+ * Set SSE response headers, flush, and return the stream's writer plus its
+ * client-disconnect signal (see {@link clientAbortSignal}).
+ */
+export declare function initSSEStream(_req: Request, res: Response, timeoutMs: number): SseStream;
 /**
  * Classify AI generation errors and send the appropriate HTTP response or SSE event.
  * If headers are already sent (streaming), writes an SSE error event and ends the response.
  */
 export declare function handleAIError(res: Response, message: string, fallbackMessage: string): void;
+export {};

package/lib/helpers/sse-helpers.js

@@ -14,24 +14,51 @@ export function writeSseHeaders(res) {
     res.setHeader('X-Accel-Buffering', 'no');
 }
 /**
- * Set SSE response headers and flush.
- * Returns an `aborted()` function to check if the client disconnected.
+ * An AbortSignal that fires when the client disconnects before the response
+ * finished — cancels a provider call (avoids wasted spend) and tells the route
+ * to stop writing.
  *
  * Disconnect is detected on the RESPONSE: `res` emits 'close' when the
  * underlying connection goes away, and `writableFinished` tells an early close
  * (client gone) from the normal close after `res.end()`. The request's own
  * 'close' is not a disconnect signal — on current Node it fires once the request
- * BODY has been consumed, which for a POST stream happens before this listener
- * is attached, so a disconnect was never observed.
+ * BODY has been consumed (express.json() does that before the handler runs), so
+ * a disconnect would never be observed.
+ */
+export function clientAbortSignal(res) {
+    const controller = new AbortController();
+    res.on('close', () => {
+        if (!res.writableFinished)
+            controller.abort();
+    });
+    return controller.signal;
+}
+/**
+ * Set SSE response headers, flush, and return the stream's writer plus its
+ * client-disconnect signal (see {@link clientAbortSignal}).
  */
 export function initSSEStream(_req, res, timeoutMs) {
     writeSseHeaders(res);
     res.setTimeout(timeoutMs);
     res.flushHeaders();
-    let _aborted = false;
-    res.on('close', () => { if (!res.writableFinished)
-        _aborted = true; });
-    return { aborted: () => _aborted };
+    const signal = clientAbortSignal(res);
+    const send = (event) => {
+        if (signal.aborted)
+            return;
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+    };
+    return {
+        signal,
+        aborted: () => signal.aborted,
+        send,
+        done: (event) => {
+            if (signal.aborted)
+                return;
+            if (event !== undefined)
+                send(event);
+            res.write('data: [DONE]\n\n');
+        },
+    };
 }
 /**
  * Classify AI generation errors and send the appropriate HTTP response or SSE event.
@@ -57,4 +84,4 @@ export function handleAIError(res, message, fallbackMessage) {
     res.write(`data: ${JSON.stringify({ type: 'error', message })}\n\n`);
     res.end();
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sse-helpers.js","sourceRoot":"","sources":["../../src/helpers/sse-helpers.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAGtC,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,GAAa;IAC3C,GAAG,CAAC,SAAS,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAC;IACnD,GAAG,CAAC,SAAS,CAAC,eAAe,EAAE,UAAU,CAAC,CAAC;IAC3C,GAAG,CAAC,SAAS,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IAC1C,GAAG,CAAC,SAAS,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAC;AAC3C,CAAC;AAQD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAqB;IACrD,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;QACnB,IAAI,CAAC,GAAG,CAAC,gBAAgB;YAAE,UAAU,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC,CAAC,CAAC;IACH,OAAO,UAAU,CAAC,MAAM,CAAC;AAC3B,CAAC;AAeD;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,IAAa,EAAE,GAAa,EAAE,SAAiB;IAC3E,eAAe,CAAC,GAAG,CAAC,CAAC;IACrB,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC1B,GAAG,CAAC,YAAY,EAAE,CAAC;IACnB,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACtC,MAAM,IAAI,GAAG,CAAC,KAAc,EAAQ,EAAE;QACpC,IAAI,MAAM,CAAC,OAAO;YAAE,OAAO;QAC3B,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC,CAAC;IACF,OAAO;QACL,MAAM;QACN,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO;QAC7B,IAAI;QACJ,IAAI,EAAE,CAAC,KAAe,EAAQ,EAAE;YAC9B,IAAI,MAAM,CAAC,OAAO;gBAAE,OAAO;YAC3B,IAAI,KAAK,KAAK,SAAS;gBAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YACrC,GAAG,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;QAChC,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,GAAa,EAAE,OAAe,EAAE,eAAuB;IACnF,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;QACrB,IAAI,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YACtE,qEAAqE;YACrE,wEAAwE;YACxE,wEAAwE;YACxE,iEAAiE;YACjE,0EAA0E;YAC1E,yEAAyE;YACzE,yEAAyE;YACzE,OAAO,iBAAiB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAAC,EAAE,CAAC;YACnD,OAAO,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;IACvE,CAAC;IACD,GAAG,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;IACrE,GAAG,CAAC,GAAG,EAAE,CAAC;AACZ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Request, Response } from 'express';\nimport { sendBadRequest, sendInternalError } from '../utils/response.js';\n\n/**\n * Set the four standard SSE response headers (does NOT flush — the caller flushes\n * after any additional per-endpoint setup like `res.setTimeout`). The single\n * source of truth for the `text/event-stream` + no-cache + keep-alive +\n * `X-Accel-Buffering: no` (disable nginx buffering) block.\n */\nexport function writeSseHeaders(res: Response): void {\n  res.setHeader('Content-Type', 'text/event-stream');\n  res.setHeader('Cache-Control', 'no-cache');\n  res.setHeader('Connection', 'keep-alive');\n  res.setHeader('X-Accel-Buffering', 'no');\n}\n\n/** The slice of an Express/Node response needed to observe a client disconnect. */\ninterface ClosableResponse {\n  on(event: 'close', listener: () => void): unknown;\n  readonly writableFinished: boolean;\n}\n\n/**\n * An AbortSignal that fires when the client disconnects before the response\n * finished — cancels a provider call (avoids wasted spend) and tells the route\n * to stop writing.\n *\n * Disconnect is detected on the RESPONSE: `res` emits 'close' when the\n * underlying connection goes away, and `writableFinished` tells an early close\n * (client gone) from the normal close after `res.end()`. The request's own\n * 'close' is not a disconnect signal — on current Node it fires once the request\n * BODY has been consumed (express.json() does that before the handler runs), so\n * a disconnect would never be observed.\n */\nexport function clientAbortSignal(res: ClosableResponse): AbortSignal {\n  const controller = new AbortController();\n  res.on('close', () => {\n    if (!res.writableFinished) controller.abort();\n  });\n  return controller.signal;\n}\n\n/** An open SSE response. */\nexport interface SseStream {\n  /** Aborted when the client disconnects before the stream finished. */\n  readonly signal: AbortSignal;\n  /** True once the client has disconnected. */\n  aborted(): boolean;\n  /** Write one `data:` frame carrying `event` as JSON. A no-op after a disconnect. */\n  send(event: unknown): void;\n  /** Write the terminal `data: [DONE]` frame (preceded by `event`, when given).\n   *  A no-op after a disconnect. The caller still ends the response. */\n  done(event?: unknown): void;\n}\n\n/**\n * Set SSE response headers, flush, and return the stream's writer plus its\n * client-disconnect signal (see {@link clientAbortSignal}).\n */\nexport function initSSEStream(_req: Request, res: Response, timeoutMs: number): SseStream {\n  writeSseHeaders(res);\n  res.setTimeout(timeoutMs);\n  res.flushHeaders();\n  const signal = clientAbortSignal(res);\n  const send = (event: unknown): void => {\n    if (signal.aborted) return;\n    res.write(`data: ${JSON.stringify(event)}\\n\\n`);\n  };\n  return {\n    signal,\n    aborted: () => signal.aborted,\n    send,\n    done: (event?: unknown): void => {\n      if (signal.aborted) return;\n      if (event !== undefined) send(event);\n      res.write('data: [DONE]\\n\\n');\n    },\n  };\n}\n\n/**\n * Classify AI generation errors and send the appropriate HTTP response or SSE event.\n * If headers are already sent (streaming), writes an SSE error event and ends the response.\n */\nexport function handleAIError(res: Response, message: string, fallbackMessage: string): void {\n  if (!res.headersSent) {\n    if (message.includes('not configured') || message.includes('API key')) {\n      // Surface the ORIGINAL message. It names the MISSING CONFIGURATION —\n      // \"no provider API key is set and OPENAI_COMPATIBLE_BASE_URL is unset\",\n      // or which env var a named provider wants — never a secret VALUE, so it\n      // is safe to show and it is the only thing that makes this error\n      // actionable. The generic replacement also mis-described the common case:\n      // it said \"for the requested provider\" when no provider was requested at\n      // all, pointing operators at a provider bug instead of at configuration.\n      return sendInternalError(res, message);\n    }\n    if (message.includes('not available for provider')) {\n      return sendBadRequest(res, message);\n    }\n    return sendInternalError(res, fallbackMessage, { details: message });\n  }\n  res.write(`data: ${JSON.stringify({ type: 'error', message })}\\n\\n`);\n  res.end();\n}\n"]}

package/lib/index.d.ts

@@ -19,7 +19,7 @@
  * **Utilities**
  * - createLogger — Winston-based structured logger factory
  * - sendSuccess, sendError, sendPaginatedNested, sendBadRequest, sendInternalError — HTTP response helpers
- * - getParam, getOrgId — request parameter extraction
+ * - getParam — request parameter extraction
  * - parseQueryInt, parseQueryString — query string parsing
  * - getIdentity — identity extraction from requests
  * - actorId — the audit actor for a route context (one `system` sentinel)
@@ -52,25 +52,27 @@
  * PUBLIC SURFACE POLICY
  *
  * The root re-exports the ten sub-barrels, and each SUB-BARREL is the allow-list
- * for its own area — that is where a module is either `export *`'d or narrowed
- * to the names services may use. Internals are excluded there rather than here,
- * so the exclusion sits next to the code that defines them and cannot be missed
- * by someone adding a module.
+ * for its own area: every re-export NAMES what it exports (no `export *`), and
+ * a name is on the list only because some other package — a service, the
+ * frontend, a test, a deploy script — actually imports it. Internals are
+ * excluded there rather than here, so the exclusion sits next to the code that
+ * defines them. Adding an export to a module does NOT publish it; add it to
+ * the sub-barrel when a consumer needs it.
  *
- * Currently narrowed (the rest is the intended surface):
- * - `services/retry-strategy` — decision functions only; `parseRetryAfter` and
- *   `addJitter` are backoff internals.
- * - `services/circuit-breaker` — `CircuitOpenError` + `resetCircuitBreakers`;
- *   the `CircuitBreaker` class is wired by the shared HTTP client, not by
- *   services.
+ * Deliberately internal, for example:
+ * - `services/retry-strategy` — decision functions only; `parseRetryAfter`,
+ *   `addJitter` and the DEFAULT_* constants are backoff internals.
+ * - `services/circuit-breaker` — `resetCircuitBreakers` only; the
+ *   `CircuitBreaker` class is wired by the shared HTTP client, not by services.
  * - `services/service-keys` — verify/inspect only; signing, the key bundle and
  *   `_resetServiceKeysForTests` stay inside.
  * - `utils/jwk` — constants, shapes, decoders and the two signer-facing helpers
  *   platform needs; `jwkThumbprint` / `publicKeyFromJwk` stay inside.
  *
- * api-core's own modules and its `testing/` helpers reach the excluded symbols
- * by DEEP import (`@pipeline-builder/api-core/lib/services/service-keys.js`),
- * which is also how the unit tests reach them.
+ * api-core's own modules reach the excluded symbols by relative import; unit
+ * tests reach them by DEEP import
+ * (`@pipeline-builder/api-core/lib/services/service-keys.js`). Test helpers are
+ * the separate `@pipeline-builder/api-core/testing` entry, never this barrel.
  */
 export * from './types/index.js';
 export * from './constants/index.js';