@pipeline-builder/api-server 4.4.3 → 4.4.5

package/lib/api/check-quota.js

@@ -1,33 +1,160 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { ErrorCode, createLogger, emitCounter, getQuotaServiceAuthHeader, sendError, sendQuotaExceeded, errorMessage } from '@pipeline-builder/api-core';
+import { armDeferredQuotaCheck, callQuotaExemption, createLogger, emitCounter, enforcedQuotaLimit, envInt, getQuotaServiceAuthHeader, isQuotaExemptRoute, meteredQuotaTypeFor, sendQuotaExceeded, errorMessage, tagRouteGate } from '@pipeline-builder/api-core';
 import { getContext } from './get-context.js';
+import { hasCompletedIdempotentResponse } from './idempotency-middleware.js';
 const logger = createLogger('check-quota');
-/** Human-readable labels for quota exceeded messages. */
-const QUOTA_LABELS = {
-    apiCalls: 'API call',
-    aiCalls: 'AI call',
-    pipelines: 'Pipeline',
-    plugins: 'Plugin',
-    storageBytes: 'Registry storage',
-    dashboards: 'Dashboard',
-    alertRules: 'Alert rule',
-    alertDestinations: 'Alert destination',
-    idpConfigs: 'IdP configuration',
-    listings: 'Plugin listing',
-};
+// PER-POD CHECK CACHE.
+//
+// The gate used to ask the quota service on EVERY metered request — a GET, a
+// JWT verify and a hierarchy resolve over there, per request here. A reading is
+// now reused per (org, quota type):
+//  - an ALLOWED reading for `QUOTA_CHECK_CACHE_TTL_MS` (default 5000; 0 turns
+//    the cache off), and only while this pod has passed fewer requests on it
+//    than the reading had headroom for (`enforcedQuotaLimit − used`), so one
+//    pod cannot run far past a nearly-full counter on a stale "yes";
+//  - a DENIED reading until the period resets, capped at
+//    `QUOTA_CHECK_DENIED_CACHE_MS` (default 60000) so an upgrade, a bundle
+//    purchase or an operator reset is honoured within a minute;
+//  - a fail-open sentinel is NEVER cached — recovery is seen on the next request.
+// Staleness is bounded and accepted: the counter itself never exceeds the cap
+// (the metered increment admits only what fits and records the rest as
+// overshoot), so a stale "yes" costs at most a few unbilled-over-cap requests
+// per pod per TTL, never an unbounded run. Concurrent misses for one key share
+// a single in-flight read.
+/** TTL (ms) of a cached ALLOWED check. `0` disables the cache. */
+export const QUOTA_CHECK_CACHE_TTL_MS = envInt('QUOTA_CHECK_CACHE_TTL_MS', 5000, { min: 0 });
+/** Longest (ms) a DENIED check is reused before re-asking (it never outlives `resetAt`). */
+export const QUOTA_CHECK_DENIED_CACHE_MS = envInt('QUOTA_CHECK_DENIED_CACHE_MS', 60000, { min: 0 });
+/** Bound on cached (org, type) readings per pod. */
+const CHECK_CACHE_MAX_ENTRIES = 10_000;
+const checkCache = new Map();
+const inFlightChecks = new Map();
+/** Drop every cached check (tests; also a safe operational reset). */
+export function clearQuotaCheckCache() {
+    checkCache.clear();
+    inFlightChecks.clear();
+}
+/** A usable cached reading for `key`, counting this request against its headroom. */
+function cachedCheck(key, quotaType) {
+    const hit = checkCache.get(key);
+    if (!hit)
+        return null;
+    if (hit.expiresAt <= Date.now()) {
+        checkCache.delete(key);
+        return null;
+    }
+    if (!hit.status.allowed)
+        return hit.status;
+    if (hit.status.limit !== -1) {
+        const headroom = enforcedQuotaLimit(quotaType, hit.status.limit) - hit.status.used;
+        if (hit.passes >= headroom) {
+            checkCache.delete(key);
+            return null;
+        }
+    }
+    hit.passes += 1;
+    return hit.status;
+}
+function rememberCheck(key, status) {
+    if (!status || status.failOpen)
+        return;
+    const now = Date.now();
+    let expiresAt;
+    if (status.allowed) {
+        if (QUOTA_CHECK_CACHE_TTL_MS === 0)
+            return;
+        expiresAt = now + QUOTA_CHECK_CACHE_TTL_MS;
+    }
+    else {
+        if (QUOTA_CHECK_DENIED_CACHE_MS === 0)
+            return;
+        const resetAt = Date.parse(status.resetAt);
+        expiresAt = Math.min(now + QUOTA_CHECK_DENIED_CACHE_MS, Number.isFinite(resetAt) ? resetAt : now);
+        if (expiresAt <= now)
+            return;
+    }
+    if (checkCache.size >= CHECK_CACHE_MAX_ENTRIES) {
+        // Map preserves insertion order, so the first key is the oldest reading.
+        const oldest = checkCache.keys().next();
+        if (!oldest.done)
+            checkCache.delete(oldest.value);
+    }
+    // The request that fetched the reading is its first pass.
+    checkCache.set(key, { status, expiresAt, passes: status.allowed ? 1 : 0 });
+}
+/**
+ * One quota read for (org, type), shared by every concurrent miss on this pod.
+ * A request that waited on someone else's read then goes back through the
+ * cache, so it is counted against the reading's headroom like any other pass
+ * (`joined` stops it from waiting a second time).
+ */
+async function readCheck(quotaService, orgId, quotaType, joined = false) {
+    const key = `${orgId}\u0000${quotaType}`;
+    const cached = cachedCheck(key, quotaType);
+    if (cached)
+        return cached;
+    const pending = inFlightChecks.get(key);
+    if (pending) {
+        if (joined)
+            return pending;
+        const status = await pending;
+        // A fail-open (or uncacheable) reading has nothing to account against.
+        return checkCache.has(key) ? readCheck(quotaService, orgId, quotaType, true) : status;
+    }
+    // Authenticate as THIS service, not by forwarding the user's token: the user
+    // token 403s at the quota read route for custom roles without `quotas:read`,
+    // and (being non-service) counts against the quota service's per-IP limiter
+    // keyed on THIS pod's IP — both of which silently fail the gate open under load.
+    const read = quotaService.check(orgId, quotaType, getQuotaServiceAuthHeader(orgId))
+        .then((status) => {
+        rememberCheck(key, status);
+        return status;
+    })
+        .finally(() => inFlightChecks.delete(key));
+    inFlightChecks.set(key, read);
+    return read;
+}
 /**
  * Create middleware that checks a specific quota type before proceeding.
  *
- * On quota exceeded, returns a 429 response with quota details.
+ * On quota exceeded, returns a 429 response with quota details (quotaType,
+ * limit, used, resetAt, upgradeUrl — see api-core `sendQuotaExceeded`).
  * On quota service failure, fails open (allows the request).
  *
+ * `apiCalls` is split per request by principal: an org service account or a
+ * personal access key is checked against `automationCalls` instead
+ * ({@link meteredQuotaTypeFor}), the
+ * same type `meterQuotaOnSuccess` increments — so mount both with `'apiCalls'`.
+ *
+ * Skipped (passes through) exactly where the meter skips, so the gate never
+ * refuses a call the meter would not bill (`callQuotaExemption`):
+ * - a SERVICE PRINCIPAL (peer-service traffic is never metered, so a tenant at
+ *   its limit must not break the internal calls its own earlier actions caused);
+ * - for `apiCalls`: an IMPERSONATION session (vendor staff diagnosing an
+ *   exhausted org must not be locked out by it) and an ON-BEHALF hop (a user
+ *   token forwarded by ask/pipeline with a signed marker — the originating
+ *   request was already gated and metered);
+ * - an `apiCalls` request on the fleet-wide `QUOTA_EXEMPT_ROUTES` (console
+ *   polling — an exhausted org must still render the banner saying so);
+ * - an idempotent RETRY whose original already completed (the replay is served
+ *   from the idempotency cache, does no work and is never metered; refusing it
+ *   would 429 a client for asking what its own earlier request returned).
+ *
+ * Readings are cached per pod (see the cache notes above), and the read itself
+ * has a short budget (api-core `QUOTA_CHECK_TIMEOUT_MS`, no retry) — a slow
+ * quota service fails open quickly instead of stalling every request.
+ *
+ * Mountable at the app-routes level (`app.use(prefix, …auth, checkQuota(...))`):
+ * the org comes from the request context when one is attached, else from the
+ * verified `req.user.organizationId` — the same fallback the meter uses.
+ *
  * @param quotaService - Quota service client
  * @param quotaType - Which quota to check (e.g. 'apiCalls', 'pipelines', 'plugins')
  * @returns Express middleware
  */
