@pipeline-builder/api-server 3.4.85 → 3.4.87

package/lib/api/idempotency-middleware.d.ts

@@ -3,6 +3,9 @@ interface CachedEntry {
     statusCode: number;
     body: unknown;
     expiresAt: number;
+    /** Reservation placeholder: the request is in-flight, no real response yet.
+     *  A duplicate that sees a pending entry is rejected with 409, not replayed. */
+    pending?: boolean;
 }
 /**
  * Pluggable backend for idempotency-key replay cache. The default in-memory
@@ -14,6 +17,16 @@ interface CachedEntry {
 export interface IdempotencyStore {
     get(key: string): Promise<CachedEntry | null>;
     set(key: string, entry: CachedEntry, ttlSeconds: number): Promise<void>;
+    /**
+     * Atomically claim `key` IFF it is currently absent. Returns `true` when THIS
+     * caller set the entry (won the race), `false` when an entry already exists.
+     * This is what serializes concurrent first-time requests that share an
+     * Idempotency-Key — a plain get-then-set leaves a window where two requests
+     * both see "not cached" and both execute the mutation.
+     */
+    reserve(key: string, entry: CachedEntry, ttlSeconds: number): Promise<boolean>;
+    /** Remove a key — releases a reservation after a non-cacheable (non-2xx) response. */
+    delete(key: string): Promise<void>;
 }
 /**
  * Minimal interface a Redis client must satisfy. Compatible with
@@ -23,7 +36,8 @@ export interface IdempotencyStore {
  */
 export interface RedisLike {
     get(key: string): Promise<string | null>;
-    set(key: string, value: string, mode?: 'EX', seconds?: number): Promise<unknown>;
+    set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
+    del?(key: string): Promise<unknown>;
 }
 /** Redis-backed idempotency store — share state across replicas. */
 export declare function createRedisIdempotencyStore(client: RedisLike, prefix?: string): IdempotencyStore;

package/lib/api/idempotency-middleware.js

@@ -20,6 +20,16 @@ export function createRedisIdempotencyStore(client, prefix = 'idemp:') {
         async set(key, entry, ttlSeconds) {
             await client.set(prefix + key, JSON.stringify(entry), 'EX', ttlSeconds);
         },
+        async reserve(key, entry, ttlSeconds) {
+            // SET key val EX ttl NX — atomic across replicas. Redis returns 'OK' when
+            // it set the key and null when the key already existed.
+            const res = await client.set(prefix + key, JSON.stringify(entry), 'EX', ttlSeconds, 'NX');
+            return res !== null && res !== undefined;
+        },
+        async delete(key) {
+            if (client.del)
+                await client.del(prefix + key);
+        },
     };
 }
 /** Default in-memory store. Single-replica only. Exported for testing. */
@@ -33,28 +43,49 @@ export function createMemoryStore() {
         }
     }, CoreConstants.IDEMPOTENCY_CLEANUP_INTERVAL_MS);
     cleanupTimer.unref();
+    /** Return the live (non-expired) entry, evicting it lazily if expired. */
+    const live = (key) => {
+        const entry = map.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt) {
+            map.delete(key);
+            return null;
+        }
+        return entry;
+    };
+    /**
+     * At capacity, evict the OLDEST entry (Map preserves insertion order) rather
+     * than silently dropping the NEW key — otherwise, once full, the store stops
+     * deduplicating fresh requests until the TTL sweep runs. Stays bounded; favors
+     * recent keys (most likely to be retried).
+     */
+    const evictIfFull = (key) => {
+        if (!map.has(key) && map.size >= CoreConstants.IDEMPOTENCY_MAX_STORE_SIZE) {
+            const oldest = map.keys().next().value;
+            if (oldest !== undefined)
+                map.delete(oldest);
+        }
+    };
     return {
         async get(key) {
-            const entry = map.get(key);
-            if (!entry)
-                return null;
-            if (Date.now() > entry.expiresAt) {
-                map.delete(key);
-                return null;
-            }
-            return entry;
+            return live(key);
         },
         async set(key, entry) {
-            // At capacity, evict the OLDEST entry (Map preserves insertion order)
-            // rather than silently dropping the NEW key — otherwise, once full, the
-            // store stops deduplicating fresh requests until the TTL sweep runs.
-            // Stays bounded; favors recent keys (most likely to be retried).
-            if (!map.has(key) && map.size >= CoreConstants.IDEMPOTENCY_MAX_STORE_SIZE) {
-                const oldest = map.keys().next().value;
-                if (oldest !== undefined)
-                    map.delete(oldest);
-            }
+            evictIfFull(key);
+            map.set(key, entry);
+        },
+        async reserve(key, entry) {
+            // Atomic in a single-threaded runtime: no await between the liveness check
+            // and the set, so two concurrent callers can't both observe "absent".
+            if (live(key))
+                return false;
+            evictIfFull(key);
             map.set(key, entry);
+            return true;
+        },
+        async delete(key) {
+            map.delete(key);
         },
     };
 }
