@pipeline-builder/api-core 4.1.1 → 4.1.3

package/lib/services/env-redis.d.ts

@@ -1,44 +1,96 @@
 /**
- * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis
- * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a
- * missing port defaults to the Sentinel default 26379. Returns an empty array
- * when the env is unset/empty (→ non-sentinel mode).
+ * The ONE place Redis connection settings are read from the environment.
+ *
+ * Two shapes, exactly one of which may be set:
+ *
+ * - **Standalone** — `REDIS_URL` (`redis://host:6379[/db]`, or `rediss://` for
+ *   TLS). Credentials may sit in the URL or in `REDIS_PASSWORD`.
+ * - **HA (Sentinel)** — `REDIS_SENTINELS` (comma-separated `host:port`) plus
+ *   `REDIS_SENTINEL_MASTER` (default `mymaster`) and optional
+ *   `REDIS_SENTINEL_PASSWORD`. `REDIS_PASSWORD` authenticates to the data nodes.
+ *   ioredis follows the master across a failover.
+ *
+ * Neither set → Redis is off, and each caller degrades to its documented
+ * no-Redis behavior.
+ *
+ * `REDIS_HOST` / `REDIS_PORT` are not read. `REDIS_HOST` is refused outright so a
+ * stale config fails at startup instead of silently running without Redis.
+ * `REDIS_PORT` can't be refused: Kubernetes injects `REDIS_PORT=tcp://<ip>:6379`
+ * into every pod in a namespace with a Service named `redis`, which is exactly
+ * why a host/port pair was unsafe to parse.
+ *
+ * Misconfiguration throws {@link RedisConfigError}. Writers and readers of the
+ * same keys (revocation, step-up, leader locks) must resolve Redis identically;
+ * a config that quietly resolved to "no Redis" on one side is how revocation
+ * once did nothing at all.
+ */
+/** Thrown for a Redis environment that can't be used as written. */
+export declare class RedisConfigError extends Error {
+    constructor(message: string);
+}
+/** Resolved connection, independent of any client library. */
+export type RedisConnection = {
+    mode: 'sentinel';
+    sentinels: Array<{
+        host: string;
+        port: number;
+    }>;
+    masterName: string;
+    password?: string;
+    sentinelPassword?: string;
+} | {
+    mode: 'url';
+    url: string;
+    password?: string;
+};
+/**
+ * Parse `REDIS_SENTINELS` into `{ host, port }[]`. Blank entries are skipped and
+ * a missing port means the Sentinel default 26379; a port that isn't a valid
+ * TCP port is a configuration error.
  */
 export declare function parseSentinels(raw: string | undefined): Array<{
     host: string;
     port: number;
 }>;
 /**
- * Construct an ioredis client from the standard `REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via
- * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was
- * previously duplicated across the leader-lock, audit-spool, and
- * token-revocation env factories.
- *
- * Connection modes (first that matches wins):
- * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis
- *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,
- *    default `mymaster`) and transparently reconnects to the new master after a
- *    failover. This is how the app gets HA against a single-node Redis loss —
- *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.
- * 2. URL — `REDIS_URL`.
- * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).
- *
- * Semantics every caller relies on (kept identical across the consolidation):
- * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades
- *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
- * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns
- *   `null` — Redis being unavailable must never crash the importing service.
- * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this
- *   module stays importable in CJS bundles and where Redis isn't installed.
- * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast
- *   rather than queueing during an outage (callers are fail-open/best-effort).
- * - An `error` listener is attached (ioredis auto-reconnects) so a dropped
- *   connection can't surface as an unhandled `'error'` event that crashes Node.
+ * Resolve the Redis connection from `env`, or `null` when Redis isn't
+ * configured. Throws {@link RedisConfigError} for an unusable configuration.
+ */
+export declare function resolveRedisConnection(env?: NodeJS.ProcessEnv): RedisConnection | null;
+/** A log-safe description of a connection (never includes credentials). */
+export declare function describeRedisConnection(conn: RedisConnection): Record<string, unknown>;
+/**
+ * Construct an ioredis client for a resolved connection. `options` are merged
+ * into the client options (e.g. `{ db, maxRetriesPerRequest: null }` for BullMQ).
+ * An `error` listener is always attached so a dropped connection is logged
+ * rather than surfacing as an unhandled `'error'` event that crashes Node.
+ */
+export declare function createRedisClient<T = unknown>(conn: RedisConnection, label: string, options?: Record<string, unknown>): T;
+/**
+ * The shared application Redis client: `null` when Redis isn't configured, so
+ * the caller degrades to its no-Redis behavior.
  *
- * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`
- * (sentinel AUTH, sentinel mode only) are threaded through when set.
+ * Commands fail fast (`maxRetriesPerRequest: 1`, no offline queue) because the
+ * request-path callers are best-effort or fail closed on their own terms — a
+ * request must not hang behind a Redis outage. That includes the moments before
+ * the first connection completes: a background caller that runs at startup must
+ * either tolerate a rejected command or wait with {@link whenRedisReady}.
  *
- * @param label short human name for this client, used in the two warn logs.
+ * Throws {@link RedisConfigError} for a bad configuration, and if Redis is
+ * configured but `ioredis` can't be loaded — both are deployment errors that
+ * must not quietly turn Redis-backed guarantees off.
  */
 export declare function createEnvRedisClient<T = unknown>(label: string): T | null;