-export function checkQuota(quotaService, quotaType) {
-    return async (req, res, next) => {
+export function checkQuota(quotaService, baseQuotaType) {
+    return tagRouteGate(async (req, res, next) => {
         // The check is sent with THIS service's credentials, so it must only run for
         // a VERIFIED caller — otherwise the org would come from the spoofable
         // header-derived identity. Mounted after requireAuth everywhere; an
@@ -36,41 +163,35 @@ export function checkQuota(quotaService, quotaType) {
             logger.warn('Quota check skipped: request is not authenticated');
             return next();
         }
+        const exemption = callQuotaExemption(req);
+        if (exemption === 'service' || (exemption && baseQuotaType === 'apiCalls'))
+            return next();
+        if (baseQuotaType === 'apiCalls' && isQuotaExemptRoute(req.method, requestPath(req)))
+            return next();
+        const quotaType = meteredQuotaTypeFor(req, baseQuotaType);
         let orgId;
         try {
-            const ctx = getContext(req);
-            orgId = ctx.identity.orgId;
+            orgId = getContext(req).identity.orgId;
         }
         catch {
-            // Context middleware not applied — fail open (log and continue)
-            logger.warn('Quota check skipped: request context not initialized');
-            return next();
-        }
-        if (!orgId) {
-            sendError(res, 400, 'Organization ID is required for quota check', ErrorCode.VALIDATION_ERROR);
-            return;
+            // No request context (platform attaches none): the verified auth org — the
+            // same fallback `meterQuotaOnSuccess` uses, so both read one counter.
+            orgId = req.user.organizationId;
         }
+        // No org, nothing to bill (the meter skips it too). Not a 400: run deferred
+        // from `requireAuth` this precedes the route's own `requireOrgId`, and a
+        // route that needs no org (a person between orgs switching into one) must
+        // not be refused by a quota gate.
+        if (!orgId)
+            return next();
+        // A retry of a completed idempotent mutation is answered from the replay
+        // cache without running the handler — nothing to gate (one store read, only
+        // for requests that carry an Idempotency-Key).
+        if (await hasCompletedIdempotentResponse(req))
+            return next();
+        let quotaStatus;
         try {
-            // Authenticate as THIS service, not by forwarding the user's token: the
-            // user token 403s at the quota read route for custom roles without
-            // `quotas:read`, and (being non-service) counts against the quota
-            // service's per-IP limiter keyed on THIS pod's IP — both of which
-            // silently fail the gate open under load.
-            const quotaStatus = await quotaService.check(orgId, quotaType, getQuotaServiceAuthHeader(orgId));
-            if (!quotaStatus.allowed) {
-                logger.warn(`${quotaType} quota exceeded`, {
-                    orgId,
-                    limit: quotaStatus.limit,
-                    used: quotaStatus.used,
-                });
-                // Route through the shared helper so the check-gate 429 emits the same
-                // Retry-After + X-Quota-* headers as the reserve-path 429 (the inline
-                // 429 this replaced omitted them). Custom message keeps the
-                // "contact your administrator" copy.
-                sendQuotaExceeded(res, quotaType, { type: quotaType, limit: quotaStatus.limit, used: quotaStatus.used, remaining: quotaStatus.remaining }, quotaStatus.resetAt, `${QUOTA_LABELS[quotaType]} quota exceeded. Please contact your administrator to increase your quota.`);
-                return;
-            }
-            next();
+            quotaStatus = await readCheck(quotaService, orgId, quotaType);
         }
         catch (error) {
             // Fail open — allow the request if quota service is unavailable
@@ -83,8 +204,41 @@ export function checkQuota(quotaService, quotaType) {
             // is ALERTABLE from one series regardless of which layer fell open. Only
             // a log line here meant every org was silently un-billed for the duration.
             emitCounter('quota_fail_open_total', { operation: 'check', reason: 'exception', quotaType });
-            next();
+            return next();
         }
-    };
+        if (!quotaStatus.allowed) {
+            logger.warn(`${quotaType} quota exceeded`, {
+                orgId,
+                limit: quotaStatus.limit,
+                used: quotaStatus.used,
+            });
+            // Route through the shared helper so the check-gate 429 emits the same
+            // Retry-After + X-Quota-* headers and the same body (which quota, the
+            // reset date, the upgrade page) as the reserve-path 429.
+            sendQuotaExceeded(res, quotaType, { type: quotaType, limit: quotaStatus.limit, used: quotaStatus.used, remaining: quotaStatus.remaining }, quotaStatus.resetAt);
+            return;
+        }
+        // Outside the try: a synchronous throw downstream must reach Express's error
+        // handling, not be mistaken for a quota-service failure and run next() twice.
+        next();
+    }, { kind: 'quota', mode: 'check', quotaType: baseQuotaType });
+}
+/** The service-local request path, without the query string. */
+export function requestPath(req) {
+    return (req.originalUrl ?? req.url ?? '').split('?')[0] ?? '';
+}
+/**
+ * The DEFERRED form of {@link checkQuota}: arms the check at mount time and lets
+ * `requireAuth` run it once the caller is verified (api-core
+ * `armDeferredQuotaCheck`). For a prefix mount ahead of routers that
+ * authenticate per route — use {@link apiCallsQuota}, which pairs it with the
+ * meter. Tagged as the check gate, so the route table records it.
+ */
+export function deferredCheckQuota(quotaService, quotaType) {
+    const check = checkQuota(quotaService, quotaType);
+    return tagRouteGate((_req, res, next) => {
+        armDeferredQuotaCheck(res, check);
+        next();
+    }, { kind: 'quota', mode: 'check', quotaType });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-quota.js","sourceRoot":"","sources":["../../src/api/check-quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { ErrorCode, createLogger, emitCounter, getQuotaServiceAuthHeader, sendError, sendQuotaExceeded, errorMessage } from '@pipeline-builder/api-core';\nimport type { QuotaType, QuotaService } from '@pipeline-builder/api-core';\nimport type { Request, Response, NextFunction } from 'express';\nimport { getContext } from './get-context.js';\n\nconst logger = createLogger('check-quota');\n\n/** Human-readable labels for quota exceeded messages. */\nconst QUOTA_LABELS: Record<QuotaType, string> = {\n  apiCalls: 'API call',\n  aiCalls: 'AI call',\n  pipelines: 'Pipeline',\n  plugins: 'Plugin',\n  storageBytes: 'Registry storage',\n  dashboards: 'Dashboard',\n  alertRules: 'Alert rule',\n  alertDestinations: 'Alert destination',\n  idpConfigs: 'IdP configuration',\n  listings: 'Plugin listing',\n};\n\n/**\n * Create middleware that checks a specific quota type before proceeding.\n *\n * On quota exceeded, returns a 429 response with quota details.\n * On quota service failure, fails open (allows the request).\n *\n * @param quotaService - Quota service client\n * @param quotaType - Which quota to check (e.g. 'apiCalls', 'pipelines', 'plugins')\n * @returns Express middleware\n */\nexport function checkQuota(\n  quotaService: QuotaService,\n  quotaType: QuotaType,\n) {\n  return async (req: Request, res: Response, next: NextFunction): Promise<void> => {\n    // The check is sent with THIS service's credentials, so it must only run for\n    // a VERIFIED caller — otherwise the org would come from the spoofable\n    // header-derived identity. Mounted after requireAuth everywhere; an\n    // unauthenticated request here is a wiring bug, so skip (fail open) loudly.\n    if (!req.user) {\n      logger.warn('Quota check skipped: request is not authenticated');\n      return next();\n    }\n\n    let orgId: string | undefined;\n\n    try {\n      const ctx = getContext(req);\n      orgId = ctx.identity.orgId;\n    } catch {\n      // Context middleware not applied — fail open (log and continue)\n      logger.warn('Quota check skipped: request context not initialized');\n      return next();\n    }\n\n    if (!orgId) {\n      sendError(res, 400, 'Organization ID is required for quota check', ErrorCode.VALIDATION_ERROR);\n      return;\n    }\n\n    try {\n      // Authenticate as THIS service, not by forwarding the user's token: the\n      // user token 403s at the quota read route for custom roles without\n      // `quotas:read`, and (being non-service) counts against the quota\n      // service's per-IP limiter keyed on THIS pod's IP — both of which\n      // silently fail the gate open under load.\n      const quotaStatus = await quotaService.check(orgId, quotaType, getQuotaServiceAuthHeader(orgId));\n\n      if (!quotaStatus.allowed) {\n        logger.warn(`${quotaType} quota exceeded`, {\n          orgId,\n          limit: quotaStatus.limit,\n          used: quotaStatus.used,\n        });\n\n        // Route through the shared helper so the check-gate 429 emits the same\n        // Retry-After + X-Quota-* headers as the reserve-path 429 (the inline\n        // 429 this replaced omitted them). Custom message keeps the\n        // \"contact your administrator\" copy.\n        sendQuotaExceeded(\n          res,\n          quotaType,\n          { type: quotaType, limit: quotaStatus.limit, used: quotaStatus.used, remaining: quotaStatus.remaining },\n          quotaStatus.resetAt,\n          `${QUOTA_LABELS[quotaType]} quota exceeded. Please contact your administrator to increase your quota.`,\n        );\n        return;\n      }\n\n      next();\n    } catch (error) {\n      // Fail open — allow the request if quota service is unavailable\n      logger.warn('QUOTA_FAIL_OPEN: Quota check exception, allowing request', {\n        orgId,\n        quotaType,\n        error: errorMessage(error),\n      });\n      // Same counter the api-core quota client emits, so a quota-service outage\n      // is ALERTABLE from one series regardless of which layer fell open. Only\n      // a log line here meant every org was silently un-billed for the duration.\n      emitCounter('quota_fail_open_total', { operation: 'check', reason: 'exception', quotaType });\n      next();\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-quota.js","sourceRoot":"","sources":["../../src/api/check-quota.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { armDeferredQuotaCheck, callQuotaExemption, createLogger, emitCounter, enforcedQuotaLimit, envInt, getQuotaServiceAuthHeader, isQuotaExemptRoute, meteredQuotaTypeFor, sendQuotaExceeded, errorMessage, tagRouteGate } from '@pipeline-builder/api-core';\nimport type { QuotaCheckResult, QuotaType, QuotaService } from '@pipeline-builder/api-core';\nimport type { Request, RequestHandler, Response, NextFunction } from 'express';\nimport { getContext } from './get-context.js';\nimport { hasCompletedIdempotentResponse } from './idempotency-middleware.js';\n\nconst logger = createLogger('check-quota');\n\n// PER-POD CHECK CACHE.\n//\n// The gate used to ask the quota service on EVERY metered request — a GET, a\n// JWT verify and a hierarchy resolve over there, per request here. A reading is\n// now reused per (org, quota type):\n//  - an ALLOWED reading for `QUOTA_CHECK_CACHE_TTL_MS` (default 5000; 0 turns\n//    the cache off), and only while this pod has passed fewer requests on it\n//    than the reading had headroom for (`enforcedQuotaLimit − used`), so one\n//    pod cannot run far past a nearly-full counter on a stale \"yes\";\n//  - a DENIED reading until the period resets, capped at\n//    `QUOTA_CHECK_DENIED_CACHE_MS` (default 60000) so an upgrade, a bundle\n//    purchase or an operator reset is honoured within a minute;\n//  - a fail-open sentinel is NEVER cached — recovery is seen on the next request.\n// Staleness is bounded and accepted: the counter itself never exceeds the cap\n// (the metered increment admits only what fits and records the rest as\n// overshoot), so a stale \"yes\" costs at most a few unbilled-over-cap requests\n// per pod per TTL, never an unbounded run. Concurrent misses for one key share\n// a single in-flight read.\n\n/** TTL (ms) of a cached ALLOWED check. `0` disables the cache. */\nexport const QUOTA_CHECK_CACHE_TTL_MS = envInt('QUOTA_CHECK_CACHE_TTL_MS', 5000, { min: 0 });\n\n/** Longest (ms) a DENIED check is reused before re-asking (it never outlives `resetAt`). */\nexport const QUOTA_CHECK_DENIED_CACHE_MS = envInt('QUOTA_CHECK_DENIED_CACHE_MS', 60000, { min: 0 });\n\n/** Bound on cached (org, type) readings per pod. */\nconst CHECK_CACHE_MAX_ENTRIES = 10_000;\n\ninterface CachedCheck {\n  status: QuotaCheckResult;\n  expiresAt: number;\n  /** Requests this pod let through on this reading. */\n  passes: number;\n}\n\nconst checkCache = new Map<string, CachedCheck>();\nconst inFlightChecks = new Map<string, Promise<QuotaCheckResult>>();\n\n/** Drop every cached check (tests; also a safe operational reset). */\nexport function clearQuotaCheckCache(): void {\n  checkCache.clear();\n  inFlightChecks.clear();\n}\n\n/** A usable cached reading for `key`, counting this request against its headroom. */\nfunction cachedCheck(key: string, quotaType: QuotaType): QuotaCheckResult | null {\n  const hit = checkCache.get(key);\n  if (!hit) return null;\n  if (hit.expiresAt <= Date.now()) {\n    checkCache.delete(key);\n    return null;\n  }\n  if (!hit.status.allowed) return hit.status;\n  if (hit.status.limit !== -1) {\n    const headroom = enforcedQuotaLimit(quotaType, hit.status.limit) - hit.status.used;\n    if (hit.passes >= headroom) {\n      checkCache.delete(key);\n      return null;\n    }\n  }\n  hit.passes += 1;\n  return hit.status;\n}\n\nfunction rememberCheck(key: string, status: QuotaCheckResult): void {\n  if (!status || status.failOpen) return;\n  const now = Date.now();\n  let expiresAt: number;\n  if (status.allowed) {\n    if (QUOTA_CHECK_CACHE_TTL_MS === 0) return;\n    expiresAt = now + QUOTA_CHECK_CACHE_TTL_MS;\n  } else {\n    if (QUOTA_CHECK_DENIED_CACHE_MS === 0) return;\n    const resetAt = Date.parse(status.resetAt);\n    expiresAt = Math.min(now + QUOTA_CHECK_DENIED_CACHE_MS, Number.isFinite(resetAt) ? resetAt : now);\n    if (expiresAt <= now) return;\n  }\n  if (checkCache.size >= CHECK_CACHE_MAX_ENTRIES) {\n    // Map preserves insertion order, so the first key is the oldest reading.\n    const oldest = checkCache.keys().next();\n    if (!oldest.done) checkCache.delete(oldest.value);\n  }\n  // The request that fetched the reading is its first pass.\n  checkCache.set(key, { status, expiresAt, passes: status.allowed ? 1 : 0 });\n}\n\n/**\n * One quota read for (org, type), shared by every concurrent miss on this pod.\n * A request that waited on someone else's read then goes back through the\n * cache, so it is counted against the reading's headroom like any other pass\n * (`joined` stops it from waiting a second time).\n */\nasync function readCheck(quotaService: QuotaService, orgId: string, quotaType: QuotaType, joined = false): Promise<QuotaCheckResult> {\n  const key = `${orgId}\\u0000${quotaType}`;\n  const cached = cachedCheck(key, quotaType);\n  if (cached) return cached;\n  const pending = inFlightChecks.get(key);\n  if (pending) {\n    if (joined) return pending;\n    const status = await pending;\n    // A fail-open (or uncacheable) reading has nothing to account against.\n    return checkCache.has(key) ? readCheck(quotaService, orgId, quotaType, true) : status;\n  }\n  // Authenticate as THIS service, not by forwarding the user's token: the user\n  // token 403s at the quota read route for custom roles without `quotas:read`,\n  // and (being non-service) counts against the quota service's per-IP limiter\n  // keyed on THIS pod's IP — both of which silently fail the gate open under load.\n  const read = quotaService.check(orgId, quotaType, getQuotaServiceAuthHeader(orgId))\n    .then((status) => {\n      rememberCheck(key, status);\n      return status;\n    })\n    .finally(() => inFlightChecks.delete(key));\n  inFlightChecks.set(key, read);\n  return read;\n}\n\n/**\n * Create middleware that checks a specific quota type before proceeding.\n *\n * On quota exceeded, returns a 429 response with quota details (quotaType,\n * limit, used, resetAt, upgradeUrl — see api-core `sendQuotaExceeded`).\n * On quota service failure, fails open (allows the request).\n *\n * `apiCalls` is split per request by principal: an org service account or a\n * personal access key is checked against `automationCalls` instead\n * ({@link meteredQuotaTypeFor}), the\n * same type `meterQuotaOnSuccess` increments — so mount both with `'apiCalls'`.\n *\n * Skipped (passes through) exactly where the meter skips, so the gate never\n * refuses a call the meter would not bill (`callQuotaExemption`):\n * - a SERVICE PRINCIPAL (peer-service traffic is never metered, so a tenant at\n *   its limit must not break the internal calls its own earlier actions caused);\n * - for `apiCalls`: an IMPERSONATION session (vendor staff diagnosing an\n *   exhausted org must not be locked out by it) and an ON-BEHALF hop (a user\n *   token forwarded by ask/pipeline with a signed marker — the originating\n *   request was already gated and metered);\n * - an `apiCalls` request on the fleet-wide `QUOTA_EXEMPT_ROUTES` (console\n *   polling — an exhausted org must still render the banner saying so);\n * - an idempotent RETRY whose original already completed (the replay is served\n *   from the idempotency cache, does no work and is never metered; refusing it\n *   would 429 a client for asking what its own earlier request returned).\n *\n * Readings are cached per pod (see the cache notes above), and the read itself\n * has a short budget (api-core `QUOTA_CHECK_TIMEOUT_MS`, no retry) — a slow\n * quota service fails open quickly instead of stalling every request.\n *\n * Mountable at the app-routes level (`app.use(prefix, …auth, checkQuota(...))`):\n * the org comes from the request context when one is attached, else from the\n * verified `req.user.organizationId` — the same fallback the meter uses.\n *\n * @param quotaService - Quota service client\n * @param quotaType - Which quota to check (e.g. 'apiCalls', 'pipelines', 'plugins')\n * @returns Express middleware\n */\nexport function checkQuota(\n  quotaService: QuotaService,\n  baseQuotaType: QuotaType,\n) {\n  return tagRouteGate(async (req: Request, res: Response, next: NextFunction): Promise<void> => {\n    // The check is sent with THIS service's credentials, so it must only run for\n    // a VERIFIED caller — otherwise the org would come from the spoofable\n    // header-derived identity. Mounted after requireAuth everywhere; an\n    // unauthenticated request here is a wiring bug, so skip (fail open) loudly.\n    if (!req.user) {\n      logger.warn('Quota check skipped: request is not authenticated');\n      return next();\n    }\n\n    const exemption = callQuotaExemption(req);\n    if (exemption === 'service' || (exemption && baseQuotaType === 'apiCalls')) return next();\n    if (baseQuotaType === 'apiCalls' && isQuotaExemptRoute(req.method, requestPath(req))) return next();\n\n    const quotaType = meteredQuotaTypeFor(req, baseQuotaType);\n    let orgId: string | undefined;\n\n    try {\n      orgId = getContext(req).identity.orgId;\n    } catch {\n      // No request context (platform attaches none): the verified auth org — the\n      // same fallback `meterQuotaOnSuccess` uses, so both read one counter.\n      orgId = req.user.organizationId;\n    }\n\n    // No org, nothing to bill (the meter skips it too). Not a 400: run deferred\n    // from `requireAuth` this precedes the route's own `requireOrgId`, and a\n    // route that needs no org (a person between orgs switching into one) must\n    // not be refused by a quota gate.\n    if (!orgId) return next();\n\n    // A retry of a completed idempotent mutation is answered from the replay\n    // cache without running the handler — nothing to gate (one store read, only\n    // for requests that carry an Idempotency-Key).\n    if (await hasCompletedIdempotentResponse(req)) return next();\n\n    let quotaStatus: QuotaCheckResult;\n    try {\n      quotaStatus = await readCheck(quotaService, orgId, quotaType);\n    } catch (error) {\n      // Fail open — allow the request if quota service is unavailable\n      logger.warn('QUOTA_FAIL_OPEN: Quota check exception, allowing request', {\n        orgId,\n        quotaType,\n        error: errorMessage(error),\n      });\n      // Same counter the api-core quota client emits, so a quota-service outage\n      // is ALERTABLE from one series regardless of which layer fell open. Only\n      // a log line here meant every org was silently un-billed for the duration.\n      emitCounter('quota_fail_open_total', { operation: 'check', reason: 'exception', quotaType });\n      return next();\n    }\n\n    if (!quotaStatus.allowed) {\n      logger.warn(`${quotaType} quota exceeded`, {\n        orgId,\n        limit: quotaStatus.limit,\n        used: quotaStatus.used,\n      });\n\n      // Route through the shared helper so the check-gate 429 emits the same\n      // Retry-After + X-Quota-* headers and the same body (which quota, the\n      // reset date, the upgrade page) as the reserve-path 429.\n      sendQuotaExceeded(\n        res,\n        quotaType,\n        { type: quotaType, limit: quotaStatus.limit, used: quotaStatus.used, remaining: quotaStatus.remaining },\n        quotaStatus.resetAt,\n      );\n      return;\n    }\n\n    // Outside the try: a synchronous throw downstream must reach Express's error\n    // handling, not be mistaken for a quota-service failure and run next() twice.\n    next();\n  }, { kind: 'quota', mode: 'check', quotaType: baseQuotaType });\n}\n\n/** The service-local request path, without the query string. */\nexport function requestPath(req: Request): string {\n  return (req.originalUrl ?? req.url ?? '').split('?')[0] ?? '';\n}\n\n/**\n * The DEFERRED form of {@link checkQuota}: arms the check at mount time and lets\n * `requireAuth` run it once the caller is verified (api-core\n * `armDeferredQuotaCheck`). For a prefix mount ahead of routers that\n * authenticate per route — use {@link apiCallsQuota}, which pairs it with the\n * meter. Tagged as the check gate, so the route table records it.\n */\nexport function deferredCheckQuota(quotaService: QuotaService, quotaType: QuotaType): RequestHandler {\n  const check = checkQuota(quotaService, quotaType) as RequestHandler;\n  return tagRouteGate((_req: Request, res: Response, next: NextFunction): void => {\n    armDeferredQuotaCheck(res, check);\n    next();\n  }, { kind: 'quota', mode: 'check', quotaType });\n}\n"]}

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

@@ -60,6 +60,28 @@ export declare function createEnvRedisIdempotencyStore(): IdempotencyStore | nul
 export declare function setIdempotencyStore(store: IdempotencyStore): void;
 /** The current process-wide default store (in-memory unless overridden). */
 export declare function getIdempotencyStore(): IdempotencyStore;
+/**
+ * `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 declare const IDEMPOTENT_REPLAY_LOCAL = "idempotentReplay";
+/** True when `res` is a replay of a cached idempotent response. */
+export declare function isIdempotentReplay(res: Response): boolean;
+/**
+ * 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 declare function hasCompletedIdempotentResponse(req: Request): Promise<boolean>;
 export interface IdempotencyMiddlewareOptions {
     /** Custom store backend. Defaults to the process-wide store set via
      *  {@link setIdempotencyStore} (in-memory until `createApp` wires Redis). */