@@ -71,6 +102,8 @@ const memoryStore = createMemoryStore();
  */
 export function idempotencyMiddleware(options = {}) {
     const store = options.store ?? memoryStore;
+    const ttlMs = CoreConstants.IDEMPOTENCY_TTL_MS;
+    const ttlSec = Math.floor(ttlMs / 1000);
     return (req, res, next) => {
         const key = req.headers['idempotency-key'];
         if (!key)
@@ -78,35 +111,82 @@ export function idempotencyMiddleware(options = {}) {
         // Only apply to mutation methods
         if (!['POST', 'PUT', 'DELETE'].includes(req.method))
             return next();
-        // Namespace by orgId to prevent cross-org cache collisions
-        const orgId = req.context?.identity?.orgId || req.user?.organizationId;
+        // Namespace by orgId to prevent cross-org cache collisions. Prefer the
+        // VERIFIED auth org (`req.user`, populated by requireAuth after signature
+        // verification) over `req.context.identity`, which some services populate
+        // pre-auth from an UNVERIFIED token peek — namespacing a mutation's replay
+        // cache on an unverified, caller-influenced org id would be unsafe.
+        const orgId = req.user?.organizationId || req.context?.identity?.orgId;
         if (!orgId)
             return next(); // skip idempotency for unauthenticated requests
         const fullKey = `${orgId}:${key}`;
-        // Check for cached response
-        store.get(fullKey).then((cached) => {
-            if (cached) {
+        /** Reject a duplicate whose original is still in-flight. */
+        const sendInProgress = () => {
+            res.setHeader('Retry-After', '1');
+            res.status(409).json({
+                success: false,
+                error: 'A request with this Idempotency-Key is already being processed',
+            });
+        };
+        store.get(fullKey).then(async (cached) => {
+            if (cached && !cached.pending) {
+                // Completed response on record → replay it.
                 logger.debug('Idempotent request replayed', { key: fullKey });
                 res.setHeader('X-Idempotent-Replayed', 'true');
                 res.status(cached.statusCode).json(cached.body);
                 return;
             }
-            // Intercept res.json to cache the response
+            if (cached && cached.pending) {
+                // The original is still running — don't run the mutation a second time.
+                logger.debug('Idempotent request rejected (in progress)', { key: fullKey });
+                return sendInProgress();
+            }
+            // Atomically reserve the key. Losing this race means a concurrent request
+            // with the same key got there first and is in-flight → 409.
+            const won = await store.reserve(fullKey, { statusCode: 0, body: null, pending: true, expiresAt: Date.now() + ttlMs }, ttlSec);
+            if (!won) {
+                logger.debug('Idempotent request rejected (lost reserve race)', { key: fullKey });
+                return sendInProgress();
+            }
+            // We own the reservation. Replace it with the real response on completion;
+            // a non-2xx response RELEASES the reservation so a retry can proceed.
+            let settled = false;
+            const release = () => {
+                if (settled)
+                    return;
+                settled = true;
+                store.delete(fullKey).catch((err) => {
+                    logger.warn('Idempotency reservation release failed', { key: fullKey, error: err instanceof Error ? err.message : String(err) });
+                });
+            };
             const originalJson = res.json.bind(res);
             res.json = (body) => {
                 res.setHeader('X-Idempotent-Replayed', 'false');
                 if (res.statusCode >= 200 && res.statusCode < 300) {
-                    // Fire-and-forget — failure to cache is logged but doesn't block the response.
+                    settled = true; // the finish-net must not delete a cached success
                     store.set(fullKey, {
                         statusCode: res.statusCode,
                         body,
-                        expiresAt: Date.now() + CoreConstants.IDEMPOTENCY_TTL_MS,
-                    }, Math.floor(CoreConstants.IDEMPOTENCY_TTL_MS / 1000)).catch((err) => {
+                        expiresAt: Date.now() + ttlMs,
+                    }, ttlSec).catch((err) => {
                         logger.warn('Idempotency store.set failed', { key: fullKey, error: err instanceof Error ? err.message : String(err) });
                     });
                 }
+                else {
+                    release();
+                }
                 return originalJson(body);
             };
+            // Safety net for response paths that bypass res.json (res.send/res.end,
+            // an error handler, a thrown request): if the response finishes non-2xx
+            // with the reservation still held, release it so retries aren't blocked
+            // for the full TTL. Guarded — test doubles may not be EventEmitters.
+            if (typeof res.on === 'function') {
+                res.on('finish', () => {
+                    if (!(res.statusCode >= 200 && res.statusCode < 300))
+                        release();
+                });
+            }
             next();
         }).catch((err) => {
             // If the store backend is down, fail open — process the request normally.
@@ -115,4 +195,4 @@ export function idempotencyMiddleware(options = {}) {
         });
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idempotency-middleware.js","sourceRoot":"","sources":["../../src/api/idempotency-middleware.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport type { Request, Response, NextFunction } from 'express';\n\nconst logger = createLogger('idempotency');\n\ninterface CachedEntry {\n  statusCode: number;\n  body: unknown;\n  expiresAt: number;\n}\n\n/**\n * Pluggable backend for idempotency-key replay cache. The default in-memory\n * implementation works fine single-replica; a Redis-backed implementation\n * is required for correct deduplication across horizontally-scaled replicas\n * (otherwise two replicas behind a load-balancer cache independently and a\n * retry hitting a different pod won't replay).\n */\nexport interface IdempotencyStore {\n  get(key: string): Promise<CachedEntry | null>;\n  set(key: string, entry: CachedEntry, ttlSeconds: number): Promise<void>;\n}\n\n/**\n * Minimal interface a Redis client must satisfy. Compatible with\n * `ioredis` and `redis` v4+ — both expose `get`/`set` and accept `EX`\n * for expiry. Pass your real client in via `idempotencyMiddleware({\n * store: createRedisIdempotencyStore(client) })`.\n */\nexport interface RedisLike {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, mode?: 'EX', seconds?: number): Promise<unknown>;\n}\n\n/** Redis-backed idempotency store — share state across replicas. */\nexport function createRedisIdempotencyStore(client: RedisLike, prefix = 'idemp:'): IdempotencyStore {\n  return {\n    async get(key) {\n      const raw = await client.get(prefix + key);\n      if (!raw) return null;\n      try {\n        return JSON.parse(raw) as CachedEntry;\n      } catch {\n        return null;\n      }\n    },\n    async set(key, entry, ttlSeconds) {\n      await client.set(prefix + key, JSON.stringify(entry), 'EX', ttlSeconds);\n    },\n  };\n}\n\n/** Default in-memory store. Single-replica only. Exported for testing. */\nexport function createMemoryStore(): IdempotencyStore {\n  const map = new Map<string, CachedEntry>();\n  const cleanupTimer = setInterval(() => {\n    const now = Date.now();\n    for (const [k, v] of map) {\n      if (now > v.expiresAt) map.delete(k);\n    }\n  }, CoreConstants.IDEMPOTENCY_CLEANUP_INTERVAL_MS);\n  cleanupTimer.unref();\n  return {\n    async get(key) {\n      const entry = map.get(key);\n      if (!entry) return null;\n      if (Date.now() > entry.expiresAt) {\n        map.delete(key);\n        return null;\n      }\n      return entry;\n    },\n    async set(key, entry) {\n      // At capacity, evict the OLDEST entry (Map preserves insertion order)\n      // rather than silently dropping the NEW key — otherwise, once full, the\n      // store stops deduplicating fresh requests until the TTL sweep runs.\n      // Stays bounded; favors recent keys (most likely to be retried).\n      if (!map.has(key) && map.size >= CoreConstants.IDEMPOTENCY_MAX_STORE_SIZE) {\n        const oldest = map.keys().next().value;\n        if (oldest !== undefined) map.delete(oldest);\n      }\n      map.set(key, entry);\n    },\n  };\n}\n\nconst memoryStore = createMemoryStore();\n\nexport interface IdempotencyMiddlewareOptions {\n  /** Custom store backend (default: in-memory). Pass a Redis-backed store\n   *  for multi-replica deployments. */\n  store?: IdempotencyStore;\n}\n\n/**\n * Middleware that supports idempotency keys for POST/PUT/DELETE mutations.\n *\n * When a request includes the `Idempotency-Key` header:\n * - First call: processes normally, caches the response\n * - Subsequent calls with same key: returns cached response (prevents duplicate mutations)\n *\n * Pass `{ store: createRedisIdempotencyStore(redisClient) }` to dedupe\n * across replicas.\n */\nexport function idempotencyMiddleware(options: IdempotencyMiddlewareOptions = {}) {\n  const store = options.store ?? memoryStore;\n  return (req: Request, res: Response, next: NextFunction) => {\n    const key = req.headers['idempotency-key'] as string | undefined;\n    if (!key) return next();\n\n    // Only apply to mutation methods\n    if (!['POST', 'PUT', 'DELETE'].includes(req.method)) return next();\n\n    // Namespace by orgId to prevent cross-org cache collisions\n    const orgId = req.context?.identity?.orgId || req.user?.organizationId;\n    if (!orgId) return next(); // skip idempotency for unauthenticated requests\n    const fullKey = `${orgId}:${key}`;\n\n    // Check for cached response\n    store.get(fullKey).then((cached) => {\n      if (cached) {\n        logger.debug('Idempotent request replayed', { key: fullKey });\n        res.setHeader('X-Idempotent-Replayed', 'true');\n        res.status(cached.statusCode).json(cached.body);\n        return;\n      }\n\n      // Intercept res.json to cache the response\n      const originalJson = res.json.bind(res);\n      res.json = (body: unknown) => {\n        res.setHeader('X-Idempotent-Replayed', 'false');\n        if (res.statusCode >= 200 && res.statusCode < 300) {\n          // Fire-and-forget — failure to cache is logged but doesn't block the response.\n          store.set(fullKey, {\n            statusCode: res.statusCode,\n            body,\n            expiresAt: Date.now() + CoreConstants.IDEMPOTENCY_TTL_MS,\n          }, Math.floor(CoreConstants.IDEMPOTENCY_TTL_MS / 1000)).catch((err) => {\n            logger.warn('Idempotency store.set failed', { key: fullKey, error: err instanceof Error ? err.message : String(err) });\n          });\n        }\n        return originalJson(body);\n      };\n\n      next();\n    }).catch((err) => {\n      // If the store backend is down, fail open — process the request normally.\n      logger.warn('Idempotency store.get failed; proceeding without dedup', { key: fullKey, error: err instanceof Error ? err.message : String(err) });\n      next();\n    });\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idempotency-middleware.js","sourceRoot":"","sources":["../../src/api/idempotency-middleware.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createLogger } from '@pipeline-builder/api-core';\nimport { CoreConstants } from '@pipeline-builder/pipeline-core';\nimport type { Request, Response, NextFunction } from 'express';\n\nconst logger = createLogger('idempotency');\n\ninterface CachedEntry {\n  statusCode: number;\n  body: unknown;\n  expiresAt: number;\n  /** Reservation placeholder: the request is in-flight, no real response yet.\n   *  A duplicate that sees a pending entry is rejected with 409, not replayed. */\n  pending?: boolean;\n}\n\n/**\n * Pluggable backend for idempotency-key replay cache. The default in-memory\n * implementation works fine single-replica; a Redis-backed implementation\n * is required for correct deduplication across horizontally-scaled replicas\n * (otherwise two replicas behind a load-balancer cache independently and a\n * retry hitting a different pod won't replay).\n */\nexport interface IdempotencyStore {\n  get(key: string): Promise<CachedEntry | null>;\n  set(key: string, entry: CachedEntry, ttlSeconds: number): Promise<void>;\n  /**\n   * Atomically claim `key` IFF it is currently absent. Returns `true` when THIS\n   * caller set the entry (won the race), `false` when an entry already exists.\n   * This is what serializes concurrent first-time requests that share an\n   * Idempotency-Key — a plain get-then-set leaves a window where two requests\n   * both see \"not cached\" and both execute the mutation.\n   */\n  reserve(key: string, entry: CachedEntry, ttlSeconds: number): Promise<boolean>;\n  /** Remove a key — releases a reservation after a non-cacheable (non-2xx) response. */\n  delete(key: string): Promise<void>;\n}\n\n/**\n * Minimal interface a Redis client must satisfy. Compatible with\n * `ioredis` and `redis` v4+ — both expose `get`/`set` and accept `EX`\n * for expiry. Pass your real client in via `idempotencyMiddleware({\n * store: createRedisIdempotencyStore(client) })`.\n */\nexport interface RedisLike {\n  get(key: string): Promise<string | null>;\n  // Variadic to fit ioredis (`set(k, v, 'EX', ttl, 'NX')`) — `reserve` needs the\n  // `NX` flag for an atomic set-if-absent, which the fixed 4-arg form can't express.\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  del?(key: string): Promise<unknown>;\n}\n\n/** Redis-backed idempotency store — share state across replicas. */\nexport function createRedisIdempotencyStore(client: RedisLike, prefix = 'idemp:'): IdempotencyStore {\n  return {\n    async get(key) {\n      const raw = await client.get(prefix + key);\n      if (!raw) return null;\n      try {\n        return JSON.parse(raw) as CachedEntry;\n      } catch {\n        return null;\n      }\n    },\n    async set(key, entry, ttlSeconds) {\n      await client.set(prefix + key, JSON.stringify(entry), 'EX', ttlSeconds);\n    },\n    async reserve(key, entry, ttlSeconds) {\n      // SET key val EX ttl NX — atomic across replicas. Redis returns 'OK' when\n      // it set the key and null when the key already existed.\n      const res = await client.set(prefix + key, JSON.stringify(entry), 'EX', ttlSeconds, 'NX');\n      return res !== null && res !== undefined;\n    },\n    async delete(key) {\n      if (client.del) await client.del(prefix + key);\n    },\n  };\n}\n\n/** Default in-memory store. Single-replica only. Exported for testing. */\nexport function createMemoryStore(): IdempotencyStore {\n  const map = new Map<string, CachedEntry>();\n  const cleanupTimer = setInterval(() => {\n    const now = Date.now();\n    for (const [k, v] of map) {\n      if (now > v.expiresAt) map.delete(k);\n    }\n  }, CoreConstants.IDEMPOTENCY_CLEANUP_INTERVAL_MS);\n  cleanupTimer.unref();\n\n  /** Return the live (non-expired) entry, evicting it lazily if expired. */\n  const live = (key: string): CachedEntry | null => {\n    const entry = map.get(key);\n    if (!entry) return null;\n    if (Date.now() > entry.expiresAt) {\n      map.delete(key);\n      return null;\n    }\n    return entry;\n  };\n  /**\n   * At capacity, evict the OLDEST entry (Map preserves insertion order) rather\n   * than silently dropping the NEW key — otherwise, once full, the store stops\n   * deduplicating fresh requests until the TTL sweep runs. Stays bounded; favors\n   * recent keys (most likely to be retried).\n   */\n  const evictIfFull = (key: string): void => {\n    if (!map.has(key) && map.size >= CoreConstants.IDEMPOTENCY_MAX_STORE_SIZE) {\n      const oldest = map.keys().next().value;\n      if (oldest !== undefined) map.delete(oldest);\n    }\n  };\n  return {\n    async get(key) {\n      return live(key);\n    },\n    async set(key, entry) {\n      evictIfFull(key);\n      map.set(key, entry);\n    },\n    async reserve(key, entry) {\n      // Atomic in a single-threaded runtime: no await between the liveness check\n      // and the set, so two concurrent callers can't both observe \"absent\".\n      if (live(key)) return false;\n      evictIfFull(key);\n      map.set(key, entry);\n      return true;\n    },\n    async delete(key) {\n      map.delete(key);\n    },\n  };\n}\n\nconst memoryStore = createMemoryStore();\n\nexport interface IdempotencyMiddlewareOptions {\n  /** Custom store backend (default: in-memory). Pass a Redis-backed store\n   *  for multi-replica deployments. */\n  store?: IdempotencyStore;\n}\n\n/**\n * Middleware that supports idempotency keys for POST/PUT/DELETE mutations.\n *\n * When a request includes the `Idempotency-Key` header:\n * - First call: processes normally, caches the response\n * - Subsequent calls with same key: returns cached response (prevents duplicate mutations)\n *\n * Pass `{ store: createRedisIdempotencyStore(redisClient) }` to dedupe\n * across replicas.\n */\nexport function idempotencyMiddleware(options: IdempotencyMiddlewareOptions = {}) {\n  const store = options.store ?? memoryStore;\n  const ttlMs = CoreConstants.IDEMPOTENCY_TTL_MS;\n  const ttlSec = Math.floor(ttlMs / 1000);\n\n  return (req: Request, res: Response, next: NextFunction) => {\n    const key = req.headers['idempotency-key'] as string | undefined;\n    if (!key) return next();\n\n    // Only apply to mutation methods\n    if (!['POST', 'PUT', 'DELETE'].includes(req.method)) return next();\n\n    // Namespace by orgId to prevent cross-org cache collisions. Prefer the\n    // VERIFIED auth org (`req.user`, populated by requireAuth after signature\n    // verification) over `req.context.identity`, which some services populate\n    // pre-auth from an UNVERIFIED token peek — namespacing a mutation's replay\n    // cache on an unverified, caller-influenced org id would be unsafe.\n    const orgId = req.user?.organizationId || req.context?.identity?.orgId;\n    if (!orgId) return next(); // skip idempotency for unauthenticated requests\n    const fullKey = `${orgId}:${key}`;\n\n    /** Reject a duplicate whose original is still in-flight. */\n    const sendInProgress = (): void => {\n      res.setHeader('Retry-After', '1');\n      res.status(409).json({\n        success: false,\n        error: 'A request with this Idempotency-Key is already being processed',\n      });\n    };\n\n    store.get(fullKey).then(async (cached) => {\n      if (cached && !cached.pending) {\n        // Completed response on record → replay it.\n        logger.debug('Idempotent request replayed', { key: fullKey });\n        res.setHeader('X-Idempotent-Replayed', 'true');\n        res.status(cached.statusCode).json(cached.body);\n        return;\n      }\n      if (cached && cached.pending) {\n        // The original is still running — don't run the mutation a second time.\n        logger.debug('Idempotent request rejected (in progress)', { key: fullKey });\n        return sendInProgress();\n      }\n\n      // Atomically reserve the key. Losing this race means a concurrent request\n      // with the same key got there first and is in-flight → 409.\n      const won = await store.reserve(\n        fullKey,\n        { statusCode: 0, body: null, pending: true, expiresAt: Date.now() + ttlMs },\n        ttlSec,\n      );\n      if (!won) {\n        logger.debug('Idempotent request rejected (lost reserve race)', { key: fullKey });\n        return sendInProgress();\n      }\n\n      // We own the reservation. Replace it with the real response on completion;\n      // a non-2xx response RELEASES the reservation so a retry can proceed.\n      let settled = false;\n      const release = (): void => {\n        if (settled) return;\n        settled = true;\n        store.delete(fullKey).catch((err) => {\n          logger.warn('Idempotency reservation release failed', { key: fullKey, error: err instanceof Error ? err.message : String(err) });\n        });\n      };\n\n      const originalJson = res.json.bind(res);\n      res.json = (body: unknown) => {\n        res.setHeader('X-Idempotent-Replayed', 'false');\n        if (res.statusCode >= 200 && res.statusCode < 300) {\n          settled = true; // the finish-net must not delete a cached success\n          store.set(fullKey, {\n            statusCode: res.statusCode,\n            body,\n            expiresAt: Date.now() + ttlMs,\n          }, ttlSec).catch((err) => {\n            logger.warn('Idempotency store.set failed', { key: fullKey, error: err instanceof Error ? err.message : String(err) });\n          });\n        } else {\n          release();\n        }\n        return originalJson(body);\n      };\n\n      // Safety net for response paths that bypass res.json (res.send/res.end,\n      // an error handler, a thrown request): if the response finishes non-2xx\n      // with the reservation still held, release it so retries aren't blocked\n      // for the full TTL. Guarded — test doubles may not be EventEmitters.\n      if (typeof (res as { on?: unknown }).on === 'function') {\n        res.on('finish', () => {\n          if (!(res.statusCode >= 200 && res.statusCode < 300)) release();\n        });\n      }\n\n      next();\n    }).catch((err) => {\n      // If the store backend is down, fail open — process the request normally.\n      logger.warn('Idempotency store.get failed; proceeding without dedup', { key: fullKey, error: err instanceof Error ? err.message : String(err) });\n      next();\n    });\n  };\n}\n"]}

package/lib/api/server.js

@@ -3,8 +3,8 @@
 import { Server } from 'http';
 import { createLogger, errorMessage, installCrashHandlers } from '@pipeline-builder/api-core';
 import { Config, getConnection, closeConnection } from '@pipeline-builder/pipeline-core';
-import { shutdownTracing } from './tracing.js';
 import { setReady, isReady } from './readiness.js';
+import { shutdownTracing } from './tracing.js';
 import { SSEManager } from '../http/sse-connection-manager.js';
 const logger = createLogger('server');
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -230,4 +230,4 @@ export function runServer(app, options = {}) {
         process.exit(1);
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { createLogger, errorMessage, installCrashHandlers } from '@pipeline-builder/api-core';\nimport { Config, getConnection, closeConnection } from '@pipeline-builder/pipeline-core';\nimport type { Express } from 'express';\nimport { shutdownTracing } from './tracing.js';\nimport { setReady, isReady } from './readiness.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n// Dependency-supervisor cadence. Initial connect retries with capped backoff;\n// once connected, re-checks at a steady interval so a later outage flips the\n// service NotReady (draining traffic) and a recovery flips it back — without\n// ever exiting / restarting the process.\nconst READY_RETRY_BASE_MS = 1000;\nconst READY_RETRY_MAX_MS = 10000;\nconst READY_MONITOR_INTERVAL_MS = parseInt(process.env.READINESS_MONITOR_INTERVAL_MS || '15000', 10);\n\n/**\n * Establish and continuously monitor the service's datastore dependency,\n * flipping readiness state instead of crash-looping.\n *\n * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped\n *   backoff until it succeeds — a cold datastore must never exit the process.\n * - Monitor phase: poll `testDatabase` for the life of the process; flip\n *   ready/NotReady on transitions. While NotReady the readiness guard 503s\n *   business traffic and orchestrator readiness probes drain the instance.\n *\n * Runs in the background (the HTTP server is already listening). Stops when\n * `aborted()` returns true (graceful shutdown), so it never keeps a closing\n * process alive.\n */\nasync function superviseDependencies(\n  name: string,\n  onBeforeStart: (() => Promise<void>) | undefined,\n  testDatabase: (() => Promise<boolean>) | false | undefined,\n  aborted: () => boolean,\n): Promise<void> {\n  if (onBeforeStart) {\n    let delay = READY_RETRY_BASE_MS;\n    while (!aborted()) {\n      try {\n        await onBeforeStart();\n        break;\n      } catch (error) {\n        logger.warn(`${name}: dependency init failed, retrying in ${delay}ms`, { error: errorMessage(error) });\n        await sleep(delay);\n        delay = Math.min(delay * 2, READY_RETRY_MAX_MS);\n      }\n    }\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    setReady(true);\n    logger.info(`${name} ready (no datastore dependency)`);\n    return;\n  }\n\n  const probe = testDatabase ?? (() => getConnection().testConnection());\n  let waitDelay = READY_RETRY_BASE_MS;\n  while (!aborted()) {\n    let ok = false;\n    try {\n      ok = await probe();\n    } catch {\n      ok = false;\n    }\n\n    if (ok && !isReady()) {\n      setReady(true);\n      waitDelay = READY_RETRY_BASE_MS;\n      logger.info(`${name} ready — dependencies connected`);\n    } else if (!ok && isReady()) {\n      setReady(false);\n      logger.warn(`${name} degraded — dependency check failing (now NotReady)`);\n    }\n\n    // Steady cadence once ready; faster backoff while waiting so we flip to\n    // ready promptly when the datastore comes up.\n    if (isReady()) {\n      await sleep(READY_MONITOR_INTERVAL_MS);\n    } else {\n      await sleep(waitDelay);\n      waitDelay = Math.min(waitDelay * 2, READY_RETRY_MAX_MS);\n    }\n  }\n}\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n\n  logger.info(`Starting ${name}...`);\n\n  // Mark NotReady synchronously, BEFORE the port opens, so no request slips\n  // through the readiness guard before the supervisor has run. The supervisor\n  // flips it true once dependencies connect.\n  setReady(false);\n\n  // Listen FIRST. Previously the process tested the DB and `process.exit(1)`'d\n  // on failure (to be restarted), so during a cold-DB stampede services\n  // crash-looped and never even opened their port. Now we open the port\n  // immediately — /health (liveness), /ready (readiness) and the readiness\n  // guard all respond at once — and establish + monitor the datastore in the\n  // background, reporting NotReady until it connects instead of exiting.\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n\n  // Background dependency supervisor — established + monitored after listen,\n  // stopped on shutdown so it never keeps a closing process alive. Guard the\n  // floating promise: every expected failure is handled inside, so a rejection\n  // here means a programming error — log it and leave the service NotReady\n  // rather than letting it become an unhandledRejection that crash-exits the\n  // process (which would defeat the whole \"never exit on dependency trouble\"\n  // goal).\n  superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {\n    logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });\n  });\n\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n\n    // Force shutdown after timeout\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // startServer now listens-first and supervises the DB in the background, so\n    // it only rejects on a genuinely fatal SETUP error (invalid auth config, a\n    // failed onStart, the port already in use). Log message + stack explicitly:\n    // an Error in winston metadata serializes to `{}` (message/stack are\n    // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: error instanceof Error ? error.message : String(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/api/server.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { Server } from 'http';\nimport { createLogger, errorMessage, installCrashHandlers } from '@pipeline-builder/api-core';\nimport { Config, getConnection, closeConnection } from '@pipeline-builder/pipeline-core';\nimport type { Express } from 'express';\nimport { setReady, isReady } from './readiness.js';\nimport { shutdownTracing } from './tracing.js';\nimport { SSEManager } from '../http/sse-connection-manager.js';\n\nconst logger = createLogger('server');\n\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n// Dependency-supervisor cadence. Initial connect retries with capped backoff;\n// once connected, re-checks at a steady interval so a later outage flips the\n// service NotReady (draining traffic) and a recovery flips it back — without\n// ever exiting / restarting the process.\nconst READY_RETRY_BASE_MS = 1000;\nconst READY_RETRY_MAX_MS = 10000;\nconst READY_MONITOR_INTERVAL_MS = parseInt(process.env.READINESS_MONITOR_INTERVAL_MS || '15000', 10);\n\n/**\n * Establish and continuously monitor the service's datastore dependency,\n * flipping readiness state instead of crash-looping.\n *\n * - Establish phase: retry `onBeforeStart` (e.g. connectMongo) with capped\n *   backoff until it succeeds — a cold datastore must never exit the process.\n * - Monitor phase: poll `testDatabase` for the life of the process; flip\n *   ready/NotReady on transitions. While NotReady the readiness guard 503s\n *   business traffic and orchestrator readiness probes drain the instance.\n *\n * Runs in the background (the HTTP server is already listening). Stops when\n * `aborted()` returns true (graceful shutdown), so it never keeps a closing\n * process alive.\n */\nasync function superviseDependencies(\n  name: string,\n  onBeforeStart: (() => Promise<void>) | undefined,\n  testDatabase: (() => Promise<boolean>) | false | undefined,\n  aborted: () => boolean,\n): Promise<void> {\n  if (onBeforeStart) {\n    let delay = READY_RETRY_BASE_MS;\n    while (!aborted()) {\n      try {\n        await onBeforeStart();\n        break;\n      } catch (error) {\n        logger.warn(`${name}: dependency init failed, retrying in ${delay}ms`, { error: errorMessage(error) });\n        await sleep(delay);\n        delay = Math.min(delay * 2, READY_RETRY_MAX_MS);\n      }\n    }\n  }\n\n  // No datastore to gate on → ready as soon as we are listening.\n  if (testDatabase === false) {\n    setReady(true);\n    logger.info(`${name} ready (no datastore dependency)`);\n    return;\n  }\n\n  const probe = testDatabase ?? (() => getConnection().testConnection());\n  let waitDelay = READY_RETRY_BASE_MS;\n  while (!aborted()) {\n    let ok = false;\n    try {\n      ok = await probe();\n    } catch {\n      ok = false;\n    }\n\n    if (ok && !isReady()) {\n      setReady(true);\n      waitDelay = READY_RETRY_BASE_MS;\n      logger.info(`${name} ready — dependencies connected`);\n    } else if (!ok && isReady()) {\n      setReady(false);\n      logger.warn(`${name} degraded — dependency check failing (now NotReady)`);\n    }\n\n    // Steady cadence once ready; faster backoff while waiting so we flip to\n    // ready promptly when the datastore comes up.\n    if (isReady()) {\n      await sleep(READY_MONITOR_INTERVAL_MS);\n    } else {\n      await sleep(waitDelay);\n      waitDelay = Math.min(waitDelay * 2, READY_RETRY_MAX_MS);\n    }\n  }\n}\n\n/**\n * Options for starting a server\n */\nexport interface StartServerOptions {\n  /** Service name for logging */\n  name?: string;\n  /** Port to listen on (default: from config) */\n  port?: number;\n  /** SSE manager for graceful shutdown */\n  sseManager?: SSEManager;\n  /** Shutdown timeout in milliseconds (default: 15000) */\n  shutdownTimeoutMs?: number;\n  /** Callback after server starts */\n  onStart?: (port: number) => void;\n  /** Callback before shutdown */\n  onShutdown?: () => Promise<void>;\n  /** Runs before database check (e.g., initialize external connections) */\n  onBeforeStart?: () => Promise<void>;\n  /** Custom database health check, or false to skip. Default: PostgreSQL testConnection */\n  testDatabase?: (() => Promise<boolean>) | false;\n  /** Custom database close, or false to skip. Default: PostgreSQL closeConnection */\n  closeDatabase?: (() => Promise<void>) | false;\n}\n\n/**\n * Result of starting a server\n */\nexport interface StartServerResult {\n  /** HTTP server instance */\n  server: Server;\n  /** Port the server is listening on */\n  port: number;\n  /** Function to manually trigger shutdown */\n  shutdown: () => Promise<void>;\n}\n\n/**\n * Start an Express server with graceful shutdown handling\n *\n * Features:\n * - Automatic database connection testing\n * - Graceful shutdown on SIGINT/SIGTERM\n * - SSE connection cleanup\n * - Configurable shutdown timeout\n *\n * @param app - Express application\n * @param options - Server options\n * @returns Server instance and control functions\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n *\n * app.post('/api/resource', requireAuth, handler);\n *\n * await startServer(app, {\n *   name: 'My Microservice',\n *   sseManager,\n *   onStart: (port) => console.log(`Listening on ${port}`),\n * });\n * ```\n */\nexport async function startServer(\n  app: Express,\n  options: StartServerOptions = {},\n): Promise<StartServerResult> {\n  const serverConfig = Config.get('server');\n  const {\n    name = 'Microservice',\n    sseManager,\n    shutdownTimeoutMs = 15000,\n    onStart,\n    onShutdown,\n    onBeforeStart,\n    testDatabase,\n    closeDatabase,\n  } = options;\n  const port = options.port ?? serverConfig.port;\n\n  // Validate auth configuration at server startup (not during CDK synthesis)\n  Config.validateAuth();\n\n  logger.info(`Starting ${name}...`);\n\n  // Mark NotReady synchronously, BEFORE the port opens, so no request slips\n  // through the readiness guard before the supervisor has run. The supervisor\n  // flips it true once dependencies connect.\n  setReady(false);\n\n  // Listen FIRST. Previously the process tested the DB and `process.exit(1)`'d\n  // on failure (to be restarted), so during a cold-DB stampede services\n  // crash-looped and never even opened their port. Now we open the port\n  // immediately — /health (liveness), /ready (readiness) and the readiness\n  // guard all respond at once — and establish + monitor the datastore in the\n  // background, reporting NotReady until it connects instead of exiting.\n  const server = app.listen(port, () => {\n    logger.info(`${name} listening on port: ${port}`);\n    logger.info(`Platform URL: ${serverConfig.platformUrl}`);\n    onStart?.(port);\n  });\n\n  // Shutdown handler (guarded against concurrent signals)\n  let shuttingDown = false;\n\n  // Background dependency supervisor — established + monitored after listen,\n  // stopped on shutdown so it never keeps a closing process alive. Guard the\n  // floating promise: every expected failure is handled inside, so a rejection\n  // here means a programming error — log it and leave the service NotReady\n  // rather than letting it become an unhandledRejection that crash-exits the\n  // process (which would defeat the whole \"never exit on dependency trouble\"\n  // goal).\n  superviseDependencies(name, onBeforeStart, testDatabase, () => shuttingDown).catch((error) => {\n    logger.error('Dependency supervisor crashed; service will remain NotReady', { error: errorMessage(error) });\n  });\n\n  const shutdown = async (signal?: string) => {\n    if (shuttingDown) return;\n    shuttingDown = true;\n\n    if (signal) {\n      logger.info(`${signal} received, shutting down gracefully...`);\n    }\n\n    // Custom shutdown callback\n    if (onShutdown) {\n      try {\n        await onShutdown();\n      } catch (error) {\n        logger.error('Error in onShutdown callback', { error });\n      }\n    }\n\n    // Close SSE connections\n    if (sseManager) {\n      sseManager.shutdown();\n      logger.info('SSE connections closed');\n    }\n\n    // Close HTTP server\n    server.close(async () => {\n      logger.info('HTTP server closed');\n\n      // Shutdown OpenTelemetry tracing\n      await shutdownTracing().catch(err => logger.error('Error shutting down tracing', { error: err }));\n\n      // Close database connection\n      if (closeDatabase !== false) {\n        try {\n          if (closeDatabase) {\n            await closeDatabase();\n          } else {\n            await closeConnection();\n          }\n          logger.info('Database connection closed');\n        } catch (error) {\n          logger.error('Error closing database', { error });\n        }\n      }\n\n      process.exit(0);\n    });\n\n    // Force shutdown after timeout\n    setTimeout(() => {\n      logger.error('Forced shutdown after timeout');\n      process.exit(1);\n    }, shutdownTimeoutMs).unref();\n  };\n\n  // Register signal handlers\n  process.once('SIGINT', () => void shutdown('SIGINT'));\n  process.once('SIGTERM', () => void shutdown('SIGTERM'));\n\n  return {\n    server,\n    port,\n    shutdown: () => shutdown(),\n  };\n}\n\n/**\n * Simple server start wrapper with error handling\n *\n * @param app - Express application\n * @param options - Server options\n *\n * @example\n * ```typescript\n * const { app, sseManager } = createApp();\n * app.post('/api/resource', handler);\n *\n * void runServer(app, { name: 'My Service', sseManager });\n * ```\n */\nexport function runServer(app: Express, options: StartServerOptions = {}): void {\n  // Last-resort fault handlers for the production entrypoint: an unhandled\n  // rejection / uncaught exception is logged (not silently fatal) then the\n  // process exits for the orchestrator to restart. No-op under NODE_ENV=test.\n  installCrashHandlers(logger);\n  startServer(app, options).catch((error) => {\n    // startServer now listens-first and supervises the DB in the background, so\n    // it only rejects on a genuinely fatal SETUP error (invalid auth config, a\n    // failed onStart, the port already in use). Log message + stack explicitly:\n    // an Error in winston metadata serializes to `{}` (message/stack are\n    // non-enumerable), which would otherwise hide the cause behind `{error:{}}`.\n    logger.error('Failed to start server', {\n      error: error instanceof Error ? error.message : String(error),\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n    process.exit(1);\n  });\n}\n"]}

package/lib/api/tenant-context.d.ts

@@ -19,9 +19,10 @@ export type TenantScopeResolver = (req: Request) => TenantContext;
  * at the request boundary" bookend the RLS enforcement plan calls for.
  *
  * Default placement is AFTER `requireAuth` + `requireOrgId` (the route factories do this);
- * pass a custom `resolve` for a different boundary. If the resolver throws (e.g. the request
- * context was never attached because `attachRequestContext` is missing), we fail OPEN —
- * proceed without a scope rather than 500. Empty GUCs HIDE rows (never expose them), so
- * this degrades safely.
+ * pass a custom `resolve` for a different boundary. A thrown resolver means tenant identity
+ * could NOT be established (a wiring bug — this runs after auth) — we hard-FAIL the request
+ * (500 via next(err)) rather than proceed. Proceeding would run queries with empty RLS GUCs;
+ * under FORCE RLS that hides rows, but while RLS is in owner-bypass mode the app-layer WHERE
+ * clause is the only tenant gate, so a scopeless request must not silently continue.
  */
 export declare function withTenantContext(resolve?: TenantScopeResolver): (req: Request, _res: Response, next: NextFunction) => void;

package/lib/api/tenant-context.js

@@ -18,10 +18,11 @@ const identityScope = (req) => ({
  * at the request boundary" bookend the RLS enforcement plan calls for.
  *
  * Default placement is AFTER `requireAuth` + `requireOrgId` (the route factories do this);
- * pass a custom `resolve` for a different boundary. If the resolver throws (e.g. the request
- * context was never attached because `attachRequestContext` is missing), we fail OPEN —
- * proceed without a scope rather than 500. Empty GUCs HIDE rows (never expose them), so
- * this degrades safely.
+ * pass a custom `resolve` for a different boundary. A thrown resolver means tenant identity
+ * could NOT be established (a wiring bug — this runs after auth) — we hard-FAIL the request
+ * (500 via next(err)) rather than proceed. Proceeding would run queries with empty RLS GUCs;
+ * under FORCE RLS that hides rows, but while RLS is in owner-bypass mode the app-layer WHERE
+ * clause is the only tenant gate, so a scopeless request must not silently continue.
  */
 export function withTenantContext(resolve = identityScope) {
     return (req, _res, next) => {
@@ -29,11 +30,11 @@ export function withTenantContext(resolve = identityScope) {
         try {
             scope = resolve(req);
         }
-        catch {
-            next();
+        catch (err) {
+            next(err);
             return;
         }
         runWithTenantContext(scope, () => next());
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -43,8 +43,8 @@
     "rate-limit-redis": "5.0.0",
     "swagger-ui-express": "5.0.1",
     "uuid": "14.0.0",
-    "@pipeline-builder/api-core": "3.4.72",
-    "@pipeline-builder/pipeline-core": "3.4.80"
+    "@pipeline-builder/api-core": "3.4.74",
+    "@pipeline-builder/pipeline-core": "3.4.82"
   },
   "keywords": [
     "aws",
@@ -88,7 +88,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.85",
+  "version": "3.4.87",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },