@pipeline-builder/api-core 0.0.1

package/lib/types/common.d.ts

@@ -0,0 +1,255 @@
+import type { Permission } from './permissions.js';
+import type { QuotaTier } from './quota-tiers.js';
+/**
+ * Capability scope catalog for machine/automation tokens. A scoped token carries
+ * exactly one of these instead of role-based permissions; endpoints that accept a
+ * scoped identity check it via `hasScope`. Kept a closed union (mirroring
+ * {@link Permission}) so a typo on either the mint or the check side is a compile
+ * error. Add a value here when introducing a new scoped-token surface.
+ */
+export type TokenScope = 'reporting:ingest';
+/**
+ * Quota type identifiers.
+ *
+ * - `plugins` / `pipelines` — count of created entities
+ * - `apiCalls` — generic API call count (read-heavy paths)
+ * - `aiCalls` — AI provider invocations (counted separately because each call
+ *   has external dollar cost; sized smaller than apiCalls per tier)
+ * - `storageBytes` — registry storage budget per org. Unlike the others
+ *   (which count discrete events), this is a measured total recomputed
+ *   on demand. Incremented by the image-registry's push-gate before
+ *   issuing a token whose scope includes `push`; the GC scheduler
+ *   eventually frees the bytes, then the next push-gate check reads
+ *   the lower value. NOT a counter-style quota in the sense of
+ *   `incrementUsage` — the registry pushes the measured total via
+ *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.
+ * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —
+ *   resource-count quotas added to close per-org DoS surfaces in the
+ *   user-editable feature tables. Without these caps a single org could
+ *   spam thousands of dashboards / rules and bloat the shared Postgres /
+ *   Mongo working sets. Counted at create time; decremented on delete.
+ */
+export type QuotaType = 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes' | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';
+/**
+ * Valid quota type values.
+ */
+export declare const VALID_QUOTA_TYPES: readonly ['plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes', 'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs'];
+/**
+ * Type guard to check if a value is a valid QuotaType.
+ *
+ * @param value - Value to check
+ * @returns True if value is a valid QuotaType
+ *
+ * @example
+ * ```typescript
+ * if (isValidQuotaType(req.body.quotaType)) {
+ *   // quotaType is guaranteed to be QuotaType
+ * }
+ * ```
+ */
+export declare function isValidQuotaType(value: unknown): value is QuotaType;
+/**
+ * Result from quota check operation.
+ */
+export interface QuotaCheckResult {
+    /** Whether the request is allowed */
+    allowed: boolean;
+    /** Maximum quota limit (-1 for unlimited) */
+    limit: number;
+    /** Current usage count */
+    used: number;
+    /** Remaining quota (-1 for unlimited) */
+    remaining: number;
+    /** ISO timestamp when quota resets */
+    resetAt: string;
+    /** Whether quota is unlimited */
+    unlimited: boolean;
+    /**
+     * True ONLY when this result is the fail-open sentinel returned because the
+     * quota service was unreachable / returned non-ok (not a real quota reading).
+     * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish
+     * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.
+     */
+    failOpen?: boolean;
+}
+/**
+ * Quota information for error responses.
+ */
+export interface QuotaInfo {
+    type: QuotaType;
+    limit: number;
+    used: number;
+    remaining: number;
+}
+/**
+ * Standard API success response.
+ */
+export interface ApiSuccessResponse<T = unknown> {
+    success: true;
+    statusCode: number;
+    data?: T;
+    message?: string;
+}
+/**
+ * Standard API error response.
+ */
+export interface ApiErrorResponse {
+    success: false;
+    statusCode: number;
+    message: string;
+    code?: string;
+    details?: unknown;
+    quota?: QuotaInfo;
+}
+/**
+ * Combined API response type.
+ */
+export type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;
+/**
+ * JWT payload from access tokens.
+ *
+ * Users can belong to multiple organizations. The token is scoped to one
+ * active organization at a time. The `role` field is the user's per-org
+ * role in that organization (from the UserOrganization junction collection),
+ * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.
+ *
+ * Use `POST /auth/switch-org` to change the active organization, which
+ * re-issues tokens with the new org's role and context.
+ */
+/**
+ * Coarse per-org membership label, DERIVED from the Roles a user is assigned
+ * (the highest `grantsRole` among them; `owner` is set only by ownership
+ * transfer). It is a display/authority label — driving `isAdmin`, ownership,
+ * and seat accounting — NOT a permission source. Effective permissions come
+ * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a
+ * global role.
+ */
+export type OrgRole = 'owner' | 'admin' | 'member';
+export interface JwtPayload {
+    /** User ID (subject) */
+    sub: string;
+    /** Username */
+    username: string;
+    /** User email */
+    email: string;
+    /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */
+    role: OrgRole;
+    /** Derived: true when role is 'admin' or 'owner' in the active organization */
+    isAdmin?: boolean;
+    /**
+     * Resolved fine-grained permissions for the active org/team — the union of
+     * the permissions carried by every Role the user is assigned (see
+     * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are
+     * granted all permissions implicitly and may omit this. Endpoints enforce via
+     * `requirePermission(...)`.
+     */
+    permissions?: Permission[];
+    /**
+     * Global super-admin flag (cross-org). When `true`, the user is treated
+     * as a system administrator regardless of which org they're currently
+     * acting under. This is the SOLE signal for sysadmin authority — the old path
+     * (membership in the well-known "system" org with role admin/owner) has been
+     * removed because it conflated "Pipeline Builder operator" with "real customer
+     * tenant" in the data model. Grant sysadmin only via `isSuperAdmin`.
+     */
+    isSuperAdmin?: boolean;
+    /** Organization's quota tier. */
+    tier?: QuotaTier;
+    /** Resolved feature flags for this user/org */
+    features?: string[];
+    /**
+     * Narrow capability scope for machine/automation tokens (e.g.
+     * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints
+     * that accept a scoped identity check this (see `hasScope`) instead of role;
+     * a scoped token is minted with minimal role for least-privilege.
+     */
+    scope?: TokenScope;
+    /** Active organization ID (from UserOrganization membership) */
+    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`
+     * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).
+     * 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
+     * user id so audit events still attribute actions correctly.
+     */
+    impersonatorId?: string;
+    /**
+     * When true, the token is read-only — any non-GET request is rejected
+     * upstream by the platform's read-only impersonation gate. Lets
+     * sysadmins "view as user X" without risking a destructive action.
+     */
+    impersonationReadOnly?: boolean;
+    /**
+     * The user's `tokenVersion` at the moment this token was issued. Every
+     * privilege change (deactivate / role or tier downgrade / membership or
+     * ownership change / password change / logout-all) increments the user's
+     * server-side `tokenVersion`, so a token whose embedded version is behind the
+     * current one has been REVOKED. Platform validates this against Mongo; the
+     * stateless services validate it against a Redis-published current-version
+     * store (see `setTokenRevocationStore`). Absent on machine/service tokens.
+     */
+    tokenVersion?: number;
+    /** Token type */
+    type: 'access' | 'refresh';
+    /** Issued at timestamp */
+    iat?: number;
+    /** Expiration timestamp */
+    exp?: number;
+}
+/**
+ * The account boundary (root org) for a token's active org.
+ *
+ * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org
+ * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries
+ * the top of its ancestry chain. Every account-scoped read (quota/seat/billing
+ * pooling) must resolve through this coalesce rather than reading
+ * `organizationId` directly — the latter silently works today (all orgs flat)
+ * but would bind to the team instead of the account once teams exist.
+ *
+ * @returns the effective root org id, or `undefined` when neither field is set.
+ */
+export declare function effectiveRootOrgId(payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>): string | undefined;
+/**
+ * Extended Express Request with user property.
+ */
+declare global {
+    namespace Express {
+        interface Request {
+            user?: JwtPayload;
+        }
+    }
+}
+/**
+ * Service configuration for internal HTTP client.
+ */
+export interface ServiceConfig {
+    /** Service hostname */
+    host: string;
+    /** Service port */
+    port: number;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Health check response.
+ */
+export interface HealthCheckResponse {
+    status: 'healthy' | 'unhealthy';
+    service: string;
+    timestamp: string;
+    uptime: number;
+    version?: string;
+    dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;
+}

package/lib/types/common.js

@@ -0,0 +1,41 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Valid quota type values.
+ */
+export const VALID_QUOTA_TYPES = [
+    'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',
+    'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',
+];
+/**
+ * Type guard to check if a value is a valid QuotaType.
+ *
+ * @param value - Value to check
+ * @returns True if value is a valid QuotaType
+ *
+ * @example
+ * ```typescript
+ * if (isValidQuotaType(req.body.quotaType)) {
+ *   // quotaType is guaranteed to be QuotaType
+ * }
+ * ```
+ */
+export function isValidQuotaType(value) {
+    return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value);
+}
+/**
+ * The account boundary (root org) for a token's active org.
+ *
+ * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org
+ * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries
+ * the top of its ancestry chain. Every account-scoped read (quota/seat/billing
+ * pooling) must resolve through this coalesce rather than reading
+ * `organizationId` directly — the latter silently works today (all orgs flat)
+ * but would bind to the team instead of the account once teams exist.
+ *
+ * @returns the effective root org id, or `undefined` when neither field is set.
+ */
+export function effectiveRootOrgId(payload) {
+    return payload.rootOrganizationId ?? payload.organizationId;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA0CtC;;GAEG;AACH,MAAM,CAAC,MAAM,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,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAyKD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAkE;IAElE,OAAO,OAAO,CAAC,kBAAkB,IAAI,OAAO,CAAC,cAAc,CAAC;AAC9D,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\nimport type { QuotaTier } from './quota-tiers.js';\n\n/**\n * Capability scope catalog for machine/automation tokens. A scoped token carries\n * exactly one of these instead of role-based permissions; endpoints that accept a\n * scoped identity check it via `hasScope`. Kept a closed union (mirroring\n * {@link Permission}) so a typo on either the mint or the check side is a compile\n * error. Add a value here when introducing a new scoped-token surface.\n */\nexport type TokenScope = 'reporting:ingest';\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 */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\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 * 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   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: 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 */\n/**\n * Coarse per-org membership label, DERIVED from the Roles a user is assigned\n * (the highest `grantsRole` among them; `owner` is set only by ownership\n * transfer). It is a display/authority label — driving `isAdmin`, ownership,\n * and seat accounting — NOT a permission source. Effective permissions come\n * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a\n * global role.\n */\nexport type OrgRole = 'owner' | 'admin' | 'member';\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: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the permissions carried by every Role the user is assigned (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\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 SOLE signal for sysadmin authority — the old path\n   * (membership in the well-known \"system\" org with role admin/owner) has been\n   * removed because it conflated \"Pipeline Builder operator\" with \"real customer\n   * tenant\" in the data model. Grant sysadmin only via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier. */\n  tier?: QuotaTier;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: TokenScope;\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   * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).\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  /**\n   * The user's `tokenVersion` at the moment this token was issued. Every\n   * privilege change (deactivate / role or tier downgrade / membership or\n   * ownership change / password change / logout-all) increments the user's\n   * server-side `tokenVersion`, so a token whose embedded version is behind the\n   * current one has been REVOKED. Platform validates this against Mongo; the\n   * stateless services validate it against a Redis-published current-version\n   * store (see `setTokenRevocationStore`). Absent on machine/service tokens.\n   */\n  tokenVersion?: number;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * The account boundary (root org) for a token's active org.\n *\n * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org\n * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries\n * the top of its ancestry chain. Every account-scoped read (quota/seat/billing\n * pooling) must resolve through this coalesce rather than reading\n * `organizationId` directly — the latter silently works today (all orgs flat)\n * but would bind to the team instead of the account once teams exist.\n *\n * @returns the effective root org id, or `undefined` when neither field is set.\n */\nexport function effectiveRootOrgId(\n  payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>,\n): string | undefined {\n  return payload.rootOrganizationId ?? payload.organizationId;\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/types/error-codes.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Standardized error codes used across all API microservices.
+ * Use these codes in error responses for consistent client handling.
+ *
+ * Each HTTP status category has one primary code. Use the `details`
+ * field in error responses for sub-type information (e.g. which quota
+ * was exceeded, which field failed validation).
+ */
+export declare enum ErrorCode {
+    UNAUTHORIZED = "UNAUTHORIZED",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    TOKEN_INVALID = "TOKEN_INVALID",
+    TOKEN_MISSING = "TOKEN_MISSING",
+    TOKEN_REVOKED = "TOKEN_REVOKED",
+    INSUFFICIENT_PERMISSIONS = "INSUFFICIENT_PERMISSIONS",
+    ORG_MISMATCH = "ORG_MISMATCH",
+    COMPLIANCE_VIOLATION = "COMPLIANCE_VIOLATION",
+    NOT_FOUND = "NOT_FOUND",
+    ORG_NOT_FOUND = "ORG_NOT_FOUND",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+    TEMPLATE_UNKNOWN_PATH = "TEMPLATE_UNKNOWN_PATH",
+    TEMPLATE_CYCLE = "TEMPLATE_CYCLE",
+    TEMPLATE_PARSE_ERROR = "TEMPLATE_PARSE_ERROR",
+    TEMPLATE_TYPE_MISMATCH = "TEMPLATE_TYPE_MISMATCH",
+    TEMPLATE_SECRETS_RESERVED = "TEMPLATE_SECRETS_RESERVED",
+    TEMPLATE_CONTRACT_VIOLATION = "TEMPLATE_CONTRACT_VIOLATION",
+    TEMPLATE_SIZE_EXCEEDED = "TEMPLATE_SIZE_EXCEEDED",
+    TEMPLATE_VALIDATION_FAILED = "TEMPLATE_VALIDATION_FAILED",
+    QUOTA_EXCEEDED = "QUOTA_EXCEEDED",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    PAYLOAD_TOO_LARGE = "PAYLOAD_TOO_LARGE",
+    CONFLICT = "CONFLICT",
+    DUPLICATE_ENTRY = "DUPLICATE_ENTRY",
+    SCAN_CONFLICT = "SCAN_CONFLICT",
+    PAYMENT_METHOD_REQUIRED = "PAYMENT_METHOD_REQUIRED",// 402
+    DISCOUNT_CEILING_EXCEEDED = "DISCOUNT_CEILING_EXCEEDED",// 400
+    DISCOUNT_NOT_FOUND = "DISCOUNT_NOT_FOUND",// 404
+    DISCOUNT_INACTIVE = "DISCOUNT_INACTIVE",// 409
+    PLAN_OVER_CAP = "PLAN_OVER_CAP",// 409
+    ADDON_OVER_CAP = "ADDON_OVER_CAP",// 409
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    DATABASE_ERROR = "DATABASE_ERROR",
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
+    COMPLIANCE_SERVICE_UNAVAILABLE = "COMPLIANCE_SERVICE_UNAVAILABLE"
+}
+/**
+ * Maps error codes to their default HTTP status codes.
+ */
+export declare const ErrorCodeStatus: Record<ErrorCode, number>;
+/**
+ * Get the HTTP status code for an error code.
+ */
+export declare function getStatusForErrorCode(code: ErrorCode): number;

package/lib/types/error-codes.js

@@ -0,0 +1,107 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Standardized error codes used across all API microservices.
+ * Use these codes in error responses for consistent client handling.
+ *
+ * Each HTTP status category has one primary code. Use the `details`
+ * field in error responses for sub-type information (e.g. which quota
+ * was exceeded, which field failed validation).
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // Authentication errors (401)
+    ErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    ErrorCode["TOKEN_EXPIRED"] = "TOKEN_EXPIRED";
+    ErrorCode["TOKEN_INVALID"] = "TOKEN_INVALID";
+    ErrorCode["TOKEN_MISSING"] = "TOKEN_MISSING";
+    ErrorCode["TOKEN_REVOKED"] = "TOKEN_REVOKED";
+    // Authorization errors (403)
+    ErrorCode["INSUFFICIENT_PERMISSIONS"] = "INSUFFICIENT_PERMISSIONS";
+    ErrorCode["ORG_MISMATCH"] = "ORG_MISMATCH";
+    ErrorCode["COMPLIANCE_VIOLATION"] = "COMPLIANCE_VIOLATION";
+    // Not found errors (404)
+    ErrorCode["NOT_FOUND"] = "NOT_FOUND";
+    ErrorCode["ORG_NOT_FOUND"] = "ORG_NOT_FOUND";
+    // Validation errors (400)
+    ErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    ErrorCode["MISSING_REQUIRED_FIELD"] = "MISSING_REQUIRED_FIELD";
+    ErrorCode["TEMPLATE_UNKNOWN_PATH"] = "TEMPLATE_UNKNOWN_PATH";
+    ErrorCode["TEMPLATE_CYCLE"] = "TEMPLATE_CYCLE";
+    ErrorCode["TEMPLATE_PARSE_ERROR"] = "TEMPLATE_PARSE_ERROR";
+    ErrorCode["TEMPLATE_TYPE_MISMATCH"] = "TEMPLATE_TYPE_MISMATCH";
+    ErrorCode["TEMPLATE_SECRETS_RESERVED"] = "TEMPLATE_SECRETS_RESERVED";
+    ErrorCode["TEMPLATE_CONTRACT_VIOLATION"] = "TEMPLATE_CONTRACT_VIOLATION";
+    ErrorCode["TEMPLATE_SIZE_EXCEEDED"] = "TEMPLATE_SIZE_EXCEEDED";
+    ErrorCode["TEMPLATE_VALIDATION_FAILED"] = "TEMPLATE_VALIDATION_FAILED";
+    // Quota/Rate limit errors (429)
+    ErrorCode["QUOTA_EXCEEDED"] = "QUOTA_EXCEEDED";
+    ErrorCode["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+    // Payload errors (413)
+    ErrorCode["PAYLOAD_TOO_LARGE"] = "PAYLOAD_TOO_LARGE";
+    // Conflict errors (409)
+    ErrorCode["CONFLICT"] = "CONFLICT";
+    ErrorCode["DUPLICATE_ENTRY"] = "DUPLICATE_ENTRY";
+    ErrorCode["SCAN_CONFLICT"] = "SCAN_CONFLICT";
+    // Billing errors
+    ErrorCode["PAYMENT_METHOD_REQUIRED"] = "PAYMENT_METHOD_REQUIRED";
+    ErrorCode["DISCOUNT_CEILING_EXCEEDED"] = "DISCOUNT_CEILING_EXCEEDED";
+    ErrorCode["DISCOUNT_NOT_FOUND"] = "DISCOUNT_NOT_FOUND";
+    ErrorCode["DISCOUNT_INACTIVE"] = "DISCOUNT_INACTIVE";
+    ErrorCode["PLAN_OVER_CAP"] = "PLAN_OVER_CAP";
+    ErrorCode["ADDON_OVER_CAP"] = "ADDON_OVER_CAP";
+    // Server errors (500)
+    ErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    ErrorCode["DATABASE_ERROR"] = "DATABASE_ERROR";
+    // Service unavailable (503)
+    ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    ErrorCode["COMPLIANCE_SERVICE_UNAVAILABLE"] = "COMPLIANCE_SERVICE_UNAVAILABLE";
+})(ErrorCode || (ErrorCode = {}));
+/**
+ * Maps error codes to their default HTTP status codes.
+ */
+export const ErrorCodeStatus = {
+    [ErrorCode.UNAUTHORIZED]: 401,
+    [ErrorCode.TOKEN_EXPIRED]: 401,
+    [ErrorCode.TOKEN_INVALID]: 401,
+    [ErrorCode.TOKEN_MISSING]: 401,
+    [ErrorCode.TOKEN_REVOKED]: 401,
+    [ErrorCode.INSUFFICIENT_PERMISSIONS]: 403,
+    [ErrorCode.ORG_MISMATCH]: 403,
+    [ErrorCode.COMPLIANCE_VIOLATION]: 403,
+    [ErrorCode.NOT_FOUND]: 404,
+    [ErrorCode.ORG_NOT_FOUND]: 404,
+    [ErrorCode.VALIDATION_ERROR]: 400,
+    [ErrorCode.MISSING_REQUIRED_FIELD]: 400,
+    [ErrorCode.TEMPLATE_UNKNOWN_PATH]: 400,
+    [ErrorCode.TEMPLATE_CYCLE]: 400,
+    [ErrorCode.TEMPLATE_PARSE_ERROR]: 400,
+    [ErrorCode.TEMPLATE_TYPE_MISMATCH]: 400,
+    [ErrorCode.TEMPLATE_SECRETS_RESERVED]: 400,
+    [ErrorCode.TEMPLATE_CONTRACT_VIOLATION]: 400,
+    [ErrorCode.TEMPLATE_SIZE_EXCEEDED]: 400,
+    [ErrorCode.TEMPLATE_VALIDATION_FAILED]: 400,
+    [ErrorCode.QUOTA_EXCEEDED]: 429,
+    [ErrorCode.RATE_LIMIT_EXCEEDED]: 429,
+    [ErrorCode.PAYLOAD_TOO_LARGE]: 413,
+    [ErrorCode.CONFLICT]: 409,
+    [ErrorCode.DUPLICATE_ENTRY]: 409,
+    [ErrorCode.SCAN_CONFLICT]: 409,
+    [ErrorCode.PAYMENT_METHOD_REQUIRED]: 402,
+    [ErrorCode.DISCOUNT_CEILING_EXCEEDED]: 400,
+    [ErrorCode.DISCOUNT_NOT_FOUND]: 404,
+    [ErrorCode.DISCOUNT_INACTIVE]: 409,
+    [ErrorCode.PLAN_OVER_CAP]: 409,
+    [ErrorCode.ADDON_OVER_CAP]: 409,
+    [ErrorCode.INTERNAL_ERROR]: 500,
+    [ErrorCode.DATABASE_ERROR]: 500,
+    [ErrorCode.SERVICE_UNAVAILABLE]: 503,
+    [ErrorCode.COMPLIANCE_SERVICE_UNAVAILABLE]: 503,
+};
+/**
+ * Get the HTTP status code for an error code.
+ */
+export function getStatusForErrorCode(code) {
+    return ErrorCodeStatus[code] ?? 500;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-codes.js","sourceRoot":"","sources":["../../src/types/error-codes.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Standardized error codes used across all API microservices.\n * Use these codes in error responses for consistent client handling.\n *\n * Each HTTP status category has one primary code. Use the `details`\n * field in error responses for sub-type information (e.g. which quota\n * was exceeded, which field failed validation).\n */\nexport enum ErrorCode {\n  // Authentication errors (401)\n  UNAUTHORIZED = 'UNAUTHORIZED',\n  TOKEN_EXPIRED = 'TOKEN_EXPIRED',\n  TOKEN_INVALID = 'TOKEN_INVALID',\n  TOKEN_MISSING = 'TOKEN_MISSING',\n  TOKEN_REVOKED = 'TOKEN_REVOKED',\n\n  // Authorization errors (403)\n  INSUFFICIENT_PERMISSIONS = 'INSUFFICIENT_PERMISSIONS',\n  ORG_MISMATCH = 'ORG_MISMATCH',\n  COMPLIANCE_VIOLATION = 'COMPLIANCE_VIOLATION',\n\n  // Not found errors (404)\n  NOT_FOUND = 'NOT_FOUND',\n  ORG_NOT_FOUND = 'ORG_NOT_FOUND',\n\n  // Validation errors (400)\n  VALIDATION_ERROR = 'VALIDATION_ERROR',\n  MISSING_REQUIRED_FIELD = 'MISSING_REQUIRED_FIELD',\n  TEMPLATE_UNKNOWN_PATH = 'TEMPLATE_UNKNOWN_PATH',\n  TEMPLATE_CYCLE = 'TEMPLATE_CYCLE',\n  TEMPLATE_PARSE_ERROR = 'TEMPLATE_PARSE_ERROR',\n  TEMPLATE_TYPE_MISMATCH = 'TEMPLATE_TYPE_MISMATCH',\n  TEMPLATE_SECRETS_RESERVED = 'TEMPLATE_SECRETS_RESERVED',\n  TEMPLATE_CONTRACT_VIOLATION = 'TEMPLATE_CONTRACT_VIOLATION',\n  TEMPLATE_SIZE_EXCEEDED = 'TEMPLATE_SIZE_EXCEEDED',\n  TEMPLATE_VALIDATION_FAILED = 'TEMPLATE_VALIDATION_FAILED',\n\n  // Quota/Rate limit errors (429)\n  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED',\n  RATE_LIMIT_EXCEEDED = 'RATE_LIMIT_EXCEEDED',\n\n  // Payload errors (413)\n  PAYLOAD_TOO_LARGE = 'PAYLOAD_TOO_LARGE',\n\n  // Conflict errors (409)\n  CONFLICT = 'CONFLICT',\n  DUPLICATE_ENTRY = 'DUPLICATE_ENTRY',\n  SCAN_CONFLICT = 'SCAN_CONFLICT',\n\n  // Billing errors\n  PAYMENT_METHOD_REQUIRED = 'PAYMENT_METHOD_REQUIRED', // 402\n  DISCOUNT_CEILING_EXCEEDED = 'DISCOUNT_CEILING_EXCEEDED', // 400\n  DISCOUNT_NOT_FOUND = 'DISCOUNT_NOT_FOUND', // 404\n  DISCOUNT_INACTIVE = 'DISCOUNT_INACTIVE', // 409\n  PLAN_OVER_CAP = 'PLAN_OVER_CAP', // 409\n  ADDON_OVER_CAP = 'ADDON_OVER_CAP', // 409\n\n  // Server errors (500)\n  INTERNAL_ERROR = 'INTERNAL_ERROR',\n  DATABASE_ERROR = 'DATABASE_ERROR',\n\n  // Service unavailable (503)\n  SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE',\n  COMPLIANCE_SERVICE_UNAVAILABLE = 'COMPLIANCE_SERVICE_UNAVAILABLE',\n}\n\n/**\n * Maps error codes to their default HTTP status codes.\n */\nexport const ErrorCodeStatus: Record<ErrorCode, number> = {\n  [ErrorCode.UNAUTHORIZED]: 401,\n  [ErrorCode.TOKEN_EXPIRED]: 401,\n  [ErrorCode.TOKEN_INVALID]: 401,\n  [ErrorCode.TOKEN_MISSING]: 401,\n  [ErrorCode.TOKEN_REVOKED]: 401,\n  [ErrorCode.INSUFFICIENT_PERMISSIONS]: 403,\n  [ErrorCode.ORG_MISMATCH]: 403,\n  [ErrorCode.COMPLIANCE_VIOLATION]: 403,\n  [ErrorCode.NOT_FOUND]: 404,\n  [ErrorCode.ORG_NOT_FOUND]: 404,\n  [ErrorCode.VALIDATION_ERROR]: 400,\n  [ErrorCode.MISSING_REQUIRED_FIELD]: 400,\n  [ErrorCode.TEMPLATE_UNKNOWN_PATH]: 400,\n  [ErrorCode.TEMPLATE_CYCLE]: 400,\n  [ErrorCode.TEMPLATE_PARSE_ERROR]: 400,\n  [ErrorCode.TEMPLATE_TYPE_MISMATCH]: 400,\n  [ErrorCode.TEMPLATE_SECRETS_RESERVED]: 400,\n  [ErrorCode.TEMPLATE_CONTRACT_VIOLATION]: 400,\n  [ErrorCode.TEMPLATE_SIZE_EXCEEDED]: 400,\n  [ErrorCode.TEMPLATE_VALIDATION_FAILED]: 400,\n  [ErrorCode.QUOTA_EXCEEDED]: 429,\n  [ErrorCode.RATE_LIMIT_EXCEEDED]: 429,\n  [ErrorCode.PAYLOAD_TOO_LARGE]: 413,\n  [ErrorCode.CONFLICT]: 409,\n  [ErrorCode.DUPLICATE_ENTRY]: 409,\n  [ErrorCode.SCAN_CONFLICT]: 409,\n  [ErrorCode.PAYMENT_METHOD_REQUIRED]: 402,\n  [ErrorCode.DISCOUNT_CEILING_EXCEEDED]: 400,\n  [ErrorCode.DISCOUNT_NOT_FOUND]: 404,\n  [ErrorCode.DISCOUNT_INACTIVE]: 409,\n  [ErrorCode.PLAN_OVER_CAP]: 409,\n  [ErrorCode.ADDON_OVER_CAP]: 409,\n  [ErrorCode.INTERNAL_ERROR]: 500,\n  [ErrorCode.DATABASE_ERROR]: 500,\n  [ErrorCode.SERVICE_UNAVAILABLE]: 503,\n  [ErrorCode.COMPLIANCE_SERVICE_UNAVAILABLE]: 503,\n};\n\n/**\n * Get the HTTP status code for an error code.\n */\nexport function getStatusForErrorCode(code: ErrorCode): number {\n  return ErrorCodeStatus[code] ?? 500;\n}\n"]}

package/lib/types/feature-flags.d.ts

@@ -0,0 +1,36 @@
+import type { QuotaTier } from './quota-tiers.js';
+/** Canonical feature flag identifiers. */
+export type FeatureFlag = 'priority_support' | 'custom_integrations' | 'ai_generation' | 'bulk_operations' | 'audit_log' | 'sso' | 'advanced_reporting' | 'team_usage_analytics' | 'compliance_standard' | 'compliance_advanced';
+/** All valid feature flags (order determines display order). */
+export declare const ALL_FEATURE_FLAGS: readonly FeatureFlag[];
+/** Check whether a string is a valid FeatureFlag. */
+export declare function isValidFeatureFlag(value: string): value is FeatureFlag;
+/** Features enabled by default for each tier. */
+export declare const TIER_FEATURES: Record<QuotaTier, readonly FeatureFlag[]>;
+/** Human-readable metadata for each feature flag. */
+export declare const FEATURE_METADATA: Record<FeatureFlag, {
+    label: string;
+    description: string;
+}>;
+/**
+ * Resolve a user's effective feature set.
+ *
+ * 1. Sysadmins (isSuperAdmin) always get ALL features.
+ * 2. Start with the tier's default features.
+ * 3. Apply per-user overrides: `true` adds a feature, `false` removes it.
+ * 4. Invalid override keys are silently ignored.
+ *
+ * @param tier - The organization's quota tier
+ * @param opts - Resolution options:
+ *   - `overrides`: per-user overrides (key = feature flag, value = enabled)
+ *   - `isSuperAdmin`: whether the user has the global super-admin flag
+ *   - `accountFeatures`: account-level entitlements (e.g. purchased add-on
+ *     bundles). A NAMED field so it can never be silently dropped by a caller
+ *     that omits a trailing positional arg.
+ * @returns Sorted array of enabled feature flags
+ */
+export declare function resolveUserFeatures(tier: QuotaTier, opts?: {
+    overrides?: Record<string, boolean> | null;
+    isSuperAdmin?: boolean;
+    accountFeatures?: readonly string[] | null;
+}): FeatureFlag[];