+/** The subset of ioredis needed to wait for a connection. */
+export interface ReadyAwareRedis {
+    status?: string;
+    once?(event: string, cb: (...args: unknown[]) => void): unknown;
+    off?(event: string, cb: (...args: unknown[]) => void): unknown;
+}
+/**
+ * Resolve once `client` is connected and ready for commands, or reject after
+ * `timeoutMs`. For startup work (creating a consumer group, subscribing) that
+ * otherwise races the first connection. A client without ioredis' `status`
+ * (e.g. a test double) counts as ready.
+ */
+export declare function whenRedisReady(client: ReadyAwareRedis, timeoutMs?: number): Promise<void>;

package/lib/services/env-redis.js

@@ -4,91 +4,171 @@ import { createRequire } from 'module';
 import { createLogger } from '../utils/logger.js';
 const logger = createLogger('env-redis');
 /**
- * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis
- * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a
- * missing port defaults to the Sentinel default 26379. Returns an empty array
- * when the env is unset/empty (→ non-sentinel mode).
+ * The ONE place Redis connection settings are read from the environment.
+ *
+ * Two shapes, exactly one of which may be set:
+ *
+ * - **Standalone** — `REDIS_URL` (`redis://host:6379[/db]`, or `rediss://` for
+ *   TLS). Credentials may sit in the URL or in `REDIS_PASSWORD`.
+ * - **HA (Sentinel)** — `REDIS_SENTINELS` (comma-separated `host:port`) plus
+ *   `REDIS_SENTINEL_MASTER` (default `mymaster`) and optional
+ *   `REDIS_SENTINEL_PASSWORD`. `REDIS_PASSWORD` authenticates to the data nodes.
+ *   ioredis follows the master across a failover.
+ *
+ * Neither set → Redis is off, and each caller degrades to its documented
+ * no-Redis behavior.
+ *
+ * `REDIS_HOST` / `REDIS_PORT` are not read. `REDIS_HOST` is refused outright so a
+ * stale config fails at startup instead of silently running without Redis.
+ * `REDIS_PORT` can't be refused: Kubernetes injects `REDIS_PORT=tcp://<ip>:6379`
+ * into every pod in a namespace with a Service named `redis`, which is exactly
+ * why a host/port pair was unsafe to parse.
+ *
+ * Misconfiguration throws {@link RedisConfigError}. Writers and readers of the
+ * same keys (revocation, step-up, leader locks) must resolve Redis identically;
+ * a config that quietly resolved to "no Redis" on one side is how revocation
+ * once did nothing at all.
+ */
+/** Thrown for a Redis environment that can't be used as written. */
+export class RedisConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RedisConfigError';
+    }
+}
+/**
+ * Parse `REDIS_SENTINELS` into `{ host, port }[]`. Blank entries are skipped and
+ * a missing port means the Sentinel default 26379; a port that isn't a valid
+ * TCP port is a configuration error.
  */
 export function parseSentinels(raw) {
     if (!raw)
         return [];
     return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {
-        const [host, port] = entry.split(':');
-        return { host, port: parseInt(port ?? '26379', 10) || 26379 };
-    }).filter((s) => !!s.host);
+        const idx = entry.lastIndexOf(':');
+        const host = idx === -1 ? entry : entry.slice(0, idx);
+        const portText = idx === -1 ? '' : entry.slice(idx + 1);
+        const port = portText === '' ? 26379 : Number(portText);
+        if (!host || !Number.isInteger(port) || port < 1 || port > 65535) {
+            throw new RedisConfigError(`REDIS_SENTINELS entry "${entry}" is not host:port`);
+        }
+        return { host, port };
+    });
 }
 /**
- * Construct an ioredis client from the standard `REDIS_URL` or
- * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via
- * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was
- * previously duplicated across the leader-lock, audit-spool, and
- * token-revocation env factories.
- *
- * Connection modes (first that matches wins):
- * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis
- *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,
- *    default `mymaster`) and transparently reconnects to the new master after a
- *    failover. This is how the app gets HA against a single-node Redis loss —
- *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.
- * 2. URL — `REDIS_URL`.
- * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).
- *
- * Semantics every caller relies on (kept identical across the consolidation):
- * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades
- *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).
- * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns
- *   `null` — Redis being unavailable must never crash the importing service.
- * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this
- *   module stays importable in CJS bundles and where Redis isn't installed.
- * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast
- *   rather than queueing during an outage (callers are fail-open/best-effort).
- * - An `error` listener is attached (ioredis auto-reconnects) so a dropped
- *   connection can't surface as an unhandled `'error'` event that crashes Node.
- *
- * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`
- * (sentinel AUTH, sentinel mode only) are threaded through when set.
- *
- * @param label short human name for this client, used in the two warn logs.
+ * Resolve the Redis connection from `env`, or `null` when Redis isn't
+ * configured. Throws {@link RedisConfigError} for an unusable configuration.
  */
