@pipeline-builder/api-core 3.4.58 → 3.4.59

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":";AAAA,+CAA+C;AAC/C,sCAAsC;;;AAgCtC,sCAIC;AAeD,sDAiBC;AAGD,oDAEC;AASD,8CAoBC;AAQD,gDAmBC;AA/HD;;;;;;;;;;;;;;;;;;GAkBG;AAEH,2EAA2E;AAC9D,QAAA,aAAa,GAAG,EAAE,CAAC;AAQhC,oFAAoF;AACpF,SAAgB,aAAa,CAAC,CAAU;IACtC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACpD,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,CAAC,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAChE,CAAC;AASD;;;;;GAKG;AACI,KAAK,UAAU,qBAAqB,CAAC,KAAa,EAAE,SAAyB;IAClF,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,IAAI,WAA+B,CAAC;IAEpC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,qBAAa,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM;YAAE,MAAM,CAAC,wBAAwB;QAC5C,0EAA0E;QAC1E,4CAA4C;QAC5C,IAAI,KAAK,KAAK,CAAC,IAAI,MAAM,KAAK,KAAK;YAAE,WAAW,GAAG,MAAM,CAAC;QAC1D,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,MAAM,CAAC,sCAAsC;QACnE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjB,SAAS,GAAG,MAAM,CAAC;IACrB,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;AACvE,CAAC;AAED,qEAAqE;AAC9D,KAAK,UAAU,oBAAoB,CAAC,KAAa,EAAE,SAAyB;IACjF,OAAO,CAAC,MAAM,qBAAqB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED;;;;;;GAMG;AACI,KAAK,UAAU,iBAAiB,CACrC,aAAqB,EACrB,cAAsB,EACtB,SAAyB;IAEzB,IAAI,aAAa,KAAK,cAAc;QAAE,OAAO,KAAK,CAAC;IAEnD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,cAAc,CAAC,CAAC,CAAC;IAC/C,IAAI,SAAS,GAAG,cAAc,CAAC;IAE/B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,qBAAa,EAAE,KAAK,EAAE,EAAE,CAAC;QACnD,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC,CAAC,kCAAkC;QAC7D,IAAI,MAAM,KAAK,aAAa;YAAE,OAAO,IAAI,CAAC;QAC1C,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC,CAAC,QAAQ;QAC5C,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjB,SAAS,GAAG,MAAM,CAAC;IACrB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,kBAAkB,CAAC,KAAa,EAAE,WAA2B;IACjF,MAAM,MAAM,GAAa,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IACtC,IAAI,QAAQ,GAAa,CAAC,KAAK,CAAC,CAAC;IAEjC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,qBAAa,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QAC1E,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC7C,MAAM,IAAI,GAAa,EAAE,CAAC;QAC1B,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;YAC3B,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBAAE,SAAS;YAClC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAChB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChB,CAAC;QACD,QAAQ,GAAG,IAAI,CAAC;IAClB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC","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/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/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.59",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },