@pipeline-builder/api-core 3.4.89 → 3.4.90

package/lib/services/token-revocation.d.ts

@@ -20,6 +20,21 @@ export declare function tokenRevocationKey(userId: string): string;
  * outage degrades to the pre-existing behaviour rather than locking users out.
  */
 export declare function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore;
+/**
+ * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily
+ * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —
+ * for a stateless service that keeps NO Redis client of its own. The client is
+ * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via
+ * a guarded dynamic require so merely importing this never breaks a build/test
+ * where Redis isn't present.
+ *
+ * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,
+ * or any read failure all resolve to `null` ("no known revocation"), so a
+ * service degrades to natural token expiry rather than locking users out. A
+ * service opts in with a single boot line:
+ *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`
+ */
+export declare function createEnvRedisTokenRevocationStore(): TokenRevocationStore;
 /**
  * Publish a user's current `tokenVersion` so the stateless services see the
  * revocation immediately (platform side). Best-effort — never throws; a failure

package/lib/services/token-revocation.js

@@ -1,5 +1,6 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
+import { createRequire } from 'module';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('token-revocation');
 /**
@@ -46,6 +47,64 @@ export function createRedisTokenRevocationStore(redis) {
         },
     };
 }
+/**
+ * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily
+ * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —
+ * for a stateless service that keeps NO Redis client of its own. The client is
+ * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via
+ * a guarded dynamic require so merely importing this never breaks a build/test
+ * where Redis isn't present.
+ *
+ * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,
+ * or any read failure all resolve to `null` ("no known revocation"), so a
+ * service degrades to natural token expiry rather than locking users out. A
+ * service opts in with a single boot line:
+ *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`
+ */
+export function createEnvRedisTokenRevocationStore() {
+    // undefined = not yet attempted; null = attempted and unavailable (stay off).
+    let cached;
+    function build() {
+        try {
+            const url = process.env.REDIS_URL;
+            const host = process.env.REDIS_HOST;
+            if (!url && !host)
+                return null; // Redis not configured — no-op reader.
+            // Dynamic require: ioredis is a runtime-only optional dep, never a static
+            // import, so this module loads cleanly wherever Redis isn't present.
+            const req = createRequire(import.meta.url);
+            const mod = req('ioredis');
+            const RedisCtor = (mod.Redis ?? mod.default ?? mod);
+            const opts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };
+            const inst = url
+                ? new RedisCtor(url, opts)
+                : new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...opts });
+            // Swallow connection errors (ioredis auto-reconnects) so an unhandled
+            // 'error' can't crash the process; the reader stays fail-open meanwhile.
+            inst
+                .on('error', (e) => logger.warn('Redis revocation-reader client error', {
+                error: e instanceof Error ? e.message : String(e),
+            }));
+            logger.info('Redis token-revocation reader initialized');
+            return inst;
+        }
+        catch (err) {
+            logger.warn('Redis unavailable for revocation reader; falling back to token expiry', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    return {
+        async getCurrentVersion(userId) {
+            if (cached === undefined)
+                cached = build();
+            if (!cached)
+                return null;
+            return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);
+        },
+    };
+}
 /**
  * Publish a user's current `tokenVersion` so the stateless services see the
  * revocation immediately (platform side). Best-effort — never throws; a failure
@@ -71,4 +130,4 @@ export async function publishTokenRevocation(redis, userId, tokenVersion, ttlSec
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-revocation.js","sourceRoot":"","sources":["../../src/services/token-revocation.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'module';\nimport type { RedisCacheClient } from './cache-service.js';\nimport type { TokenRevocationStore } from '../middleware/auth.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('token-revocation');\n\n/**\n * Redis key namespace for the per-user current `tokenVersion`. The platform\n * PUBLISHES to this key on every privilege change; the stateless services READ\n * it in `requireAuth` (via {@link createRedisTokenRevocationStore}) to reject\n * tokens minted before that change. Publisher and readers MUST share this exact\n * prefix — hence both helpers live here, in one place.\n */\nexport const TOKEN_REVOCATION_KEY_PREFIX = 'authrev:tv:';\n\n/** The revocation key for a user id. */\nexport function tokenRevocationKey(userId: string): string {\n  return `${TOKEN_REVOCATION_KEY_PREFIX}${userId}`;\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client, for a stateless\n * service to register via `setTokenRevocationStore`. Reads the current\n * `tokenVersion` the platform published for the user.\n *\n * Fail-open by contract: a miss, a parse failure, or a Redis error all yield\n * `null` (— `requireAuth` treats that as \"no known revocation\"), so a Redis\n * outage degrades to the pre-existing behaviour rather than locking users out.\n */\nexport function createRedisTokenRevocationStore(redis: RedisCacheClient): TokenRevocationStore {\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      try {\n        const raw = await redis.get(tokenRevocationKey(userId));\n        if (raw === null || raw === undefined || raw.trim() === '') return null;\n        // Strict integer parse: `Number` (unlike `parseInt`) rejects trailing\n        // garbage (\"5abc\" → NaN), so a corrupted entry fails open (null → \"not\n        // revoked\") rather than being read as a bogus version. The empty-string\n        // guard above matters because `Number('')` is 0, not NaN.\n        const n = Number(raw);\n        return Number.isInteger(n) ? n : null;\n      } catch (err) {\n        logger.debug('Token-revocation read failed (fail-open)', {\n          userId, error: err instanceof Error ? err.message : String(err),\n        });\n        return null;\n      }\n    },\n  };\n}\n\n/**\n * Build a {@link TokenRevocationStore} backed by a Redis client that is lazily\n * constructed from the standard `REDIS_URL` or `REDIS_HOST`/`REDIS_PORT` env —\n * for a stateless service that keeps NO Redis client of its own. The client is\n * built on first `getCurrentVersion` call and memoized; `ioredis` is loaded via\n * a guarded dynamic require so merely importing this never breaks a build/test\n * where Redis isn't present.\n *\n * FULLY FAIL-OPEN: no env configured, an ioredis load failure, a connect error,\n * or any read failure all resolve to `null` (\"no known revocation\"), so a\n * service degrades to natural token expiry rather than locking users out. A\n * service opts in with a single boot line:\n *   `setTokenRevocationStore(createEnvRedisTokenRevocationStore());`\n */\nexport function createEnvRedisTokenRevocationStore(): TokenRevocationStore {\n  // undefined = not yet attempted; null = attempted and unavailable (stay off).\n  let cached: RedisCacheClient | null | undefined;\n\n  function build(): RedisCacheClient | null {\n    try {\n      const url = process.env.REDIS_URL;\n      const host = process.env.REDIS_HOST;\n      if (!url && !host) return null; // Redis not configured — no-op reader.\n      // Dynamic require: ioredis is a runtime-only optional dep, never a static\n      // import, so this module loads cleanly wherever Redis isn't present.\n      const req = createRequire(import.meta.url);\n      const mod = req('ioredis') as {\n        Redis?: new (...args: unknown[]) => unknown;\n        default?: new (...args: unknown[]) => unknown;\n      };\n      const RedisCtor = (mod.Redis ?? mod.default ?? mod) as new (...args: unknown[]) => RedisCacheClient;\n      const opts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };\n      const inst = url\n        ? new RedisCtor(url, opts)\n        : new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...opts });\n      // Swallow connection errors (ioredis auto-reconnects) so an unhandled\n      // 'error' can't crash the process; the reader stays fail-open meanwhile.\n      (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n        .on('error', (e) => logger.warn('Redis revocation-reader client error', {\n          error: e instanceof Error ? e.message : String(e),\n        }));\n      logger.info('Redis token-revocation reader initialized');\n      return inst;\n    } catch (err) {\n      logger.warn('Redis unavailable for revocation reader; falling back to token expiry', {\n        error: err instanceof Error ? err.message : String(err),\n      });\n      return null;\n    }\n  }\n\n  return {\n    async getCurrentVersion(userId: string): Promise<number | null> {\n      if (cached === undefined) cached = build();\n      if (!cached) return null;\n      return createRedisTokenRevocationStore(cached).getCurrentVersion(userId);\n    },\n  };\n}\n\n/**\n * Publish a user's current `tokenVersion` so the stateless services see the\n * revocation immediately (platform side). Best-effort — never throws; a failure\n * just means the services fall back to natural token expiry for this change.\n *\n * The key is written with a TTL equal to the access-token lifetime: any token\n * that could still carry an older version has expired by the time the entry\n * lapses, so an expired entry can never cause a false \"revoked\" nor a missed one.\n *\n * @param redis - the platform's Redis client\n * @param userId - the user whose sessions changed\n * @param tokenVersion - the user's NEW (post-increment) tokenVersion\n * @param ttlSeconds - access-token lifetime in seconds\n */\nexport async function publishTokenRevocation(\n  redis: RedisCacheClient,\n  userId: string,\n  tokenVersion: number,\n  ttlSeconds: number,\n): Promise<void> {\n  try {\n    // ioredis-style variadic SET with expiry: SET key val EX ttl.\n    await redis.set(tokenRevocationKey(userId), String(tokenVersion), 'EX', Math.max(1, Math.floor(ttlSeconds)));\n  } catch (err) {\n    logger.warn('Token-revocation publish failed (services fall back to token expiry)', {\n      userId, error: err instanceof Error ? err.message : String(err),\n    });\n  }\n}\n"]}

package/package.json

@@ -27,6 +27,7 @@
     "@aws-sdk/client-sts": "3.1089.0",
     "@aws-sdk/credential-providers": "3.1089.0",
     "express": "5.2.1",
+    "ioredis": "5.11.1",
     "jsonwebtoken": "9.0.3",
     "winston": "3.19.0",
     "zod": "4.4.3"
@@ -85,7 +86,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "3.4.89",
+  "version": "3.4.90",
   "bugs": {
     "url": "https://github.com/mwashburn160/pipeline-builder/issues"
   },