@pipeline-builder/api-server 0.0.1

package/lib/api/idempotency-middleware.js

@@ -0,0 +1,321 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { createHash } from 'crypto';
+import { createLogger, sendError, ErrorCode, createEnvRedisClient } from '@pipeline-builder/api-core';
+import { CoreConstants } from '@pipeline-builder/pipeline-core';
+const logger = createLogger('idempotency');
+/**
+ * Canonical (key-sorted) JSON serialization so the SAME logical payload hashes
+ * identically regardless of property insertion order — a plain `JSON.stringify`
+ * would let `{a,b}` and `{b,a}` produce different fingerprints for one request.
+ */
+function stableStringify(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    if (Array.isArray(value))
+        return '[' + value.map(stableStringify).join(',') + ']';
+    const obj = value;
+    return '{' + Object.keys(obj).sort().map((k) => JSON.stringify(k) + ':' + stableStringify(obj[k])).join(',') + '}';
+}
+/**
+ * Short, stable fingerprint of a request body. Folds the payload into the
+ * idempotency key so replaying the SAME key with a DIFFERENT body is treated as
+ * a distinct operation (fresh execution) rather than replaying the old response.
+ * Empty/absent bodies collapse to '-' so body-less mutations stay unaffected.
+ */
+function bodyFingerprint(body) {
+    if (body === undefined || body === null)
+        return '-';
+    if (typeof body === 'object' && Object.keys(body).length === 0)
+        return '-';
+    try {
+        return createHash('sha256').update(stableStringify(body)).digest('hex').slice(0, 16);
+    }
+    catch {
+        // Non-serializable body (e.g. a stream/circular ref): skip fingerprinting
+        // rather than fail the request — key stays scoped by method+route+org.
+        return '-';
+    }
+}
+/** Default in-memory store. Single-replica only. Exported for testing. */
+export function createMemoryStore() {
+    const map = new Map();
+    const cleanupTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [k, v] of map) {
+            if (now > v.expiresAt)
+                map.delete(k);
+        }
+    }, 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) {
+            return live(key);
+        },
+        async set(key, entry) {
+            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);
+        },
+    };
+}
+const REDIS_KEY_PREFIX = 'idem:';
+/**
+ * Redis-backed {@link IdempotencyStore} for correct deduplication across
+ * horizontally-scaled replicas. `reserve` maps to an atomic `SET … NX` so two
+ * pods behind a load-balancer can't both win a first-time request sharing an
+ * Idempotency-Key; a retry landing on ANY pod sees the same committed response.
+ * Redis TTL owns expiry (the `CachedEntry.expiresAt` field is carried only for
+ * API-shape parity with the memory store).
+ */
+export function createRedisIdempotencyStore(redis) {
+    const k = (key) => `${REDIS_KEY_PREFIX}${key}`;
+    return {
+        async get(key) {
+            const raw = await redis.get(k(key));
+            if (!raw)
+                return null;
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                // Corrupt entry → treat as absent so the request proceeds fresh.
+                return null;
+            }
+        },
+        async set(key, entry, ttlSeconds) {
+            await redis.set(k(key), JSON.stringify(entry), 'EX', Math.max(1, ttlSeconds));
+        },
+        async reserve(key, entry, ttlSeconds) {
+            // Atomic claim: SET key val EX ttl NX → 'OK' only if the key was absent.
+            const res = await redis.set(k(key), JSON.stringify(entry), 'EX', Math.max(1, ttlSeconds), 'NX');
+            return res === 'OK';
+        },
+        async delete(key) {
+            await redis.del(k(key));
+        },
+    };
+}
+/**
+ * Build a Redis-backed idempotency store from the shared env Redis (the same
+ * `REDIS_URL` / `REDIS_HOST` wiring the rate-limiter and audit-spool use).
+ * Returns `null` when Redis isn't configured/available so the caller keeps the
+ * in-memory default (single-replica correctness). Never throws.
+ */
+export function createEnvRedisIdempotencyStore() {
+    const client = createEnvRedisClient('idempotency');
+    if (!client)
+        return null;
+    logger.info('Redis idempotency store initialized');
+    return createRedisIdempotencyStore(client);
+}
+const memoryStore = createMemoryStore();
+/**
+ * Process-wide default store used by `idempotencyMiddleware()` when no explicit
+ * `store` is passed. Defaults to the in-memory store; `createApp` promotes it to
+ * the shared env-Redis store (multi-replica dedup) at startup via
+ * {@link setIdempotencyStore}. The route factories keep calling
+ * `idempotencyMiddleware()` with no args and transparently pick this up.
+ */
+let defaultStore = memoryStore;
+/** Inject the process-wide idempotency store (e.g. a Redis-backed one). */
+export function setIdempotencyStore(store) {
+    defaultStore = store;
+}
+/** The current process-wide default store (in-memory unless overridden). */
+export function getIdempotencyStore() {
+    return defaultStore;
+}
+/**
+ * Middleware that supports idempotency keys for POST/PUT/DELETE mutations.
+ *
+ * When a request includes the `Idempotency-Key` header:
+ * - First call: processes normally, caches the response
+ * - Subsequent calls with same key: returns cached response (prevents duplicate mutations)
+ *
+ * Defaults to an in-memory store (single-replica). Pass a custom
+ * cross-replica `{ store }` implementing `IdempotencyStore` to dedupe across
+ * replicas.
+ */
+export function idempotencyMiddleware(options = {}) {
+    // Resolve the store PER REQUEST (not at factory time) so a store injected by
+    // createApp AFTER the route chains are built still takes effect. An explicit
+    // `options.store` always wins.
+    const explicitStore = options.store;
+    const ttlMs = CoreConstants.IDEMPOTENCY_TTL_MS;
+    const ttlSec = Math.floor(ttlMs / 1000);
+    return (req, res, next) => {
+        const store = explicitStore ?? defaultStore;
+        const key = req.headers['idempotency-key'];
+        if (!key)
+            return next();
+        // Only apply to mutation methods
+        if (!['POST', 'PUT', 'DELETE'].includes(req.method))
+            return next();
+        // 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
+        // Namespace the stored key by (method, route, org, body) so an Idempotency-Key
+        // is scoped to ONE specific endpoint+payload. Reusing a single key across two
+        // routes (e.g. POST /pipelines then POST /plugins) previously replayed the
+        // first endpoint's 2xx for the second — the store is a module-level singleton
+        // shared by every route. Folding in method + route path + a body fingerprint
+        // only makes keys MORE specific, so there is no cross-contamination risk.
+        const routePath = (req.baseUrl ?? '') + (req.route?.path ?? req.path ?? '');
+        const fullKey = `${req.method}:${routePath}:${orgId}:${bodyFingerprint(req.body)}:${key}`;
+        /** Reject a duplicate whose original is still in-flight. */
+        const sendInProgress = () => {
+            res.setHeader('Retry-After', '1');
+            sendError(res, 409, 'A request with this Idempotency-Key is already being processed', ErrorCode.CONFLICT);
+        };
+        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;
+            }
+            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. It MUST be resolved exactly once — either the
+            // real 2xx response is cached for replay, or the reservation is released so
+            // a retry can proceed. `settled` guards against a double-resolve.
+            let settled = false;
+            let capturedBody;
+            let bodyCaptured = false;
+            /** Remember the response body for replay (first capture wins). */
+            const captureBody = (body) => {
+                if (!bodyCaptured) {
+                    capturedBody = body;
+                    bodyCaptured = true;
+                }
+            };
+            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 cacheSuccess = () => {
+                if (settled)
+                    return;
+                settled = true;
+                store.set(fullKey, {
+                    statusCode: res.statusCode,
+                    body: bodyCaptured ? capturedBody : null,
+                    expiresAt: Date.now() + ttlMs,
+                }, ttlSec).catch((err) => {
+                    logger.warn('Idempotency store.set failed', { key: fullKey, error: err instanceof Error ? err.message : String(err) });
+                });
+            };
+            /** Resolve the reservation from the ACTUAL final status: cache 2xx, else release. */
+            const settleFromStatus = () => {
+                if (settled)
+                    return;
+                if (res.statusCode >= 200 && res.statusCode < 300)
+                    cacheSuccess();
+                else
+                    release();
+            };
+            // Fast path: res.json is the common completion. Capture the body and settle
+            // immediately off the status set by res.status(...).json(...).
+            const originalJson = res.json.bind(res);
+            res.json = (body) => {
+                res.setHeader('X-Idempotent-Replayed', 'false');
+                captureBody(body);
+                settleFromStatus();
+                return originalJson(body);
+            };
+            // Body-capture backstops for completions that bypass res.json
+            // (res.send / res.end / res.sendFile → res.end). These only RECORD the body;
+            // the actual settle happens on `finish` from the real status code. First
+            // capture wins, so res.json's body is never clobbered by its internal
+            // res.send/res.end calls.
+            const patched = res;
+            if (typeof patched.send === 'function') {
+                const originalSend = patched.send.bind(res);
+                patched.send = (body) => {
+                    captureBody(body);
+                    return originalSend(body);
+                };
+            }
+            if (typeof patched.end === 'function') {
+                const originalEnd = patched.end.bind(res);
+                patched.end = (...args) => {
+                    const chunk = args[0];
+                    if (chunk !== undefined && typeof chunk !== 'function')
+                        captureBody(chunk);
+                    return originalEnd(...args);
+                };
+            }
+            // Backstop for ANY completion path — including a 2xx that finished via
+            // res.send/res.end/res.sendFile/204 and never hit the patched res.json.
+            // Deciding on the real final status here means a successful op is cached
+            // (or a failed one released) instead of stranding the reservation and
+            // 409-ing every retry for the full TTL. Guarded — test doubles may not be
+            // EventEmitters; res.json's fast path already settled the common case.
+            if (typeof patched.on === 'function') {
+                patched.on('finish', settleFromStatus);
+            }
+            next();
+        }).catch((err) => {
+            // If the store backend is down, fail open — process the request normally.
+            logger.warn('Idempotency store.get failed; proceeding without dedup', { key: fullKey, error: err instanceof Error ? err.message : String(err) });
+            next();
+        });
+    };
+}
+//# 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 { createHash } from 'crypto';\nimport { createLogger, sendError, ErrorCode, createEnvRedisClient } 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\n/**\n * Canonical (key-sorted) JSON serialization so the SAME logical payload hashes\n * identically regardless of property insertion order — a plain `JSON.stringify`\n * would let `{a,b}` and `{b,a}` produce different fingerprints for one request.\n */\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null';\n  if (Array.isArray(value)) return '[' + value.map(stableStringify).join(',') + ']';\n  const obj = value as Record<string, unknown>;\n  return '{' + Object.keys(obj).sort().map((k) => JSON.stringify(k) + ':' + stableStringify(obj[k])).join(',') + '}';\n}\n\n/**\n * Short, stable fingerprint of a request body. Folds the payload into the\n * idempotency key so replaying the SAME key with a DIFFERENT body is treated as\n * a distinct operation (fresh execution) rather than replaying the old response.\n * Empty/absent bodies collapse to '-' so body-less mutations stay unaffected.\n */\nfunction bodyFingerprint(body: unknown): string {\n  if (body === undefined || body === null) return '-';\n  if (typeof body === 'object' && Object.keys(body as object).length === 0) return '-';\n  try {\n    return createHash('sha256').update(stableStringify(body)).digest('hex').slice(0, 16);\n  } catch {\n    // Non-serializable body (e.g. a stream/circular ref): skip fingerprinting\n    // rather than fail the request — key stays scoped by method+route+org.\n    return '-';\n  }\n}\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/** 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\n/**\n * Minimal Redis surface the idempotency store needs (an ioredis subset).\n * `set` supports the variadic option tail: `SET key val EX <ttl> [NX]`, which\n * returns `'OK'` on success and `null` when an `NX` set was refused.\n */\nexport interface RedisIdempotencyClient {\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string, ...args: (string | number)[]): Promise<string | null>;\n  del(key: string): Promise<number>;\n}\n\nconst REDIS_KEY_PREFIX = 'idem:';\n\n/**\n * Redis-backed {@link IdempotencyStore} for correct deduplication across\n * horizontally-scaled replicas. `reserve` maps to an atomic `SET … NX` so two\n * pods behind a load-balancer can't both win a first-time request sharing an\n * Idempotency-Key; a retry landing on ANY pod sees the same committed response.\n * Redis TTL owns expiry (the `CachedEntry.expiresAt` field is carried only for\n * API-shape parity with the memory store).\n */\nexport function createRedisIdempotencyStore(redis: RedisIdempotencyClient): IdempotencyStore {\n  const k = (key: string): string => `${REDIS_KEY_PREFIX}${key}`;\n  return {\n    async get(key) {\n      const raw = await redis.get(k(key));\n      if (!raw) return null;\n      try {\n        return JSON.parse(raw) as CachedEntry;\n      } catch {\n        // Corrupt entry → treat as absent so the request proceeds fresh.\n        return null;\n      }\n    },\n    async set(key, entry, ttlSeconds) {\n      await redis.set(k(key), JSON.stringify(entry), 'EX', Math.max(1, ttlSeconds));\n    },\n    async reserve(key, entry, ttlSeconds) {\n      // Atomic claim: SET key val EX ttl NX → 'OK' only if the key was absent.\n      const res = await redis.set(k(key), JSON.stringify(entry), 'EX', Math.max(1, ttlSeconds), 'NX');\n      return res === 'OK';\n    },\n    async delete(key) {\n      await redis.del(k(key));\n    },\n  };\n}\n\n/**\n * Build a Redis-backed idempotency store from the shared env Redis (the same\n * `REDIS_URL` / `REDIS_HOST` wiring the rate-limiter and audit-spool use).\n * Returns `null` when Redis isn't configured/available so the caller keeps the\n * in-memory default (single-replica correctness). Never throws.\n */\nexport function createEnvRedisIdempotencyStore(): IdempotencyStore | null {\n  const client = createEnvRedisClient<RedisIdempotencyClient>('idempotency');\n  if (!client) return null;\n  logger.info('Redis idempotency store initialized');\n  return createRedisIdempotencyStore(client);\n}\n\nconst memoryStore = createMemoryStore();\n\n/**\n * Process-wide default store used by `idempotencyMiddleware()` when no explicit\n * `store` is passed. Defaults to the in-memory store; `createApp` promotes it to\n * the shared env-Redis store (multi-replica dedup) at startup via\n * {@link setIdempotencyStore}. The route factories keep calling\n * `idempotencyMiddleware()` with no args and transparently pick this up.\n */\nlet defaultStore: IdempotencyStore = memoryStore;\n\n/** Inject the process-wide idempotency store (e.g. a Redis-backed one). */\nexport function setIdempotencyStore(store: IdempotencyStore): void {\n  defaultStore = store;\n}\n\n/** The current process-wide default store (in-memory unless overridden). */\nexport function getIdempotencyStore(): IdempotencyStore {\n  return defaultStore;\n}\n\nexport interface IdempotencyMiddlewareOptions {\n  /** Custom store backend. Defaults to the process-wide store set via\n   *  {@link setIdempotencyStore} (in-memory until `createApp` wires Redis). */\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 * Defaults to an in-memory store (single-replica). Pass a custom\n * cross-replica `{ store }` implementing `IdempotencyStore` to dedupe across\n * replicas.\n */\nexport function idempotencyMiddleware(options: IdempotencyMiddlewareOptions = {}) {\n  // Resolve the store PER REQUEST (not at factory time) so a store injected by\n  // createApp AFTER the route chains are built still takes effect. An explicit\n  // `options.store` always wins.\n  const explicitStore = options.store;\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 store = explicitStore ?? defaultStore;\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\n    // Namespace the stored key by (method, route, org, body) so an Idempotency-Key\n    // is scoped to ONE specific endpoint+payload. Reusing a single key across two\n    // routes (e.g. POST /pipelines then POST /plugins) previously replayed the\n    // first endpoint's 2xx for the second — the store is a module-level singleton\n    // shared by every route. Folding in method + route path + a body fingerprint\n    // only makes keys MORE specific, so there is no cross-contamination risk.\n    const routePath = (req.baseUrl ?? '') + (req.route?.path ?? req.path ?? '');\n    const fullKey = `${req.method}:${routePath}:${orgId}:${bodyFingerprint(req.body)}:${key}`;\n\n    /** Reject a duplicate whose original is still in-flight. */\n    const sendInProgress = (): void => {\n      res.setHeader('Retry-After', '1');\n      sendError(res, 409, 'A request with this Idempotency-Key is already being processed', ErrorCode.CONFLICT);\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. It MUST be resolved exactly once — either the\n      // real 2xx response is cached for replay, or the reservation is released so\n      // a retry can proceed. `settled` guards against a double-resolve.\n      let settled = false;\n      let capturedBody: unknown;\n      let bodyCaptured = false;\n\n      /** Remember the response body for replay (first capture wins). */\n      const captureBody = (body: unknown): void => {\n        if (!bodyCaptured) {\n          capturedBody = body;\n          bodyCaptured = true;\n        }\n      };\n\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 cacheSuccess = (): void => {\n        if (settled) return;\n        settled = true;\n        store.set(fullKey, {\n          statusCode: res.statusCode,\n          body: bodyCaptured ? capturedBody : null,\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      };\n\n      /** Resolve the reservation from the ACTUAL final status: cache 2xx, else release. */\n      const settleFromStatus = (): void => {\n        if (settled) return;\n        if (res.statusCode >= 200 && res.statusCode < 300) cacheSuccess();\n        else release();\n      };\n\n      // Fast path: res.json is the common completion. Capture the body and settle\n      // immediately off the status set by res.status(...).json(...).\n      const originalJson = res.json.bind(res);\n      res.json = (body: unknown) => {\n        res.setHeader('X-Idempotent-Replayed', 'false');\n        captureBody(body);\n        settleFromStatus();\n        return originalJson(body);\n      };\n\n      // Body-capture backstops for completions that bypass res.json\n      // (res.send / res.end / res.sendFile → res.end). These only RECORD the body;\n      // the actual settle happens on `finish` from the real status code. First\n      // capture wins, so res.json's body is never clobbered by its internal\n      // res.send/res.end calls.\n      const patched = res as unknown as {\n        send?: (body?: unknown) => unknown;\n        end?: (...args: unknown[]) => unknown;\n        on?: (event: string, cb: () => void) => unknown;\n      };\n      if (typeof patched.send === 'function') {\n        const originalSend = patched.send.bind(res);\n        patched.send = (body?: unknown) => {\n          captureBody(body);\n          return originalSend(body);\n        };\n      }\n      if (typeof patched.end === 'function') {\n        const originalEnd = patched.end.bind(res);\n        patched.end = (...args: unknown[]) => {\n          const chunk = args[0];\n          if (chunk !== undefined && typeof chunk !== 'function') captureBody(chunk);\n          return originalEnd(...args);\n        };\n      }\n\n      // Backstop for ANY completion path — including a 2xx that finished via\n      // res.send/res.end/res.sendFile/204 and never hit the patched res.json.\n      // Deciding on the real final status here means a successful op is cached\n      // (or a failed one released) instead of stranding the reservation and\n      // 409-ing every retry for the full TTL. Guarded — test doubles may not be\n      // EventEmitters; res.json's fast path already settled the common case.\n      if (typeof patched.on === 'function') {\n        patched.on('finish', settleFromStatus);\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/index.d.ts