-export function createEnvRedisClient(label) {
-    try {
-        const sentinels = parseSentinels(process.env.REDIS_SENTINELS);
-        const url = process.env.REDIS_URL;
-        const host = process.env.REDIS_HOST;
-        if (sentinels.length === 0 && !url && !host)
-            return null;
-        const req = createRequire(import.meta.url);
-        const mod = req('ioredis');
-        const RedisCtor = (mod.Redis ?? mod.default ?? mod);
-        const redisOpts = { maxRetriesPerRequest: 1, enableOfflineQueue: false };
-        if (process.env.REDIS_PASSWORD)
-            redisOpts.password = process.env.REDIS_PASSWORD;
-        let inst;
-        if (sentinels.length > 0) {
-            // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.
-            const sentinelOpts = {
-                sentinels,
-                name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',
-                ...redisOpts,
-            };
-            if (process.env.REDIS_SENTINEL_PASSWORD)
-                sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;
-            inst = new RedisCtor(sentinelOpts);
-            logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });
+export function resolveRedisConnection(env = process.env) {
+    if (env.REDIS_HOST) {
+        throw new RedisConfigError('REDIS_HOST is not supported. Set REDIS_URL=redis://<host>:<port> (or REDIS_SENTINELS for HA) and remove REDIS_HOST/REDIS_PORT.');
+    }
+    const sentinels = parseSentinels(env.REDIS_SENTINELS);
+    const url = env.REDIS_URL?.trim();
+    const password = env.REDIS_PASSWORD || undefined;
+    if (sentinels.length > 0 && url) {
+        throw new RedisConfigError('Set REDIS_URL or REDIS_SENTINELS, not both.');
+    }
+    if (sentinels.length > 0) {
+        return {
+            mode: 'sentinel',
+            sentinels,
+            masterName: env.REDIS_SENTINEL_MASTER || 'mymaster',
+            password,
+            sentinelPassword: env.REDIS_SENTINEL_PASSWORD || undefined,
+        };
+    }
+    if (url) {
+        let parsed;
+        try {
+            parsed = new URL(url);
         }
-        else if (url) {
-            inst = new RedisCtor(url, redisOpts);
+        catch {
+            throw new RedisConfigError('REDIS_URL is not a valid URL (expected redis://<host>:<port>).');
         }
-        else {
-            inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });
+        if (parsed.protocol !== 'redis:' && parsed.protocol !== 'rediss:') {
+            throw new RedisConfigError(`REDIS_URL must use redis:// or rediss://, got ${parsed.protocol}//`);
         }
-        inst
-            .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));
-        return inst;
+        if (!parsed.hostname)
+            throw new RedisConfigError('REDIS_URL has no host.');
+        return { mode: 'url', url, password };
     }
