@pipeline-builder/api-core 0.0.1

package/lib/helpers/org-hierarchy.js

@@ -0,0 +1,110 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Org → team hierarchy traversal (org-team-hierarchy proposal).
+ *
+ * A "team" is an organization whose `parentOrgId` points at another org; a root
+ * org has `parentOrgId = null`. These helpers walk that single self-referential
+ * column, but hold **no database dependency** of their own: each takes a query
+ * callback so every service (platform, quota, …) can share the cycle-safe,
+ * depth-capped traversal logic while reading its own Mongoose model with its own
+ * `_id` casting rules.
+ *
+ *   - {@link resolveOrgLineageWith} — UP: direct parent + root of the chain.
+ *   - {@link resolveRootOrgIdWith}   — UP: just the root id.
+ *   - {@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.
+ */
+/** Hard ceiling on ancestry/descendant traversal — cycle + abuse guard. */
+export const MAX_ORG_DEPTH = 16;
+/** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */
+export function toOrgIdString(v) {
+    if (v === null || v === undefined)
+        return undefined;
+    const s = String(v);
+    return s && s !== 'null' && s !== 'undefined' ? s : undefined;
+}
+/**
+ * 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
+ * detected cycle, a missing org, or the depth cap, traversal stops and the last
+ * reached id is treated as the root.
+ */
+export async function resolveOrgLineageWith(orgId, getParent) {
+    const seen = new Set([orgId]);
+    let currentId = orgId;
+    let parentOrgId;
+    for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {
+        const parent = toOrgIdString(await getParent(currentId));
+        if (!parent)
+            break; // currentId is the root
+        // Record the direct parent only when it isn't a self-loop, so a malformed
+        // A→A org isn't reported as its own parent.
+        if (depth === 0 && parent !== orgId)
+            parentOrgId = parent;
+        if (seen.has(parent))
+            break; // cycle — treat currentId as the root
+        seen.add(parent);
+        currentId = parent;
+    }
+    return { rootOrgId: currentId, ...(parentOrgId && { parentOrgId }) };
+}
+/** Walk `parentOrgId` up to the root and return just the root id. */
+export async function resolveRootOrgIdWith(orgId, getParent) {
+    return (await resolveOrgLineageWith(orgId, getParent)).rootOrgId;
+}
+/**
+ * True when `ancestorOrgId` is an ancestor of `candidateOrgId` — i.e.
+ * `candidateOrgId` lives somewhere in the subtree rooted at `ancestorOrgId`.
+ * Walks `candidateOrgId`'s parent chain upward, depth-capped and cycle-safe.
+ * Returns `false` when the two are equal (an org is not its own ancestor) or
+ * unrelated.
+ */
+export async function isAncestorOrgWith(ancestorOrgId, candidateOrgId, getParent) {
+    if (ancestorOrgId === candidateOrgId)
+        return false;
+    const seen = new Set([candidateOrgId]);
+    let currentId = candidateOrgId;
+    for (let depth = 0; depth < MAX_ORG_DEPTH; depth++) {
+        const parent = toOrgIdString(await getParent(currentId));
+        if (!parent)
+            return false; // reached a root without matching
+        if (parent === ancestorOrgId)
+            return true;
+        if (seen.has(parent))
+            return false; // cycle
+        seen.add(parent);
+        currentId = parent;
+    }
+    return false;
+}
+/**
+ * Expand `orgId` to itself plus every descendant org id (breadth-first over
+ * `parentOrgId`). This is the scope a parent org "sees" for visibility and
+ * analytics rollups: `[self, ...descendants]`. Returns `[orgId]` when the org
+ * has no children. Cycle-safe and depth-capped.
+ */
+export async function expandOrgScopeWith(orgId, getChildren) {
+    const result = [orgId];
+    const seen = new Set([orgId]);
+    let frontier = [orgId];
+    for (let depth = 0; depth < MAX_ORG_DEPTH && frontier.length > 0; depth++) {
+        const children = await getChildren(frontier);
+        const next = [];
+        for (const raw of children) {
+            const id = toOrgIdString(raw);
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            result.push(id);
+            next.push(id);
+        }
+        frontier = next;
+    }
+    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\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"]}

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

@@ -0,0 +1,49 @@
+import type { Request, Response } from 'express';
+import type { Permission } from '../types/permissions.js';
+/** Minimal shape a restore route needs from the entity it restores. */
+export interface RestorableEntity {
+    orgId: string;
+    /** Rung the tombstone sat at — drives the restore/purge authority check. */
+    visibility?: string;
+    /** Author — the only non-admin who may restore/purge a `private` row. */
+    createdBy?: string;
+}
+/** The slice of a service a restore route uses (satisfied by any CrudService). */
+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). Purge is intentionally NOT step-up
+ * gated: it only finalizes what the retention sweep would remove anyway, and the
+ * frontend gates it with an explicit confirm dialog. DRYs the near-identical
+ * pipeline / pipeline_template purge routes.
+ */
+export declare function loadAndPurge<T extends RestorableEntity>(req: Request, res: Response, orgId: string, service: PurgeableService<T>, label: string, publishPermission: Permission, userId: string): Promise<{
+    existing: T;
+    purgedId: string;
+} | null>;

package/lib/helpers/restore-helpers.js

@@ -0,0 +1,78 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { requireVisibilityWriteAccess } from './access-helpers.js';
+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) {
+    const id = getParam(req.params, 'id');
+    if (!id) {
+        sendBadRequest(res, `${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);
+    if (!existing) {
+        sendEntityNotFound(res, 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);
+        return null;
+    }
+    return { existing, restored };
+}
+/**
+ * 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). Purge is intentionally NOT step-up
+ * gated: it only finalizes what the retention sweep would remove anyway, and the
+ * frontend gates it with an explicit confirm dialog. DRYs the near-identical
+ * pipeline / pipeline_template purge routes.
+ */
+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);
+        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);
+        return null;
+    }
+    // Same ladder authority as delete/restore (see loadAndRestore).
+    if (!requireVisibilityWriteAccess(req, res, existing, userId || '', publishPermission))
+        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);
+    if (!purgedId) {
+        sendEntityNotFound(res, label);
+        return null;
+    }
+    return { 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). Purge is intentionally NOT step-up\n * gated: it only finalizes what the retention sweep would remove anyway, and the\n * frontend gates it with an explicit confirm dialog. 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"]}

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

@@ -0,0 +1,20 @@
+import type { Request, Response } from 'express';
+/**
+ * Set the four standard SSE response headers (does NOT flush — the caller flushes
+ * after any additional per-endpoint setup like `res.setTimeout`). The single
+ * source of truth for the `text/event-stream` + no-cache + keep-alive +
+ * `X-Accel-Buffering: no` (disable nginx buffering) block.
+ */
+export declare function writeSseHeaders(res: Response): void;
+/**
+ * Set SSE response headers and flush.
+ * Returns an `aborted()` function to check if the client disconnected.
+ */
+export declare function initSSEStream(req: Request, res: Response, timeoutMs: number): {
+    aborted: () => boolean;
+};
+/**
+ * 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;

package/lib/helpers/sse-helpers.js

@@ -0,0 +1,45 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { sendBadRequest, sendInternalError } from '../utils/response.js';
+/**
+ * Set the four standard SSE response headers (does NOT flush — the caller flushes
+ * after any additional per-endpoint setup like `res.setTimeout`). The single
+ * source of truth for the `text/event-stream` + no-cache + keep-alive +
+ * `X-Accel-Buffering: no` (disable nginx buffering) block.
+ */
+export function writeSseHeaders(res) {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+}
+/**
+ * Set SSE response headers and flush.
+ * Returns an `aborted()` function to check if the client disconnected.
+ */
+export function initSSEStream(req, res, timeoutMs) {
+    writeSseHeaders(res);
+    res.setTimeout(timeoutMs);
+    res.flushHeaders();
+    let _aborted = false;
+    req.on('close', () => { _aborted = true; });
+    return { aborted: () => _aborted };
+}
+/**
+ * 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 function handleAIError(res, message, fallbackMessage) {
+    if (!res.headersSent) {
+        if (message.includes('not configured') || message.includes('API key')) {
+            return sendInternalError(res, 'AI generation is not configured for the requested provider');
+        }
+        if (message.includes('not available for provider')) {
+            return sendBadRequest(res, message);
+        }
+        return sendInternalError(res, fallbackMessage, { details: message });
+    }
+    res.write(`data: ${JSON.stringify({ type: 'error', message })}\n\n`);
+    res.end();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @module @pipeline-builder/api-core
+ *
+ * Core API utilities shared across all services.
+ *
+ * **Middleware**
+ * - requireAuth, requireSystemAdmin, requireFeature — JWT authentication
+ * - isSystemAdmin, isServicePrincipal — authorization helpers (isSystemOrgId remains as a content-owner check, not a privilege gate)
+ * - signServiceToken, getServiceAuthHeader — inter-service JWT minting
+ *
+ * **Types**
+ * - ErrorCode, ErrorCodeStatus — standardized error code enum and status mapping
+ * - RequestIdentity — parsed JWT identity
+ * - ServiceConfig, RequestOptions — HTTP client types
+ * - QuotaType, QuotaCheckResult — quota service types
+ * - PipelineType, ComputeType, Visibility — pipeline domain types
+ * - FeatureFlags — feature flag types
+ *
+ * **Utilities**
+ * - createLogger — Winston-based structured logger factory
+ * - sendSuccess, sendError, sendPaginatedNested, sendBadRequest, sendInternalError — HTTP response helpers
+ * - getParam, getOrgId — request parameter extraction
+ * - parseQueryInt, parseQueryString — query string parsing
+ * - getIdentity — identity extraction from requests
+ * - errorMessage — safe error-to-string conversion
+ *
+ * **Constants**
+ * - HTTP status codes, AI provider identifiers, time constants
+ *
+ * **Services**
+ * - InternalHttpClient, createSafeClient — internal service-to-service HTTP client
+ * - createQuotaService — quota enforcement client factory
+ * - CacheService — in-memory TTL cache
+ * - ComplianceClient — compliance service client
+ * - EntityEventEmitter — domain event pub/sub
+ *
+ * **Errors**
+ * - AppError, NotFoundError, ForbiddenError — typed HTTP error classes
+ *
+ * **Validation**
+ * - Zod-based request validation schemas and middleware
+ *
+ * **Routes**
+ * - Health check route factory
+ *
+ * **OpenAPI**
+ * - Schema registry and spec generation
+ */
+export * from './types/index.js';
+export * from './constants/index.js';
+export * from './utils/index.js';
+export * from './helpers/index.js';
+export * from './services/index.js';
+export * from './middleware/index.js';
+export * from './routes/index.js';
+export * from './errors/index.js';
+export * from './validation/index.js';
+export * from './openapi/index.js';

package/lib/index.js

@@ -0,0 +1,71 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * @module @pipeline-builder/api-core
+ *
+ * Core API utilities shared across all services.
+ *
+ * **Middleware**
+ * - requireAuth, requireSystemAdmin, requireFeature — JWT authentication
+ * - isSystemAdmin, isServicePrincipal — authorization helpers (isSystemOrgId remains as a content-owner check, not a privilege gate)
+ * - signServiceToken, getServiceAuthHeader — inter-service JWT minting
+ *
+ * **Types**
+ * - ErrorCode, ErrorCodeStatus — standardized error code enum and status mapping
+ * - RequestIdentity — parsed JWT identity
+ * - ServiceConfig, RequestOptions — HTTP client types
+ * - QuotaType, QuotaCheckResult — quota service types
+ * - PipelineType, ComputeType, Visibility — pipeline domain types
+ * - FeatureFlags — feature flag types
+ *
+ * **Utilities**
+ * - createLogger — Winston-based structured logger factory
+ * - sendSuccess, sendError, sendPaginatedNested, sendBadRequest, sendInternalError — HTTP response helpers
+ * - getParam, getOrgId — request parameter extraction
+ * - parseQueryInt, parseQueryString — query string parsing
+ * - getIdentity — identity extraction from requests
+ * - errorMessage — safe error-to-string conversion
+ *
+ * **Constants**
+ * - HTTP status codes, AI provider identifiers, time constants
+ *
+ * **Services**
+ * - InternalHttpClient, createSafeClient — internal service-to-service HTTP client
+ * - createQuotaService — quota enforcement client factory
+ * - CacheService — in-memory TTL cache
+ * - ComplianceClient — compliance service client
+ * - EntityEventEmitter — domain event pub/sub
+ *
+ * **Errors**
+ * - AppError, NotFoundError, ForbiddenError — typed HTTP error classes
+ *
+ * **Validation**
+ * - Zod-based request validation schemas and middleware
+ *
+ * **Routes**
+ * - Health check route factory
+ *
+ * **OpenAPI**
+ * - Schema registry and spec generation
+ */
+// Types
+export * from './types/index.js';
+// Constants
+export * from './constants/index.js';
+// Utils
+export * from './utils/index.js';
+// Helpers
+export * from './helpers/index.js';
+// Services
+export * from './services/index.js';
+// Middleware
+export * from './middleware/index.js';
+// Routes
+export * from './routes/index.js';
+// Errors
+export * from './errors/index.js';
+// Validation
+export * from './validation/index.js';
+// OpenAPI
+export * from './openapi/index.js';
+//# sourceMappingURL=data:application/json;base64,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