@@ -0,0 +1,20 @@
+export * from './middleware.js';
+export * from './middleware-factory.js';
+export * from './context-middleware.js';
+export * from './check-quota.js';
+export * from './meter-quota.js';
+export * from './rate-limit-by-org.js';
+export * from './require-org-id.js';
+export * from './tenant-context.js';
+export * from './get-context.js';
+export * from './app-factory.js';
+export * from './health-checks.js';
+export * from './mongo-connect.js';
+export * from './quota-helpers.js';
+export * from './idempotency-middleware.js';
+export * from './tracing.js';
+export * from './metrics.js';
+export * from './server.js';
+export * from './readiness.js';
+export * from './route-wrapper.js';
+export * from './request-types.js';

package/lib/api/index.js

@@ -0,0 +1,34 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+// Middleware
+export * from './middleware.js';
+export * from './middleware-factory.js';
+export * from './context-middleware.js';
+export * from './check-quota.js';
+export * from './meter-quota.js';
+export * from './rate-limit-by-org.js';
+export * from './require-org-id.js';
+export * from './tenant-context.js';
+export * from './get-context.js';
+// App factory
+export * from './app-factory.js';
+// Health-check helpers
+export * from './health-checks.js';
+// MongoDB connection helper (dependency-injected mongoose)
+export * from './mongo-connect.js';
+// Quota helpers
+export * from './quota-helpers.js';
+// Idempotency
+export * from './idempotency-middleware.js';
+// Observability
+export * from './tracing.js';
+export * from './metrics.js';
+// Server utilities
+export * from './server.js';
+// Readiness state + guard middleware
+export * from './readiness.js';
+// Route wrapper
+export * from './route-wrapper.js';
+// Request/Response types
+export * from './request-types.js';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/meter-quota.d.ts