-    catch (err) {
-        logger.warn(`Redis unavailable for ${label}`, { error: err instanceof Error ? err.message : String(err) });
-        return null;
+    return null;
+}
+/** A log-safe description of a connection (never includes credentials). */
+export function describeRedisConnection(conn) {
+    if (conn.mode === 'sentinel') {
+        return { mode: 'sentinel', master: conn.masterName, sentinels: conn.sentinels.length };
     }
+    const u = new URL(conn.url);
+    return { mode: 'url', host: u.hostname, port: u.port || '6379', tls: u.protocol === 'rediss:' };
+}
+function loadIoredis() {
+    const req = createRequire(import.meta.url);
+    const mod = req('ioredis');
+    return (mod.Redis ?? mod.default ?? mod);
+}
+/**
+ * Construct an ioredis client for a resolved connection. `options` are merged
+ * into the client options (e.g. `{ db, maxRetriesPerRequest: null }` for BullMQ).
+ * An `error` listener is always attached so a dropped connection is logged
+ * rather than surfacing as an unhandled `'error'` event that crashes Node.
+ */
+export function createRedisClient(conn, label, options = {}) {
+    const Ctor = loadIoredis();
+    const auth = conn.password ? { password: conn.password } : {};
+    const inst = conn.mode === 'sentinel'
+        ? new Ctor({
+            sentinels: conn.sentinels,
+            name: conn.masterName,
+            ...(conn.sentinelPassword ? { sentinelPassword: conn.sentinelPassword } : {}),
+            ...auth,
+            ...options,
+        })
+        : new Ctor(conn.url, { ...auth, ...options });
+    inst
+        .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));
+    return inst;
+}
+/**
+ * The shared application Redis client: `null` when Redis isn't configured, so
+ * the caller degrades to its no-Redis behavior.
+ *
+ * Commands fail fast (`maxRetriesPerRequest: 1`, no offline queue) because the
+ * request-path callers are best-effort or fail closed on their own terms — a
+ * request must not hang behind a Redis outage. That includes the moments before
+ * the first connection completes: a background caller that runs at startup must
+ * either tolerate a rejected command or wait with {@link whenRedisReady}.
+ *
+ * Throws {@link RedisConfigError} for a bad configuration, and if Redis is
+ * configured but `ioredis` can't be loaded — both are deployment errors that
+ * must not quietly turn Redis-backed guarantees off.
+ */
+export function createEnvRedisClient(label) {
+    const conn = resolveRedisConnection();
+    if (!conn)
+        return null;
+    const inst = createRedisClient(conn, label, { maxRetriesPerRequest: 1, enableOfflineQueue: false });
+    logger.info(`Redis ${label} client created`, describeRedisConnection(conn));
+    return inst;
+}
+/**
+ * Resolve once `client` is connected and ready for commands, or reject after
+ * `timeoutMs`. For startup work (creating a consumer group, subscribing) that
+ * otherwise races the first connection. A client without ioredis' `status`
+ * (e.g. a test double) counts as ready.
+ */
+export function whenRedisReady(client, timeoutMs = 30_000) {
+    if (client.status === undefined || client.status === 'ready' || !client.once)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const onReady = () => { clearTimeout(timer); resolve(); };
+        const timer = setTimeout(() => {
+            client.off?.('ready', onReady);
+            reject(new Error(`Redis not ready after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        client.once('ready', onReady);
+    });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env-redis.js","sourceRoot":"","sources":["../../src/services/env-redis.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,MAAM,GAAG,YAAY,CAAC,WAAW,CAAC,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,GAAuB;IACpD,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IACpB,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACvE,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,OAAO,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;IAChE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,oBAAoB,CAAc,KAAa;IAC7D,IAAI,CAAC;QACH,MAAM,SAAS,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC9D,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;QAClC,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;QACpC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QACzD,MAAM,GAAG,GAAG,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,GAAG,GAAG,GAAG,CAAC,SAAS,CAGxB,CAAC;QACF,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,CAAkC,CAAC;QACrF,MAAM,SAAS,GAA4B,EAAE,oBAAoB,EAAE,CAAC,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;QAClG,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc;YAAE,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC;QAEhF,IAAI,IAAO,CAAC;QACZ,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,gFAAgF;YAChF,MAAM,YAAY,GAA4B;gBAC5C,SAAS;gBACT,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,UAAU;gBACrD,GAAG,SAAS;aACb,CAAC;YACF,IAAI,OAAO,CAAC,GAAG,CAAC,uBAAuB;gBAAE,YAAY,CAAC,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC;YAC7G,IAAI,GAAG,IAAI,SAAS,CAAC,YAAY,CAAC,CAAC;YACnC,MAAM,CAAC,IAAI,CAAC,SAAS,KAAK,iBAAiB,EAAE,EAAE,MAAM,EAAE,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;QAC3G,CAAC;aAAM,IAAI,GAAG,EAAE,CAAC;YACf,IAAI,GAAG,IAAI,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QACvC,CAAC;aAAM,CAAC;YACN,IAAI,GAAG,IAAI,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,MAAM,EAAE,EAAE,CAAC,EAAE,GAAG,SAAS,EAAE,CAAC,CAAC;QACrG,CAAC;QACA,IAA2E;aACzE,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,KAAK,eAAe,EAAE,EAAE,KAAK,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACzH,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,yBAAyB,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC3G,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { createRequire } from 'module';\n\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('env-redis');\n\n/**\n * Parse `REDIS_SENTINELS` (comma-separated `host:port` list) into the ioredis\n * `{ host, port }[]` sentinel array. Blank/garbage entries are skipped; a\n * missing port defaults to the Sentinel default 26379. Returns an empty array\n * when the env is unset/empty (→ non-sentinel mode).\n */\nexport function parseSentinels(raw: string | undefined): Array<{ host: string; port: number }> {\n  if (!raw) return [];\n  return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {\n    const [host, port] = entry.split(':');\n    return { host, port: parseInt(port ?? '26379', 10) || 26379 };\n  }).filter((s) => !!s.host);\n}\n\n/**\n * Construct an ioredis client from the standard `REDIS_URL` or\n * `REDIS_HOST`/`REDIS_PORT` env — OR, for HA, from Redis Sentinel via\n * `REDIS_SENTINELS` + `REDIS_SENTINEL_MASTER`. The shared construction was\n * previously duplicated across the leader-lock, audit-spool, and\n * token-revocation env factories.\n *\n * Connection modes (first that matches wins):\n * 1. SENTINEL — `REDIS_SENTINELS` set (comma-separated `host:port`): ioredis\n *    resolves the current master from the sentinels (`name` = `REDIS_SENTINEL_MASTER`,\n *    default `mymaster`) and transparently reconnects to the new master after a\n *    failover. This is how the app gets HA against a single-node Redis loss —\n *    also the shape a managed ElastiCache (cluster-mode-disabled) speaks.\n * 2. URL — `REDIS_URL`.\n * 3. HOST/PORT — `REDIS_HOST`(+`REDIS_PORT`).\n *\n * Semantics every caller relies on (kept identical across the consolidation):\n * - Returns `null` when NONE of sentinels/url/host is set, so a caller degrades\n *   to its no-Redis fallback (run-on-every-pod / best-effort / fail-open).\n * - FAIL-SAFE: any ioredis load or construction error is swallowed and returns\n *   `null` — Redis being unavailable must never crash the importing service.\n * - `ioredis` is a runtime-only optional dep loaded via `createRequire`, so this\n *   module stays importable in CJS bundles and where Redis isn't installed.\n * - `maxRetriesPerRequest: 1` + `enableOfflineQueue: false`: commands fail fast\n *   rather than queueing during an outage (callers are fail-open/best-effort).\n * - An `error` listener is attached (ioredis auto-reconnects) so a dropped\n *   connection can't surface as an unhandled `'error'` event that crashes Node.\n *\n * Optional auth: `REDIS_PASSWORD` (data-node AUTH) and `REDIS_SENTINEL_PASSWORD`\n * (sentinel AUTH, sentinel mode only) are threaded through when set.\n *\n * @param label short human name for this client, used in the two warn logs.\n */\nexport function createEnvRedisClient<T = unknown>(label: string): T | null {\n  try {\n    const sentinels = parseSentinels(process.env.REDIS_SENTINELS);\n    const url = process.env.REDIS_URL;\n    const host = process.env.REDIS_HOST;\n    if (sentinels.length === 0 && !url && !host) return null;\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[]) => T;\n    const redisOpts: Record<string, unknown> = { maxRetriesPerRequest: 1, enableOfflineQueue: false };\n    if (process.env.REDIS_PASSWORD) redisOpts.password = process.env.REDIS_PASSWORD;\n\n    let inst: T;\n    if (sentinels.length > 0) {\n      // Sentinel mode: ioredis tracks the master via the sentinels + auto-fails-over.\n      const sentinelOpts: Record<string, unknown> = {\n        sentinels,\n        name: process.env.REDIS_SENTINEL_MASTER || 'mymaster',\n        ...redisOpts,\n      };\n      if (process.env.REDIS_SENTINEL_PASSWORD) sentinelOpts.sentinelPassword = process.env.REDIS_SENTINEL_PASSWORD;\n      inst = new RedisCtor(sentinelOpts);\n      logger.info(`Redis ${label}: Sentinel mode`, { master: sentinelOpts.name, sentinels: sentinels.length });\n    } else if (url) {\n      inst = new RedisCtor(url, redisOpts);\n    } else {\n      inst = new RedisCtor({ host, port: parseInt(process.env.REDIS_PORT ?? '6379', 10), ...redisOpts });\n    }\n    (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n      .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));\n    return inst;\n  } catch (err) {\n    logger.warn(`Redis unavailable for ${label}`, { error: err instanceof Error ? err.message : String(err) });\n    return null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env-redis.js","sourceRoot":"","sources":["../../src/services/env-redis.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';\n\nimport { createLogger } from '../utils/logger.js';\n\nconst logger = createLogger('env-redis');\n\n/**\n * The ONE place Redis connection settings are read from the environment.\n *\n * Two shapes, exactly one of which may be set:\n *\n * - **Standalone** — `REDIS_URL` (`redis://host:6379[/db]`, or `rediss://` for\n *   TLS). Credentials may sit in the URL or in `REDIS_PASSWORD`.\n * - **HA (Sentinel)** — `REDIS_SENTINELS` (comma-separated `host:port`) plus\n *   `REDIS_SENTINEL_MASTER` (default `mymaster`) and optional\n *   `REDIS_SENTINEL_PASSWORD`. `REDIS_PASSWORD` authenticates to the data nodes.\n *   ioredis follows the master across a failover.\n *\n * Neither set → Redis is off, and each caller degrades to its documented\n * no-Redis behavior.\n *\n * `REDIS_HOST` / `REDIS_PORT` are not read. `REDIS_HOST` is refused outright so a\n * stale config fails at startup instead of silently running without Redis.\n * `REDIS_PORT` can't be refused: Kubernetes injects `REDIS_PORT=tcp://<ip>:6379`\n * into every pod in a namespace with a Service named `redis`, which is exactly\n * why a host/port pair was unsafe to parse.\n *\n * Misconfiguration throws {@link RedisConfigError}. Writers and readers of the\n * same keys (revocation, step-up, leader locks) must resolve Redis identically;\n * a config that quietly resolved to \"no Redis\" on one side is how revocation\n * once did nothing at all.\n */\n\n/** Thrown for a Redis environment that can't be used as written. */\nexport class RedisConfigError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'RedisConfigError';\n  }\n}\n\n/** Resolved connection, independent of any client library. */\nexport type RedisConnection =\n  | {\n    mode: 'sentinel';\n    sentinels: Array<{ host: string; port: number }>;\n    masterName: string;\n    password?: string;\n    sentinelPassword?: string;\n  }\n  | {\n    mode: 'url';\n    url: string;\n    password?: string;\n  };\n\n/**\n * Parse `REDIS_SENTINELS` into `{ host, port }[]`. Blank entries are skipped and\n * a missing port means the Sentinel default 26379; a port that isn't a valid\n * TCP port is a configuration error.\n */\nexport function parseSentinels(raw: string | undefined): Array<{ host: string; port: number }> {\n  if (!raw) return [];\n  return raw.split(',').map((s) => s.trim()).filter(Boolean).map((entry) => {\n    const idx = entry.lastIndexOf(':');\n    const host = idx === -1 ? entry : entry.slice(0, idx);\n    const portText = idx === -1 ? '' : entry.slice(idx + 1);\n    const port = portText === '' ? 26379 : Number(portText);\n    if (!host || !Number.isInteger(port) || port < 1 || port > 65535) {\n      throw new RedisConfigError(`REDIS_SENTINELS entry \"${entry}\" is not host:port`);\n    }\n    return { host, port };\n  });\n}\n\n/**\n * Resolve the Redis connection from `env`, or `null` when Redis isn't\n * configured. Throws {@link RedisConfigError} for an unusable configuration.\n */\nexport function resolveRedisConnection(env: NodeJS.ProcessEnv = process.env): RedisConnection | null {\n  if (env.REDIS_HOST) {\n    throw new RedisConfigError(\n      'REDIS_HOST is not supported. Set REDIS_URL=redis://<host>:<port> (or REDIS_SENTINELS for HA) and remove REDIS_HOST/REDIS_PORT.',\n    );\n  }\n\n  const sentinels = parseSentinels(env.REDIS_SENTINELS);\n  const url = env.REDIS_URL?.trim();\n  const password = env.REDIS_PASSWORD || undefined;\n\n  if (sentinels.length > 0 && url) {\n    throw new RedisConfigError('Set REDIS_URL or REDIS_SENTINELS, not both.');\n  }\n\n  if (sentinels.length > 0) {\n    return {\n      mode: 'sentinel',\n      sentinels,\n      masterName: env.REDIS_SENTINEL_MASTER || 'mymaster',\n      password,\n      sentinelPassword: env.REDIS_SENTINEL_PASSWORD || undefined,\n    };\n  }\n\n  if (url) {\n    let parsed: URL;\n    try {\n      parsed = new URL(url);\n    } catch {\n      throw new RedisConfigError('REDIS_URL is not a valid URL (expected redis://<host>:<port>).');\n    }\n    if (parsed.protocol !== 'redis:' && parsed.protocol !== 'rediss:') {\n      throw new RedisConfigError(`REDIS_URL must use redis:// or rediss://, got ${parsed.protocol}//`);\n    }\n    if (!parsed.hostname) throw new RedisConfigError('REDIS_URL has no host.');\n    return { mode: 'url', url, password };\n  }\n\n  return null;\n}\n\n/** A log-safe description of a connection (never includes credentials). */\nexport function describeRedisConnection(conn: RedisConnection): Record<string, unknown> {\n  if (conn.mode === 'sentinel') {\n    return { mode: 'sentinel', master: conn.masterName, sentinels: conn.sentinels.length };\n  }\n  const u = new URL(conn.url);\n  return { mode: 'url', host: u.hostname, port: u.port || '6379', tls: u.protocol === 'rediss:' };\n}\n\ntype RedisCtor<T> = new (...args: unknown[]) => T;\n\nfunction loadIoredis<T>(): RedisCtor<T> {\n  const req = createRequire(import.meta.url);\n  const mod = req('ioredis') as { Redis?: RedisCtor<T>; default?: RedisCtor<T> };\n  return (mod.Redis ?? mod.default ?? mod) as RedisCtor<T>;\n}\n\n/**\n * Construct an ioredis client for a resolved connection. `options` are merged\n * into the client options (e.g. `{ db, maxRetriesPerRequest: null }` for BullMQ).\n * An `error` listener is always attached so a dropped connection is logged\n * rather than surfacing as an unhandled `'error'` event that crashes Node.\n */\nexport function createRedisClient<T = unknown>(\n  conn: RedisConnection,\n  label: string,\n  options: Record<string, unknown> = {},\n): T {\n  const Ctor = loadIoredis<T>();\n  const auth = conn.password ? { password: conn.password } : {};\n  const inst = conn.mode === 'sentinel'\n    ? new Ctor({\n      sentinels: conn.sentinels,\n      name: conn.masterName,\n      ...(conn.sentinelPassword ? { sentinelPassword: conn.sentinelPassword } : {}),\n      ...auth,\n      ...options,\n    })\n    : new Ctor(conn.url, { ...auth, ...options });\n  (inst as unknown as { on: (evt: string, cb: (e: unknown) => void) => void })\n    .on('error', (e) => logger.warn(`Redis ${label} client error`, { error: e instanceof Error ? e.message : String(e) }));\n  return inst;\n}\n\n/**\n * The shared application Redis client: `null` when Redis isn't configured, so\n * the caller degrades to its no-Redis behavior.\n *\n * Commands fail fast (`maxRetriesPerRequest: 1`, no offline queue) because the\n * request-path callers are best-effort or fail closed on their own terms — a\n * request must not hang behind a Redis outage. That includes the moments before\n * the first connection completes: a background caller that runs at startup must\n * either tolerate a rejected command or wait with {@link whenRedisReady}.\n *\n * Throws {@link RedisConfigError} for a bad configuration, and if Redis is\n * configured but `ioredis` can't be loaded — both are deployment errors that\n * must not quietly turn Redis-backed guarantees off.\n */\nexport function createEnvRedisClient<T = unknown>(label: string): T | null {\n  const conn = resolveRedisConnection();\n  if (!conn) return null;\n  const inst = createRedisClient<T>(conn, label, { maxRetriesPerRequest: 1, enableOfflineQueue: false });\n  logger.info(`Redis ${label} client created`, describeRedisConnection(conn));\n  return inst;\n}\n\n/** The subset of ioredis needed to wait for a connection. */\nexport interface ReadyAwareRedis {\n  status?: string;\n  once?(event: string, cb: (...args: unknown[]) => void): unknown;\n  off?(event: string, cb: (...args: unknown[]) => void): unknown;\n}\n\n/**\n * Resolve once `client` is connected and ready for commands, or reject after\n * `timeoutMs`. For startup work (creating a consumer group, subscribing) that\n * otherwise races the first connection. A client without ioredis' `status`\n * (e.g. a test double) counts as ready.\n */\nexport function whenRedisReady(client: ReadyAwareRedis, timeoutMs = 30_000): Promise<void> {\n  if (client.status === undefined || client.status === 'ready' || !client.once) return Promise.resolve();\n  return new Promise((resolve, reject) => {\n    const onReady = () => { clearTimeout(timer); resolve(); };\n    const timer = setTimeout(() => {\n      client.off?.('ready', onReady);\n      reject(new Error(`Redis not ready after ${timeoutMs}ms`));\n    }, timeoutMs);\n    timer.unref?.();\n    client.once!('ready', onReady);\n  });\n}\n"]}

package/lib/services/leader-lock.d.ts

@@ -30,12 +30,15 @@ export declare function closeLeaderLock(redis: LockRedis | null | undefined): Pr
  * released on completion, but only if we still own it — a slower predecessor
  * never deletes a successor's lock. `ttlMs` should comfortably exceed one run.
  *
- * @returns true if we held the lock and ran `fn`; false if another holder did.
+ * If Redis can't be reached the run is skipped (returns false) rather than
+ * rejecting — callers are timers, and a Redis blip must not crash the process.
+ *
+ * @returns true if we held the lock and ran `fn`; false if another holder did or
+ *   the lock couldn't be taken.
  */
 export declare function withLeaderLock(redis: LockRedis, key: string, ttlMs: number, fn: () => Promise<void>): Promise<boolean>;
 /**
- * A `LockRedis` backed by an env-configured ioredis client (`REDIS_URL` or
- * `REDIS_HOST`) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
+ * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
  * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to
  * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to
  * running on every pod (the atomic guards it wraps must still make that safe).

package/lib/services/leader-lock.js

@@ -38,11 +38,27 @@ const RELEASE_IF_OWNER = 'if redis.call("get", KEYS[1]) == ARGV[1] then return r
  * released on completion, but only if we still own it — a slower predecessor
  * never deletes a successor's lock. `ttlMs` should comfortably exceed one run.
  *
- * @returns true if we held the lock and ran `fn`; false if another holder did.
+ * If Redis can't be reached the run is skipped (returns false) rather than
+ * rejecting — callers are timers, and a Redis blip must not crash the process.
+ *
+ * @returns true if we held the lock and ran `fn`; false if another holder did or
+ *   the lock couldn't be taken.
  */
 export async function withLeaderLock(redis, key, ttlMs, fn) {
     const token = randomUUID();
-    const acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');
+    let acquired;
+    try {
+        acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');
+    }
+    catch (err) {
+        // Redis unreachable (including before the first connection completes): no
+        // pod can prove it's the leader, so nobody runs this window. Skipping is
+        // the safe side — running here could duplicate destructive work across pods.
+        lockLogger.warn('Leader lock unavailable; skipping this run', {
+            key, error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
     if (acquired !== 'OK')
         return false;
     try {
@@ -68,8 +84,7 @@ export async function withLeaderLock(redis, key, ttlMs, fn) {
     return true;
 }
 /**
- * A `LockRedis` backed by an env-configured ioredis client (`REDIS_URL` or
- * `REDIS_HOST`) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
+ * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /
  * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to
  * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to
  * running on every pod (the atomic guards it wraps must still make that safe).
@@ -82,4 +97,4 @@ export function createEnvRedisLock() {
         lockLogger.info('Redis leader-lock client initialized');
     return inst;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"leader-lock.js","sourceRoot":"","sources":["../../src/services/leader-lock.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,UAAU,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;AAoB/C;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,KAAmC;IACvE,IAAI,CAAC,KAAK;QAAE,OAAO;IACnB,IAAI,CAAC;QACH,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAAC,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;YAAC,OAAO;QAAC,CAAC;IACvE,CAAC;IAAC,MAAM,CAAC;QACP,6BAA6B;IAC/B,CAAC;IACD,IAAI,CAAC;QAAC,KAAK,CAAC,UAAU,EAAE,EAAE,CAAC;IAAC,CAAC;IAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC,CAAC;AAC3D,CAAC;AAED;iEACiE;AACjE,MAAM,gBAAgB,GACpB,mGAAmG,CAAC;AAEtG;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,KAAgB,EAChB,GAAW,EACX,KAAa,EACb,EAAuB;IAEvB,MAAM,KAAK,GAAG,UAAU,EAAE,CAAC;IAC3B,IAAI,QAAiB,CAAC;IACtB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,0EAA0E;QAC1E,yEAAyE;QACzE,6EAA6E;QAC7E,UAAU,CAAC,IAAI,CAAC,4CAA4C,EAAE;YAC5D,GAAG,EAAE,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;SAC7D,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAEpC,IAAI,CAAC;QACH,MAAM,EAAE,EAAE,CAAC;IACb,CAAC;YAAS,CAAC;QACT,0EAA0E;QAC1E,wEAAwE;QACxE,4EAA4E;QAC5E,qDAAqD;QACrD,IAAI,CAAC;YACH,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBACrC,MAAM,KAAK,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACpD,CAAC;iBAAM,IAAI,CAAC,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC;gBAC5C,MAAM,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,oDAAoD;QACtD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB;IAChC,MAAM,IAAI,GAAG,oBAAoB,CAAY,aAAa,CAAC,CAAC;IAC5D,IAAI,IAAI;QAAE,UAAU,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;IAClE,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport { randomUUID } from 'crypto';\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\n\nconst lockLogger = createLogger('leader-lock');\n\n/**\n * Minimal Redis client surface needed for a leader lock (a subset of ioredis).\n * `set` is variadic so callers can pass `'PX', ttl, 'NX'`.\n */\nexport interface LockRedis {\n  set(key: string, value: string, ...args: unknown[]): Promise<unknown>;\n  get(key: string): Promise<string | null>;\n  del(...keys: string[]): Promise<number>;\n  /** Optional Lua eval (ioredis has it). When present, release uses an atomic\n   *  compare-and-delete so a lapsed holder can't free a successor's lock. */\n  eval?(script: string, numKeys: number, ...args: unknown[]): Promise<unknown>;\n  /** Graceful close (ioredis `quit`) — called on shutdown so the connection\n   *  doesn't keep the event loop alive. */\n  quit?(): Promise<unknown>;\n  /** Immediate close (ioredis `disconnect`) — the fallback if `quit` fails. */\n  disconnect?(): void;\n}\n\n/**\n * Best-effort close of a leader-lock Redis client on shutdown. Prefers graceful\n * `quit`; falls back to `disconnect`. No-op for a null client / one without\n * either method. Never throws.\n */\nexport async function closeLeaderLock(redis: LockRedis | null | undefined): Promise<void> {\n  if (!redis) return;\n  try {\n    if (typeof redis.quit === 'function') { await redis.quit(); return; }\n  } catch {\n    // fall through to disconnect\n  }\n  try { redis.disconnect?.(); } catch { /* best-effort */ }\n}\n\n/** Atomic \"delete only if I still own it\" — closes the get-then-del race where\n *  the lock expires and is re-acquired between the two calls. */\nconst RELEASE_IF_OWNER =\n  'if redis.call(\"get\", KEYS[1]) == ARGV[1] then return redis.call(\"del\", KEYS[1]) else return 0 end';\n\n/**\n * Run `fn` only if this process wins a short-lived distributed lock — the\n * across-pods \"single runner\" guard for periodic jobs (digest flushes, etc.).\n *\n * Uses `SET key token NX PX ttl`, so exactly one holder runs per window and the\n * lock auto-expires if that holder dies mid-run (no stuck lock). The lock is\n * released on completion, but only if we still own it — a slower predecessor\n * never deletes a successor's lock. `ttlMs` should comfortably exceed one run.\n *\n * If Redis can't be reached the run is skipped (returns false) rather than\n * rejecting — callers are timers, and a Redis blip must not crash the process.\n *\n * @returns true if we held the lock and ran `fn`; false if another holder did or\n *   the lock couldn't be taken.\n */\nexport async function withLeaderLock(\n  redis: LockRedis,\n  key: string,\n  ttlMs: number,\n  fn: () => Promise<void>,\n): Promise<boolean> {\n  const token = randomUUID();\n  let acquired: unknown;\n  try {\n    acquired = await redis.set(key, token, 'PX', ttlMs, 'NX');\n  } catch (err) {\n    // Redis unreachable (including before the first connection completes): no\n    // pod can prove it's the leader, so nobody runs this window. Skipping is\n    // the safe side — running here could duplicate destructive work across pods.\n    lockLogger.warn('Leader lock unavailable; skipping this run', {\n      key, error: err instanceof Error ? err.message : String(err),\n    });\n    return false;\n  }\n  if (acquired !== 'OK') return false;\n\n  try {\n    await fn();\n  } finally {\n    // Release only if the lock is still ours — if our run overran the TTL and\n    // another holder took over, releasing here would free their lock early.\n    // Prefer an atomic CAS (Lua); fall back to get-then-del for clients without\n    // eval (the small non-atomic window is TTL-bounded).\n    try {\n      if (typeof redis.eval === 'function') {\n        await redis.eval(RELEASE_IF_OWNER, 1, key, token);\n      } else if ((await redis.get(key)) === token) {\n        await redis.del(key);\n      }\n    } catch {\n      // Best-effort: the TTL expires the lock regardless.\n    }\n  }\n  return true;\n}\n\n/**\n * A `LockRedis` backed by the shared env Redis client (see env-redis.ts) — the leader-lock counterpart to `createEnvRedisAuditSpool` /\n * `createEnvRedisTokenRevocationStore`, for a service that has no BullMQ client to\n * borrow. Returns `null` when Redis isn't configured, so a caller can degrade to\n * running on every pod (the atomic guards it wraps must still make that safe).\n * The client is a real ioredis instance; ioredis exposes `set`/`get`/`del`/`eval`,\n * satisfying `LockRedis` including the atomic CAS release.\n */\nexport function createEnvRedisLock(): LockRedis | null {\n  const inst = createEnvRedisClient<LockRedis>('leader-lock');\n  if (inst) lockLogger.info('Redis leader-lock client initialized');\n  return inst;\n}\n"]}