@pipeline-builder/api-core 4.1.2 → 4.1.3

package/lib/services/durable-event-bus.js

@@ -104,21 +104,28 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                     }
                 }
             };
+            // The consumer group must exist before XREADGROUP can succeed. Creating it
+            // is retried inside the loop: at startup the client may not have connected
+            // yet, and a single failed attempt used to leave the consumer reading a
+            // group that was never created — forever.
+            let groupReady = false;
             const ensureGroup = async () => {
                 try {
                     // MKSTREAM so the stream need not exist yet; '$' = only new messages.
                     await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');
+                    groupReady = true;
                 }
                 catch (err) {
-                    if (!isBusyGroup(err)) {
-                        logger.warn('Event bus group create failed', { topic, group, error: errMsg(err) });
-                    }
+                    if (!isBusyGroup(err))
+                        throw err;
+                    groupReady = true;
                 }
             };
             const loop = async () => {
-                await ensureGroup();
                 while (!stopped) {
                     try {
+                        if (!groupReady)
+                            await ensureGroup();
                         // 1) Reclaim messages stranded by a crashed consumer in this group.
                         const claimed = await redis.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);
                         // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]
@@ -137,6 +144,9 @@ export function createRedisDurableEventBus(redis, opts = {}) {
                     catch (err) {
                         if (stopped)
                             break;
+                        // The stream or group was deleted out from under us — recreate it.
+                        if (/NOGROUP/i.test(errMsg(err)))
+                            groupReady = false;
                         logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });
                         // Back off so a persistent Redis error doesn't hot-spin.
                         await new Promise((r) => setTimeout(r, 1000));
@@ -201,4 +211,4 @@ export function createEntityEventBusPublisher(bus) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"durable-event-bus.js","sourceRoot":"","sources":["../../src/services/durable-event-bus.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Durable, at-least-once event backbone (Redis Streams).\n *\n * The platform's cross-service signalling today is point-to-point HTTP plus\n * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).\n * There is no durable bus, so a signal produced on one pod is either delivered\n * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer\n * is momentarily down (the reconcilers exist to paper over exactly that).\n *\n * This is that missing bus, as a reusable primitive:\n *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic\n *    stream. Durable across restarts, shared by all replicas.\n *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer.\n *    Consumer GROUPS give at-least-once: each group gets every message once, a\n *    message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`\n *    reclaims messages stranded by a crashed consumer. Multiple groups on one\n *    topic = independent fan-out (e.g. quota-sync AND audit both react).\n *\n * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}\n * returns `null` when Redis isn't configured, so a service without it simply\n * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-\n * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.\n *\n * Migrating a specific reconciler (e.g. billing→quota entitlement sync) onto this\n * is deliberately follow-on work — this lands the backbone + an additive entity-\n * event bridge; the reconcilers stay as the belt-and-suspenders backstop until a\n * flow is fully cut over.\n */\n\nimport type { EntityEvent, EntityEventSubscriber } from './entity-events.js';\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('durable-event-bus');\n\n/** A delivered event: its stream id, topic, and decoded payload. */\nexport interface EventEnvelope<T = unknown> {\n  /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */\n  id: string;\n  topic: string;\n  payload: T;\n}\n\nexport interface SubscribeOptions<T = unknown> {\n  /** Topic (stream) to consume. */\n  topic: string;\n  /** Consumer group — one delivery per group; distinct groups fan out. */\n  group: string;\n  /** This consumer's id within the group (e.g. `${service}-${pid}`). */\n  consumer: string;\n  /** Async handler. Resolves ⇒ the message is acked; throws ⇒ left pending for redelivery. */\n  handler: (env: EventEnvelope<T>) => Promise<void>;\n  /** Max messages per read (default 16). */\n  batchSize?: number;\n  /** XREADGROUP block time in ms (default 5000). */\n  blockMs?: number;\n  /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */\n  minIdleMs?: number;\n}\n\nexport interface EventSubscription {\n  /** Stop the consumer loop. Resolves once the in-flight read returns. */\n  stop(): Promise<void>;\n}\n\nexport interface DurableEventBus {\n  /** Publish a payload to a topic. Returns the stream id, or null on failure (dropped, never throws). */\n  publish<T>(topic: string, payload: T): Promise<string | null>;\n  /** Start a consumer-group reader for a topic. Fire-and-forget loop; call `stop()` to end it. */\n  subscribe<T>(opts: SubscribeOptions<T>): EventSubscription;\n}\n\n/**\n * The subset of ioredis' Stream API the bus uses. Kept minimal so a test can\n * supply an in-memory fake and so merely importing this never hard-depends on\n * ioredis (constructed via the shared env helper).\n */\nexport interface RedisStreamClient {\n  xadd(key: string, ...args: (string | number)[]): Promise<string | null>;\n  xgroup(...args: (string | number)[]): Promise<unknown>;\n  xreadgroup(...args: (string | number)[]): Promise<unknown>;\n  xack(key: string, group: string, ...ids: string[]): Promise<number>;\n  xautoclaim(...args: (string | number)[]): Promise<unknown>;\n}\n\nconst DEFAULT_MAXLEN = 10_000;\nconst DEFAULT_BATCH = 16;\nconst DEFAULT_BLOCK_MS = 5_000;\nconst DEFAULT_MIN_IDLE_MS = 60_000;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction streamKey(topic: string): string {\n  return `evt:${topic}`;\n}\n\n/** True when the error is Redis' \"group already exists\" (idempotent create). */\nfunction isBusyGroup(err: unknown): boolean {\n  return errMsg(err).includes('BUSYGROUP');\n}\n\n/**\n * Parse the nested array shape XREADGROUP / XAUTOCLAIM return into flat envelopes.\n * XREADGROUP: `[[streamKey, [[id, [f, v, ...]], ...]]]`.\n * XAUTOCLAIM: `[nextCursor, [[id, [f, v, ...]], ...], deletedIds]`.\n * We store the JSON payload under a single field `d`.\n */\nfunction parseEntries<T>(topic: string, entries: unknown): EventEnvelope<T>[] {\n  const out: EventEnvelope<T>[] = [];\n  if (!Array.isArray(entries)) return out;\n  for (const entry of entries) {\n    if (!Array.isArray(entry) || entry.length < 2) continue;\n    const id = String(entry[0]);\n    const fields = entry[1];\n    if (!Array.isArray(fields)) continue;\n    // fields is [name, value, name, value, ...]; find 'd'.\n    let raw: string | undefined;\n    for (let i = 0; i + 1 < fields.length; i += 2) {\n      if (String(fields[i]) === 'd') { raw = String(fields[i + 1]); break; }\n    }\n    // A missing `d` field (an entry not written by publish()) OR a corrupt JSON\n    // payload both yield an undefined-payload envelope so `deliver()` ACKs it —\n    // a poison message must never wedge the group by staying perpetually pending.\n    if (raw === undefined) {\n      out.push({ id, topic, payload: undefined as unknown as T });\n      continue;\n    }\n    try {\n      out.push({ id, topic, payload: JSON.parse(raw) as T });\n    } catch {\n      out.push({ id, topic, payload: undefined as unknown as T });\n    }\n  }\n  return out;\n}\n\n/** Build a durable event bus over a Redis Streams client. */\nexport function createRedisDurableEventBus(\n  redis: RedisStreamClient,\n  opts: { maxLen?: number } = {},\n): DurableEventBus {\n  const maxLen = Math.max(1, opts.maxLen ?? DEFAULT_MAXLEN);\n\n  return {\n    async publish<T>(topic: string, payload: T): Promise<string | null> {\n      const key = streamKey(topic);\n      try {\n        // MAXLEN ~ <n> bounds the stream approximately (cheap); `*` = server id.\n        const id = await redis.xadd(key, 'MAXLEN', '~', maxLen, '*', 'd', JSON.stringify(payload));\n        emitCounter('event_bus_published_total', { topic });\n        return id;\n      } catch (err) {\n        emitCounter('event_bus_publish_failed_total', { topic });\n        logger.warn('Event bus publish failed (event dropped)', { topic, error: errMsg(err) });\n        return null;\n      }\n    },\n\n    subscribe<T>(subOpts: SubscribeOptions<T>): EventSubscription {\n      const { topic, group, consumer, handler } = subOpts;\n      const key = streamKey(topic);\n      const batch = Math.max(1, subOpts.batchSize ?? DEFAULT_BATCH);\n      const blockMs = Math.max(0, subOpts.blockMs ?? DEFAULT_BLOCK_MS);\n      const minIdle = Math.max(0, subOpts.minIdleMs ?? DEFAULT_MIN_IDLE_MS);\n\n      let stopped = false;\n      let started = false;\n\n      const deliver = async (envs: EventEnvelope<T>[]): Promise<void> => {\n        for (const env of envs) {\n          try {\n            if (env.payload !== undefined) await handler(env);\n            // Ack on success OR on an undefined (corrupt) payload — a poison\n            // message must not block the group forever.\n            await redis.xack(key, group, env.id);\n            emitCounter('event_bus_delivered_total', { topic, group });\n          } catch (err) {\n            // Leave it pending (no XACK) — XAUTOCLAIM redelivers it after minIdle.\n            emitCounter('event_bus_handler_failed_total', { topic, group });\n            logger.warn('Event handler failed; leaving message pending for redelivery', {\n              topic, group, id: env.id, error: errMsg(err),\n            });\n          }\n        }\n      };\n\n      const ensureGroup = async (): Promise<void> => {\n        try {\n          // MKSTREAM so the stream need not exist yet; '$' = only new messages.\n          await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');\n        } catch (err) {\n          if (!isBusyGroup(err)) {\n            logger.warn('Event bus group create failed', { topic, group, error: errMsg(err) });\n          }\n        }\n      };\n\n      const loop = async (): Promise<void> => {\n        await ensureGroup();\n        while (!stopped) {\n          try {\n            // 1) Reclaim messages stranded by a crashed consumer in this group.\n            const claimed = await redis.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);\n            // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]\n            if (Array.isArray(claimed) && claimed.length >= 2) {\n              await deliver(parseEntries<T>(topic, claimed[1]));\n            }\n            if (stopped) break;\n\n            // 2) Read new, never-delivered messages for this group ('>').\n            const res = await redis.xreadgroup(\n              'GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>',\n            );\n            // XREADGROUP reply: [[streamKey, entries]] | null (on block timeout)\n            if (Array.isArray(res) && res.length > 0 && Array.isArray(res[0]) && res[0].length >= 2) {\n              await deliver(parseEntries<T>(topic, res[0][1]));\n            }\n          } catch (err) {\n            if (stopped) break;\n            logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });\n            // Back off so a persistent Redis error doesn't hot-spin.\n            await new Promise((r) => setTimeout(r, 1000));\n          }\n        }\n      };\n\n      let loopPromise = Promise.resolve();\n      if (!started) {\n        started = true;\n        loopPromise = loop();\n        logger.info('Event bus consumer started', { topic, group, consumer });\n      }\n\n      return {\n        async stop(): Promise<void> {\n          stopped = true;\n          // Await the in-flight read/handler so a caller (e.g. a service shutting\n          // down its DB) doesn't race a message still being processed. Bounded by\n          // the XREADGROUP BLOCK window. Never rejects — the loop swallows errors.\n          await loopPromise.catch(() => undefined);\n        },\n      };\n    },\n  };\n}\n\n/**\n * Build a durable event bus from the ambient Redis env via the shared\n * `createEnvRedisClient`. Returns `null` when Redis is not configured — the\n * caller then runs without a bus (today's HTTP/reconciler behavior), never\n * crashing. Opt in with a single boot line where a service wants durable events.\n */\nexport function createEnvRedisDurableEventBus(opts: { maxLen?: number } = {}): DurableEventBus | null {\n  const inst = createEnvRedisClient<RedisStreamClient>('event-bus');\n  if (!inst) return null;\n  logger.info('Redis durable event bus initialized');\n  return createRedisDurableEventBus(inst, opts);\n}\n\n// ---------------------------------------------------------------------------\n// Entity-event bridge (additive, opt-in)\n//\n// Lets a service give its in-process {@link entityEvents} emitter a DURABLE,\n// cross-pod delivery leg WITHOUT changing existing behavior: register the\n// returned subscriber and every entity mutation is ALSO published to the bus.\n// A consumer elsewhere (`bus.subscribe`) then reacts at-least-once across pods\n// and restarts. The in-process subscribers keep firing exactly as before, so\n// this is purely additive — no double-processing unless a service intentionally\n// runs a bus consumer for the same reaction. Kept here (not in entity-events.ts)\n// so that module stays infrastructure-free per its own contract.\n// ---------------------------------------------------------------------------\n\n/** Topic the entity-event bridge publishes to. */\nexport const ENTITY_EVENT_TOPIC = 'entity-events';\n\n/**\n * An {@link EntityEventSubscriber} that forwards each entity event to the durable\n * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the\n * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)\n * serializes to an ISO string on the wire — a consumer re-hydrates as needed.\n */\nexport function createEntityEventBusPublisher(bus: DurableEventBus): EntityEventSubscriber {\n  return {\n    async onEntityEvent(event: EntityEvent): Promise<void> {\n      await bus.publish(ENTITY_EVENT_TOPIC, event);\n    },\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"durable-event-bus.js","sourceRoot":"","sources":["../../src/services/durable-event-bus.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Durable, at-least-once event backbone (Redis Streams).\n *\n * The platform's cross-service signalling today is point-to-point HTTP plus\n * polling reconcilers plus an IN-PROCESS best-effort emitter ({@link entityEvents}).\n * There is no durable bus, so a signal produced on one pod is either delivered\n * synchronously over HTTP (coupling + retry-storm risk) or lost if the consumer\n * is momentarily down (the reconcilers exist to paper over exactly that).\n *\n * This is that missing bus, as a reusable primitive:\n *  - **publish(topic, payload)** → `XADD` onto a bounded (`MAXLEN ~`) per-topic\n *    stream. Durable across restarts, shared by all replicas.\n *  - **subscribe({topic, group, consumer, handler})** → a `XREADGROUP` consumer.\n *    Consumer GROUPS give at-least-once: each group gets every message once, a\n *    message stays pending until the handler `XACK`s it, and `XAUTOCLAIM`\n *    reclaims messages stranded by a crashed consumer. Multiple groups on one\n *    topic = independent fan-out (e.g. quota-sync AND audit both react).\n *\n * FAIL-SAFE + OPT-IN, exactly like the audit spool: {@link createEnvRedisDurableEventBus}\n * returns `null` when Redis isn't configured, so a service without it simply\n * doesn't use the bus (keeps today's behavior). A publish failure is dropped-with-\n * -metric, never thrown; a handler throw leaves the message un-acked for redelivery.\n *\n * Migrating a specific reconciler (e.g. billing→quota entitlement sync) onto this\n * is deliberately follow-on work — this lands the backbone + an additive entity-\n * event bridge; the reconcilers stay as the belt-and-suspenders backstop until a\n * flow is fully cut over.\n */\n\nimport type { EntityEvent, EntityEventSubscriber } from './entity-events.js';\nimport { createEnvRedisClient } from './env-redis.js';\nimport { createLogger } from '../utils/logger.js';\nimport { emitCounter } from '../utils/metric-emitter.js';\n\nconst logger = createLogger('durable-event-bus');\n\n/** A delivered event: its stream id, topic, and decoded payload. */\nexport interface EventEnvelope<T = unknown> {\n  /** Redis Stream entry id (`<ms>-<seq>`) — also the idempotency handle. */\n  id: string;\n  topic: string;\n  payload: T;\n}\n\nexport interface SubscribeOptions<T = unknown> {\n  /** Topic (stream) to consume. */\n  topic: string;\n  /** Consumer group — one delivery per group; distinct groups fan out. */\n  group: string;\n  /** This consumer's id within the group (e.g. `${service}-${pid}`). */\n  consumer: string;\n  /** Async handler. Resolves ⇒ the message is acked; throws ⇒ left pending for redelivery. */\n  handler: (env: EventEnvelope<T>) => Promise<void>;\n  /** Max messages per read (default 16). */\n  batchSize?: number;\n  /** XREADGROUP block time in ms (default 5000). */\n  blockMs?: number;\n  /** A pending message idle this long (ms) is reclaimed from a dead consumer (default 60000). */\n  minIdleMs?: number;\n}\n\nexport interface EventSubscription {\n  /** Stop the consumer loop. Resolves once the in-flight read returns. */\n  stop(): Promise<void>;\n}\n\nexport interface DurableEventBus {\n  /** Publish a payload to a topic. Returns the stream id, or null on failure (dropped, never throws). */\n  publish<T>(topic: string, payload: T): Promise<string | null>;\n  /** Start a consumer-group reader for a topic. Fire-and-forget loop; call `stop()` to end it. */\n  subscribe<T>(opts: SubscribeOptions<T>): EventSubscription;\n}\n\n/**\n * The subset of ioredis' Stream API the bus uses. Kept minimal so a test can\n * supply an in-memory fake and so merely importing this never hard-depends on\n * ioredis (constructed via the shared env helper).\n */\nexport interface RedisStreamClient {\n  xadd(key: string, ...args: (string | number)[]): Promise<string | null>;\n  xgroup(...args: (string | number)[]): Promise<unknown>;\n  xreadgroup(...args: (string | number)[]): Promise<unknown>;\n  xack(key: string, group: string, ...ids: string[]): Promise<number>;\n  xautoclaim(...args: (string | number)[]): Promise<unknown>;\n}\n\nconst DEFAULT_MAXLEN = 10_000;\nconst DEFAULT_BATCH = 16;\nconst DEFAULT_BLOCK_MS = 5_000;\nconst DEFAULT_MIN_IDLE_MS = 60_000;\n\nfunction errMsg(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\nfunction streamKey(topic: string): string {\n  return `evt:${topic}`;\n}\n\n/** True when the error is Redis' \"group already exists\" (idempotent create). */\nfunction isBusyGroup(err: unknown): boolean {\n  return errMsg(err).includes('BUSYGROUP');\n}\n\n/**\n * Parse the nested array shape XREADGROUP / XAUTOCLAIM return into flat envelopes.\n * XREADGROUP: `[[streamKey, [[id, [f, v, ...]], ...]]]`.\n * XAUTOCLAIM: `[nextCursor, [[id, [f, v, ...]], ...], deletedIds]`.\n * We store the JSON payload under a single field `d`.\n */\nfunction parseEntries<T>(topic: string, entries: unknown): EventEnvelope<T>[] {\n  const out: EventEnvelope<T>[] = [];\n  if (!Array.isArray(entries)) return out;\n  for (const entry of entries) {\n    if (!Array.isArray(entry) || entry.length < 2) continue;\n    const id = String(entry[0]);\n    const fields = entry[1];\n    if (!Array.isArray(fields)) continue;\n    // fields is [name, value, name, value, ...]; find 'd'.\n    let raw: string | undefined;\n    for (let i = 0; i + 1 < fields.length; i += 2) {\n      if (String(fields[i]) === 'd') { raw = String(fields[i + 1]); break; }\n    }\n    // A missing `d` field (an entry not written by publish()) OR a corrupt JSON\n    // payload both yield an undefined-payload envelope so `deliver()` ACKs it —\n    // a poison message must never wedge the group by staying perpetually pending.\n    if (raw === undefined) {\n      out.push({ id, topic, payload: undefined as unknown as T });\n      continue;\n    }\n    try {\n      out.push({ id, topic, payload: JSON.parse(raw) as T });\n    } catch {\n      out.push({ id, topic, payload: undefined as unknown as T });\n    }\n  }\n  return out;\n}\n\n/** Build a durable event bus over a Redis Streams client. */\nexport function createRedisDurableEventBus(\n  redis: RedisStreamClient,\n  opts: { maxLen?: number } = {},\n): DurableEventBus {\n  const maxLen = Math.max(1, opts.maxLen ?? DEFAULT_MAXLEN);\n\n  return {\n    async publish<T>(topic: string, payload: T): Promise<string | null> {\n      const key = streamKey(topic);\n      try {\n        // MAXLEN ~ <n> bounds the stream approximately (cheap); `*` = server id.\n        const id = await redis.xadd(key, 'MAXLEN', '~', maxLen, '*', 'd', JSON.stringify(payload));\n        emitCounter('event_bus_published_total', { topic });\n        return id;\n      } catch (err) {\n        emitCounter('event_bus_publish_failed_total', { topic });\n        logger.warn('Event bus publish failed (event dropped)', { topic, error: errMsg(err) });\n        return null;\n      }\n    },\n\n    subscribe<T>(subOpts: SubscribeOptions<T>): EventSubscription {\n      const { topic, group, consumer, handler } = subOpts;\n      const key = streamKey(topic);\n      const batch = Math.max(1, subOpts.batchSize ?? DEFAULT_BATCH);\n      const blockMs = Math.max(0, subOpts.blockMs ?? DEFAULT_BLOCK_MS);\n      const minIdle = Math.max(0, subOpts.minIdleMs ?? DEFAULT_MIN_IDLE_MS);\n\n      let stopped = false;\n      let started = false;\n\n      const deliver = async (envs: EventEnvelope<T>[]): Promise<void> => {\n        for (const env of envs) {\n          try {\n            if (env.payload !== undefined) await handler(env);\n            // Ack on success OR on an undefined (corrupt) payload — a poison\n            // message must not block the group forever.\n            await redis.xack(key, group, env.id);\n            emitCounter('event_bus_delivered_total', { topic, group });\n          } catch (err) {\n            // Leave it pending (no XACK) — XAUTOCLAIM redelivers it after minIdle.\n            emitCounter('event_bus_handler_failed_total', { topic, group });\n            logger.warn('Event handler failed; leaving message pending for redelivery', {\n              topic, group, id: env.id, error: errMsg(err),\n            });\n          }\n        }\n      };\n\n      // The consumer group must exist before XREADGROUP can succeed. Creating it\n      // is retried inside the loop: at startup the client may not have connected\n      // yet, and a single failed attempt used to leave the consumer reading a\n      // group that was never created — forever.\n      let groupReady = false;\n      const ensureGroup = async (): Promise<void> => {\n        try {\n          // MKSTREAM so the stream need not exist yet; '$' = only new messages.\n          await redis.xgroup('CREATE', key, group, '$', 'MKSTREAM');\n          groupReady = true;\n        } catch (err) {\n          if (!isBusyGroup(err)) throw err;\n          groupReady = true;\n        }\n      };\n\n      const loop = async (): Promise<void> => {\n        while (!stopped) {\n          try {\n            if (!groupReady) await ensureGroup();\n            // 1) Reclaim messages stranded by a crashed consumer in this group.\n            const claimed = await redis.xautoclaim(key, group, consumer, minIdle, '0', 'COUNT', batch);\n            // XAUTOCLAIM reply: [nextCursor, entries, deletedIds]\n            if (Array.isArray(claimed) && claimed.length >= 2) {\n              await deliver(parseEntries<T>(topic, claimed[1]));\n            }\n            if (stopped) break;\n\n            // 2) Read new, never-delivered messages for this group ('>').\n            const res = await redis.xreadgroup(\n              'GROUP', group, consumer, 'COUNT', batch, 'BLOCK', blockMs, 'STREAMS', key, '>',\n            );\n            // XREADGROUP reply: [[streamKey, entries]] | null (on block timeout)\n            if (Array.isArray(res) && res.length > 0 && Array.isArray(res[0]) && res[0].length >= 2) {\n              await deliver(parseEntries<T>(topic, res[0][1]));\n            }\n          } catch (err) {\n            if (stopped) break;\n            // The stream or group was deleted out from under us — recreate it.\n            if (/NOGROUP/i.test(errMsg(err))) groupReady = false;\n            logger.warn('Event bus consumer loop error; backing off', { topic, group, error: errMsg(err) });\n            // Back off so a persistent Redis error doesn't hot-spin.\n            await new Promise((r) => setTimeout(r, 1000));\n          }\n        }\n      };\n\n      let loopPromise = Promise.resolve();\n      if (!started) {\n        started = true;\n        loopPromise = loop();\n        logger.info('Event bus consumer started', { topic, group, consumer });\n      }\n\n      return {\n        async stop(): Promise<void> {\n          stopped = true;\n          // Await the in-flight read/handler so a caller (e.g. a service shutting\n          // down its DB) doesn't race a message still being processed. Bounded by\n          // the XREADGROUP BLOCK window. Never rejects — the loop swallows errors.\n          await loopPromise.catch(() => undefined);\n        },\n      };\n    },\n  };\n}\n\n/**\n * Build a durable event bus from the ambient Redis env via the shared\n * `createEnvRedisClient`. Returns `null` when Redis is not configured — the\n * caller then runs without a bus (today's HTTP/reconciler behavior), never\n * crashing. Opt in with a single boot line where a service wants durable events.\n */\nexport function createEnvRedisDurableEventBus(opts: { maxLen?: number } = {}): DurableEventBus | null {\n  const inst = createEnvRedisClient<RedisStreamClient>('event-bus');\n  if (!inst) return null;\n  logger.info('Redis durable event bus initialized');\n  return createRedisDurableEventBus(inst, opts);\n}\n\n// ---------------------------------------------------------------------------\n// Entity-event bridge (additive, opt-in)\n//\n// Lets a service give its in-process {@link entityEvents} emitter a DURABLE,\n// cross-pod delivery leg WITHOUT changing existing behavior: register the\n// returned subscriber and every entity mutation is ALSO published to the bus.\n// A consumer elsewhere (`bus.subscribe`) then reacts at-least-once across pods\n// and restarts. The in-process subscribers keep firing exactly as before, so\n// this is purely additive — no double-processing unless a service intentionally\n// runs a bus consumer for the same reaction. Kept here (not in entity-events.ts)\n// so that module stays infrastructure-free per its own contract.\n// ---------------------------------------------------------------------------\n\n/** Topic the entity-event bridge publishes to. */\nexport const ENTITY_EVENT_TOPIC = 'entity-events';\n\n/**\n * An {@link EntityEventSubscriber} that forwards each entity event to the durable\n * bus. `bus.publish` is fail-safe (drops-with-metric, never throws), matching the\n * emitter's fire-and-forget contract. Note `EntityEvent.timestamp` (a Date)\n * serializes to an ISO string on the wire — a consumer re-hydrates as needed.\n */\nexport function createEntityEventBusPublisher(bus: DurableEventBus): EntityEventSubscriber {\n  return {\n    async onEntityEvent(event: EntityEvent): Promise<void> {\n      await bus.publish(ENTITY_EVENT_TOPIC, event);\n    },\n  };\n}\n"]}

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":"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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 * 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"]}