@pipeline-builder/api-server 4.4.3 → 4.4.4

package/lib/api/idempotency-middleware.js

@@ -156,6 +156,76 @@ export function getIdempotencyStore() {
  * pending reservation and answered 409.
  */
 const IDEMPOTENCY_HANDLED = Symbol('pipeline-builder.idempotency.handled');
+/**
+ * `res.locals` key set to `true` when the response was REPLAYED from the
+ * idempotency cache instead of running the handler. A replay did no work, so
+ * anything that bills per successful response (`meterQuotaOnSuccess`) must skip
+ * it — the original request already paid. Use {@link isIdempotentReplay}.
+ */
+export const IDEMPOTENT_REPLAY_LOCAL = 'idempotentReplay';
+/** True when `res` is a replay of a cached idempotent response. */
+export function isIdempotentReplay(res) {
+    return res.locals?.[IDEMPOTENT_REPLAY_LOCAL] === true;
+}
+/**
+ * The store key a request's `Idempotency-Key` is recorded under, or `undefined`
+ * when the request has no org to namespace it by (unauthenticated — skipped).
+ *
+ * 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.
+ *
+ * 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) must not replay 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. Also namespace by
+ * the VERIFIED user. `Idempotency-Key` is chosen by the client, so two users in
+ * the same org sending the same body with the same key collided: the second
+ * user's mutation was SKIPPED and they were served the first user's cached
+ * response. Falls back to the org alone only when there is no verified subject
+ * (service principals carry one).
+ */
+function idempotencyStoreKey(req, key) {
+    const orgId = req.user?.organizationId || req.context?.identity?.orgId;
+    if (!orgId)
+        return undefined;
+    const sub = req.user?.sub;
+    const routePath = (req.baseUrl ?? '') + (req.route?.path ?? req.path ?? '');
+    return `${req.method}:${routePath}:${orgId}:${sub ?? '-'}:${bodyFingerprint(req.body)}:${key}`;
+}
+/** Methods the idempotency middleware applies to. */
+const IDEMPOTENT_METHODS = ['POST', 'PUT', 'DELETE'];
+/**
+ * True when this request is a RETRY of an idempotent mutation whose original
+ * has COMPLETED (a cached 2xx on record) — i.e. the idempotency middleware will
+ * replay it without running the handler. The apiCalls check uses it to skip
+ * the gate for such a retry: the replay does no work and is never metered, so
+ * refusing it at the quota gate (which runs in requireAuth, BEFORE replay
+ * detection in most chains) would 429 a client for re-reading its own result.
+ *
+ * One store read, and only for a mutation carrying `Idempotency-Key`; every
+ * failure answers `false` (the gate then runs as usual). Uses the process-wide
+ * store — the same one the route chains' middleware resolves.
+ */
+export async function hasCompletedIdempotentResponse(req) {
+    const key = req.headers?.['idempotency-key'];
+    if (typeof key !== 'string' || !key || !IDEMPOTENT_METHODS.includes(req.method))
+        return false;
+    const fullKey = idempotencyStoreKey(req, key);
+    if (!fullKey)
+        return false;
+    try {
+        const cached = await defaultStore.get(fullKey);
+        return !!cached && !cached.pending;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Middleware that supports idempotency keys for POST/PUT/DELETE mutations.
  *
@@ -185,35 +255,16 @@ export function idempotencyMiddleware(options = {}) {
         if (!key)
             return next();
         // Only apply to mutation methods
-        if (!['POST', 'PUT', 'DELETE'].includes(req.method))
+        if (!IDEMPOTENT_METHODS.includes(req.method))
             return next();
         // One pass per request: a later stacked chain must not re-check the key.
         const marked = req;
         if (marked[IDEMPOTENCY_HANDLED])
             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)
+        const fullKey = idempotencyStoreKey(req, key);
+        if (!fullKey)
             return next(); // skip idempotency for unauthenticated requests
         marked[IDEMPOTENCY_HANDLED] = true;
-        // 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) must not replay 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.
-        // Also namespace by the VERIFIED user. `Idempotency-Key` is chosen by the
-        // client, so two users in the same org sending the same body with the same
-        // key collided: the second user's mutation was SKIPPED and they were served
-        // the first user's cached response. Falls back to the org alone only when
-        // there is no verified subject (service principals carry one).
-        const sub = req.user?.sub;
-        const routePath = (req.baseUrl ?? '') + (req.route?.path ?? req.path ?? '');
-        const fullKey = `${req.method}:${routePath}:${orgId}:${sub ?? '-'}:${bodyFingerprint(req.body)}:${key}`;
         /** Reject a duplicate whose original is still in-flight. */
         const sendInProgress = () => {
             res.setHeader('Retry-After', '1');
@@ -223,6 +274,7 @@ export function idempotencyMiddleware(options = {}) {
             if (cached && !cached.pending) {
                 // Completed response on record → replay it.
                 logger.debug('Idempotent request replayed', { key: fullKey });
+                (res.locals ??= {})[IDEMPOTENT_REPLAY_LOCAL] = true;
                 res.setHeader('X-Idempotent-Replayed', 'true');
                 res.status(cached.statusCode).json(cached.body);
                 return;
@@ -345,4 +397,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 { createHash } from 'crypto';\nimport { createLogger, sendError, ErrorCode, createEnvRedisClient, errorMessage, stableStringify } 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 * 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_SENTINELS` 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\n/**\n * Marks a request idempotency has already handled. Route chains are stacked —\n * several `app.use(prefix, ...createAuthenticatedWithOrgRoute(), router)` mounts\n * share a prefix, and a request that falls through the first router runs the\n * next chain's idempotency middleware again. That second pass found its OWN\n * pending reservation and answered 409.\n */\nconst IDEMPOTENCY_HANDLED = Symbol('pipeline-builder.idempotency.handled');\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  // A reservation lives only as long as a handler plausibly runs: if the\n  // process dies mid-handler nothing ever settles it, and this — not the full\n  // replay TTL — is how long retries of that key are refused.\n  const pendingTtlMs = Math.min(CoreConstants.IDEMPOTENCY_PENDING_TTL_MS, ttlMs);\n  const pendingTtlSec = Math.max(1, Math.floor(pendingTtlMs / 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    // One pass per request: a later stacked chain must not re-check the key.\n    const marked = req as Request & { [IDEMPOTENCY_HANDLED]?: true };\n    if (marked[IDEMPOTENCY_HANDLED]) 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    marked[IDEMPOTENCY_HANDLED] = true;\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) must not replay 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    // Also namespace by the VERIFIED user. `Idempotency-Key` is chosen by the\n    // client, so two users in the same org sending the same body with the same\n    // key collided: the second user's mutation was SKIPPED and they were served\n    // the first user's cached response. Falls back to the org alone only when\n    // there is no verified subject (service principals carry one).\n    const sub = req.user?.sub;\n    const routePath = (req.baseUrl ?? '') + (req.route?.path ?? req.path ?? '');\n    const fullKey = `${req.method}:${routePath}:${orgId}:${sub ?? '-'}:${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() + pendingTtlMs },\n        pendingTtlSec,\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: errorMessage(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: errorMessage(err) });\n        });\n      };\n\n      /**\n       * Resolve the reservation from the ACTUAL final status: a 2xx is cached for\n       * replay; anything else (the handler refused or failed — the mutation did\n       * not take effect) releases the key so a retry genuinely re-runs.\n       */\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          const out = originalEnd(...args);\n          // The handler has produced its final status. Settle HERE rather than\n          // waiting for 'finish': after a client disconnect 'finish' never fires,\n          // and the handler's outcome must still be recorded.\n          settleFromStatus();\n          return out;\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        // A client that disconnects emits 'close' WITHOUT 'finish' — but the\n        // HANDLER keeps running and may still commit the mutation. Releasing\n        // here let the client's retry run it a second time (a duplicate create /\n        // double charge — the very thing the key exists to prevent). So the\n        // reservation stays pending: the handler's own completion settles it\n        // (res.json / res.end above), and if the process dies instead, the\n        // short pending TTL frees the key.\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: errorMessage(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 { createHash } from 'crypto';\nimport { createLogger, sendError, ErrorCode, createEnvRedisClient, errorMessage, stableStringify } 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 * 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_SENTINELS` 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\n/**\n * Marks a request idempotency has already handled. Route chains are stacked —\n * several `app.use(prefix, ...createAuthenticatedWithOrgRoute(), router)` mounts\n * share a prefix, and a request that falls through the first router runs the\n * next chain's idempotency middleware again. That second pass found its OWN\n * pending reservation and answered 409.\n */\nconst IDEMPOTENCY_HANDLED = Symbol('pipeline-builder.idempotency.handled');\n\n/**\n * `res.locals` key set to `true` when the response was REPLAYED from the\n * idempotency cache instead of running the handler. A replay did no work, so\n * anything that bills per successful response (`meterQuotaOnSuccess`) must skip\n * it — the original request already paid. Use {@link isIdempotentReplay}.\n */\nexport const IDEMPOTENT_REPLAY_LOCAL = 'idempotentReplay';\n\n/** True when `res` is a replay of a cached idempotent response. */\nexport function isIdempotentReplay(res: Response): boolean {\n  return res.locals?.[IDEMPOTENT_REPLAY_LOCAL] === true;\n}\n\n/**\n * The store key a request's `Idempotency-Key` is recorded under, or `undefined`\n * when the request has no org to namespace it by (unauthenticated — skipped).\n *\n * Namespace by orgId to prevent cross-org cache collisions. Prefer the VERIFIED\n * auth org (`req.user`, populated by requireAuth after signature verification)\n * over `req.context.identity`, which some services populate pre-auth from an\n * UNVERIFIED token peek — namespacing a mutation's replay cache on an\n * unverified, caller-influenced org id would be unsafe.\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) must not replay the first\n * endpoint's 2xx for the second — the store is a module-level singleton shared\n * by every route. Folding in method + route path + a body fingerprint only makes\n * keys MORE specific, so there is no cross-contamination risk. Also namespace by\n * the VERIFIED user. `Idempotency-Key` is chosen by the client, so two users in\n * the same org sending the same body with the same key collided: the second\n * user's mutation was SKIPPED and they were served the first user's cached\n * response. Falls back to the org alone only when there is no verified subject\n * (service principals carry one).\n */\nfunction idempotencyStoreKey(req: Request, key: string): string | undefined {\n  const orgId = req.user?.organizationId || req.context?.identity?.orgId;\n  if (!orgId) return undefined;\n  const sub = req.user?.sub;\n  const routePath = (req.baseUrl ?? '') + (req.route?.path ?? req.path ?? '');\n  return `${req.method}:${routePath}:${orgId}:${sub ?? '-'}:${bodyFingerprint(req.body)}:${key}`;\n}\n\n/** Methods the idempotency middleware applies to. */\nconst IDEMPOTENT_METHODS = ['POST', 'PUT', 'DELETE'];\n\n/**\n * True when this request is a RETRY of an idempotent mutation whose original\n * has COMPLETED (a cached 2xx on record) — i.e. the idempotency middleware will\n * replay it without running the handler. The apiCalls check uses it to skip\n * the gate for such a retry: the replay does no work and is never metered, so\n * refusing it at the quota gate (which runs in requireAuth, BEFORE replay\n * detection in most chains) would 429 a client for re-reading its own result.\n *\n * One store read, and only for a mutation carrying `Idempotency-Key`; every\n * failure answers `false` (the gate then runs as usual). Uses the process-wide\n * store — the same one the route chains' middleware resolves.\n */\nexport async function hasCompletedIdempotentResponse(req: Request): Promise<boolean> {\n  const key = req.headers?.['idempotency-key'];\n  if (typeof key !== 'string' || !key || !IDEMPOTENT_METHODS.includes(req.method)) return false;\n  const fullKey = idempotencyStoreKey(req, key);\n  if (!fullKey) return false;\n  try {\n    const cached = await defaultStore.get(fullKey);\n    return !!cached && !cached.pending;\n  } catch {\n    return false;\n  }\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  // A reservation lives only as long as a handler plausibly runs: if the\n  // process dies mid-handler nothing ever settles it, and this — not the full\n  // replay TTL — is how long retries of that key are refused.\n  const pendingTtlMs = Math.min(CoreConstants.IDEMPOTENCY_PENDING_TTL_MS, ttlMs);\n  const pendingTtlSec = Math.max(1, Math.floor(pendingTtlMs / 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 (!IDEMPOTENT_METHODS.includes(req.method)) return next();\n\n    // One pass per request: a later stacked chain must not re-check the key.\n    const marked = req as Request & { [IDEMPOTENCY_HANDLED]?: true };\n    if (marked[IDEMPOTENCY_HANDLED]) return next();\n\n    const fullKey = idempotencyStoreKey(req, key);\n    if (!fullKey) return next(); // skip idempotency for unauthenticated requests\n    marked[IDEMPOTENCY_HANDLED] = true;\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.locals ??= {})[IDEMPOTENT_REPLAY_LOCAL] = true;\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() + pendingTtlMs },\n        pendingTtlSec,\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: errorMessage(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: errorMessage(err) });\n        });\n      };\n\n      /**\n       * Resolve the reservation from the ACTUAL final status: a 2xx is cached for\n       * replay; anything else (the handler refused or failed — the mutation did\n       * not take effect) releases the key so a retry genuinely re-runs.\n       */\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          const out = originalEnd(...args);\n          // The handler has produced its final status. Settle HERE rather than\n          // waiting for 'finish': after a client disconnect 'finish' never fires,\n          // and the handler's outcome must still be recorded.\n          settleFromStatus();\n          return out;\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        // A client that disconnects emits 'close' WITHOUT 'finish' — but the\n        // HANDLER keeps running and may still commit the mutation. Releasing\n        // here let the client's retry run it a second time (a duplicate create /\n        // double charge — the very thing the key exists to prevent). So the\n        // reservation stays pending: the handler's own completion settles it\n        // (res.json / res.end above), and if the process dies instead, the\n        // short pending TTL frees the key.\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: errorMessage(err) });\n      next();\n    });\n  };\n}\n"]}

package/lib/api/index.d.ts

@@ -12,9 +12,10 @@ export * from './app-factory.js';
 export * from './health-checks.js';
 export * from './mongo-connect.js';
 export * from './quota-reservation.js';
-export { getIdempotencyStore, type IdempotencyStore } from './idempotency-middleware.js';
+export * from './ai-call-reservation.js';
+export { getIdempotencyStore, isIdempotentReplay, IDEMPOTENT_REPLAY_LOCAL, type IdempotencyStore } from './idempotency-middleware.js';
 export { withSpan, currentTraceId } from './tracing.js';
-export { registerSecretRotationGauge, incCounter, observe, setGauge, createMetricHelpers, type MetricHelpers } from './metrics.js';
+export { registerSecretRotationGauge, incCounter, observe, setGauge, resetGauge, createMetricHelpers, type MetricHelpers } from './metrics.js';
 export * from './server.js';
 export { isReady, setReady, readinessGuard } from './readiness.js';
 export * from './route-wrapper.js';

package/lib/api/index.js

@@ -19,14 +19,15 @@ export * from './health-checks.js';
 export * from './mongo-connect.js';
 // Quota helpers
 export * from './quota-reservation.js';
+export * from './ai-call-reservation.js';
 // Idempotency — only the store accessor is public; the middleware, the store
 // factories and the store setter are wired by `createApp`/`middleware-factory`
 // inside this package and have no external caller.
-export { getIdempotencyStore } from './idempotency-middleware.js';
+export { getIdempotencyStore, isIdempotentReplay, IDEMPOTENT_REPLAY_LOCAL } from './idempotency-middleware.js';
 // Observability. `shutdownTracing` is called by this package's own `server.js`
 // shutdown path, and the metrics middleware/handler are mounted by `createApp`.
 export { withSpan, currentTraceId } from './tracing.js';
-export { registerSecretRotationGauge, incCounter, observe, setGauge, createMetricHelpers } from './metrics.js';
+export { registerSecretRotationGauge, incCounter, observe, setGauge, resetGauge, createMetricHelpers } from './metrics.js';
 // Server utilities
 export * from './server.js';
 // Readiness state + guard middleware. `DEFAULT_READINESS_BYPASS` is the guard's
@@ -34,4 +35,4 @@ export * from './server.js';
 export { isReady, setReady, readinessGuard } from './readiness.js';
 // Route wrapper
 export * from './route-wrapper.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,5 @@
 import type { QuotaType, QuotaService } from '@pipeline-builder/api-core';
-import type { Request, Response, NextFunction } from 'express';
+import type { Request, RequestHandler, Response, NextFunction } from 'express';
 /**
  * Middleware that METERS (increments) a quota counter once per SUCCESSFUL
  * request, on response `finish`.
@@ -13,19 +13,56 @@ import type { Request, Response, NextFunction } from 'express';
  *
  * 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);
+ * - `incrementQuota` BUFFERS the unit (api-core quota-increment-batcher): the
+ *   pod sends one metered increment per (org, type) per flush interval, so the
+ *   counter lags by at most `QUOTA_INCREMENT_FLUSH_MS`, and a unit past the cap
+ *   is recorded as `overshoot` rather than counted. Errors are swallowed and
+ *   counted (`quota_increment_failures_total`);
+ * - only 2xx responses are metered (a rejected/errored request costs nothing).
+ *   A 304 from an ETag match is not 2xx, so revalidating an unchanged
+ *   resource is free; a response that never FINISHES (client aborted a stream
+ *   mid-flight, socket destroyed) never emits `finish` and is not counted;
+ * - a response REPLAYED from the idempotency cache is skipped — the original
+ *   request already paid, and the replay did no work. This holds whether the
+ *   meter is mounted before or after the idempotency middleware: the flag is
+ *   read at `finish`, after both have run;
  * - 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.
+ *   An ORG SERVICE ACCOUNT (or a personal access key) is not a service principal
+ *   and IS metered — on `automationCalls` instead of `apiCalls`
+ *   ({@link meteredQuotaTypeFor});
+ * - for `apiCalls`, an IMPERSONATION session and an ON-BEHALF hop (a user token
+ *   forwarded by ask/pipeline with a signed marker) are skipped too — see
+ *   api-core `callQuotaExemption`;
+ * - an `apiCalls` request on the fleet-wide `QUOTA_EXEMPT_ROUTES` (console
+ *   polling) is skipped.
+ *
+ * Every increment carries usage attribution (principal, key, route pattern,
+ * pipeline, request id) for the quota service's usage ledger.
  *
  * Mount it once per route: a second meter for the same quota type on the same
- * request double-counts.
+ * request double-counts (the route table records each meter, and the quota
+ * coverage check fails a route metered twice).
  *
  * @param quotaService - Quota service client
- * @param quotaType - Which quota to meter (e.g. 'apiCalls')
+ * @param quotaType - Which quota to meter (e.g. 'apiCalls' — split per request
+ *   into apiCalls / automationCalls by principal)
  */
 export declare function meterQuotaOnSuccess(quotaService: QuotaService, quotaType: QuotaType): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * THE apiCalls convention for a service's user surface: meter once per 2xx AND
+ * gate after authentication, mounted ONCE at the app-routes level ahead of the
+ * routers it covers — `app.use('/things', ...apiCallsQuota(quotaService))`.
+ *
+ * The check is DEFERRED to `requireAuth` ({@link deferredCheckQuota}), so the
+ * mount can precede routers that authenticate per route. Both halves skip
+ * service principals, unauthenticated requests and the console-polling
+ * `QUOTA_EXEMPT_ROUTES`; a service account spends `automationCalls`. A route
+ * under such a prefix must NOT also mount its own `meterQuotaOnSuccess` for
+ * apiCalls (that bills twice — the quota coverage check fails it).
+ */
+export declare function apiCallsQuota(quotaService: QuotaService): RequestHandler[];

package/lib/api/meter-quota.js

@@ -1,7 +1,9 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { incrementQuota, isServicePrincipal, createLogger } from '@pipeline-builder/api-core';
+import { callQuotaExemption, incrementQuota, isQuotaExemptRoute, createLogger, meteredQuotaTypeFor, quotaAttributionFromRequest, tagRouteGate } from '@pipeline-builder/api-core';
+import { deferredCheckQuota, requestPath } from './check-quota.js';
 import { getContext } from './get-context.js';
+import { isIdempotentReplay } from './idempotency-middleware.js';
 const logger = createLogger('meter-quota');
 /**
  * Middleware that METERS (increments) a quota counter once per SUCCESSFUL
@@ -16,28 +18,55 @@ const logger = createLogger('meter-quota');
  *
  * 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);
+ * - `incrementQuota` BUFFERS the unit (api-core quota-increment-batcher): the
+ *   pod sends one metered increment per (org, type) per flush interval, so the
+ *   counter lags by at most `QUOTA_INCREMENT_FLUSH_MS`, and a unit past the cap
+ *   is recorded as `overshoot` rather than counted. Errors are swallowed and
+ *   counted (`quota_increment_failures_total`);
+ * - only 2xx responses are metered (a rejected/errored request costs nothing).
+ *   A 304 from an ETag match is not 2xx, so revalidating an unchanged
+ *   resource is free; a response that never FINISHES (client aborted a stream
+ *   mid-flight, socket destroyed) never emits `finish` and is not counted;
+ * - a response REPLAYED from the idempotency cache is skipped — the original
+ *   request already paid, and the replay did no work. This holds whether the
+ *   meter is mounted before or after the idempotency middleware: the flag is
+ *   read at `finish`, after both have run;
  * - 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.
+ *   An ORG SERVICE ACCOUNT (or a personal access key) is not a service principal
+ *   and IS metered — on `automationCalls` instead of `apiCalls`
+ *   ({@link meteredQuotaTypeFor});
+ * - for `apiCalls`, an IMPERSONATION session and an ON-BEHALF hop (a user token
+ *   forwarded by ask/pipeline with a signed marker) are skipped too — see
+ *   api-core `callQuotaExemption`;
+ * - an `apiCalls` request on the fleet-wide `QUOTA_EXEMPT_ROUTES` (console
+ *   polling) is skipped.
+ *
+ * Every increment carries usage attribution (principal, key, route pattern,
+ * pipeline, request id) for the quota service's usage ledger.
  *
  * Mount it once per route: a second meter for the same quota type on the same
- * request double-counts.
+ * request double-counts (the route table records each meter, and the quota
+ * coverage check fails a route metered twice).
  *
  * @param quotaService - Quota service client
- * @param quotaType - Which quota to meter (e.g. 'apiCalls')
+ * @param quotaType - Which quota to meter (e.g. 'apiCalls' — split per request
+ *   into apiCalls / automationCalls by principal)
  */
 export function meterQuotaOnSuccess(quotaService, quotaType) {
-    return (req, res, next) => {
+    return tagRouteGate((req, res, next) => {
         res.on('finish', () => {
             try {
                 // Only successful responses are billable.
                 if (res.statusCode < 200 || res.statusCode >= 300)
                     return;
+                // A cached replay did no work; the original already paid.
+                if (isIdempotentReplay(res))
+                    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
@@ -60,12 +89,17 @@ export function meterQuotaOnSuccess(quotaService, quotaType) {
                 }
                 if (!orgId)
                     return;
-                // Internal service-to-service calls must not consume a tenant's quota.
-                if (isServicePrincipal(req))
+                // Internal service-to-service calls must not consume a tenant's quota;
+                // nor, on the call budget, impersonation sessions or on-behalf hops.
+                const exemption = callQuotaExemption(req);
+                if (exemption === 'service' || (exemption && quotaType === 'apiCalls'))
+                    return;
+                // Console polling never spends a call.
+                if (quotaType === 'apiCalls' && isQuotaExemptRoute(req.method, requestPath(req)))
                     return;
                 // incrementQuota authenticates as THIS service (the increment endpoint
                 // is service-principal only — a forwarded user token is always 403).
-                incrementQuota(quotaService, orgId, quotaType, (message, data) => logger.warn(message, data));
+                incrementQuota(quotaService, orgId, meteredQuotaTypeFor(req, quotaType), (message, data) => logger.warn(message, data), quotaAttributionFromRequest(req));
             }
             catch {
                 // Metering must never affect the response; a missing user/context just
@@ -73,6 +107,24 @@ export function meterQuotaOnSuccess(quotaService, quotaType) {
             }
         });
         next();
-    };
+    }, { kind: 'quota', mode: 'meter', quotaType });
+}
+/**
+ * THE apiCalls convention for a service's user surface: meter once per 2xx AND
+ * gate after authentication, mounted ONCE at the app-routes level ahead of the
+ * routers it covers — `app.use('/things', ...apiCallsQuota(quotaService))`.
+ *
+ * The check is DEFERRED to `requireAuth` ({@link deferredCheckQuota}), so the
+ * mount can precede routers that authenticate per route. Both halves skip
+ * service principals, unauthenticated requests and the console-polling
+ * `QUOTA_EXEMPT_ROUTES`; a service account spends `automationCalls`. A route
+ * under such a prefix must NOT also mount its own `meterQuotaOnSuccess` for
+ * apiCalls (that bills twice — the quota coverage check fails it).
+ */
+export function apiCallsQuota(quotaService) {
+    return [
+        meterQuotaOnSuccess(quotaService, 'apiCalls'),
+        deferredCheckQuota(quotaService, 'apiCalls'),
+    ];
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meter-quota.js","sourceRoot":"","sources":["../../src/api/meter-quota.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,kBAAkB,EAAE,YAAY,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAGlL,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEjE,MAAM,MAAM,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,UAAU,mBAAmB,CAAC,YAA0B,EAAE,SAAoB;IAClF,OAAO,YAAY,CAAC,CAAC,GAAY,EAAE,GAAa,EAAE,IAAkB,EAAQ,EAAE;QAC5E,GAAG,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YACpB,IAAI,CAAC;gBACH,0CAA0C;gBAC1C,IAAI,GAAG,CAAC,UAAU,GAAG,GAAG,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG;oBAAE,OAAO;gBAC1D,0DAA0D;gBAC1D,IAAI,kBAAkB,CAAC,GAAG,CAAC;oBAAE,OAAO;gBACpC,+DAA+D;gBAC/D,6EAA6E;gBAC7E,2EAA2E;gBAC3E,wEAAwE;gBACxE,6EAA6E;gBAC7E,+DAA+D;gBAC/D,EAAE;gBACF,qEAAqE;gBACrE,0EAA0E;gBAC1E,wEAAwE;gBACxE,qCAAqC;gBACrC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,cAAc;oBAAE,OAAO;gBACtC,IAAI,KAAyB,CAAC;gBAC9B,IAAI,CAAC;oBAAC,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAAC,CAAC;gBAAC,MAAM,CAAC;oBAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC;gBAAC,CAAC;gBAC1F,IAAI,CAAC,KAAK;oBAAE,OAAO;gBACnB,uEAAuE;gBACvE,qEAAqE;gBACrE,MAAM,SAAS,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;gBAC1C,IAAI,SAAS,KAAK,SAAS,IAAI,CAAC,SAAS,IAAI,SAAS,KAAK,UAAU,CAAC;oBAAE,OAAO;gBAC/E,uCAAuC;gBACvC,IAAI,SAAS,KAAK,UAAU,IAAI,kBAAkB,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;oBAAE,OAAO;gBACzF,uEAAuE;gBACvE,qEAAqE;gBACrE,cAAc,CACZ,YAAY,EACZ,KAAK,EACL,mBAAmB,CAAC,GAAG,EAAE,SAAS,CAAC,EACnC,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,IAA+B,CAAC,EACxE,2BAA2B,CAAC,GAAG,CAAC,CACjC,CAAC;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,uEAAuE;gBACvE,wEAAwE;YAC1E,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,EAAE,CAAC;IACT,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAC,YAA0B;IACtD,OAAO;QACL,mBAAmB,CAAC,YAAY,EAAE,UAAU,CAAmB;QAC/D,kBAAkB,CAAC,YAAY,EAAE,UAAU,CAAC;KAC7C,CAAC;AACJ,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { callQuotaExemption, incrementQuota, isQuotaExemptRoute, createLogger, meteredQuotaTypeFor, quotaAttributionFromRequest, tagRouteGate } from '@pipeline-builder/api-core';\nimport type { QuotaType, QuotaService } from '@pipeline-builder/api-core';\nimport type { Request, RequestHandler, Response, NextFunction } from 'express';\nimport { deferredCheckQuota, requestPath } from './check-quota.js';\nimport { getContext } from './get-context.js';\nimport { isIdempotentReplay } from './idempotency-middleware.js';\n\nconst logger = createLogger('meter-quota');\n\n/**\n * Middleware that METERS (increments) a quota counter once per SUCCESSFUL\n * request, on response `finish`.\n *\n * The complement to {@link checkQuota}: `checkQuota` only GATES (reads current\n * usage and 429s when over) — it never increments, so a service that mounts it\n * but never increments checks against a counter its own traffic never moves.\n * This is THE apiCalls metering convention: put it on each metered route (or\n * mount it ahead of a service's whole surface) rather than incrementing by hand\n * in handlers.\n *\n * Fire-and-forget + fail-safe by construction:\n * - runs in a `finish` listener, so it never blocks or fails the response;\n * - `incrementQuota` BUFFERS the unit (api-core quota-increment-batcher): the\n *   pod sends one metered increment per (org, type) per flush interval, so the\n *   counter lags by at most `QUOTA_INCREMENT_FLUSH_MS`, and a unit past the cap\n *   is recorded as `overshoot` rather than counted. Errors are swallowed and\n *   counted (`quota_increment_failures_total`);\n * - only 2xx responses are metered (a rejected/errored request costs nothing).\n *   A 304 from an ETag match is not 2xx, so revalidating an unchanged\n *   resource is free; a response that never FINISHES (client aborted a stream\n *   mid-flight, socket destroyed) never emits `finish` and is not counted;\n * - a response REPLAYED from the idempotency cache is skipped — the original\n *   request already paid, and the replay did no work. This holds whether the\n *   meter is mounted before or after the idempotency middleware: the flag is\n *   read at `finish`, after both have run;\n * - a request with no VERIFIED org (`req.user.organizationId` — set by\n *   requireAuth, never the spoofable header identity) is skipped\n *   (unauthenticated / health / early-terminated);\n * - SERVICE-PRINCIPAL callers are skipped: internal service-to-service traffic\n *   (e.g. a peer calling compliance `validate`) must not burn a tenant's quota —\n *   the originating service already meters the user action that triggered it.\n *   An ORG SERVICE ACCOUNT (or a personal access key) is not a service principal\n *   and IS metered — on `automationCalls` instead of `apiCalls`\n *   ({@link meteredQuotaTypeFor});\n * - for `apiCalls`, an IMPERSONATION session and an ON-BEHALF hop (a user token\n *   forwarded by ask/pipeline with a signed marker) are skipped too — see\n *   api-core `callQuotaExemption`;\n * - an `apiCalls` request on the fleet-wide `QUOTA_EXEMPT_ROUTES` (console\n *   polling) is skipped.\n *\n * Every increment carries usage attribution (principal, key, route pattern,\n * pipeline, request id) for the quota service's usage ledger.\n *\n * Mount it once per route: a second meter for the same quota type on the same\n * request double-counts (the route table records each meter, and the quota\n * coverage check fails a route metered twice).\n *\n * @param quotaService - Quota service client\n * @param quotaType - Which quota to meter (e.g. 'apiCalls' — split per request\n *   into apiCalls / automationCalls by principal)\n */\nexport function meterQuotaOnSuccess(quotaService: QuotaService, quotaType: QuotaType) {\n  return tagRouteGate((req: Request, res: Response, next: NextFunction): void => {\n    res.on('finish', () => {\n      try {\n        // Only successful responses are billable.\n        if (res.statusCode < 200 || res.statusCode >= 300) return;\n        // A cached replay did no work; the original already paid.\n        if (isIdempotentReplay(res)) return;\n        // Resolve the org id from the SAME source `checkQuota` reads —\n        // `getContext().identity.orgId`, which is normalized (trimmed + lowercased).\n        // Metering off the raw `req.user.organizationId` while the gate checks the\n        // normalized id would land increments on a different key than the check\n        // reads (a silent bypass if an org id ever carries mixed case). Fall back to\n        // the raw auth org only when context middleware isn't mounted.\n        //\n        // Only a VERIFIED caller is metered. The increment is sent with THIS\n        // service's credentials, so metering an org taken from the header-derived\n        // identity of an unauthenticated request would let anyone burn a victim\n        // org's quota by setting `x-org-id`.\n        if (!req.user?.organizationId) return;\n        let orgId: string | undefined;\n        try { orgId = getContext(req).identity.orgId; } catch { orgId = req.user.organizationId; }\n        if (!orgId) return;\n        // Internal service-to-service calls must not consume a tenant's quota;\n        // nor, on the call budget, impersonation sessions or on-behalf hops.\n        const exemption = callQuotaExemption(req);\n        if (exemption === 'service' || (exemption && quotaType === 'apiCalls')) return;\n        // Console polling never spends a call.\n        if (quotaType === 'apiCalls' && isQuotaExemptRoute(req.method, requestPath(req))) return;\n        // incrementQuota authenticates as THIS service (the increment endpoint\n        // is service-principal only — a forwarded user token is always 403).\n        incrementQuota(\n          quotaService,\n          orgId,\n          meteredQuotaTypeFor(req, quotaType),\n          (message, data) => logger.warn(message, data as Record<string, unknown>),\n          quotaAttributionFromRequest(req),\n        );\n      } catch {\n        // Metering must never affect the response; a missing user/context just\n        // means an unauthenticated or early-terminated request — skip silently.\n      }\n    });\n    next();\n  }, { kind: 'quota', mode: 'meter', quotaType });\n}\n\n/**\n * THE apiCalls convention for a service's user surface: meter once per 2xx AND\n * gate after authentication, mounted ONCE at the app-routes level ahead of the\n * routers it covers — `app.use('/things', ...apiCallsQuota(quotaService))`.\n *\n * The check is DEFERRED to `requireAuth` ({@link deferredCheckQuota}), so the\n * mount can precede routers that authenticate per route. Both halves skip\n * service principals, unauthenticated requests and the console-polling\n * `QUOTA_EXEMPT_ROUTES`; a service account spends `automationCalls`. A route\n * under such a prefix must NOT also mount its own `meterQuotaOnSuccess` for\n * apiCalls (that bills twice — the quota coverage check fails it).\n */\nexport function apiCallsQuota(quotaService: QuotaService): RequestHandler[] {\n  return [\n    meterQuotaOnSuccess(quotaService, 'apiCalls') as RequestHandler,\n    deferredCheckQuota(quotaService, 'apiCalls'),\n  ];\n}\n"]}

package/lib/api/metrics.d.ts

@@ -24,6 +24,7 @@ export interface MetricHelpers {
     incCounter(name: string, labels?: Record<string, string>, value?: number): void;
     observe(name: string, labels: Record<string, string>, value: number): void;
     setGauge(name: string, labels: Record<string, string>, value: number): void;
+    resetGauge(name: string): void;
 }
 /**
  * Build `incCounter` / `observe` / `setGauge` over a caller-supplied registry.
@@ -84,3 +85,11 @@ export declare function observe(name: string, labels: Record<string, string>, va
  * ```
  */
 export declare function setGauge(name: string, labels: Record<string, string>, value: number): void;
+/**
+ * Drop EVERY series of a business gauge. For a gauge that describes a SET — one
+ * series per configured entry — and is re-published whole: without the reset, a
+ * series for an entry that has since been deleted keeps its last value forever,
+ * and an alert on it keeps firing for something that no longer exists. Call it
+ * immediately before re-setting the current set. A gauge never set is a no-op.
+ */
+export declare function resetGauge(name: string): void;