@@ -0,0 +1,32 @@
+import type { QuotaType, QuotaService } from '@pipeline-builder/api-core';
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * Middleware that METERS (increments) a quota counter once per SUCCESSFUL
+ * request, on response `finish`.
+ *
+ * The complement to {@link checkQuota}: `checkQuota` only GATES (reads current
+ * usage and 429s when over) — it never increments, so a service that mounts it
+ * but never calls `incrementQuota` checks against a counter that its own traffic
+ * never moves (the metering gap this fixes for the compliance service). Mount
+ * this ALONGSIDE the auth/org chain to close the loop with one line instead of
+ * threading `quotaService` + a manual `incrementQuotaFromCtx` through every
+ * route factory and handler.
+ *
+ * Fire-and-forget + fail-safe by construction:
+ * - runs in a `finish` listener, so it never blocks or fails the response;
+ * - `incrementQuota` swallows its own errors (logs a warning);
+ * - only 2xx responses are metered (a rejected/errored request costs nothing);
+ * - a request with no VERIFIED org (`req.user.organizationId` — set by
+ *   requireAuth, never the spoofable header identity) is skipped
+ *   (unauthenticated / health / early-terminated);
+ * - SERVICE-PRINCIPAL callers are skipped: internal service-to-service traffic
+ *   (e.g. a peer calling compliance `validate`) must not burn a tenant's quota —
+ *   the originating service already meters the user action that triggered it.
+ *
+ * Do NOT combine this with a handler that already calls `incrementQuotaFromCtx`
+ * for the same quota type on the same route — that double-counts.
+ *
+ * @param quotaService - Quota service client
+ * @param quotaType - Which quota to meter (e.g. 'apiCalls')
+ */
+export declare function meterQuotaOnSuccess(quotaService: QuotaService, quotaType: QuotaType): (req: Request, res: Response, next: NextFunction) => void;

