@pipeline-builder/api-core 3.4.58 → 3.4.60

package/lib/helpers/index.d.ts

@@ -2,3 +2,4 @@ export * from './crud-helpers';
 export * from './access-helpers';
 export * from './mask-helpers';
 export * from './sse-helpers';
+export * from './org-hierarchy';

package/lib/helpers/index.js

@@ -20,4 +20,5 @@ __exportStar(require("./crud-helpers"), exports);
 __exportStar(require("./access-helpers"), exports);
 __exportStar(require("./mask-helpers"), exports);
 __exportStar(require("./sse-helpers"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0NBQStDO0FBQy9DLHNDQUFzQzs7Ozs7Ozs7Ozs7Ozs7OztBQUV0QyxpREFBK0I7QUFDL0IsbURBQWlDO0FBQ2pDLGlEQUErQjtBQUMvQixnREFBOEIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9jcnVkLWhlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9hY2Nlc3MtaGVscGVycyc7XG5leHBvcnQgKiBmcm9tICcuL21hc2staGVscGVycyc7XG5leHBvcnQgKiBmcm9tICcuL3NzZS1oZWxwZXJzJztcbiJdfQ==
+__exportStar(require("./org-hierarchy"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaGVscGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0NBQStDO0FBQy9DLHNDQUFzQzs7Ozs7Ozs7Ozs7Ozs7OztBQUV0QyxpREFBK0I7QUFDL0IsbURBQWlDO0FBQ2pDLGlEQUErQjtBQUMvQixnREFBOEI7QUFDOUIsa0RBQWdDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vY3J1ZC1oZWxwZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vYWNjZXNzLWhlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9tYXNrLWhlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zc2UtaGVscGVycyc7XG5leHBvcnQgKiBmcm9tICcuL29yZy1oaWVyYXJjaHknO1xuIl19

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[]>;

package/lib/helpers/org-hierarchy.js

@@ -0,0 +1,118 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ORG_DEPTH = void 0;
+exports.toOrgIdString = toOrgIdString;
+exports.resolveOrgLineageWith = resolveOrgLineageWith;
+exports.resolveRootOrgIdWith = resolveRootOrgIdWith;
+exports.isAncestorOrgWith = isAncestorOrgWith;
+exports.expandOrgScopeWith = expandOrgScopeWith;
+/**
+ * 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. */
+exports.MAX_ORG_DEPTH = 16;
+/** Normalize a Mixed/ObjectId/string org id to a non-empty string, or undefined. */
+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.
+ */
+async function resolveOrgLineageWith(orgId, getParent) {
+    const seen = new Set([orgId]);
+    let currentId = orgId;
+    let parentOrgId;
+    for (let depth = 0; depth < exports.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. */
+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.
+ */
+async function isAncestorOrgWith(ancestorOrgId, candidateOrgId, getParent) {
+    if (ancestorOrgId === candidateOrgId)
+        return false;
+    const seen = new Set([candidateOrgId]);
+    let currentId = candidateOrgId;
+    for (let depth = 0; depth < exports.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.
+ */
+async function expandOrgScopeWith(orgId, getChildren) {
+    const result = [orgId];
+    const seen = new Set([orgId]);
+    let frontier = [orgId];
+    for (let depth = 0; depth < exports.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/middleware/auth.d.ts

@@ -66,10 +66,19 @@ export interface ServiceTokenOptions {
     orgName?: string;
     /** TTL in seconds (default 300). */
     ttlSeconds?: number;
+    /**
+     * Role the token carries. Defaults to `'owner'` for backward compatibility —
+     * many existing inter-service calls hit admin-gated endpoints. **Pass the
+     * LOWEST role the call actually needs** (`'member'` for read / data-plane
+     * calls) so a leaked service token can't perform admin actions in the target
+     * org. `isAdmin` is derived from this (admin|owner → true).
+     */
+    role?: 'owner' | 'admin' | 'member';
 }
 /**
  * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.
  * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.
+ * Scope it with `opts.role` — least privilege keeps a leaked token low-value.
  */
 export declare function signServiceToken(opts: ServiceTokenOptions): string;
 /** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */

package/lib/middleware/auth.js

@@ -198,14 +198,16 @@ const DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;
 /**
  * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.
  * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.
+ * Scope it with `opts.role` — least privilege keeps a leaked token low-value.
  */
 function signServiceToken(opts) {
+    const role = opts.role ?? 'owner';
     const payload = {
         sub: `service:${opts.serviceName}`,
         username: `${opts.serviceName}-service`,
         email: `${opts.serviceName}@internal`,
-        role: 'owner',
-        isAdmin: true,
+        role,
+        isAdmin: role === 'owner' || role === 'admin',
         type: 'access',
         organizationId: opts.orgId,
         organizationName: opts.orgName ?? opts.orgId,
@@ -230,4 +232,4 @@ function getServiceAuthHeader(opts) {
 function isServicePrincipal(req) {
     return req.user?.sub?.startsWith('service:') ?? false;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { HttpStatus } from '../constants/http-status';\nimport { JwtPayload } from '../types/common';\nimport { ErrorCode } from '../types/error-codes';\nimport { getHeaderString } from '../utils/headers';\nimport { createLogger } from '../utils/logger';\nimport { sendError } from '../utils/response';\n\nconst logger = createLogger('auth-middleware');\n\n/** Cached JWT secret with periodic refresh from env var. */\nlet _jwtSecret: string | undefined;\nlet _jwtSecretRefreshedAt = 0;\nconst JWT_SECRET_REFRESH_INTERVAL_MS = 300_000; // 5 minutes\n\nfunction getJwtSecret(): string {\n  const now = Date.now();\n  if (!_jwtSecret || now - _jwtSecretRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    const secret = process.env.JWT_SECRET;\n    if (!secret) {\n      logger.error('JWT_SECRET environment variable is not set');\n      throw new Error('JWT_SECRET environment variable is required');\n    }\n    if (_jwtSecret && _jwtSecret !== secret) {\n      logger.info('JWT secret rotated');\n    }\n    _jwtSecret = secret;\n    _jwtSecretRefreshedAt = now;\n  }\n  return _jwtSecret;\n}\n\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * **SECURITY WARNING:** When enabled, a caller can set `x-org-id` to ANY\n   * organization ID, effectively impersonating that org. This MUST only be\n   * used on routes that are:\n   *   1. Internal service-to-service routes (not exposed to end users)\n   *   2. Behind network isolation (container network, VPC, etc.)\n   *\n   * NEVER enable this on user-facing API routes. If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  return (req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  };\n}\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  try {\n    // Pass through optional issuer/audience verification when env-configured.\n    // Without these, a JWT signed by any system that happens to share the\n    // same JWT_SECRET would be accepted — defence-in-depth for shared-secret\n    // misconfigurations across services / environments.\n    const verifyOptions: jwt.VerifyOptions = {};\n    const expectedIssuer = process.env.JWT_ISSUER;\n    const expectedAudience = process.env.JWT_AUDIENCE;\n    if (expectedIssuer) verifyOptions.issuer = expectedIssuer;\n    if (expectedAudience) verifyOptions.audience = expectedAudience;\n    const decoded = jwt.verify(parts[1], getJwtSecret(), verifyOptions) as JwtPayload;\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    req.user = { ...decoded };\n\n    if (options.allowOrgHeaderOverride) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    if (error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n/**\n * Requires admin role. Use after requireAuth.\n * Permits users whose per-org role is 'admin' or 'owner'.\n */\nexport function requireAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n\n  if (req.user.role !== 'admin' && req.user.role !== 'owner') {\n    return sendError(res, HttpStatus.FORBIDDEN, 'Admin access required', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n\n  next();\n}\n\n/** Organization ID/name that identifies the system (super-admin) tenant. */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || 'system').toLowerCase();\n\n/**\n * Check if an orgId or orgName matches the system org.\n * Use this instead of comparing directly against SYSTEM_ORG_ID,\n * because the JWT orgId is a database ID (e.g. MongoDB ObjectId)\n * while SYSTEM_ORG_ID is the well-known name \"system\".\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_ID;\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/** Requires system admin (admin role + system organization). */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  };\n}\n\n/**\n * Resolve the effective access modifier for an entity being created/updated.\n * 'public' is permitted for any admin or owner role (system admins create\n * catalog-wide public entities; org admins create org-wide public entities).\n * Everyone else (member role, no role) gets 'private'.\n */\nexport function resolveAccessModifier(req: Request, requested: string | undefined): 'public' | 'private' {\n  if (requested === 'public' && (req.user?.role === 'admin' || req.user?.role === 'owner')) {\n    return 'public';\n  }\n  return 'private';\n}\n\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived JWT signed with the shared\n// JWT_SECRET, identifying the calling service via `sub: 'service:<name>'`.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireAdmin` rely on the org/role embedded in the token.\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org ID, or 'system' for system-wide ops. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const payload: JwtPayload = {\n    sub: `service:${opts.serviceName}`,\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    role: 'owner',\n    isAdmin: true,\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n  };\n  // Match the optional issuer/audience that requireAuth verifies, when\n  // configured. Without these, a service token signed here would fail\n  // requireAuth in a deployment that has set JWT_ISSUER/JWT_AUDIENCE.\n  const signOptions: jwt.SignOptions = {\n    expiresIn: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n  };\n  if (process.env.JWT_ISSUER) signOptions.issuer = process.env.JWT_ISSUER;\n  if (process.env.JWT_AUDIENCE) signOptions.audience = process.env.JWT_AUDIENCE;\n  return jwt.sign(payload, getJwtSecret(), signOptions);\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user.sub` was issued by `signServiceToken` (i.e. starts with `service:`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.sub?.startsWith('service:') ?? false;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;;;;;AA2DtC,kCAaC;AAkED,oCAcC;AAWD,sCAEC;AAaD,sCAEC;AAGD,gDAaC;AAOD,wCAsBC;AAQD,sDAKC;AA2CD,4CAqBC;AAGD,oDAEC;AAGD,gDAEC;AArTD,gEAA+B;AAC/B,0DAAsD;AAEtD,sDAAiD;AACjD,8CAAmD;AACnD,4CAA+C;AAC/C,gDAA8C;AAE9C,MAAM,MAAM,GAAG,IAAA,qBAAY,EAAC,iBAAiB,CAAC,CAAC;AAE/C,4DAA4D;AAC5D,IAAI,UAA8B,CAAC;AACnC,IAAI,qBAAqB,GAAG,CAAC,CAAC;AAC9B,MAAM,8BAA8B,GAAG,OAAO,CAAC,CAAC,YAAY;AAE5D,SAAS,YAAY;IACnB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,IAAI,CAAC,UAAU,IAAI,GAAG,GAAG,qBAAqB,GAAG,8BAA8B,EAAE,CAAC;QAChF,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC;YAC3D,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,UAAU,IAAI,UAAU,KAAK,MAAM,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QACpC,CAAC;QACD,UAAU,GAAG,MAAM,CAAC;QACpB,qBAAqB,GAAG,GAAG,CAAC;IAC9B,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AA0BD,SAAgB,WAAW,CACzB,YAA2C,EAC3C,GAAc,EACd,IAAmB;IAEnB,IAAI,YAAY,IAAI,GAAG,IAAI,IAAI,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC;QAC7D,OAAO,YAAY,CAAC,EAAE,EAAE,YAAuB,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IAC9D,CAAC;IAED,MAAM,OAAO,GAAI,YAAmC,IAAI,EAAE,CAAC;IAC3D,OAAO,CAAC,GAAY,EAAE,QAAkB,EAAE,SAAuB,EAAE,EAAE;QACnE,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,YAAY,CACnB,OAA2B,EAC3B,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,MAAM,UAAU,GAAG,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC;IAE7C,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,+BAA+B,EAAE,uBAAS,CAAC,aAAa,CAAC,CAAC;IAC3G,CAAC;IAED,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACpC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,EAAE,CAAC;QAChD,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,mDAAmD,EAAE,uBAAS,CAAC,aAAa,CAAC,CAAC;IAC/H,CAAC;IAED,IAAI,CAAC;QACH,0EAA0E;QAC1E,sEAAsE;QACtE,yEAAyE;QACzE,oDAAoD;QACpD,MAAM,aAAa,GAAsB,EAAE,CAAC;QAC5C,MAAM,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;QAC9C,MAAM,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;QAClD,IAAI,cAAc;YAAE,aAAa,CAAC,MAAM,GAAG,cAAc,CAAC;QAC1D,IAAI,gBAAgB;YAAE,aAAa,CAAC,QAAQ,GAAG,gBAAgB,CAAC;QAChE,MAAM,OAAO,GAAG,sBAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,aAAa,CAAe,CAAC;QAElF,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,iDAAiD,EAAE,uBAAS,CAAC,aAAa,CAAC,CAAC;QAC7H,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YAClC,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,+BAA+B,EAAE,uBAAS,CAAC,aAAa,CAAC,CAAC;QAC3G,CAAC;QAED,GAAG,CAAC,IAAI,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;QAE1B,IAAI,OAAO,CAAC,sBAAsB,EAAE,CAAC;YACnC,MAAM,WAAW,GAAG,IAAA,yBAAe,EAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;YAC7D,MAAM,aAAa,GAAG,IAAA,yBAAe,EAAC,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;YACjE,IAAI,WAAW;gBAAE,GAAG,CAAC,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC;YACvD,IAAI,aAAa;gBAAE,GAAG,CAAC,IAAI,CAAC,gBAAgB,GAAG,aAAa,CAAC;QAC/D,CAAC;QAED,IAAI,EAAE,CAAC;IACT,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,sBAAG,CAAC,iBAAiB,EAAE,CAAC;YAC3C,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,mBAAmB,EAAE,uBAAS,CAAC,aAAa,CAAC,CAAC;QAC/F,CAAC;QAED,IAAI,KAAK,YAAY,sBAAG,CAAC,iBAAiB,EAAE,CAAC;YAC3C,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,eAAe,EAAE,uBAAS,CAAC,aAAa,CAAC,CAAC;QAC3F,CAAC;QAED,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,uBAAuB,EAAE,uBAAS,CAAC,YAAY,CAAC,CAAC;IAClG,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAC1B,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACd,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,uBAAS,CAAC,YAAY,CAAC,CAAC;IACpG,CAAC;IAED,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC3D,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,SAAS,EAAE,uBAAuB,EAAE,uBAAS,CAAC,wBAAwB,CAAC,CAAC;IAC3G,CAAC;IAED,IAAI,EAAE,CAAC;AACT,CAAC;AAED,4EAA4E;AAC/D,QAAA,aAAa,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;AAEnF;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,KAAc,EAAE,OAAgB;IAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,qBAAa,IAAI,OAAO,EAAE,WAAW,EAAE,KAAK,qBAAa,CAAC;AAC5F,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,aAAa,CAAC,GAAY;IACxC,OAAO,GAAG,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;AACzC,CAAC;AAED,gEAAgE;AAChE,SAAgB,kBAAkB,CAChC,GAAY,EACZ,GAAa,EACb,IAAkB;IAElB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,OAAO,IAAA,oBAAS,EACd,GAAG,EAAE,wBAAU,CAAC,SAAS,EACzB,oEAAoE,EACpE,uBAAS,CAAC,wBAAwB,CACnC,CAAC;IACJ,CAAC;IACD,IAAI,EAAE,CAAC;AACT,CAAC;AAED;;;;GAIG;AACH,SAAgB,cAAc,CAAC,OAAe;IAC5C,OAAO,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC/D,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACd,OAAO,IAAA,oBAAS,EAAC,GAAG,EAAE,wBAAU,CAAC,YAAY,EAAE,yBAAyB,EAAE,uBAAS,CAAC,YAAY,CAAC,CAAC;QACpG,CAAC;QAED,qEAAqE;QACrE,uEAAuE;QACvE,qEAAqE;QACrE,kBAAkB;QAClB,IAAI,GAAG,CAAC,IAAI,CAAC,YAAY,KAAK,IAAI;YAAE,OAAO,IAAI,EAAE,CAAC;QAElD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC1C,OAAO,IAAA,oBAAS,EACd,GAAG,EAAE,wBAAU,CAAC,SAAS,EACzB,wCAAwC,OAAO,GAAG,EAClD,uBAAS,CAAC,wBAAwB,CACnC,CAAC;QACJ,CAAC;QAED,IAAI,EAAE,CAAC;IACT,CAAC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,qBAAqB,CAAC,GAAY,EAAE,SAA6B;IAC/E,IAAI,SAAS,KAAK,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,EAAE,CAAC;QACzF,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,8EAA8E;AAC9E,4BAA4B;AAC5B,EAAE;AACF,4EAA4E;AAC5E,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,6EAA6E;AAC7E,oEAAoE;AACpE,6DAA6D;AAC7D,EAAE;AACF,yEAAyE;AACzE,iDAAiD;AACjD,8EAA8E;AAE9E,MAAM,iCAAiC,GAAG,GAAG,CAAC;AAqB9C;;;;GAIG;AACH,SAAgB,gBAAgB,CAAC,IAAyB;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC;IAClC,MAAM,OAAO,GAAe;QAC1B,GAAG,EAAE,WAAW,IAAI,CAAC,WAAW,EAAE;QAClC,QAAQ,EAAE,GAAG,IAAI,CAAC,WAAW,UAAU;QACvC,KAAK,EAAE,GAAG,IAAI,CAAC,WAAW,WAAW;QACrC,IAAI;QACJ,OAAO,EAAE,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,OAAO;QAC7C,IAAI,EAAE,QAAQ;QACd,cAAc,EAAE,IAAI,CAAC,KAAK;QAC1B,gBAAgB,EAAE,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK;KAC7C,CAAC;IACF,qEAAqE;IACrE,oEAAoE;IACpE,oEAAoE;IACpE,MAAM,WAAW,GAAoB;QACnC,SAAS,EAAE,IAAI,CAAC,UAAU,IAAI,iCAAiC;KAChE,CAAC;IACF,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU;QAAE,WAAW,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;IACxE,IAAI,OAAO,CAAC,GAAG,CAAC,YAAY;QAAE,WAAW,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC;IAC9E,OAAO,sBAAG,CAAC,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,WAAW,CAAC,CAAC;AACxD,CAAC;AAED,kFAAkF;AAClF,SAAgB,oBAAoB,CAAC,IAAyB;IAC5D,OAAO,UAAU,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;AAC5C,CAAC;AAED,+FAA+F;AAC/F,SAAgB,kBAAkB,CAAC,GAAY;IAC7C,OAAO,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,UAAU,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC;AACxD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Request, Response, NextFunction } from 'express';\nimport jwt from 'jsonwebtoken';\nimport { HttpStatus } from '../constants/http-status';\nimport { JwtPayload } from '../types/common';\nimport { ErrorCode } from '../types/error-codes';\nimport { getHeaderString } from '../utils/headers';\nimport { createLogger } from '../utils/logger';\nimport { sendError } from '../utils/response';\n\nconst logger = createLogger('auth-middleware');\n\n/** Cached JWT secret with periodic refresh from env var. */\nlet _jwtSecret: string | undefined;\nlet _jwtSecretRefreshedAt = 0;\nconst JWT_SECRET_REFRESH_INTERVAL_MS = 300_000; // 5 minutes\n\nfunction getJwtSecret(): string {\n  const now = Date.now();\n  if (!_jwtSecret || now - _jwtSecretRefreshedAt > JWT_SECRET_REFRESH_INTERVAL_MS) {\n    const secret = process.env.JWT_SECRET;\n    if (!secret) {\n      logger.error('JWT_SECRET environment variable is not set');\n      throw new Error('JWT_SECRET environment variable is required');\n    }\n    if (_jwtSecret && _jwtSecret !== secret) {\n      logger.info('JWT secret rotated');\n    }\n    _jwtSecret = secret;\n    _jwtSecretRefreshedAt = now;\n  }\n  return _jwtSecret;\n}\n\nexport interface RequireAuthOptions {\n  /**\n   * Allow x-org-id/x-org-name headers to override the JWT's organization fields.\n   *\n   * **SECURITY WARNING:** When enabled, a caller can set `x-org-id` to ANY\n   * organization ID, effectively impersonating that org. This MUST only be\n   * used on routes that are:\n   *   1. Internal service-to-service routes (not exposed to end users)\n   *   2. Behind network isolation (container network, VPC, etc.)\n   *\n   * NEVER enable this on user-facing API routes. If unsure, leave it disabled.\n   */\n  allowOrgHeaderOverride?: boolean;\n}\n\n/** JWT auth middleware. Use directly or call with options. */\nexport function requireAuth(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void;\nexport function requireAuth(\n  options?: RequireAuthOptions,\n): (req: Request, res: Response, next: NextFunction) => void;\nexport function requireAuth(\n  reqOrOptions?: Request | RequireAuthOptions,\n  res?: Response,\n  next?: NextFunction,\n): void | ((req: Request, res: Response, next: NextFunction) => void) {\n  if (reqOrOptions && res && next && 'headers' in reqOrOptions) {\n    return _requireAuth({}, reqOrOptions as Request, res, next);\n  }\n\n  const options = (reqOrOptions as RequireAuthOptions) || {};\n  return (req: Request, resInner: Response, nextInner: NextFunction) => {\n    _requireAuth(options, req, resInner, nextInner);\n  };\n}\n\nfunction _requireAuth(\n  options: RequireAuthOptions,\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  const authHeader = req.headers.authorization;\n\n  if (!authHeader) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authorization header required', ErrorCode.TOKEN_MISSING);\n  }\n\n  const parts = authHeader.split(' ');\n  if (parts.length !== 2 || parts[0] !== 'Bearer') {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid authorization format. Use: Bearer <token>', ErrorCode.TOKEN_INVALID);\n  }\n\n  try {\n    // Pass through optional issuer/audience verification when env-configured.\n    // Without these, a JWT signed by any system that happens to share the\n    // same JWT_SECRET would be accepted — defence-in-depth for shared-secret\n    // misconfigurations across services / environments.\n    const verifyOptions: jwt.VerifyOptions = {};\n    const expectedIssuer = process.env.JWT_ISSUER;\n    const expectedAudience = process.env.JWT_AUDIENCE;\n    if (expectedIssuer) verifyOptions.issuer = expectedIssuer;\n    if (expectedAudience) verifyOptions.audience = expectedAudience;\n    const decoded = jwt.verify(parts[1], getJwtSecret(), verifyOptions) as JwtPayload;\n\n    if (decoded.type !== 'access') {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Only access tokens can be used for API requests', ErrorCode.TOKEN_INVALID);\n    }\n\n    if (!decoded.sub || !decoded.role) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token missing required fields', ErrorCode.TOKEN_INVALID);\n    }\n\n    req.user = { ...decoded };\n\n    if (options.allowOrgHeaderOverride) {\n      const headerOrgId = getHeaderString(req.headers['x-org-id']);\n      const headerOrgName = getHeaderString(req.headers['x-org-name']);\n      if (headerOrgId) req.user.organizationId = headerOrgId;\n      if (headerOrgName) req.user.organizationName = headerOrgName;\n    }\n\n    next();\n  } catch (error) {\n    if (error instanceof jwt.TokenExpiredError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Token has expired', ErrorCode.TOKEN_EXPIRED);\n    }\n\n    if (error instanceof jwt.JsonWebTokenError) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Invalid token', ErrorCode.TOKEN_INVALID);\n    }\n\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication failed', ErrorCode.UNAUTHORIZED);\n  }\n}\n\n/**\n * Requires admin role. Use after requireAuth.\n * Permits users whose per-org role is 'admin' or 'owner'.\n */\nexport function requireAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!req.user) {\n    return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n  }\n\n  if (req.user.role !== 'admin' && req.user.role !== 'owner') {\n    return sendError(res, HttpStatus.FORBIDDEN, 'Admin access required', ErrorCode.INSUFFICIENT_PERMISSIONS);\n  }\n\n  next();\n}\n\n/** Organization ID/name that identifies the system (super-admin) tenant. */\nexport const SYSTEM_ORG_ID = (process.env.SYSTEM_ORG_ID || 'system').toLowerCase();\n\n/**\n * Check if an orgId or orgName matches the system org.\n * Use this instead of comparing directly against SYSTEM_ORG_ID,\n * because the JWT orgId is a database ID (e.g. MongoDB ObjectId)\n * while SYSTEM_ORG_ID is the well-known name \"system\".\n */\nexport function isSystemOrgId(orgId?: string, orgName?: string): boolean {\n  return orgId?.toLowerCase() === SYSTEM_ORG_ID || orgName?.toLowerCase() === SYSTEM_ORG_ID;\n}\n\n/**\n * Check if the request is from a system admin.\n *\n * Authority is granted solely by the user-level `isSuperAdmin` flag carried\n * in the JWT. The \"membership in the well-known 'system' org with role\n * admin/owner\" path was removed — it conflated a Pipeline Builder operator\n * with a real customer tenant in the data model, and meant any unintended\n * write that created a 'system'-named org could quietly grant cross-org\n * authority. The `system` org still exists as a *content holder* for shared\n * sample data; it just no longer confers privilege.\n */\nexport function isSystemAdmin(req: Request): boolean {\n  return req.user?.isSuperAdmin === true;\n}\n\n/** Requires system admin (admin role + system organization). */\nexport function requireSystemAdmin(\n  req: Request,\n  res: Response,\n  next: NextFunction,\n): void {\n  if (!isSystemAdmin(req)) {\n    return sendError(\n      res, HttpStatus.FORBIDDEN,\n      'Access denied. Only system administrators can perform this action.',\n      ErrorCode.INSUFFICIENT_PERMISSIONS,\n    );\n  }\n  next();\n}\n\n/**\n * Require a specific feature flag. Use after requireAuth.\n * Checks the `features` array in the JWT payload (set at token issuance).\n * Sysadmins (isSuperAdmin) bypass — they always have every feature.\n */\nexport function requireFeature(feature: string) {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    if (!req.user) {\n      return sendError(res, HttpStatus.UNAUTHORIZED, 'Authentication required', ErrorCode.UNAUTHORIZED);\n    }\n\n    // Sysadmins get all features; the `features` array on their token is\n    // populated with every flag at issuance time but the bypass here keeps\n    // the rule explicit and survives a token issued before a new feature\n    // flag was added.\n    if (req.user.isSuperAdmin === true) return next();\n\n    if (!req.user.features?.includes(feature)) {\n      return sendError(\n        res, HttpStatus.FORBIDDEN,\n        `This feature requires a higher plan (${feature})`,\n        ErrorCode.INSUFFICIENT_PERMISSIONS,\n      );\n    }\n\n    next();\n  };\n}\n\n/**\n * Resolve the effective access modifier for an entity being created/updated.\n * 'public' is permitted for any admin or owner role (system admins create\n * catalog-wide public entities; org admins create org-wide public entities).\n * Everyone else (member role, no role) gets 'private'.\n */\nexport function resolveAccessModifier(req: Request, requested: string | undefined): 'public' | 'private' {\n  if (requested === 'public' && (req.user?.role === 'admin' || req.user?.role === 'owner')) {\n    return 'public';\n  }\n  return 'private';\n}\n\n// ---------------------------------------------------------------------------\n// Service-to-service tokens\n//\n// Inter-service HTTP calls (billing → message, platform → compliance, etc.)\n// need to satisfy the same `requireAuth` middleware as user requests.\n// `signServiceToken` mints a short-lived JWT signed with the shared\n// JWT_SECRET, identifying the calling service via `sub: 'service:<name>'`.\n// `requireAuth` accepts these tokens transparently — they pass `decoded.sub`\n// and `decoded.role` checks, and downstream `requireOrganization` /\n// `requireAdmin` rely on the org/role embedded in the token.\n//\n// Tokens default to 5-minute TTL — long enough to survive a backend hop,\n// short enough that a leaked token is low-value.\n// ---------------------------------------------------------------------------\n\nconst DEFAULT_SERVICE_TOKEN_TTL_SECONDS = 300;\n\nexport interface ServiceTokenOptions {\n  /** Calling service identifier (e.g. 'billing', 'platform'). Embedded as `sub: service:<name>`. */\n  serviceName: string;\n  /** Active org context for the call. Use the target tenant's org ID, or 'system' for system-wide ops. */\n  orgId?: string;\n  /** Active org name. Defaults to orgId. */\n  orgName?: string;\n  /** TTL in seconds (default 300). */\n  ttlSeconds?: number;\n  /**\n   * Role the token carries. Defaults to `'owner'` for backward compatibility —\n   * many existing inter-service calls hit admin-gated endpoints. **Pass the\n   * LOWEST role the call actually needs** (`'member'` for read / data-plane\n   * calls) so a leaked service token can't perform admin actions in the target\n   * org. `isAdmin` is derived from this (admin|owner → true).\n   */\n  role?: 'owner' | 'admin' | 'member';\n}\n\n/**\n * Mint a JWT identifying the calling service. Used for inter-service HTTP calls.\n * The token satisfies `requireAuth` and (when orgId is present) `requireOrganization`.\n * Scope it with `opts.role` — least privilege keeps a leaked token low-value.\n */\nexport function signServiceToken(opts: ServiceTokenOptions): string {\n  const role = opts.role ?? 'owner';\n  const payload: JwtPayload = {\n    sub: `service:${opts.serviceName}`,\n    username: `${opts.serviceName}-service`,\n    email: `${opts.serviceName}@internal`,\n    role,\n    isAdmin: role === 'owner' || role === 'admin',\n    type: 'access',\n    organizationId: opts.orgId,\n    organizationName: opts.orgName ?? opts.orgId,\n  };\n  // Match the optional issuer/audience that requireAuth verifies, when\n  // configured. Without these, a service token signed here would fail\n  // requireAuth in a deployment that has set JWT_ISSUER/JWT_AUDIENCE.\n  const signOptions: jwt.SignOptions = {\n    expiresIn: opts.ttlSeconds ?? DEFAULT_SERVICE_TOKEN_TTL_SECONDS,\n  };\n  if (process.env.JWT_ISSUER) signOptions.issuer = process.env.JWT_ISSUER;\n  if (process.env.JWT_AUDIENCE) signOptions.audience = process.env.JWT_AUDIENCE;\n  return jwt.sign(payload, getJwtSecret(), signOptions);\n}\n\n/** Convenience: returns a `Bearer <token>` header value for fetch/axios calls. */\nexport function getServiceAuthHeader(opts: ServiceTokenOptions): string {\n  return `Bearer ${signServiceToken(opts)}`;\n}\n\n/** True when `req.user.sub` was issued by `signServiceToken` (i.e. starts with `service:`). */\nexport function isServicePrincipal(req: Request): boolean {\n  return req.user?.sub?.startsWith('service:') ?? false;\n}\n"]}

package/lib/types/audit-events.d.ts

@@ -14,8 +14,21 @@
  *      doc lives) including any payload-specific fields.
  *   3. Emit via `emitAudit(logger, 'event.name', { … })` from the route.
  */
+/**
+ * Correlation context shared by every cross-service audit event. Optional so
+ * existing emit sites compile unchanged; when populated, these let an operator
+ * pivot a Loki audit line to the originating HTTP request (`requestId`) or the
+ * end-to-end distributed trace (`traceId`) — and line them up with platform's
+ * MongoDB audit events, which carry the same two fields.
+ */
+export interface AuditCorrelation {
+    /** Originating request id (propagated `x-request-id`). */
+    requestId?: string;
+    /** OpenTelemetry trace id of the active span, when tracing is enabled. */
+    traceId?: string;
+}
 /** Tag-copy emitted from image-registry's POST /api/images/copy. */
-export interface RegistryTagCopyAudit {
+export interface RegistryTagCopyAudit extends AuditCorrelation {
     event: 'registry.tag.copy';
     actor: string;
     source: string;
@@ -30,7 +43,7 @@ export interface RegistryTagCopyAudit {
     };
 }
 /** Tag-delete emitted from image-registry's DELETE /api/images/:name/manifests/:reference. */
-export interface RegistryTagDeleteAudit {
+export interface RegistryTagDeleteAudit extends AuditCorrelation {
     event: 'registry.tag.delete';
     actor: string;
     repo: string;

package/lib/types/audit-events.js

@@ -2,4 +2,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/common.d.ts

@@ -148,6 +148,16 @@ export interface JwtPayload {
     organizationId?: string;
     /** Active organization name */
     organizationName?: string;
+    /**
+     * Org → team hierarchy (org-team-hierarchy proposal, phase 1).
+     * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`
+     * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —
+     * consumers should treat the effective root as `rootOrganizationId ?? organizationId`.
+     * Currently every org is flat, so these are absent on all tokens today.
+     */
+    parentOrganizationId?: string;
+    /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */
+    rootOrganizationId?: string;
     /**
      * Set on tokens issued by the sysadmin impersonation flow
      * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's

package/lib/types/common.js

@@ -53,4 +53,4 @@ function validateQuotaType(value, fieldName = 'quotaType') {
     }
     return value;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;;AAgDtC,4CAEC;AAqBD,8CAOC;AAnDD;;GAEG;AACU,QAAA,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,SAAgB,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,yBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,iBAAiB,CAAC,KAAc,EAAE,SAAS,GAAG,WAAW;IACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,MAAM,KAAK,sBAAsB,yBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Validate and assert that a value is a valid QuotaType.\n * Throws an error if validation fails.\n *\n * @param value - Value to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @returns The validated QuotaType\n * @throws Error if value is not a valid QuotaType\n *\n * @example\n * ```typescript\n * try {\n *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');\n *   // Use quotaType safely\n * } catch (err) {\n *   return sendError(res, 400, err.message);\n * }\n * ```\n */\nexport function validateQuotaType(value: unknown, fieldName = 'quotaType'): QuotaType {\n  if (!isValidQuotaType(value)) {\n    throw new Error(\n      `Invalid ${fieldName}: \"${value}\". Must be one of: ${VALID_QUOTA_TYPES.join(', ')}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: 'owner' | 'admin' | 'member';\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the canonical signal for sysadmin authority —\n   * previously the only path was membership in the well-known \"system\" org\n   * with role admin/owner, which conflated \"Pipeline Builder operator\" with\n   * \"real customer tenant\" in the data model. Either path still works\n   * during the rollout; new users should be granted via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier ('developer' | 'pro' | 'unlimited') */\n  tier?: string;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,sCAAsC;;;AAgDtC,4CAEC;AAqBD,8CAOC;AAnDD;;GAEG;AACU,QAAA,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,SAAgB,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,yBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,iBAAiB,CAAC,KAAc,EAAE,SAAS,GAAG,WAAW;IACvE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,WAAW,SAAS,MAAM,KAAK,sBAAsB,yBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACpF,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Validate and assert that a value is a valid QuotaType.\n * Throws an error if validation fails.\n *\n * @param value - Value to validate\n * @param fieldName - Name of the field being validated (for error messages)\n * @returns The validated QuotaType\n * @throws Error if value is not a valid QuotaType\n *\n * @example\n * ```typescript\n * try {\n *   const quotaType = validateQuotaType(req.body.quotaType, 'quotaType');\n *   // Use quotaType safely\n * } catch (err) {\n *   return sendError(res, 400, err.message);\n * }\n * ```\n */\nexport function validateQuotaType(value: unknown, fieldName = 'quotaType'): QuotaType {\n  if (!isValidQuotaType(value)) {\n    throw new Error(\n      `Invalid ${fieldName}: \"${value}\". Must be one of: ${VALID_QUOTA_TYPES.join(', ')}`,\n    );\n  }\n  return value;\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: 'owner' | 'admin' | 'member';\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the canonical signal for sysadmin authority —\n   * previously the only path was membership in the well-known \"system\" org\n   * with role admin/owner, which conflated \"Pipeline Builder operator\" with\n   * \"real customer tenant\" in the data model. Either path still works\n   * during the rollout; new users should be granted via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier ('developer' | 'pro' | 'unlimited') */\n  tier?: string;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`.\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}

package/lib/utils/crash-handlers.d.ts

@@ -0,0 +1,18 @@
+import type { Logger } from 'winston';
+/**
+ * Install last-resort process-level fault handlers.
+ *
+ * Without these, an uncaught exception or an unhandled promise rejection in a
+ * fire-and-forget async path crashes the container with NO structured log line
+ * (and on modern Node terminates the process by default). That makes incidents
+ * undebuggable from logs. This logs the fault through the service logger, then
+ * exits non-zero so the orchestrator restarts a CLEAN process — a faulted
+ * process is in an undefined state and must not keep serving.
+ *
+ * This is orthogonal to graceful SIGTERM shutdown (handled in api-server /
+ * platform): that drains on a normal stop; this is the abnormal-fault path.
+ *
+ * Idempotent — call once at process start; repeat calls are no-ops. Skipped
+ * under NODE_ENV=test so it never competes with the test runner's own handlers.
+ */
+export declare function installCrashHandlers(log?: Logger): void;

package/lib/utils/crash-handlers.js

@@ -0,0 +1,39 @@
+"use strict";
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installCrashHandlers = installCrashHandlers;
+const logger_1 = require("./logger");
+let installed = false;
+/**
+ * Install last-resort process-level fault handlers.
+ *
+ * Without these, an uncaught exception or an unhandled promise rejection in a
+ * fire-and-forget async path crashes the container with NO structured log line
+ * (and on modern Node terminates the process by default). That makes incidents
+ * undebuggable from logs. This logs the fault through the service logger, then
+ * exits non-zero so the orchestrator restarts a CLEAN process — a faulted
+ * process is in an undefined state and must not keep serving.
+ *
+ * This is orthogonal to graceful SIGTERM shutdown (handled in api-server /
+ * platform): that drains on a normal stop; this is the abnormal-fault path.
+ *
+ * Idempotent — call once at process start; repeat calls are no-ops. Skipped
+ * under NODE_ENV=test so it never competes with the test runner's own handlers.
+ */
+function installCrashHandlers(log = (0, logger_1.createLogger)('process')) {
+    if (installed || process.env.NODE_ENV === 'test')
+        return;
+    installed = true;
+    const fatal = (kind, error, extra = {}) => {
+        log.error(`${kind} — exiting for restart`, { error: error.message, stack: error.stack, ...extra });
+        // Give winston a tick to flush async transports, then exit. `unref` so this
+        // timer never keeps an otherwise-idle process alive.
+        setTimeout(() => process.exit(1), 100).unref();
+    };
+    process.on('uncaughtException', (error, origin) => fatal('Uncaught exception', error, { origin }));
+    process.on('unhandledRejection', (reason) => {
+        fatal('Unhandled promise rejection', reason instanceof Error ? reason : new Error(String(reason)));
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './logger';
+export * from './crash-handlers';
 export * from './response';
 export * from './params';
 export * from './headers';

package/lib/utils/index.js

@@ -17,6 +17,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./logger"), exports);
+__exportStar(require("./crash-handlers"), exports);
 __exportStar(require("./response"), exports);
 __exportStar(require("./params"), exports);
 __exportStar(require("./headers"), exports);
@@ -28,4 +29,4 @@ __exportStar(require("./audit"), exports);
 __exportStar(require("./secret-encryption"), exports);
 __exportStar(require("./org-aws-credentials"), exports);
 __exportStar(require("./metric-emitter"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFdEMsMkNBQXlCO0FBQ3pCLDZDQUEyQjtBQUMzQiwyQ0FBeUI7QUFDekIsNENBQTBCO0FBQzFCLDZDQUEyQjtBQUMzQiwyQ0FBeUI7QUFDekIsbURBQWlDO0FBQ2pDLGdEQUE4QjtBQUM5QiwwQ0FBd0I7QUFDeEIsc0RBQW9DO0FBQ3BDLHdEQUFzQztBQUN0QyxtREFBaUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9sb2dnZXInO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNwb25zZSc7XG5leHBvcnQgKiBmcm9tICcuL3BhcmFtcyc7XG5leHBvcnQgKiBmcm9tICcuL2hlYWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9pZGVudGl0eSc7XG5leHBvcnQgKiBmcm9tICcuL29iamVjdCc7XG5leHBvcnQgKiBmcm9tICcuL2FsaWFzLXJlc29sdmVyJztcbmV4cG9ydCAqIGZyb20gJy4vY29uY3VycmVuY3knO1xuZXhwb3J0ICogZnJvbSAnLi9hdWRpdCc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3JldC1lbmNyeXB0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vb3JnLWF3cy1jcmVkZW50aWFscyc7XG5leHBvcnQgKiBmcm9tICcuL21ldHJpYy1lbWl0dGVyJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0M7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFdEMsMkNBQXlCO0FBQ3pCLG1EQUFpQztBQUNqQyw2Q0FBMkI7QUFDM0IsMkNBQXlCO0FBQ3pCLDRDQUEwQjtBQUMxQiw2Q0FBMkI7QUFDM0IsMkNBQXlCO0FBQ3pCLG1EQUFpQztBQUNqQyxnREFBOEI7QUFDOUIsMENBQXdCO0FBQ3hCLHNEQUFvQztBQUNwQyx3REFBc0M7QUFDdEMsbURBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMjYgUGlwZWxpbmUgQnVpbGRlciBDb250cmlidXRvcnNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wXG5cbmV4cG9ydCAqIGZyb20gJy4vbG9nZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vY3Jhc2gtaGFuZGxlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNwb25zZSc7XG5leHBvcnQgKiBmcm9tICcuL3BhcmFtcyc7XG5leHBvcnQgKiBmcm9tICcuL2hlYWRlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9pZGVudGl0eSc7XG5leHBvcnQgKiBmcm9tICcuL29iamVjdCc7XG5leHBvcnQgKiBmcm9tICcuL2FsaWFzLXJlc29sdmVyJztcbmV4cG9ydCAqIGZyb20gJy4vY29uY3VycmVuY3knO1xuZXhwb3J0ICogZnJvbSAnLi9hdWRpdCc7XG5leHBvcnQgKiBmcm9tICcuL3NlY3JldC1lbmNyeXB0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vb3JnLWF3cy1jcmVkZW50aWFscyc7XG5leHBvcnQgKiBmcm9tICcuL21ldHJpYy1lbWl0dGVyJztcbiJdfQ==

package/package.json

@@ -49,7 +49,7 @@
     "plugins",
     "typescript",
     "self-service",
-    "multi-tenant",
+    "multi-team",
     "compliance",
     "automation",
     "infrastructure-as-code",
@@ -73,7 +73,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.58",
+  "version": "3.4.60",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },