@pipeline-builder/api-core 0.0.1

package/lib/errors/app-errors.js

@@ -0,0 +1,53 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { ErrorCode, getStatusForErrorCode } from '../types/error-codes.js';
+/**
+ * Base application error with HTTP status code and error code.
+ * Extend this for domain-specific error types.
+ */
+export class AppError extends Error {
+    statusCode;
+    code;
+    constructor(statusCode, code, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = 'AppError';
+    }
+}
+/** 404 — Resource not found. */
+export class NotFoundError extends AppError {
+    constructor(message) {
+        super(getStatusForErrorCode(ErrorCode.NOT_FOUND), ErrorCode.NOT_FOUND, message);
+        this.name = 'NotFoundError';
+    }
+}
+/** 403 — Insufficient permissions. */
+export class ForbiddenError extends AppError {
+    constructor(message) {
+        super(getStatusForErrorCode(ErrorCode.INSUFFICIENT_PERMISSIONS), ErrorCode.INSUFFICIENT_PERMISSIONS, message);
+        this.name = 'ForbiddenError';
+    }
+}
+/** 400 — Validation / bad request. */
+export class ValidationError extends AppError {
+    constructor(message) {
+        super(getStatusForErrorCode(ErrorCode.VALIDATION_ERROR), ErrorCode.VALIDATION_ERROR, message);
+        this.name = 'ValidationError';
+    }
+}
+/** 409 — Conflict / duplicate. */
+export class ConflictError extends AppError {
+    constructor(message) {
+        super(getStatusForErrorCode(ErrorCode.CONFLICT), ErrorCode.CONFLICT, message);
+        this.name = 'ConflictError';
+    }
+}
+/** 401 — Unauthorized / authentication required. */
+export class UnauthorizedError extends AppError {
+    constructor(message) {
+        super(getStatusForErrorCode(ErrorCode.UNAUTHORIZED), ErrorCode.UNAUTHORIZED, message);
+        this.name = 'UnauthorizedError';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './app-errors.js';

package/lib/errors/index.js

@@ -0,0 +1,4 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from './app-errors.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZXJyb3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7QUFFdEMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2FwcC1lcnJvcnMuanMnO1xuIl19

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

@@ -0,0 +1,63 @@
+import type { Request, Response } from 'express';
+import type { Permission } from '../types/permissions.js';
+import type { Visibility } from '../types/visibility.js';
+/** The slice of a catalog entity the write gate needs. */
+export interface VisibilityWriteTarget {
+    /** Rung the row currently sits at — see {@link Visibility}. */
+    visibility?: string;
+    /** Author. The only non-admin who may touch a `private` row. */
+    createdBy?: string;
+}
+/**
+ * Check whether the caller may modify a catalog entity, per its visibility rung.
+ * The single write gate behind every pipeline / plugin / template mutation.
+ *
+ * - `public` — a system admin, or the holder of `publishPermission` (the same
+ *   permission that let them publish it in the first place, so whoever can
+ *   publish can also manage what they published)
+ * - `org` — anyone who got this far: the resource's `:write` permission plus the
+ *   org scoping the caller already passed IS the gate
+ * - `private` — the AUTHOR alone (plus system admins)
+ *
+ * The `private` branch is load-bearing on the TOMBSTONE paths (restore / purge),
+ * which are org-scoped rather than visibility-scoped because soft-delete is one
+ * shared code path — without it, any org member could resurrect someone else's
+ * personal draft. On the live paths the read predicate has already hidden the
+ * row, making this defense in depth.
+ *
+ * Returns `true` if the request may proceed; returns `false` having ALREADY sent
+ * a 403.
+ *
+ * @example
+ * ```typescript
+ * if (!requireVisibilityWriteAccess(req, res, pipeline, userId, 'pipelines:publish')) return;
+ * await pipelineService.delete(id, orgId, userId);
+ * ```
+ */
+export declare function requireVisibilityWriteAccess(req: Request, res: Response, resource: VisibilityWriteTarget, userId: string, publishPermission: Permission): boolean;
+/**
+ * Resolve the effective visibility for an entity being created or updated.
+ *
+ * `public` requires the publish capability (superadmins pass via implicit-all);
+ * a caller who asks for it without the permission is clamped to `org` rather
+ * than dropped to a personal draft — they asked to SHARE it, and `org` is the
+ * widest rung they are entitled to. Anything else passes through.
+ *
+ * `fallback` is the rung an UNSPECIFIED visibility lands on, and it is
+ * deliberately per-entity even though the ladder itself is identical everywhere:
+ *
+ * - **templates** default to `private` — draft-first is the whole point of the
+ *   personal rung; you polish a starter before publishing it.
+ * - **pipelines / plugins** default to `org` — they are team assets that deploy
+ *   shared infrastructure, so creating one must not hide it from the team. A
+ *   personal draft stays available, but opt-in.
+ *
+ * Same ladder, same gate, different centre of gravity — expressed as an argument
+ * rather than a second code path.
+ *
+ * Permission-based (not coarse-role-based): a bespoke custom Role can be granted
+ * publish rights and is no longer forced private by its `member` label. Built-in
+ * Admin/Owner bundles carry the publish permissions; the built-in Member bundle
+ * does not, so members top out at `org`.
+ */
+export declare function resolveVisibility(req: Request, requested: string | undefined, publishPermission: Permission, fallback?: Visibility): Visibility;

package/lib/helpers/access-helpers.js

@@ -0,0 +1,82 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { isSystemAdmin, userHasPermission } from '../middleware/auth.js';
+import { ErrorCode } from '../types/error-codes.js';
+import { sendError } from '../utils/response.js';
+/**
+ * Check whether the caller may modify a catalog entity, per its visibility rung.
+ * The single write gate behind every pipeline / plugin / template mutation.
+ *
+ * - `public` — a system admin, or the holder of `publishPermission` (the same
+ *   permission that let them publish it in the first place, so whoever can
+ *   publish can also manage what they published)
+ * - `org` — anyone who got this far: the resource's `:write` permission plus the
+ *   org scoping the caller already passed IS the gate
+ * - `private` — the AUTHOR alone (plus system admins)
+ *
+ * The `private` branch is load-bearing on the TOMBSTONE paths (restore / purge),
+ * which are org-scoped rather than visibility-scoped because soft-delete is one
+ * shared code path — without it, any org member could resurrect someone else's
+ * personal draft. On the live paths the read predicate has already hidden the
+ * row, making this defense in depth.
+ *
+ * Returns `true` if the request may proceed; returns `false` having ALREADY sent
+ * a 403.
+ *
+ * @example
+ * ```typescript
+ * if (!requireVisibilityWriteAccess(req, res, pipeline, userId, 'pipelines:publish')) return;
+ * await pipelineService.delete(id, orgId, userId);
+ * ```
+ */
+export function requireVisibilityWriteAccess(req, res, resource, userId, publishPermission) {
+    if (isSystemAdmin(req))
+        return true;
+    if (resource.visibility === 'public' && !userHasPermission(req, publishPermission)) {
+        sendError(res, 403, 'You lack permission to modify this public resource.', ErrorCode.INSUFFICIENT_PERMISSIONS);
+        return false;
+    }
+    // Fail closed on an anonymous/absent caller — an empty userId must never match
+    // an empty `createdBy` and hand over someone else's draft.
+    if (resource.visibility === 'private' && (!userId || resource.createdBy !== userId)) {
+        sendError(res, 403, 'Only the author can modify a private resource.', ErrorCode.INSUFFICIENT_PERMISSIONS);
+        return false;
+    }
+    return true;
+}
+/**
+ * Resolve the effective visibility for an entity being created or updated.
+ *
+ * `public` requires the publish capability (superadmins pass via implicit-all);
+ * a caller who asks for it without the permission is clamped to `org` rather
+ * than dropped to a personal draft — they asked to SHARE it, and `org` is the
+ * widest rung they are entitled to. Anything else passes through.
+ *
+ * `fallback` is the rung an UNSPECIFIED visibility lands on, and it is
+ * deliberately per-entity even though the ladder itself is identical everywhere:
+ *
+ * - **templates** default to `private` — draft-first is the whole point of the
+ *   personal rung; you polish a starter before publishing it.
+ * - **pipelines / plugins** default to `org` — they are team assets that deploy
+ *   shared infrastructure, so creating one must not hide it from the team. A
+ *   personal draft stays available, but opt-in.
+ *
+ * Same ladder, same gate, different centre of gravity — expressed as an argument
+ * rather than a second code path.
+ *
+ * Permission-based (not coarse-role-based): a bespoke custom Role can be granted
+ * publish rights and is no longer forced private by its `member` label. Built-in
+ * Admin/Owner bundles carry the publish permissions; the built-in Member bundle
+ * does not, so members top out at `org`.
+ */
+export function resolveVisibility(req, requested, publishPermission, fallback = 'private') {
+    if (requested === 'public') {
+        return userHasPermission(req, publishPermission) ? 'public' : 'org';
+    }
+    if (requested === 'org')
+        return 'org';
+    if (requested === 'private')
+        return 'private';
+    return fallback;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,9 @@
+import type { Response } from 'express';
+/**
+ * Coerce listed fields on a DB-returned record to arrays. Drizzle/pg sometimes
+ * returns `null` for jsonb columns when the row was inserted with a missing
+ * key — callers expect `[]` so map iteration doesn't crash.
+ */
+export declare function normalizeArrayFields<T extends Record<string, unknown>>(record: T, arrayFields: (keyof T)[]): T;
+/** Send a 404 NOT_FOUND error with a standard `${entityName} not found.` message. */
+export declare function sendEntityNotFound(res: Response, entityName: string): void;

package/lib/helpers/crud-helpers.js

@@ -0,0 +1,23 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { ErrorCode } from '../types/error-codes.js';
+import { sendError } from '../utils/response.js';
+/**
+ * Coerce listed fields on a DB-returned record to arrays. Drizzle/pg sometimes
+ * returns `null` for jsonb columns when the row was inserted with a missing
+ * key — callers expect `[]` so map iteration doesn't crash.
+ */
+export function normalizeArrayFields(record, arrayFields) {
+    const normalized = { ...record };
+    for (const field of arrayFields) {
+        if (field in normalized && !Array.isArray(normalized[field])) {
+            normalized[field] = [];
+        }
+    }
+    return normalized;
+}
+/** Send a 404 NOT_FOUND error with a standard `${entityName} not found.` message. */
+export function sendEntityNotFound(res, entityName) {
+    sendError(res, 404, `${entityName} not found.`, ErrorCode.NOT_FOUND);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/helpers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './crud-helpers.js';
+export * from './access-helpers.js';
+export * from './restore-helpers.js';
+export * from './sse-helpers.js';
+export * from './org-hierarchy.js';
+export * from './org-hierarchy-http.js';

package/lib/helpers/index.js

@@ -0,0 +1,9 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+export * from './crud-helpers.js';
+export * from './access-helpers.js';
+export * from './restore-helpers.js';
+export * from './sse-helpers.js';
+export * from './org-hierarchy.js';
+export * from './org-hierarchy-http.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQ0FBK0M7QUFDL0Msc0NBQXNDO0FBRXRDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vY3J1ZC1oZWxwZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vYWNjZXNzLWhlbHBlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXN0b3JlLWhlbHBlcnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9zc2UtaGVscGVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL29yZy1oaWVyYXJjaHkuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9vcmctaGllcmFyY2h5LWh0dHAuanMnO1xuIl19

package/lib/helpers/org-hierarchy-http.d.ts

@@ -0,0 +1,74 @@
+import type { ServiceConfig } from '../types/common.js';
+/** Options shared by the platform org-hierarchy HTTP lookups. */
+export interface OrgHierarchyHttpOptions {
+    /** Platform service host/port (+ optional default timeout) for the client. */
+    service: ServiceConfig;
+    /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */
+    serviceName: string;
+    /**
+     * Org id embedded in the signed service token's org context. Defaults to the
+     * queried `orgId`; pass a system org id for a system-scoped lookup.
+     */
+    authOrgId?: string;
+    /** Role carried by the service token (default 'member' — least privilege). */
+    role?: 'owner' | 'admin' | 'member';
+    /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */
+    headers?: Record<string, string>;
+    /** Per-request timeout override in ms (falls back to the client default). */
+    timeout?: number;
+    /**
+     * When true, a non-2xx response THROWS instead of resolving to `undefined`.
+     * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the
+     * message/reporting root-resolution callers rely on). A caller for whom a
+     * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a
+     * team org as parent-less would silently skip inherited blocking rules — sets
+     * this so it can distinguish "root org" (`undefined`) from "lookup failed".
+     */
+    throwOnHttpError?: boolean;
+}
+/**
+ * Resolve an org's direct parent id via platform's
+ * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx
+ * response resolves to `undefined` by default, or THROWS when
+ * `throwOnHttpError` is set. Always throws on a transport failure
+ * (connection/timeout) so the caller can apply its own fallback.
+ */
+export declare function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined>;
+/**
+ * Resolve `[self, ...descendantOrgIds]` for an org via platform's
+ * `GET /organization/:id/descendants`. Returns the id list only when it is
+ * larger than the org itself (a real subtree), else `undefined`; also
+ * `undefined` on a non-2xx response. Throws on a transport failure so the
+ * caller can apply its own fallback.
+ *
+ * This is a trust boundary: the response is validated element-by-element rather
+ * than cast — every entry must be a string, and any non-string is dropped — so
+ * a malformed payload can never smuggle a non-string into the returned
+ * `string[]`.
+ */
+export declare function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined>;
+/**
+ * Batch-resolve org id → display NAME via platform's `POST /organization/names`.
+ * Returns a lowercased `{ [orgId]: name }` map — ids the platform doesn't know
+ * are simply absent (caller falls back to the raw id).
+ *
+ * Best-effort by design: a non-2xx response (e.g. the caller isn't a service
+ * principal) or a malformed body yields `{}`, and it throws ONLY on a transport
+ * failure (connection/timeout) — matching the fail-soft policy of the other
+ * lookups here so a name-enrichment read never fails the caller's request. The
+ * response is validated entry-by-entry (only string→string pairs survive), so a
+ * malformed payload can't smuggle a non-string into the returned map.
+ */
+export declare function fetchOrgNames(orgIds: string[], opts: OrgHierarchyHttpOptions): Promise<Record<string, string>>;
+/**
+ * Check whether `userId` is an ACTIVE member of `orgId` via platform's
+ * `GET /organization/:id/members/:userId/exists`. Returns the boolean the
+ * platform reports.
+ *
+ * Returns `undefined` (— "couldn't determine") on a non-2xx response, and
+ * throws only on a transport failure (connection/timeout) — so the caller
+ * distinguishes a definitive not-a-member (`false`) from an indeterminate
+ * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`
+ * differs from the parent/descendants shape, so this builds its own request.
+ */
+export declare function fetchOrgMembership(orgId: string, userId: string, opts: OrgHierarchyHttpOptions): Promise<boolean | undefined>;

package/lib/helpers/org-hierarchy-http.js

@@ -0,0 +1,144 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Org → team hierarchy lookups over HTTP against the platform service.
+ *
+ * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that
+ * own the org table (platform, quota). Everyone else reads the hierarchy over
+ * the wire from platform's authoritative `/organization/:id/*` endpoints. This
+ * module centralizes the transport for those reads — URL construction, the
+ * signed service-token auth header, and timeout+retry via the shared
+ * {@link InternalHttpClient} — so compliance, reporting, and any future caller
+ * share ONE mechanism instead of each hand-rolling a `fetch`/client with its
+ * own auth and failure semantics.
+ *
+ * These functions deliberately do NOT swallow transport errors: a connection
+ * failure/timeout propagates so each caller keeps its own fallback policy (log
+ * level, degrade-to-self vs. return-undefined). A non-2xx response is treated
+ * as "no data" (returns undefined), matching what the callers previously did.
+ */
+import { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';
+import { InternalHttpClient } from '../services/http-client.js';
+function buildRequest(orgId, suffix, opts) {
+    const client = new InternalHttpClient(opts.service);
+    const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;
+    const headers = {
+        Authorization: getServiceAuthHeader({
+            serviceName: opts.serviceName,
+            orgId: opts.authOrgId ?? orgId,
+            role: opts.role ?? 'member',
+        }),
+        ...opts.headers,
+    };
+    return { client, path, headers };
+}
+/**
+ * Resolve an org's direct parent id via platform's
+ * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx
+ * response resolves to `undefined` by default, or THROWS when
+ * `throwOnHttpError` is set. Always throws on a transport failure
+ * (connection/timeout) so the caller can apply its own fallback.
+ */
+export async function fetchParentOrgId(orgId, opts) {
+    const { client, path, headers } = buildRequest(orgId, 'parent', opts);
+    const res = await client.get(path, { headers, timeout: opts.timeout });
+    if (res.statusCode >= 400) {
+        if (opts.throwOnHttpError) {
+            throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);
+        }
+        return undefined;
+    }
+    return res.body?.data?.parentOrgId ?? undefined;
+}
+/**
+ * Resolve `[self, ...descendantOrgIds]` for an org via platform's
+ * `GET /organization/:id/descendants`. Returns the id list only when it is
+ * larger than the org itself (a real subtree), else `undefined`; also
+ * `undefined` on a non-2xx response. Throws on a transport failure so the
+ * caller can apply its own fallback.
+ *
+ * This is a trust boundary: the response is validated element-by-element rather
+ * than cast — every entry must be a string, and any non-string is dropped — so
+ * a malformed payload can never smuggle a non-string into the returned
+ * `string[]`.
+ */
+export async function fetchOrgDescendants(orgId, opts) {
+    const { client, path, headers } = buildRequest(orgId, 'descendants', opts);
+    const res = await client.get(path, { headers, timeout: opts.timeout });
+    if (res.statusCode >= 400)
+        return undefined;
+    const ids = res.body?.data?.orgIds;
+    if (!Array.isArray(ids))
+        return undefined;
+    const orgIds = ids.filter((id) => typeof id === 'string');
+    // Only meaningful when the (validated) subtree is larger than the org itself.
+    return orgIds.length > 1 ? orgIds : undefined;
+}
+/**
+ * Batch-resolve org id → display NAME via platform's `POST /organization/names`.
+ * Returns a lowercased `{ [orgId]: name }` map — ids the platform doesn't know
+ * are simply absent (caller falls back to the raw id).
+ *
+ * Best-effort by design: a non-2xx response (e.g. the caller isn't a service
+ * principal) or a malformed body yields `{}`, and it throws ONLY on a transport
+ * failure (connection/timeout) — matching the fail-soft policy of the other
+ * lookups here so a name-enrichment read never fails the caller's request. The
+ * response is validated entry-by-entry (only string→string pairs survive), so a
+ * malformed payload can't smuggle a non-string into the returned map.
+ */
+export async function fetchOrgNames(orgIds, opts) {
+    if (orgIds.length === 0)
+        return {};
+    const client = new InternalHttpClient(opts.service);
+    const headers = {
+        Authorization: getServiceAuthHeader({
+            serviceName: opts.serviceName,
+            // A cross-org registry read, not a tenant-scoped op — default to the system
+            // org context when the caller doesn't pin one.
+            orgId: opts.authOrgId ?? SYSTEM_ORG_ID,
+            role: opts.role ?? 'member',
+        }),
+        ...opts.headers,
+    };
+    const res = await client.post('/organization/names', { orgIds }, { headers, timeout: opts.timeout });
+    if (res.statusCode >= 400)
+        return {};
+    const names = res.body?.data?.names;
+    if (!names || typeof names !== 'object')
+        return {};
+    const out = {};
+    for (const [id, name] of Object.entries(names)) {
+        if (typeof name === 'string')
+            out[id.toLowerCase()] = name;
+    }
+    return out;
+}
+/**
+ * Check whether `userId` is an ACTIVE member of `orgId` via platform's
+ * `GET /organization/:id/members/:userId/exists`. Returns the boolean the
+ * platform reports.
+ *
+ * Returns `undefined` (— "couldn't determine") on a non-2xx response, and
+ * throws only on a transport failure (connection/timeout) — so the caller
+ * distinguishes a definitive not-a-member (`false`) from an indeterminate
+ * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`
+ * differs from the parent/descendants shape, so this builds its own request.
+ */
+export async function fetchOrgMembership(orgId, userId, opts) {
+    const client = new InternalHttpClient(opts.service);
+    const path = `/organization/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}/exists`;
+    const headers = {
+        Authorization: getServiceAuthHeader({
+            serviceName: opts.serviceName,
+            orgId: opts.authOrgId ?? orgId,
+            role: opts.role ?? 'member',
+        }),
+        ...opts.headers,
+    };
+    const res = await client.get(path, { headers, timeout: opts.timeout });
+    if (res.statusCode >= 400)
+        return undefined;
+    const isMember = res.body?.data?.isMember;
+    return typeof isMember === 'boolean' ? isMember : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"org-hierarchy-http.js","sourceRoot":"","sources":["../../src/helpers/org-hierarchy-http.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 lookups over HTTP against the platform service.\n *\n * The Mongoose-based traversal in {@link ./org-hierarchy} is for services that\n * own the org table (platform, quota). Everyone else reads the hierarchy over\n * the wire from platform's authoritative `/organization/:id/*` endpoints. This\n * module centralizes the transport for those reads — URL construction, the\n * signed service-token auth header, and timeout+retry via the shared\n * {@link InternalHttpClient} — so compliance, reporting, and any future caller\n * share ONE mechanism instead of each hand-rolling a `fetch`/client with its\n * own auth and failure semantics.\n *\n * These functions deliberately do NOT swallow transport errors: a connection\n * failure/timeout propagates so each caller keeps its own fallback policy (log\n * level, degrade-to-self vs. return-undefined). A non-2xx response is treated\n * as \"no data\" (returns undefined), matching what the callers previously did.\n */\n\nimport { getServiceAuthHeader, SYSTEM_ORG_ID } from '../middleware/auth.js';\nimport { InternalHttpClient } from '../services/http-client.js';\nimport type { ServiceConfig } from '../types/common.js';\n\n/** Options shared by the platform org-hierarchy HTTP lookups. */\nexport interface OrgHierarchyHttpOptions {\n  /** Platform service host/port (+ optional default timeout) for the client. */\n  service: ServiceConfig;\n  /** Service name minted into the service-auth JWT `sub` (e.g. 'compliance'). */\n  serviceName: string;\n  /**\n   * Org id embedded in the signed service token's org context. Defaults to the\n   * queried `orgId`; pass a system org id for a system-scoped lookup.\n   */\n  authOrgId?: string;\n  /** Role carried by the service token (default 'member' — least privilege). */\n  role?: 'owner' | 'admin' | 'member';\n  /** Extra request headers merged after `Authorization` (e.g. `x-org-id`). */\n  headers?: Record<string, string>;\n  /** Per-request timeout override in ms (falls back to the client default). */\n  timeout?: number;\n  /**\n   * When true, a non-2xx response THROWS instead of resolving to `undefined`.\n   * Default false (a 4xx/5xx maps to `undefined`, the fail-soft policy the\n   * message/reporting root-resolution callers rely on). A caller for whom a\n   * failed lookup must fail-CLOSED — e.g. a compliance scan, where treating a\n   * team org as parent-less would silently skip inherited blocking rules — sets\n   * this so it can distinguish \"root org\" (`undefined`) from \"lookup failed\".\n   */\n  throwOnHttpError?: boolean;\n}\n\nfunction buildRequest(\n  orgId: string,\n  suffix: 'parent' | 'descendants',\n  opts: OrgHierarchyHttpOptions,\n): { client: InternalHttpClient; path: string; headers: Record<string, string> } {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/${suffix}`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  return { client, path, headers };\n}\n\n/**\n * Resolve an org's direct parent id via platform's\n * `GET /organization/:id/parent`. Returns `undefined` for a root org. A non-2xx\n * response resolves to `undefined` by default, or THROWS when\n * `throwOnHttpError` is set. Always throws on a transport failure\n * (connection/timeout) so the caller can apply its own fallback.\n */\nexport async function fetchParentOrgId(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'parent', opts);\n  const res = await client.get<{ data?: { parentOrgId?: string | null } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) {\n    if (opts.throwOnHttpError) {\n      throw new Error(`parent-org lookup failed for ${orgId}: HTTP ${res.statusCode}`);\n    }\n    return undefined;\n  }\n  return res.body?.data?.parentOrgId ?? undefined;\n}\n\n/**\n * Resolve `[self, ...descendantOrgIds]` for an org via platform's\n * `GET /organization/:id/descendants`. Returns the id list only when it is\n * larger than the org itself (a real subtree), else `undefined`; also\n * `undefined` on a non-2xx response. Throws on a transport failure so the\n * caller can apply its own fallback.\n *\n * This is a trust boundary: the response is validated element-by-element rather\n * than cast — every entry must be a string, and any non-string is dropped — so\n * a malformed payload can never smuggle a non-string into the returned\n * `string[]`.\n */\nexport async function fetchOrgDescendants(orgId: string, opts: OrgHierarchyHttpOptions): Promise<string[] | undefined> {\n  const { client, path, headers } = buildRequest(orgId, 'descendants', opts);\n  const res = await client.get<{ data?: { orgIds?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const ids = res.body?.data?.orgIds;\n  if (!Array.isArray(ids)) return undefined;\n  const orgIds = ids.filter((id): id is string => typeof id === 'string');\n  // Only meaningful when the (validated) subtree is larger than the org itself.\n  return orgIds.length > 1 ? orgIds : undefined;\n}\n\n/**\n * Batch-resolve org id → display NAME via platform's `POST /organization/names`.\n * Returns a lowercased `{ [orgId]: name }` map — ids the platform doesn't know\n * are simply absent (caller falls back to the raw id).\n *\n * Best-effort by design: a non-2xx response (e.g. the caller isn't a service\n * principal) or a malformed body yields `{}`, and it throws ONLY on a transport\n * failure (connection/timeout) — matching the fail-soft policy of the other\n * lookups here so a name-enrichment read never fails the caller's request. The\n * response is validated entry-by-entry (only string→string pairs survive), so a\n * malformed payload can't smuggle a non-string into the returned map.\n */\nexport async function fetchOrgNames(\n  orgIds: string[],\n  opts: OrgHierarchyHttpOptions,\n): Promise<Record<string, string>> {\n  if (orgIds.length === 0) return {};\n  const client = new InternalHttpClient(opts.service);\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      // A cross-org registry read, not a tenant-scoped op — default to the system\n      // org context when the caller doesn't pin one.\n      orgId: opts.authOrgId ?? SYSTEM_ORG_ID,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  const res = await client.post<{ data?: { names?: unknown } }>(\n    '/organization/names',\n    { orgIds },\n    { headers, timeout: opts.timeout },\n  );\n  if (res.statusCode >= 400) return {};\n  const names = res.body?.data?.names;\n  if (!names || typeof names !== 'object') return {};\n  const out: Record<string, string> = {};\n  for (const [id, name] of Object.entries(names as Record<string, unknown>)) {\n    if (typeof name === 'string') out[id.toLowerCase()] = name;\n  }\n  return out;\n}\n\n/**\n * Check whether `userId` is an ACTIVE member of `orgId` via platform's\n * `GET /organization/:id/members/:userId/exists`. Returns the boolean the\n * platform reports.\n *\n * Returns `undefined` (— \"couldn't determine\") on a non-2xx response, and\n * throws only on a transport failure (connection/timeout) — so the caller\n * distinguishes a definitive not-a-member (`false`) from an indeterminate\n * lookup (`undefined`) and applies its own fail-open/closed policy. The `path`\n * differs from the parent/descendants shape, so this builds its own request.\n */\nexport async function fetchOrgMembership(\n  orgId: string,\n  userId: string,\n  opts: OrgHierarchyHttpOptions,\n): Promise<boolean | undefined> {\n  const client = new InternalHttpClient(opts.service);\n  const path = `/organization/${encodeURIComponent(orgId)}/members/${encodeURIComponent(userId)}/exists`;\n  const headers: Record<string, string> = {\n    Authorization: getServiceAuthHeader({\n      serviceName: opts.serviceName,\n      orgId: opts.authOrgId ?? orgId,\n      role: opts.role ?? 'member',\n    }),\n    ...opts.headers,\n  };\n  const res = await client.get<{ data?: { isMember?: unknown } }>(path, { headers, timeout: opts.timeout });\n  if (res.statusCode >= 400) return undefined;\n  const isMember = res.body?.data?.isMember;\n  return typeof isMember === 'boolean' ? isMember : undefined;\n}\n"]}

package/lib/helpers/org-hierarchy.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 declare const MAX_ORG_DEPTH = 16;
+/** Fetch an org's direct `parentOrgId`, or undefined for a root/missing org. */
+export type GetParentOrgId = (orgId: string) => Promise<string | undefined>;
+/** Fetch the direct child org ids of every org in `frontier` (one round of BFS). */
+export type GetChildOrgIds = (frontier: string[]) => Promise<string[]>;
+/** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */
+export declare function toOrgIdString(v: unknown): string | undefined;
+export interface OrgLineage {
+    /** The org's direct parent id, or `undefined` when it's a root org. */
+    parentOrgId?: string;
+    /** Top of the ancestry chain. Equals the input `orgId` for a root org. */
+    rootOrgId: string;
+}
+/**
+ * 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 declare function resolveOrgLineageWith(orgId: string, getParent: GetParentOrgId): Promise<OrgLineage>;
+/** Walk `parentOrgId` up to the root and return just the root id. */
+export declare function resolveRootOrgIdWith(orgId: string, getParent: GetParentOrgId): Promise<string>;
+/**
+ * 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 declare function isAncestorOrgWith(ancestorOrgId: string, candidateOrgId: string, getParent: GetParentOrgId): Promise<boolean>;
+/**
+ * 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 declare function expandOrgScopeWith(orgId: string, getChildren: GetChildOrgIds): Promise<string[]>;