package/lib/api/meter-quota.js

@@ -0,0 +1,70 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+import { incrementQuota, isServicePrincipal, createLogger } from '@pipeline-builder/api-core';
+import { getContext } from './get-context.js';
+const logger = createLogger('meter-quota');
+/**
+ * Middleware that METERS (increments) a quota counter once per SUCCESSFUL
+ * request, on response `finish`.
+ *
+ * The complement to {@link checkQuota}: `checkQuota` only GATES (reads current
+ * usage and 429s when over) — it never increments, so a service that mounts it
+ * but never calls `incrementQuota` checks against a counter that its own traffic
+ * never moves (the metering gap this fixes for the compliance service). Mount
+ * this ALONGSIDE the auth/org chain to close the loop with one line instead of
+ * threading `quotaService` + a manual `incrementQuotaFromCtx` through every
+ * route factory and handler.
+ *
+ * Fire-and-forget + fail-safe by construction:
+ * - runs in a `finish` listener, so it never blocks or fails the response;
+ * - `incrementQuota` swallows its own errors (logs a warning);
+ * - only 2xx responses are metered (a rejected/errored request costs nothing);
+ * - a request with no VERIFIED org (`req.user.organizationId` — set by
+ *   requireAuth, never the spoofable header identity) is skipped
+ *   (unauthenticated / health / early-terminated);
+ * - SERVICE-PRINCIPAL callers are skipped: internal service-to-service traffic
+ *   (e.g. a peer calling compliance `validate`) must not burn a tenant's quota —
+ *   the originating service already meters the user action that triggered it.
+ *
+ * Do NOT combine this with a handler that already calls `incrementQuotaFromCtx`
+ * for the same quota type on the same route — that double-counts.
+ *
+ * @param quotaService - Quota service client
+ * @param quotaType - Which quota to meter (e.g. 'apiCalls')
+ */
+export function meterQuotaOnSuccess(quotaService, quotaType) {
+    return (req, res, next) => {
+        res.on('finish', () => {
+            try {
+                // Only successful responses are billable.
+                if (res.statusCode < 200 || res.statusCode >= 300)
+                    return;
+                // Resolve the org id from the SAME source `checkQuota` reads —
+                // `getContext().identity.orgId`, which is normalized (trimmed + lowercased).
+                // Metering off the raw `req.user.organizationId` while the gate checks the
+                // normalized id would land increments on a different key than the check
+                // reads (a silent bypass if an org id ever carries mixed case). Fall back to
+                // the raw auth org only when context middleware isn't mounted.
+                let orgId;
+                try {
+                    orgId = getContext(req).identity.orgId;
+                }
+                catch {
+                    orgId = req.user?.organizationId;
+                }
+                if (!orgId)
+                    return;
+                // Internal service-to-service calls must not consume a tenant's quota.
+                if (isServicePrincipal(req))
+                    return;
+                incrementQuota(quotaService, orgId, quotaType, req.headers.authorization || '', (message, data) => logger.warn(message, data));
+            }
+            catch {
+                // Metering must never affect the response; a missing user/context just
+                // means an unauthenticated or early-terminated request — skip silently.
+            }
+        });
+        next();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/metrics.d.ts

@@ -0,0 +1,47 @@
+import type { Request, Response, NextFunction } from 'express';
+/**
+ * Express middleware that records request duration and count.
+ *
+ * Must be registered before route handlers so `res.on('finish')` fires
+ * after the response is sent.
+ */
+export declare function metricsMiddleware(): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Express handler that returns Prometheus metrics in text exposition format.
+ */
+export declare function metricsHandler(): (_req: Request, res: Response) => Promise<void>;
+/**
+ * Increment a business counter, creating it on first use.
+ *
+ * @example
+ * ```typescript
+ * incCounter('pipelines_generated_total', { provider: 'anthropic' });
+ * incCounter('plugin_builds_total', { status: 'completed' });
+ * incCounter('quota_threshold_crossed_total', { type: 'aiCalls', tier: 'pro' });
+ * incCounter('compliance_violations_found_total', { severity: 'critical' });
+ * ```
+ */
+export declare function incCounter(name: string, labels?: Record<string, string>, value?: number): void;
+/**
+ * Record an observation on a business histogram, creating it on first use.
+ * Use for durations, sizes, anything where percentiles matter.
+ *
+ * @example
+ * ```typescript
+ * observe('ai_generation_duration_seconds', { provider: 'anthropic', model: 'sonnet' }, durationSec);
+ * observe('plugin_build_duration_seconds', { buildType: 'docker' }, durationSec);
+ * ```
+ */
+export declare function observe(name: string, labels: Record<string, string>, value: number): void;
+/**
+ * Set the value of a business gauge, creating it on first use. Use for
+ * point-in-time observations sampled by a scraper — queue depth, active
+ * connection counts, in-flight requests.
+ *
+ * @example
+ * ```typescript
+ * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'waiting' }, 12);
+ * setGauge('plugin_queue_jobs', { queue: 'plugin-build', state: 'active' }, 3);
+ * ```
+ */
+export declare function setGauge(name: string, labels: Record<string, string>, value: number): void;