@pipeline-builder/api-core 4.1.1 → 4.1.3

package/lib/services/token-revocation.js

@@ -16,6 +16,16 @@ export const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';
 export function tokenRevocationKey(userId) {
     return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;
 }
+/**
+ * Redis key namespace for ended IMPERSONATION sessions, by token `jti`. Same
+ * publish/read split as the tokenVersion keys above, and kept beside them for the
+ * same reason: publisher and readers must agree on this exact prefix.
+ */
+export const SESSION_REVOCATION_KEY_PREFIX = 'authrev:jti:';
+/** The revocation key for one session's token id. */
+export function sessionRevocationKey(jti) {
+    return `${SESSION_REVOCATION_KEY_PREFIX}${jti}`;
+}
 /**
  * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless
  * service to register via `setTokenRevocationStore`. Reads the current
@@ -54,11 +64,27 @@ export function createRedisTokenRevocationStore(redis) {
                 return null;
             }
         },
+        async getSessionRevocation(jti) {
+            try {
+                const raw = await redis.get(sessionRevocationKey(jti));
+                return raw === null || raw === undefined ? 'live' : 'revoked';
+            }
+            catch (err) {
+                // NOT fail-open, unlike getCurrentVersion above: `unavailable` rejects
+                // the impersonation token. Counted so a sustained outage — which stops
+                // support impersonation everywhere — is visible and alertable.
+                emitCounter('session_revocation_unavailable_total', { reason: 'read-error' });
+                logger.debug('Session-revocation read failed (rejecting impersonation token)', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return 'unavailable';
+            }
+        },
     };
 }
 /**
  * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily
- * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —
+ * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —
  * for a stateless service that keeps NO Redis client of its own. The client is
  * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via
  * a guarded dynamic require so merely importing this never breaks a build/test
@@ -74,9 +100,9 @@ export function createEnvRedisTokenRevocationStore() {
     // undefined = not yet attempted; null = attempted and unavailable (stay off).
     let cached;
     function build() {
-        // Shared env-configured ioredis construction (fail-open, error-listener
-        // attached, null when Redis isn't configured/available); the reader stays
-        // fail-open — a null client just falls back to natural token expiry.
+        // Shared env-configured ioredis construction (error listener attached, null
+        // when Redis isn't configured); the reader stays fail-open — a null client
+        // just falls back to natural token expiry.
         const inst = createEnvRedisClient('revocation-reader');
         if (inst)
             logger.info('Redis token-revocation reader initialized');
@@ -90,6 +116,18 @@ export function createEnvRedisTokenRevocationStore() {
                 return null;
             return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);
         },
+        async getSessionRevocation(jti) {
+            if (cached === undefined)
+                cached = build();
+            // No Redis configured ⇒ there is no way to learn a session was ended, so
+            // an impersonation token can't be trusted. Every real deployment runs Redis
+            // (the build queue needs it), so this only bites a misconfigured service.
+            if (!cached) {
+                emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });
+                return 'unavailable';
+            }
+            return createRedisTokenRevocationStore(cached).getSessionRevocation(jti);
+        },
     };
 }
 /**
@@ -117,4 +155,30 @@ export async function publishTokenRevocation(redis, userId, tokenVersion, ttlSec
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { RedisCacheClient } from './cache-service.js';\nimport { createEnvRedisClient } from './env-redis.js';\nimport type { TokenRevocationStore } from '../middleware/auth.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        // Redis was reachable enough to try but the read errored — this is a\n        // DEGRADATION: while it persists, forced logouts / privilege revocations\n        // silently stop taking effect until natural token expiry. Emit a counter\n        // so `TokenRevocationFailingOpen` can alert on a SUSTAINED rate (mirrors\n        // the quota_fail_open_total pattern). Not emitted for the \"Redis not\n        // configured\" path (createEnvRedisTokenRevocationStore → null client),\n        // which is a deliberate opt-out, not a degradation.\n        emitCounter('token_revocation_fail_open_total', { reason: 'read-error' });\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: err instanceof Error ? err.message : String(err),\n        });\n        return null;\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: RedisCacheClient | null | undefined;\n\n  function build(): RedisCacheClient | null {\n    // Shared env-configured ioredis construction (fail-open, error-listener\n    // attached, null when Redis isn't configured/available); the reader stays\n    // fail-open — a null client just falls back to natural token expiry.\n    const inst = createEnvRedisClient<RedisCacheClient>('revocation-reader');\n    if (inst) logger.info('Redis token-revocation reader initialized');\n    return inst;\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      if (cached === undefined) cached = build();\n      if (!cached) return null;\n      return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // ioredis-style variadic SET with expiry: SET key val EX ttl.\n    await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: err instanceof Error ? err.message : String(err),\n    });\n  }\n}\n"]}
+/**
+ * Publish that one IMPERSONATION session has ended, so every stateless service
+ * rejects its token on the next request (platform side).
+ *
+ * Returns whether the publish landed — unlike `publishTokenRevocation`, which is
+ * fire-and-forget. The caller must be able to tell the person who ended the
+ * session that it did NOT end everywhere, rather than reporting success while
+ * the token still works against other services.
+ *
+ * The entry expires with the session: once the token itself can no longer be
+ * used, there is nothing left to revoke, so the key cleans itself up.
+ *
+ * @param ttlMs - time remaining on the session's token
+ */
+export async function publishSessionRevocation(redis, jti, ttlMs) {
+    try {
+        await redis.set(sessionRevocationKey(jti), '1', 'PX', Math.max(1000, Math.ceil(ttlMs)));
+        return true;
+    }
+    catch (err) {
+        logger.warn('Session-revocation publish failed (other services will honour the token until it expires)', {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { RedisCacheClient } from './cache-service.js';\nimport { createEnvRedisClient } from './env-redis.js';\nimport type { SessionRevocationState, TokenRevocationStore } from '../middleware/auth.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Redis key namespace for ended IMPERSONATION sessions, by token `jti`. Same\n * publish/read split as the tokenVersion keys above, and kept beside them for the\n * same reason: publisher and readers must agree on this exact prefix.\n */\nexport const SESSION_REVOCATION_KEY_PREFIX = 'authrev:jti:';\n\n/** The revocation key for one session's token id. */\nexport function sessionRevocationKey(jti: string): string {\n  return `${SESSION_REVOCATION_KEY_PREFIX}${jti}`;\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        // Redis was reachable enough to try but the read errored — this is a\n        // DEGRADATION: while it persists, forced logouts / privilege revocations\n        // silently stop taking effect until natural token expiry. Emit a counter\n        // so `TokenRevocationFailingOpen` can alert on a SUSTAINED rate (mirrors\n        // the quota_fail_open_total pattern). Not emitted for the \"Redis not\n        // configured\" path (createEnvRedisTokenRevocationStore → null client),\n        // which is a deliberate opt-out, not a degradation.\n        emitCounter('token_revocation_fail_open_total', { reason: 'read-error' });\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: err instanceof Error ? err.message : String(err),\n        });\n        return null;\n      }\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      try {\n        const raw = await redis.get(sessionRevocationKey(jti));\n        return raw === null || raw === undefined ? 'live' : 'revoked';\n      } catch (err) {\n        // NOT fail-open, unlike getCurrentVersion above: `unavailable` rejects\n        // the impersonation token. Counted so a sustained outage — which stops\n        // support impersonation everywhere — is visible and alertable.\n        emitCounter('session_revocation_unavailable_total', { reason: 'read-error' });\n        logger.debug('Session-revocation read failed (rejecting impersonation token)', {\n          error: err instanceof Error ? err.message : String(err),\n        });\n        return 'unavailable';\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_SENTINELS` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: RedisCacheClient | null | undefined;\n\n  function build(): RedisCacheClient | null {\n    // Shared env-configured ioredis construction (error listener attached, null\n    // when Redis isn't configured); the reader stays fail-open — a null client\n    // just falls back to natural token expiry.\n    const inst = createEnvRedisClient<RedisCacheClient>('revocation-reader');\n    if (inst) logger.info('Redis token-revocation reader initialized');\n    return inst;\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      if (cached === undefined) cached = build();\n      if (!cached) return null;\n      return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);\n    },\n    async getSessionRevocation(jti: string): Promise<SessionRevocationState> {\n      if (cached === undefined) cached = build();\n      // No Redis configured ⇒ there is no way to learn a session was ended, so\n      // an impersonation token can't be trusted. Every real deployment runs Redis\n      // (the build queue needs it), so this only bites a misconfigured service.\n      if (!cached) {\n        emitCounter('session_revocation_unavailable_total', { reason: 'not-configured' });\n        return 'unavailable';\n      }\n      return createRedisTokenRevocationStore(cached).getSessionRevocation!(jti);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // ioredis-style variadic SET with expiry: SET key val EX ttl.\n    await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: err instanceof Error ? err.message : String(err),\n    });\n  }\n}\n\n/**\n * Publish that one IMPERSONATION session has ended, so every stateless service\n * rejects its token on the next request (platform side).\n *\n * Returns whether the publish landed — unlike `publishTokenRevocation`, which is\n * fire-and-forget. The caller must be able to tell the person who ended the\n * session that it did NOT end everywhere, rather than reporting success while\n * the token still works against other services.\n *\n * The entry expires with the session: once the token itself can no longer be\n * used, there is nothing left to revoke, so the key cleans itself up.\n *\n * @param ttlMs - time remaining on the session's token\n */\nexport async function publishSessionRevocation(\n  redis: RedisCacheClient,\n  jti: string,\n  ttlMs: number,\n): Promise<boolean> {\n  try {\n    await redis.set(sessionRevocationKey(jti), '1', 'PX', Math.max(1000, Math.ceil(ttlMs)));\n    return true;\n  } catch (err) {\n    logger.warn('Session-revocation publish failed (other services will honour the token until it expires)', {\n      error: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n}\n"]}

package/lib/types/common.d.ts

@@ -185,6 +185,14 @@ export interface JwtPayload {
      * user id so audit events still attribute actions correctly.
      */
     impersonatorId?: string;
+    /**
+     * Unique token id. On an impersonation token it identifies the SESSION, so it
+     * can be revoked on its own across every service (see
+     * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens carry
+     * one too, validated against a different record — which is why a `jti` alone
+     * never marks a token as impersonation; `impersonatorId` does.
+     */
+    jti?: string;
     /**
      * When true, the token is read-only — any non-GET request is rejected
      * upstream by the platform's read-only impersonation gate. Lets

package/lib/types/common.js

@@ -38,4 +38,4 @@ export function isValidQuotaType(value) {
 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"]}
+//# 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;AAiLD;;;;;;;;;;;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   * Unique token id. On an impersonation token it identifies the SESSION, so it\n   * can be revoked on its own across every service (see\n   * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens carry\n   * one too, validated against a different record — which is why a `jti` alone\n   * never marks a token as impersonation; `impersonatorId` does.\n   */\n  jti?: 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/permissions.d.ts

@@ -12,7 +12,7 @@ import type { OrgRole } from './common.js';
  * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`
  * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.
  */
-export type Permission = 'pipelines:read' | 'pipelines:write' | 'pipelines:publish' | 'templates:read' | 'templates:write' | 'templates:publish' | 'plugins:read' | 'plugins:write' | 'plugins:publish' | 'compliance:read' | 'compliance:write' | 'members:manage' | 'roles:manage' | 'invitations:manage' | 'dashboards:read' | 'dashboards:write' | 'observability:read' | 'observability:write' | 'reports:read' | 'reports:rollup' | 'messages:read' | 'messages:write' | 'billing:read' | 'billing:manage' | 'quotas:read' | 'registry:read' | 'registry:write' | 'org:settings' | 'org:idp' | 'org:kms';
+export type Permission = 'pipelines:read' | 'pipelines:write' | 'pipelines:publish' | 'templates:read' | 'templates:write' | 'templates:publish' | 'plugins:read' | 'plugins:write' | 'plugins:publish' | 'compliance:read' | 'compliance:write' | 'members:manage' | 'roles:manage' | 'invitations:manage' | 'dashboards:read' | 'dashboards:write' | 'observability:read' | 'observability:write' | 'reports:read' | 'reports:rollup' | 'messages:read' | 'messages:write' | 'billing:read' | 'billing:manage' | 'quotas:read' | 'registry:read' | 'registry:write' | 'org:settings' | 'org:idp' | 'org:kms' | 'org:impersonation';
 /** All valid permissions (order determines display order in the picker). */
 export declare const ALL_PERMISSIONS: readonly Permission[];
 /** Check whether a string is a valid Permission. */

package/lib/types/permissions.js

@@ -14,7 +14,7 @@ export const ALL_PERMISSIONS = [
     'billing:read', 'billing:manage',
     'quotas:read',
     'registry:read', 'registry:write',
-    'org:settings', 'org:idp', 'org:kms',
+    'org:settings', 'org:idp', 'org:kms', 'org:impersonation',
 ];
 /** Check whether a string is a valid Permission. */
 export function isValidPermission(value) {
@@ -128,4 +128,4 @@ export function hasPermission(granted, permission, isSuperAdmin) {
         return true;
     return !!granted && granted.includes(permission);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/types/permissions.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA2EtC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAA0B;IACpD,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB;IACxD,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB;IACxD,cAAc,EAAE,eAAe,EAAE,iBAAiB;IAClD,iBAAiB,EAAE,kBAAkB;IACrC,gBAAgB,EAAE,cAAc,EAAE,oBAAoB;IACtD,iBAAiB,EAAE,kBAAkB;IACrC,oBAAoB,EAAE,qBAAqB;IAC3C,cAAc,EAAE,gBAAgB;IAChC,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,gBAAgB;IAChC,aAAa;IACb,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,SAAS,EAAE,SAAS;CACrC,CAAC;AAEF,oDAAoD;AACpD,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,OAAQ,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAA0B;IAChE,eAAe;IACf,gBAAgB;CACjB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GACrC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1E,+EAA+E;AAC/E,MAAM,UAAU,yBAAyB,CAAC,UAAsB;IAC9D,OAAO,CAAC,2BAA2B,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC3D,CAAC;AAED,gFAAgF;AAChF,6BAA6B;AAC7B,gFAAgF;AAEhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,kBAAkB,GAA0B;IAChD,gBAAgB,EAAE,iBAAiB;IACnC,gBAAgB,EAAE,iBAAiB;IACnC,cAAc,EAAE,eAAe;IAC/B,iBAAiB;IACjB,iBAAiB;IACjB,oBAAoB;IACpB,cAAc;IACd,eAAe,EAAE,gBAAgB;IACjC,cAAc;IACd,aAAa;CACd,CAAC;AAEF,MAAM,iBAAiB,GAA0B,CAAC,GAAG,0BAA0B,CAAC,CAAC;AAEjF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA2C;IACtE,MAAM,EAAE,kBAAkB;IAC1B,KAAK,EAAE,iBAAiB;IACxB,KAAK,EAAE,iBAAiB;CACzB,CAAC;AAEF,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,sBAAsB,CACpC,mBAA8C,EAC9C,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC;IAE9C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAc,CAAC;IACpC,IAAI,mBAAmB,EAAE,CAAC;QACxB,KAAK,MAAM,CAAC,IAAI,mBAAmB,EAAE,CAAC;YACpC,IAAI,iBAAiB,CAAC,CAAC,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,aAAa,CAC3B,OAA6C,EAC7C,UAAsB,EACtB,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { OrgRole } from './common.js';\n\n// =============================================================================\n// Permission identifiers\n// =============================================================================\n\n/**\n * Canonical fine-grained permission identifiers, in `resource:action` form.\n *\n * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by\n * design — `:write` covers create/update/delete for a resource — so the catalog\n * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`\n * later if a resource needs it.\n *\n * NOT modeled here (intentionally): platform-operator actions (org delete, tier/\n * quota override, user admin, impersonation, platform settings) stay behind the\n * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`\n * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.\n */\nexport type Permission =\n  // Pipelines\n  | 'pipelines:read'\n  | 'pipelines:write'\n  | 'pipelines:publish'\n  // Golden-path pipeline templates. Split out of `pipelines:*` so a platform\n  // team can curate the starter catalog WITHOUT write access to every pipeline\n  // (and vice versa) — the two used to share one gate. `:publish` maps to the\n  // template ladder's `public` rung; `org` and `private` need only `:write`.\n  | 'templates:read'\n  | 'templates:write'\n  | 'templates:publish'\n  // Plugins\n  | 'plugins:read'\n  | 'plugins:write'\n  | 'plugins:publish'\n  // Compliance\n  | 'compliance:read'\n  | 'compliance:write'\n  // Members & access\n  | 'members:manage'\n  | 'roles:manage'\n  | 'invitations:manage'\n  // Observability\n  | 'dashboards:read'\n  | 'dashboards:write'\n  | 'observability:read'\n  | 'observability:write'\n  // Insights\n  | 'reports:read'\n  | 'reports:rollup'\n  // Messaging\n  | 'messages:read'\n  | 'messages:write'\n  // Billing & quotas\n  | 'billing:read'\n  | 'billing:manage'\n  | 'quotas:read'\n  // Registry\n  | 'registry:read'\n  | 'registry:write'\n  // Organization settings.\n  //  - `org:settings` — general org settings + AI config.\n  //  - `org:idp`      — SSO / IdP configuration (sensitive: controls login).\n  //  - `org:kms`      — customer-managed KMS key configuration (sensitive:\n  //                     controls encryption of org data).\n  // `org:idp`/`org:kms` were split OUT of `org:settings` so a custom role can\n  // grant general settings WITHOUT the two sensitive surfaces. Both remain\n  // org-assignable and are seeded into the admin/owner bundles (via\n  // ORG_ASSIGNABLE_PERMISSIONS) so existing admins keep full access.\n  | 'org:settings'\n  | 'org:idp'\n  | 'org:kms';\n\n/** All valid permissions (order determines display order in the picker). */\nexport const ALL_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write', 'pipelines:publish',\n  'templates:read', 'templates:write', 'templates:publish',\n  'plugins:read', 'plugins:write', 'plugins:publish',\n  'compliance:read', 'compliance:write',\n  'members:manage', 'roles:manage', 'invitations:manage',\n  'dashboards:read', 'dashboards:write',\n  'observability:read', 'observability:write',\n  'reports:read', 'reports:rollup',\n  'messages:read', 'messages:write',\n  'billing:read', 'billing:manage',\n  'quotas:read',\n  'registry:read', 'registry:write',\n  'org:settings', 'org:idp', 'org:kms',\n];\n\n/** Check whether a string is a valid Permission. */\nexport function isValidPermission(value: string): value is Permission {\n  return (ALL_PERMISSIONS as readonly string[]).includes(value);\n}\n\n/**\n * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —\n * they gate platform-operator surfaces (the shared image registry), so allowing\n * an org admin to mint a Role carrying them would be a latent privilege\n * escalation. They are NOT seeded into ANY built-in Role bundle (neither\n * `member` nor `admin`), so the only holder is a superadmin (implicit-all) —\n * which is what makes the image-registry gates that require them effectively\n * superadmin-only. This list ALSO blocks custom-Role authoring from requesting\n * them (see platform `sanitizePermissions`).\n */\nexport const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[] = [\n  'registry:read',\n  'registry:write',\n];\n\n/**\n * Permissions an org may assign via a CUSTOM Role — every permission except the\n * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the\n * requested permission set against this (see platform roles-service).\n */\nexport const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => !SUPERADMIN_ONLY_PERMISSIONS.includes(p));\n\n/** Whether `permission` may be granted through a user-authored custom Role. */\nexport function isOrgAssignablePermission(permission: Permission): boolean {\n  return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission);\n}\n\n// =============================================================================\n// Built-in Role seed bundles\n// =============================================================================\n\n/**\n * Permission bundles used to SEED the built-in Roles (\"Admin\", \"Member\").\n *\n * This is the single definition of what those built-in Roles grant — it is used\n * when a Role record is created (and by the startup backfill) to populate that\n * Role's own `permissions[]`. It is NOT a runtime permission source: a user's\n * effective permissions come ONLY from the Roles assigned to them (see\n * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)\n * survives only for `isAdmin`/ownership/display, never to grant permissions.\n *\n * - `member`  — day-to-day builder: read + write on pipelines/templates/plugins,\n *   read elsewhere. No member/role/billing management, no compliance/alert\n *   authoring, and no `:publish` on any catalog.\n * - `admin`   — full org administration: every ORG-ASSIGNABLE permission (i.e.\n *   ALL_PERMISSIONS minus the {@link SUPERADMIN_ONLY_PERMISSIONS}, so `registry:*`\n *   stay superadmin-implicit-only and are NOT granted to org admins).\n * - `owner`   — same as admin (ownership itself — transfer/delete — is gated\n *   separately, not via a permission).\n */\nconst MEMBER_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'templates:read', 'templates:write',\n  'plugins:read', 'plugins:write',\n  'compliance:read',\n  'dashboards:read',\n  'observability:read',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read',\n  'quotas:read',\n];\n\nconst ADMIN_PERMISSIONS: readonly Permission[] = [...ORG_ASSIGNABLE_PERMISSIONS];\n\n/**\n * Seed bundle for each built-in Role, keyed by the coarse role it grants.\n * Consumed by the Role seeder + the startup backfill to populate a built-in\n * Role's `permissions[]`. NOT consulted at request time — see\n * {@link resolveUserPermissions}.\n */\nexport const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]> = {\n  member: MEMBER_PERMISSIONS,\n  admin: ADMIN_PERMISSIONS,\n  owner: ADMIN_PERMISSIONS,\n};\n\n// =============================================================================\n// Resolution\n// =============================================================================\n\n/**\n * Resolve a user's effective org permissions from the Roles assigned to them.\n *\n * Single-source model: a user's abilities are EXACTLY the union of the\n * permissions carried by the Roles they hold (a Role = a named permission set;\n * built-in Roles carry their bundle explicitly, seeded from\n * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the\n * coarse `role` label no longer grants anything on its own.\n *\n * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.\n * 2. Otherwise, union every permission granted by the user's assigned Roles.\n * 3. Invalid/unknown permission strings are silently ignored.\n *\n * @param assignedPermissions - Flattened permissions from every Role the user holds\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Effective permissions in canonical order\n */\nexport function resolveUserPermissions(\n  assignedPermissions?: readonly string[] | null,\n  isSuperAdmin?: boolean,\n): Permission[] {\n  if (isSuperAdmin) return [...ALL_PERMISSIONS];\n\n  const perms = new Set<Permission>();\n  if (assignedPermissions) {\n    for (const p of assignedPermissions) {\n      if (isValidPermission(p)) perms.add(p);\n    }\n  }\n  return ALL_PERMISSIONS.filter(p => perms.has(p));\n}\n\n/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */\nexport function hasPermission(\n  granted: readonly string[] | null | undefined,\n  permission: Permission,\n  isSuperAdmin?: boolean,\n): boolean {\n  if (isSuperAdmin) return true;\n  return !!granted && granted.includes(permission);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/types/permissions.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAgFtC,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAA0B;IACpD,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB;IACxD,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB;IACxD,cAAc,EAAE,eAAe,EAAE,iBAAiB;IAClD,iBAAiB,EAAE,kBAAkB;IACrC,gBAAgB,EAAE,cAAc,EAAE,oBAAoB;IACtD,iBAAiB,EAAE,kBAAkB;IACrC,oBAAoB,EAAE,qBAAqB;IAC3C,cAAc,EAAE,gBAAgB;IAChC,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,gBAAgB;IAChC,aAAa;IACb,eAAe,EAAE,gBAAgB;IACjC,cAAc,EAAE,SAAS,EAAE,SAAS,EAAE,mBAAmB;CAC1D,CAAC;AAEF,oDAAoD;AACpD,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC7C,OAAQ,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAA0B;IAChE,eAAe;IACf,gBAAgB;CACjB,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GACrC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1E,+EAA+E;AAC/E,MAAM,UAAU,yBAAyB,CAAC,UAAsB;IAC9D,OAAO,CAAC,2BAA2B,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AAC3D,CAAC;AAED,gFAAgF;AAChF,6BAA6B;AAC7B,gFAAgF;AAEhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,kBAAkB,GAA0B;IAChD,gBAAgB,EAAE,iBAAiB;IACnC,gBAAgB,EAAE,iBAAiB;IACnC,cAAc,EAAE,eAAe;IAC/B,iBAAiB;IACjB,iBAAiB;IACjB,oBAAoB;IACpB,cAAc;IACd,eAAe,EAAE,gBAAgB;IACjC,cAAc;IACd,aAAa;CACd,CAAC;AAEF,MAAM,iBAAiB,GAA0B,CAAC,GAAG,0BAA0B,CAAC,CAAC;AAEjF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAA2C;IACtE,MAAM,EAAE,kBAAkB;IAC1B,KAAK,EAAE,iBAAiB;IACxB,KAAK,EAAE,iBAAiB;CACzB,CAAC;AAEF,gFAAgF;AAChF,aAAa;AACb,gFAAgF;AAEhF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,sBAAsB,CACpC,mBAA8C,EAC9C,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,CAAC,GAAG,eAAe,CAAC,CAAC;IAE9C,MAAM,KAAK,GAAG,IAAI,GAAG,EAAc,CAAC;IACpC,IAAI,mBAAmB,EAAE,CAAC;QACxB,KAAK,MAAM,CAAC,IAAI,mBAAmB,EAAE,CAAC;YACpC,IAAI,iBAAiB,CAAC,CAAC,CAAC;gBAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,aAAa,CAC3B,OAA6C,EAC7C,UAAsB,EACtB,YAAsB;IAEtB,IAAI,YAAY;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,CAAC,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;AACnD,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { OrgRole } from './common.js';\n\n// =============================================================================\n// Permission identifiers\n// =============================================================================\n\n/**\n * Canonical fine-grained permission identifiers, in `resource:action` form.\n *\n * These are the ORG-SCOPED capabilities a Role can grant (RBAC). Coarse by\n * design — `:write` covers create/update/delete for a resource — so the catalog\n * and permission-picker UI stay small; split a `:write` into `:create`/`:delete`\n * later if a resource needs it.\n *\n * NOT modeled here (intentionally): platform-operator actions (org delete, tier/\n * quota override, user admin, impersonation, platform settings) stay behind the\n * global `isSuperAdmin` flag, not a per-org permission; and `requireStepUp`\n * (MFA) / `requireFeature` (plan entitlements) remain orthogonal gates.\n */\nexport type Permission =\n  // Pipelines\n  | 'pipelines:read'\n  | 'pipelines:write'\n  | 'pipelines:publish'\n  // Golden-path pipeline templates. Split out of `pipelines:*` so a platform\n  // team can curate the starter catalog WITHOUT write access to every pipeline\n  // (and vice versa) — the two used to share one gate. `:publish` maps to the\n  // template ladder's `public` rung; `org` and `private` need only `:write`.\n  | 'templates:read'\n  | 'templates:write'\n  | 'templates:publish'\n  // Plugins\n  | 'plugins:read'\n  | 'plugins:write'\n  | 'plugins:publish'\n  // Compliance\n  | 'compliance:read'\n  | 'compliance:write'\n  // Members & access\n  | 'members:manage'\n  | 'roles:manage'\n  | 'invitations:manage'\n  // Observability\n  | 'dashboards:read'\n  | 'dashboards:write'\n  | 'observability:read'\n  | 'observability:write'\n  // Insights\n  | 'reports:read'\n  | 'reports:rollup'\n  // Messaging\n  | 'messages:read'\n  | 'messages:write'\n  // Billing & quotas\n  | 'billing:read'\n  | 'billing:manage'\n  | 'quotas:read'\n  // Registry\n  | 'registry:read'\n  | 'registry:write'\n  // Organization settings.\n  //  - `org:settings` — general org settings + AI config.\n  //  - `org:idp`      — SSO / IdP configuration (sensitive: controls login).\n  //  - `org:kms`      — customer-managed KMS key configuration (sensitive:\n  //                     controls encryption of org data).\n  //  - `org:impersonation` — the impersonation policy (sensitive: controls who\n  //                     may VIEW the org's data as one of its members).\n  // `org:idp`/`org:kms`/`org:impersonation` were split OUT of `org:settings` so a\n  // custom role can grant general settings WITHOUT the sensitive surfaces — a\n  // \"settings manager\" role for org name or AI provider must not also be able to\n  // switch the org to `open`. All remain org-assignable and are seeded into the\n  // admin/owner bundles (via ORG_ASSIGNABLE_PERMISSIONS) so existing admins keep\n  // full access.\n  | 'org:settings'\n  | 'org:idp'\n  | 'org:kms'\n  | 'org:impersonation';\n\n/** All valid permissions (order determines display order in the picker). */\nexport const ALL_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write', 'pipelines:publish',\n  'templates:read', 'templates:write', 'templates:publish',\n  'plugins:read', 'plugins:write', 'plugins:publish',\n  'compliance:read', 'compliance:write',\n  'members:manage', 'roles:manage', 'invitations:manage',\n  'dashboards:read', 'dashboards:write',\n  'observability:read', 'observability:write',\n  'reports:read', 'reports:rollup',\n  'messages:read', 'messages:write',\n  'billing:read', 'billing:manage',\n  'quotas:read',\n  'registry:read', 'registry:write',\n  'org:settings', 'org:idp', 'org:kms', 'org:impersonation',\n];\n\n/** Check whether a string is a valid Permission. */\nexport function isValidPermission(value: string): value is Permission {\n  return (ALL_PERMISSIONS as readonly string[]).includes(value);\n}\n\n/**\n * Permissions that must NEVER be grantable through a user-authored CUSTOM Role —\n * they gate platform-operator surfaces (the shared image registry), so allowing\n * an org admin to mint a Role carrying them would be a latent privilege\n * escalation. They are NOT seeded into ANY built-in Role bundle (neither\n * `member` nor `admin`), so the only holder is a superadmin (implicit-all) —\n * which is what makes the image-registry gates that require them effectively\n * superadmin-only. This list ALSO blocks custom-Role authoring from requesting\n * them (see platform `sanitizePermissions`).\n */\nexport const SUPERADMIN_ONLY_PERMISSIONS: readonly Permission[] = [\n  'registry:read',\n  'registry:write',\n];\n\n/**\n * Permissions an org may assign via a CUSTOM Role — every permission except the\n * {@link SUPERADMIN_ONLY_PERMISSIONS}. Custom-Role create/update validates the\n * requested permission set against this (see platform roles-service).\n */\nexport const ORG_ASSIGNABLE_PERMISSIONS: readonly Permission[] =\n  ALL_PERMISSIONS.filter((p) => !SUPERADMIN_ONLY_PERMISSIONS.includes(p));\n\n/** Whether `permission` may be granted through a user-authored custom Role. */\nexport function isOrgAssignablePermission(permission: Permission): boolean {\n  return !SUPERADMIN_ONLY_PERMISSIONS.includes(permission);\n}\n\n// =============================================================================\n// Built-in Role seed bundles\n// =============================================================================\n\n/**\n * Permission bundles used to SEED the built-in Roles (\"Admin\", \"Member\").\n *\n * This is the single definition of what those built-in Roles grant — it is used\n * when a Role record is created (and by the startup backfill) to populate that\n * Role's own `permissions[]`. It is NOT a runtime permission source: a user's\n * effective permissions come ONLY from the Roles assigned to them (see\n * {@link resolveUserPermissions}). The coarse `role` label (owner/admin/member)\n * survives only for `isAdmin`/ownership/display, never to grant permissions.\n *\n * - `member`  — day-to-day builder: read + write on pipelines/templates/plugins,\n *   read elsewhere. No member/role/billing management, no compliance/alert\n *   authoring, and no `:publish` on any catalog.\n * - `admin`   — full org administration: every ORG-ASSIGNABLE permission (i.e.\n *   ALL_PERMISSIONS minus the {@link SUPERADMIN_ONLY_PERMISSIONS}, so `registry:*`\n *   stay superadmin-implicit-only and are NOT granted to org admins).\n * - `owner`   — same as admin (ownership itself — transfer/delete — is gated\n *   separately, not via a permission).\n */\nconst MEMBER_PERMISSIONS: readonly Permission[] = [\n  'pipelines:read', 'pipelines:write',\n  'templates:read', 'templates:write',\n  'plugins:read', 'plugins:write',\n  'compliance:read',\n  'dashboards:read',\n  'observability:read',\n  'reports:read',\n  'messages:read', 'messages:write',\n  'billing:read',\n  'quotas:read',\n];\n\nconst ADMIN_PERMISSIONS: readonly Permission[] = [...ORG_ASSIGNABLE_PERMISSIONS];\n\n/**\n * Seed bundle for each built-in Role, keyed by the coarse role it grants.\n * Consumed by the Role seeder + the startup backfill to populate a built-in\n * Role's `permissions[]`. NOT consulted at request time — see\n * {@link resolveUserPermissions}.\n */\nexport const ROLE_PERMISSIONS: Record<OrgRole, readonly Permission[]> = {\n  member: MEMBER_PERMISSIONS,\n  admin: ADMIN_PERMISSIONS,\n  owner: ADMIN_PERMISSIONS,\n};\n\n// =============================================================================\n// Resolution\n// =============================================================================\n\n/**\n * Resolve a user's effective org permissions from the Roles assigned to them.\n *\n * Single-source model: a user's abilities are EXACTLY the union of the\n * permissions carried by the Roles they hold (a Role = a named permission set;\n * built-in Roles carry their bundle explicitly, seeded from\n * {@link ROLE_PERMISSIONS}). There is no separate role-derived baseline — the\n * coarse `role` label no longer grants anything on its own.\n *\n * 1. Platform superadmins (`isSuperAdmin`) always get ALL permissions.\n * 2. Otherwise, union every permission granted by the user's assigned Roles.\n * 3. Invalid/unknown permission strings are silently ignored.\n *\n * @param assignedPermissions - Flattened permissions from every Role the user holds\n * @param isSuperAdmin - Whether the user has the global super-admin flag\n * @returns Effective permissions in canonical order\n */\nexport function resolveUserPermissions(\n  assignedPermissions?: readonly string[] | null,\n  isSuperAdmin?: boolean,\n): Permission[] {\n  if (isSuperAdmin) return [...ALL_PERMISSIONS];\n\n  const perms = new Set<Permission>();\n  if (assignedPermissions) {\n    for (const p of assignedPermissions) {\n      if (isValidPermission(p)) perms.add(p);\n    }\n  }\n  return ALL_PERMISSIONS.filter(p => perms.has(p));\n}\n\n/** Whether a resolved permission list grants `permission` (superadmin ⇒ always). */\nexport function hasPermission(\n  granted: readonly string[] | null | undefined,\n  permission: Permission,\n  isSuperAdmin?: boolean,\n): boolean {\n  if (isSuperAdmin) return true;\n  return !!granted && granted.includes(permission);\n}\n"]}

package/lib/utils/response.d.ts

@@ -73,8 +73,16 @@ export declare function sendPaginatedNested<T>(res: Response, dataKey: string, d
  * Extracts PostgreSQL error codes, details, hints, and constraint names
  * from database errors for better error messages.
  *
+ * Only a genuine Postgres error yields a `dbCode`. Any error object carrying a
+ * `.code` used to be reported as one, so a transport failure (`ECONNRESET` when
+ * the pooler drops out of the Service endpoints, say) logged as
+ * `{"db":{"dbCode":"ECONNRESET"}}` and sent every reader hunting through clean
+ * Postgres logs. The transport code is not lost — callers log the error message
+ * itself alongside these details — it just stops claiming to be a DB fault.
+ *
  * @param error - Error object from database operation
- * @returns Object with extracted error details
+ * @returns Object with extracted error details; `{}` when `error` is not a
+ *   Postgres error (no SQLSTATE and none of the pg-specific fields)
  *
  * @example
  * ```typescript

package/lib/utils/response.js

@@ -128,14 +128,37 @@ export function sendPaginatedNested(res, dataKey, data, options) {
         data: { [dataKey]: data, pagination },
     });
 }
+/**
+ * SQLSTATE: exactly five characters, digits and uppercase Latin letters
+ * (e.g. `23505` unique_violation, `42601` syntax_error). Node's own socket and
+ * DNS errors use the same `.code` property but spell it differently
+ * (`ECONNRESET`, `ETIMEDOUT`, `ENOTFOUND`), which is what this tells apart.
+ */
+const SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+/**
+ * Length alone is not enough: `EPIPE` and `E2BIG` are five uppercase characters
+ * and would pass as SQLSTATEs. Every libuv/Node errno starts with `E`, and
+ * Postgres defines no error class that does — its classes are 00-0Z, 20-2F,
+ * 34-3F, 40-44, 53-58, 72, F0, HV, P0 and XX (see the server's errcodes.txt).
+ * So a leading `E` settles it.
+ */
+const NODE_ERRNO_PATTERN = /^E/;
 /**
  * Extract database error details for logging/response.
  *
  * Extracts PostgreSQL error codes, details, hints, and constraint names
  * from database errors for better error messages.
  *
+ * Only a genuine Postgres error yields a `dbCode`. Any error object carrying a
+ * `.code` used to be reported as one, so a transport failure (`ECONNRESET` when
+ * the pooler drops out of the Service endpoints, say) logged as
+ * `{"db":{"dbCode":"ECONNRESET"}}` and sent every reader hunting through clean
+ * Postgres logs. The transport code is not lost — callers log the error message
+ * itself alongside these details — it just stops claiming to be a DB fault.
+ *
  * @param error - Error object from database operation
- * @returns Object with extracted error details
+ * @returns Object with extracted error details; `{}` when `error` is not a
+ *   Postgres error (no SQLSTATE and none of the pg-specific fields)
  *
  * @example
  * ```typescript
@@ -156,8 +179,11 @@ export function extractDbError(error) {
     const err = error;
     const source = (err.cause && typeof err.cause === 'object' ? err.cause : err);
     const details = {};
-    if (source.code)
+    if (typeof source.code === 'string'
+        && SQLSTATE_PATTERN.test(source.code)
+        && !NODE_ERRNO_PATTERN.test(source.code)) {
         details.dbCode = source.code;
+    }
     if (source.detail)
         details.dbDetail = source.detail;
     if (source.hint)
@@ -220,4 +246,4 @@ export function parsePaginationParams(query) {
     const sortOrder = String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';
     return { limit, offset, sortBy, sortOrder };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/utils/response.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\nimport { createLogger } from './logger.js';\nimport type { QuotaInfo } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { MAX_PAGE_LIMIT, MAX_PAGE_OFFSET } from '../validation/common-schemas.js';\n\nconst logger = createLogger('response');\n\n/**\n * Send a standardized success response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code (default: 200)\n * @param data - Response data\n * @param message - Optional success message\n *\n * @example\n * ```typescript\n * sendSuccess(res, 200, { plugin: pluginData });\n * sendSuccess(res, 201, { id: newId }, 'Resource created');\n * ```\n */\nexport function sendSuccess<T>(\n  res: Response,\n  statusCode: number = 200,\n  data?: T,\n  message?: string,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send success after headers already sent', { statusCode });\n    return;\n  }\n\n  const response: {\n    success: true;\n    statusCode: number;\n    data?: T;\n    message?: string;\n  } = {\n    success: true,\n    statusCode,\n  };\n\n  if (data !== undefined) {\n    response.data = data;\n  }\n\n  if (message) {\n    response.message = message;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a standardized error response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code\n * @param message - Error message\n * @param code - Error code from ErrorCode enum\n * @param details - Optional additional details\n *\n * @example\n * ```typescript\n * sendError(res, 404, 'Plugin not found', ErrorCode.NOT_FOUND);\n * sendError(res, 400, 'Invalid input', ErrorCode.VALIDATION_ERROR, { field: 'name' });\n * ```\n */\nexport function sendError(\n  res: Response,\n  statusCode: number,\n  message: string,\n  code?: ErrorCode | string,\n  details?: unknown,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send error after headers already sent', { statusCode, message });\n    return;\n  }\n\n  const response: {\n    success: false;\n    statusCode: number;\n    message: string;\n    code?: string;\n    details?: unknown;\n  } = {\n    success: false,\n    statusCode,\n    message,\n  };\n\n  if (code) {\n    response.code = code;\n  }\n\n  if (details !== undefined) {\n    response.details = details;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a quota exceeded error response.\n *\n * @param res - Express response object\n * @param quotaType - Type of quota exceeded\n * @param quota - Current quota information\n * @param resetAt - ISO timestamp when quota resets\n *\n * @example\n * ```typescript\n * sendQuotaExceeded(res, 'apiCalls', { type: 'apiCalls', limit: 10000, used: 10000, remaining: 0 }, resetAt);\n * ```\n */\nexport function sendQuotaExceeded(\n  res: Response,\n  quotaType: string,\n  quota: QuotaInfo,\n  resetAt?: string,\n  message?: string,\n): void {\n  const resetDate = resetAt ? new Date(resetAt) : new Date();\n  const resetIn = Math.max(0, Math.ceil((resetDate.getTime() - Date.now()) / 1000));\n\n  // Guard like the sibling helpers: `setHeader` throws synchronously once the\n  // response has been sent, so skip the quota headers (and let `sendError` no-op)\n  // instead of crashing the handler on an already-committed response.\n  if (!res.headersSent) {\n    res.setHeader('Retry-After', resetIn);\n    res.setHeader('X-Quota-Limit', quota.limit);\n    res.setHeader('X-Quota-Used', quota.used);\n    res.setHeader('X-Quota-Remaining', Math.max(0, quota.remaining));\n\n    if (resetAt) {\n      res.setHeader('X-Quota-Reset', resetAt);\n    }\n  }\n\n  sendError(\n    res,\n    429,\n    message ?? `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`,\n    ErrorCode.QUOTA_EXCEEDED,\n    { quota },\n  );\n}\n\n/**\n * Send a paginated list response with the items nested under a named key.\n * Use when the API contract is `{ <key>: [...], pagination: {...} }`\n * (the dominant shape across api/* services).\n *\n * @example\n * ```typescript\n * sendPaginatedNested(res, 'pipelines', items, {\n *   total: 50, limit: 25, offset: 0, hasMore: true,\n * });\n * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }\n * ```\n */\nexport function sendPaginatedNested<T>(\n  res: Response,\n  dataKey: string,\n  data: T[],\n  options: {\n    total?: number;\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n    nextCursor?: string;\n    statusCode?: number;\n  },\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send paginated response after headers already sent');\n    return;\n  }\n  const { statusCode = 200, total, limit, offset, hasMore, nextCursor } = options;\n  const pagination: Record<string, unknown> = { limit, offset, hasMore };\n  if (total !== undefined) pagination.total = total;\n  if (nextCursor) pagination.nextCursor = nextCursor;\n  res.status(statusCode).json({\n    success: true,\n    statusCode,\n    data: { [dataKey]: data, pagination },\n  });\n}\n\n/**\n * Extract database error details for logging/response.\n *\n * Extracts PostgreSQL error codes, details, hints, and constraint names\n * from database errors for better error messages.\n *\n * @param error - Error object from database operation\n * @returns Object with extracted error details\n *\n * @example\n * ```typescript\n * try {\n *   await db.insert(plugins).values(newPlugin);\n * } catch (error) {\n *   const dbDetails = extractDbError(error);\n *   return sendError(res, 500, 'Database error', ErrorCode.DATABASE_ERROR, dbDetails);\n * }\n * ```\n */\nexport function extractDbError(error: unknown): Record<string, unknown> {\n  if (!error || typeof error !== 'object') {\n    return {};\n  }\n\n  // Drizzle ORM wraps the original pg error in error.cause —\n  // check the cause first, then fall back to the error itself.\n  const err = error as Record<string, unknown>;\n  const source = (err.cause && typeof err.cause === 'object' ? err.cause : err) as Record<string, unknown>;\n  const details: Record<string, unknown> = {};\n\n  if (source.code) details.dbCode = source.code;\n  if (source.detail) details.dbDetail = source.detail;\n  if (source.hint) details.dbHint = source.hint;\n  if (source.constraint) details.constraint = source.constraint;\n  if (source.table) details.table = source.table;\n  if (source.column) details.column = source.column;\n\n  return details;\n}\n\n// Convenience helpers (shared across plugin, pipeline, quota services)\n\n/**\n * Extract a human-readable message from an unknown catch value.\n *\n * Falls back beyond `.message` because several common Node errors carry an\n * EMPTY `.message`:\n *  - dual-stack (IPv4+IPv6) connect failures surface as an `AggregateError`\n *    whose own message is blank — the cause lives in `.code` (e.g.\n *    `ECONNREFUSED`/`ETIMEDOUT`) and/or the `.errors[]` sub-errors;\n *  - raw socket `ErrnoException`s can likewise carry only a `.code`.\n * Without this, an unreachable internal service (e.g. compliance still\n * starting) produced blank per-item errors in bulk responses and `error:\"\"`\n * in logs — a silent black box. Order: message → code → joined sub-errors →\n * error name.\n */\nexport function errorMessage(error: unknown): string {\n  if (!(error instanceof Error)) return String(error);\n  if (error.message) return error.message;\n\n  const code = (error as { code?: string }).code;\n  if (code) return code;\n\n  const inner = (error as { errors?: unknown[] }).errors;\n  if (Array.isArray(inner) && inner.length > 0) {\n    const joined = inner.map(errorMessage).filter(Boolean).join('; ');\n    if (joined) return joined;\n  }\n\n  return error.name || 'Unknown error';\n}\n\n/** Send a 400 bad-request response. */\nexport function sendBadRequest(\n  res: Response,\n  message: string,\n  code: ErrorCode | string = ErrorCode.VALIDATION_ERROR,\n): void {\n  sendError(res, 400, message, code);\n}\n\n/** Send a 500 internal error response. */\nexport function sendInternalError(\n  res: Response,\n  message: string,\n  details?: Record<string, unknown>,\n): void {\n  sendError(res, 500, message, ErrorCode.INTERNAL_ERROR, details);\n}\n\n// Pagination\n\n/** Common pagination + sorting parameters. */\nexport interface PaginationParams {\n  limit: number;\n  offset: number;\n  sortBy: string;\n  sortOrder: 'asc' | 'desc';\n}\n\n/** Parse pagination/sort params from query string, clamping to safe defaults. */\nexport function parsePaginationParams(query: Record<string, unknown>): PaginationParams {\n  const limit = Math.min(Math.max(parseInt(String(query.limit), 10) || 10, 1), MAX_PAGE_LIMIT);\n  // Clamp offset too — an unbounded offset forces Postgres to scan+discard huge row\n  // counts on hot list endpoints (a cheap DoS amplifier). Deep paging should use the\n  // cursor API. Ceiling = MAX_PAGE_OFFSET.\n  const offset = Math.min(Math.max(parseInt(String(query.offset), 10) || 0, 0), MAX_PAGE_OFFSET);\n  const sortBy = String(query.sortBy || 'createdAt');\n  const sortOrder: 'asc' | 'desc' =\n    String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';\n\n  return { limit, offset, sortBy, sortOrder };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/utils/response.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Response } from 'express';\nimport { createLogger } from './logger.js';\nimport type { QuotaInfo } from '../types/common.js';\nimport { ErrorCode } from '../types/error-codes.js';\nimport { MAX_PAGE_LIMIT, MAX_PAGE_OFFSET } from '../validation/common-schemas.js';\n\nconst logger = createLogger('response');\n\n/**\n * Send a standardized success response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code (default: 200)\n * @param data - Response data\n * @param message - Optional success message\n *\n * @example\n * ```typescript\n * sendSuccess(res, 200, { plugin: pluginData });\n * sendSuccess(res, 201, { id: newId }, 'Resource created');\n * ```\n */\nexport function sendSuccess<T>(\n  res: Response,\n  statusCode: number = 200,\n  data?: T,\n  message?: string,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send success after headers already sent', { statusCode });\n    return;\n  }\n\n  const response: {\n    success: true;\n    statusCode: number;\n    data?: T;\n    message?: string;\n  } = {\n    success: true,\n    statusCode,\n  };\n\n  if (data !== undefined) {\n    response.data = data;\n  }\n\n  if (message) {\n    response.message = message;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a standardized error response.\n *\n * @param res - Express response object\n * @param statusCode - HTTP status code\n * @param message - Error message\n * @param code - Error code from ErrorCode enum\n * @param details - Optional additional details\n *\n * @example\n * ```typescript\n * sendError(res, 404, 'Plugin not found', ErrorCode.NOT_FOUND);\n * sendError(res, 400, 'Invalid input', ErrorCode.VALIDATION_ERROR, { field: 'name' });\n * ```\n */\nexport function sendError(\n  res: Response,\n  statusCode: number,\n  message: string,\n  code?: ErrorCode | string,\n  details?: unknown,\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send error after headers already sent', { statusCode, message });\n    return;\n  }\n\n  const response: {\n    success: false;\n    statusCode: number;\n    message: string;\n    code?: string;\n    details?: unknown;\n  } = {\n    success: false,\n    statusCode,\n    message,\n  };\n\n  if (code) {\n    response.code = code;\n  }\n\n  if (details !== undefined) {\n    response.details = details;\n  }\n\n  res.status(statusCode).json(response);\n}\n\n/**\n * Send a quota exceeded error response.\n *\n * @param res - Express response object\n * @param quotaType - Type of quota exceeded\n * @param quota - Current quota information\n * @param resetAt - ISO timestamp when quota resets\n *\n * @example\n * ```typescript\n * sendQuotaExceeded(res, 'apiCalls', { type: 'apiCalls', limit: 10000, used: 10000, remaining: 0 }, resetAt);\n * ```\n */\nexport function sendQuotaExceeded(\n  res: Response,\n  quotaType: string,\n  quota: QuotaInfo,\n  resetAt?: string,\n  message?: string,\n): void {\n  const resetDate = resetAt ? new Date(resetAt) : new Date();\n  const resetIn = Math.max(0, Math.ceil((resetDate.getTime() - Date.now()) / 1000));\n\n  // Guard like the sibling helpers: `setHeader` throws synchronously once the\n  // response has been sent, so skip the quota headers (and let `sendError` no-op)\n  // instead of crashing the handler on an already-committed response.\n  if (!res.headersSent) {\n    res.setHeader('Retry-After', resetIn);\n    res.setHeader('X-Quota-Limit', quota.limit);\n    res.setHeader('X-Quota-Used', quota.used);\n    res.setHeader('X-Quota-Remaining', Math.max(0, quota.remaining));\n\n    if (resetAt) {\n      res.setHeader('X-Quota-Reset', resetAt);\n    }\n  }\n\n  sendError(\n    res,\n    429,\n    message ?? `${quotaType} quota exceeded (${quota.used}/${quota.limit}). Please try again later.`,\n    ErrorCode.QUOTA_EXCEEDED,\n    { quota },\n  );\n}\n\n/**\n * Send a paginated list response with the items nested under a named key.\n * Use when the API contract is `{ <key>: [...], pagination: {...} }`\n * (the dominant shape across api/* services).\n *\n * @example\n * ```typescript\n * sendPaginatedNested(res, 'pipelines', items, {\n *   total: 50, limit: 25, offset: 0, hasMore: true,\n * });\n * // → { pipelines: [...], pagination: { total: 50, limit: 25, offset: 0, hasMore: true } }\n * ```\n */\nexport function sendPaginatedNested<T>(\n  res: Response,\n  dataKey: string,\n  data: T[],\n  options: {\n    total?: number;\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n    nextCursor?: string;\n    statusCode?: number;\n  },\n): void {\n  if (res.headersSent) {\n    logger.warn('Attempted to send paginated response after headers already sent');\n    return;\n  }\n  const { statusCode = 200, total, limit, offset, hasMore, nextCursor } = options;\n  const pagination: Record<string, unknown> = { limit, offset, hasMore };\n  if (total !== undefined) pagination.total = total;\n  if (nextCursor) pagination.nextCursor = nextCursor;\n  res.status(statusCode).json({\n    success: true,\n    statusCode,\n    data: { [dataKey]: data, pagination },\n  });\n}\n\n/**\n * SQLSTATE: exactly five characters, digits and uppercase Latin letters\n * (e.g. `23505` unique_violation, `42601` syntax_error). Node's own socket and\n * DNS errors use the same `.code` property but spell it differently\n * (`ECONNRESET`, `ETIMEDOUT`, `ENOTFOUND`), which is what this tells apart.\n */\nconst SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;\n\n/**\n * Length alone is not enough: `EPIPE` and `E2BIG` are five uppercase characters\n * and would pass as SQLSTATEs. Every libuv/Node errno starts with `E`, and\n * Postgres defines no error class that does — its classes are 00-0Z, 20-2F,\n * 34-3F, 40-44, 53-58, 72, F0, HV, P0 and XX (see the server's errcodes.txt).\n * So a leading `E` settles it.\n */\nconst NODE_ERRNO_PATTERN = /^E/;\n\n/**\n * Extract database error details for logging/response.\n *\n * Extracts PostgreSQL error codes, details, hints, and constraint names\n * from database errors for better error messages.\n *\n * Only a genuine Postgres error yields a `dbCode`. Any error object carrying a\n * `.code` used to be reported as one, so a transport failure (`ECONNRESET` when\n * the pooler drops out of the Service endpoints, say) logged as\n * `{\"db\":{\"dbCode\":\"ECONNRESET\"}}` and sent every reader hunting through clean\n * Postgres logs. The transport code is not lost — callers log the error message\n * itself alongside these details — it just stops claiming to be a DB fault.\n *\n * @param error - Error object from database operation\n * @returns Object with extracted error details; `{}` when `error` is not a\n *   Postgres error (no SQLSTATE and none of the pg-specific fields)\n *\n * @example\n * ```typescript\n * try {\n *   await db.insert(plugins).values(newPlugin);\n * } catch (error) {\n *   const dbDetails = extractDbError(error);\n *   return sendError(res, 500, 'Database error', ErrorCode.DATABASE_ERROR, dbDetails);\n * }\n * ```\n */\nexport function extractDbError(error: unknown): Record<string, unknown> {\n  if (!error || typeof error !== 'object') {\n    return {};\n  }\n\n  // Drizzle ORM wraps the original pg error in error.cause —\n  // check the cause first, then fall back to the error itself.\n  const err = error as Record<string, unknown>;\n  const source = (err.cause && typeof err.cause === 'object' ? err.cause : err) as Record<string, unknown>;\n  const details: Record<string, unknown> = {};\n\n  if (typeof source.code === 'string'\n    && SQLSTATE_PATTERN.test(source.code)\n    && !NODE_ERRNO_PATTERN.test(source.code)) {\n    details.dbCode = source.code;\n  }\n  if (source.detail) details.dbDetail = source.detail;\n  if (source.hint) details.dbHint = source.hint;\n  if (source.constraint) details.constraint = source.constraint;\n  if (source.table) details.table = source.table;\n  if (source.column) details.column = source.column;\n\n  return details;\n}\n\n// Convenience helpers (shared across plugin, pipeline, quota services)\n\n/**\n * Extract a human-readable message from an unknown catch value.\n *\n * Falls back beyond `.message` because several common Node errors carry an\n * EMPTY `.message`:\n *  - dual-stack (IPv4+IPv6) connect failures surface as an `AggregateError`\n *    whose own message is blank — the cause lives in `.code` (e.g.\n *    `ECONNREFUSED`/`ETIMEDOUT`) and/or the `.errors[]` sub-errors;\n *  - raw socket `ErrnoException`s can likewise carry only a `.code`.\n * Without this, an unreachable internal service (e.g. compliance still\n * starting) produced blank per-item errors in bulk responses and `error:\"\"`\n * in logs — a silent black box. Order: message → code → joined sub-errors →\n * error name.\n */\nexport function errorMessage(error: unknown): string {\n  if (!(error instanceof Error)) return String(error);\n  if (error.message) return error.message;\n\n  const code = (error as { code?: string }).code;\n  if (code) return code;\n\n  const inner = (error as { errors?: unknown[] }).errors;\n  if (Array.isArray(inner) && inner.length > 0) {\n    const joined = inner.map(errorMessage).filter(Boolean).join('; ');\n    if (joined) return joined;\n  }\n\n  return error.name || 'Unknown error';\n}\n\n/** Send a 400 bad-request response. */\nexport function sendBadRequest(\n  res: Response,\n  message: string,\n  code: ErrorCode | string = ErrorCode.VALIDATION_ERROR,\n): void {\n  sendError(res, 400, message, code);\n}\n\n/** Send a 500 internal error response. */\nexport function sendInternalError(\n  res: Response,\n  message: string,\n  details?: Record<string, unknown>,\n): void {\n  sendError(res, 500, message, ErrorCode.INTERNAL_ERROR, details);\n}\n\n// Pagination\n\n/** Common pagination + sorting parameters. */\nexport interface PaginationParams {\n  limit: number;\n  offset: number;\n  sortBy: string;\n  sortOrder: 'asc' | 'desc';\n}\n\n/** Parse pagination/sort params from query string, clamping to safe defaults. */\nexport function parsePaginationParams(query: Record<string, unknown>): PaginationParams {\n  const limit = Math.min(Math.max(parseInt(String(query.limit), 10) || 10, 1), MAX_PAGE_LIMIT);\n  // Clamp offset too — an unbounded offset forces Postgres to scan+discard huge row\n  // counts on hot list endpoints (a cheap DoS amplifier). Deep paging should use the\n  // cursor API. Ceiling = MAX_PAGE_OFFSET.\n  const offset = Math.min(Math.max(parseInt(String(query.offset), 10) || 0, 0), MAX_PAGE_OFFSET);\n  const sortBy = String(query.sortBy || 'createdAt');\n  const sortOrder: 'asc' | 'desc' =\n    String(query.sortOrder || 'desc').toLowerCase() === 'asc' ? 'asc' : 'desc';\n\n  return { limit, offset, sortBy, sortOrder };\n}\n"]}

package/package.json

@@ -87,7 +87,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.1.1",
+  "version": "4.1.3",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },