@pipeline-builder/api-server 4.1.19 → 4.1.21

package/lib/api/rate-limit-store.d.ts

@@ -8,8 +8,8 @@ import type { Store } from 'express-rate-limit';
  * exactly when an HPA has scaled out under load. Use a namespace unique to the
  * service AND limiter, so separate limiters never share a counter. Pair it with
  * `passOnStoreError: true`: a Redis outage then lets requests through instead of
- * failing them. A store whose scripts can't load at startup (Redis not yet
- * connected) is tolerated by express-rate-limit and reloads on first use.
+ * failing them. Script loading is deferred to the first request and retried on
+ * failure — see {@link withRetryingInit}.
  */
 export declare function createSharedRateLimitStore(namespace: string): Store | undefined;
 /** Test-only: forget the memoized client. */

package/lib/api/rate-limit-store.js

@@ -1,10 +1,84 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
-import { createEnvRedisClient, createLogger, safeCreateRequire } from '@pipeline-builder/api-core';
+import { createEnvRedisClient, createLogger, errorMessage, safeCreateRequire } from '@pipeline-builder/api-core';
 const logger = createLogger('rate-limit-store');
 /** One Redis connection for every rate limiter in the process.
  *  undefined = not built yet; null = Redis not configured. */
 let client;
+/**
+ * Run the wrapped store's `init` on FIRST USE rather than at route setup, and
+ * run it again if it fails.
+ *
+ * `rate-limit-redis` loads its two Lua scripts in `init` and keeps the in-flight
+ * `SCRIPT LOAD` promises on the instance (`incrementScriptSha`, `getScriptSha`),
+ * which every later `increment` awaits. express-rate-limit calls `init` exactly
+ * once, at route setup, does not await it, and never calls it again — its own
+ * contract says so. So ONE rejection there is memoized for the life of the
+ * process: every subsequent request re-awaits that same rejected promise and the
+ * limiter is silently off. The store's internal retry doesn't help, because it
+ * only re-loads on a `NOSCRIPT` reply.
+ *
+ * At boot that rejection is a live race, not a hypothetical. The env Redis
+ * client has no offline queue, and its readiness gate waits only
+ * `REQUEST_PATH_REDIS_READY_TIMEOUT_MS` before letting the command run against a
+ * socket that is still connecting — so on a slow start the `SCRIPT LOAD` is
+ * rejected with "Stream isn't writeable", and rate limiting never comes back.
+ *
+ * Both halves of the fix matter, and neither touches the connection's semantics
+ * (no offline queue, still fail-fast — a request must never hang behind a Redis
+ * outage). Deferring `init` to the first actual request removes the race, since
+ * a request arrives long after the connection settles. Re-running it on failure
+ * means no limiter can be left permanently off by one bad moment. A failure
+ * still propagates to express-rate-limit, which — paired with
+ * `passOnStoreError: true` — lets that one request through and logs it.
+ */
+function withRetryingInit(store, namespace) {
+    let initOptions;
+    let inflight = null;
+    let failed = false;
+    const initialized = () => {
+        // express-rate-limit always calls `init` before any other method; if some
+        // caller doesn't, pass straight through rather than inventing options.
+        if (initOptions === undefined)
+            return Promise.resolve();
+        if (!inflight) {
+            inflight = Promise.resolve(store.init?.(initOptions))
+                .then(() => {
+                // Worth a line: the failure below is loud, and an operator who saw it
+                // needs to know rate limiting is actually enforcing again.
+                if (failed)
+                    logger.info('Rate-limit store recovered — scripts loaded', { namespace });
+                failed = false;
+            })
+                .catch((error) => {
+                // Forget the failure so the NEXT request builds fresh script promises
+                // instead of re-awaiting this rejected one forever.
+                inflight = null;
+                failed = true;
+                logger.warn('Rate-limit store init failed — requests pass unlimited until it succeeds', {
+                    namespace, error: errorMessage(error),
+                });
+                throw error;
+            });
+        }
+        return inflight;
+    };
+    // Exactly `RedisStore`'s surface, which is all this ever wraps. It has no
+    // `resetAll`, `shutdown` or `localKeys`, and express-rate-limit reads the
+    // PRESENCE of those as "the store supports it" — so forwarding them
+    // defensively would advertise capabilities that don't exist. Omitting
+    // `localKeys` is also the correct answer for a Redis store: keys are shared
+    // across replicas, which is the whole point.
+    return {
+        // Captured, not forwarded — the real init runs from `initialized()`.
+        init: (options) => { initOptions = options; },
+        get: async (key) => { await initialized(); return store.get?.(key); },
+        increment: async (key) => { await initialized(); return store.increment(key); },
+        decrement: async (key) => { await initialized(); return store.decrement(key); },
+        resetKey: async (key) => { await initialized(); return store.resetKey(key); },
+        prefix: store.prefix,
+    };
+}
 /**
  * A cross-replica rate-limit store under `rl:<namespace>:`, or `undefined` when
  * Redis isn't configured (express-rate-limit then uses its per-process memory
@@ -14,8 +88,8 @@ let client;
  * exactly when an HPA has scaled out under load. Use a namespace unique to the
  * service AND limiter, so separate limiters never share a counter. Pair it with
  * `passOnStoreError: true`: a Redis outage then lets requests through instead of
- * failing them. A store whose scripts can't load at startup (Redis not yet
- * connected) is tolerated by express-rate-limit and reloads on first use.
+ * failing them. Script loading is deferred to the first request and retried on
+ * failure — see {@link withRetryingInit}.
  */
 export function createSharedRateLimitStore(namespace) {
     if (client === undefined)
@@ -27,13 +101,13 @@ export function createSharedRateLimitStore(namespace) {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { RedisStore } = require('rate-limit-redis');
     logger.debug('Shared rate-limit store created', { namespace });
-    return new RedisStore({
+    return withRetryingInit(new RedisStore({
         prefix: `rl:${namespace}:`,
         sendCommand: (...args) => redis.call(...args),
-    });
+    }), namespace);
 }
 /** Test-only: forget the memoized client. */
 export function __resetSharedRateLimitStoreForTests() {
     client = undefined;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rate-limit-store.js","sourceRoot":"","sources":["../../src/api/rate-limit-store.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createEnvRedisClient, createLogger, errorMessage, safeCreateRequire } from '@pipeline-builder/api-core';\nimport type { Store } from 'express-rate-limit';\n\nconst logger = createLogger('rate-limit-store');\n\ntype CommandClient = { call: (...args: string[]) => Promise<unknown> };\n\n/** The options express-rate-limit hands to `Store.init`. */\ntype StoreInitOptions = Parameters<NonNullable<Store['init']>>[0];\n\n/** One Redis connection for every rate limiter in the process.\n *  undefined = not built yet; null = Redis not configured. */\nlet client: CommandClient | null | undefined;\n\n/**\n * Run the wrapped store's `init` on FIRST USE rather than at route setup, and\n * run it again if it fails.\n *\n * `rate-limit-redis` loads its two Lua scripts in `init` and keeps the in-flight\n * `SCRIPT LOAD` promises on the instance (`incrementScriptSha`, `getScriptSha`),\n * which every later `increment` awaits. express-rate-limit calls `init` exactly\n * once, at route setup, does not await it, and never calls it again — its own\n * contract says so. So ONE rejection there is memoized for the life of the\n * process: every subsequent request re-awaits that same rejected promise and the\n * limiter is silently off. The store's internal retry doesn't help, because it\n * only re-loads on a `NOSCRIPT` reply.\n *\n * At boot that rejection is a live race, not a hypothetical. The env Redis\n * client has no offline queue, and its readiness gate waits only\n * `REQUEST_PATH_REDIS_READY_TIMEOUT_MS` before letting the command run against a\n * socket that is still connecting — so on a slow start the `SCRIPT LOAD` is\n * rejected with \"Stream isn't writeable\", and rate limiting never comes back.\n *\n * Both halves of the fix matter, and neither touches the connection's semantics\n * (no offline queue, still fail-fast — a request must never hang behind a Redis\n * outage). Deferring `init` to the first actual request removes the race, since\n * a request arrives long after the connection settles. Re-running it on failure\n * means no limiter can be left permanently off by one bad moment. A failure\n * still propagates to express-rate-limit, which — paired with\n * `passOnStoreError: true` — lets that one request through and logs it.\n */\nfunction withRetryingInit(store: Store, namespace: string): Store {\n  let initOptions: StoreInitOptions | undefined;\n  let inflight: Promise<void> | null = null;\n  let failed = false;\n\n  const initialized = (): Promise<void> => {\n    // express-rate-limit always calls `init` before any other method; if some\n    // caller doesn't, pass straight through rather than inventing options.\n    if (initOptions === undefined) return Promise.resolve();\n    if (!inflight) {\n      inflight = Promise.resolve(store.init?.(initOptions))\n        .then(() => {\n          // Worth a line: the failure below is loud, and an operator who saw it\n          // needs to know rate limiting is actually enforcing again.\n          if (failed) logger.info('Rate-limit store recovered — scripts loaded', { namespace });\n          failed = false;\n        })\n        .catch((error: unknown) => {\n          // Forget the failure so the NEXT request builds fresh script promises\n          // instead of re-awaiting this rejected one forever.\n          inflight = null;\n          failed = true;\n          logger.warn('Rate-limit store init failed — requests pass unlimited until it succeeds', {\n            namespace, error: errorMessage(error),\n          });\n          throw error;\n        });\n    }\n    return inflight;\n  };\n\n  // Exactly `RedisStore`'s surface, which is all this ever wraps. It has no\n  // `resetAll`, `shutdown` or `localKeys`, and express-rate-limit reads the\n  // PRESENCE of those as \"the store supports it\" — so forwarding them\n  // defensively would advertise capabilities that don't exist. Omitting\n  // `localKeys` is also the correct answer for a Redis store: keys are shared\n  // across replicas, which is the whole point.\n  return {\n    // Captured, not forwarded — the real init runs from `initialized()`.\n    init: (options) => { initOptions = options; },\n    get: async (key) => { await initialized(); return store.get?.(key); },\n    increment: async (key) => { await initialized(); return store.increment(key); },\n    decrement: async (key) => { await initialized(); return store.decrement(key); },\n    resetKey: async (key) => { await initialized(); return store.resetKey(key); },\n    prefix: store.prefix,\n  };\n}\n\n/**\n * A cross-replica rate-limit store under `rl:<namespace>:`, or `undefined` when\n * Redis isn't configured (express-rate-limit then uses its per-process memory\n * store, which is right for a single replica).\n *\n * Without a shared store every limit is really `max × replicas`, and weakest\n * exactly when an HPA has scaled out under load. Use a namespace unique to the\n * service AND limiter, so separate limiters never share a counter. Pair it with\n * `passOnStoreError: true`: a Redis outage then lets requests through instead of\n * failing them. Script loading is deferred to the first request and retried on\n * failure — see {@link withRetryingInit}.\n */\nexport function createSharedRateLimitStore(namespace: string): Store | undefined {\n  if (client === undefined) client = createEnvRedisClient<CommandClient>('rate-limit');\n  if (!client) return undefined;\n  const redis = client;\n  const require = safeCreateRequire(import.meta.url);\n  // eslint-disable-next-line @typescript-eslint/no-require-imports\n  const { RedisStore } = require('rate-limit-redis') as { RedisStore: new (o: unknown) => Store };\n  logger.debug('Shared rate-limit store created', { namespace });\n  return withRetryingInit(new RedisStore({\n    prefix: `rl:${namespace}:`,\n    sendCommand: (...args: string[]) => redis.call(...args),\n  }), namespace);\n}\n\n/** Test-only: forget the memoized client. */\nexport function __resetSharedRateLimitStoreForTests(): void {\n  client = undefined;\n}\n"]}

package/package.json

@@ -50,9 +50,9 @@
     "swagger-ui-express": "5.0.1",
     "unified": "11.0.5",
     "uuid": "14.0.2",
-    "@pipeline-builder/pipeline-core": "4.1.19",
-    "@pipeline-builder/pipeline-data": "4.1.19",
-    "@pipeline-builder/api-core": "4.1.17"
+    "@pipeline-builder/api-core": "4.1.19",
+    "@pipeline-builder/pipeline-data": "4.1.21",
+    "@pipeline-builder/pipeline-core": "4.1.21"
   },
   "keywords": [
     "ci-cd",
@@ -108,7 +108,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "4.1.19",
+  "version": "4.1.21",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },