@nymbalhq/event-bus-redis-streams 0.0.0-stage → 1.2.0

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { EventBusAdapter, Logger, HealthReport, NymbalEvent, EventHandler, SubscriptionConfig, Subscription, AdapterContext } from '@nymbalhq/types';
+import { Redis } from 'ioredis';
+
+interface RedisStreamsEventBusOptions {
+    /** `redis://[user:password@]host:port[/db]`; the db index in the path is honoured. */
+    url: string;
+    /** Namespaces the stream (`<prefix>:events`) and so every consumer group on it. */
+    prefix: string;
+    logger?: Logger;
+    /** How long `publish` waits for the groups it delivers to before it rejects (default 15 000). */
+    ackTimeoutMs?: number;
+    /** How long an entry may stay pending on a consumer before a live consumer of its group takes it over (5 000). */
+    claimIdleMs?: number;
+    /** The approximate length the stream is trimmed to (`XADD MAXLEN ~`, default 10 000). */
+    streamMaxLen?: number;
+}
+/**
+ * An event bus on Redis Streams that keeps the in-process delivery contract. Every event is one entry on
+ * `<prefix>:events`. A named subscription is a durable consumer group, shared by every instance, so each event is
+ * handled once per name; an unnamed subscription reads the stream from where it subscribed, so every subscriber on
+ * every instance receives every event. `publish` resolves once every matching group this instance reads, and every
+ * matching unnamed subscription it holds, has handled the event.
+ */
+declare class RedisStreamsEventBus implements EventBusAdapter {
+    #private;
+    constructor(cmd: Redis, reader: Redis, options: RedisStreamsEventBusOptions);
+    capabilities(): readonly string[];
+    healthCheck(): Promise<HealthReport>;
+    publish<T>(event: NymbalEvent<T>): Promise<void>;
+    publishBatch(events: NymbalEvent<unknown>[]): Promise<void>;
+    replay(events: NymbalEvent<unknown>[]): Promise<void>;
+    subscribe(eventPattern: string | string[], handler: EventHandler, config?: SubscriptionConfig): Promise<Subscription>;
+    unsubscribe(subscription: Subscription): Promise<void>;
+    close(): Promise<void>;
+}
+/** Connects the bus's two clients: one for commands, one for the blocking read of the stream. */
+declare function createRedisStreamsEventBus(options: RedisStreamsEventBusOptions): Promise<RedisStreamsEventBus>;
+
+/**
+ * The kernel's entry: `infrastructure.eventBus: 'redis-streams'`, with `{ url, prefix, ackTimeoutMs, claimIdleMs,
+ * streamMaxLen }` from the `redis` block.
+ */
+declare function createAdapter(ctx: AdapterContext): Promise<EventBusAdapter>;
+
+export { RedisStreamsEventBus, createAdapter, createRedisStreamsEventBus };
+export type { RedisStreamsEventBusOptions };

package/dist/index.js

@@ -0,0 +1,697 @@
+// src/index.ts
+import { ConfigError } from "@nymbalhq/types";
+
+// src/redis-streams-event-bus.ts
+import { randomUUID } from "crypto";
+import { Redis } from "ioredis";
+import {
+  AdapterError,
+  boundedHealthCheck,
+  connectionSecrets,
+  HEALTH_CHECK_TIMEOUT_MS,
+  ValidationError
+} from "@nymbalhq/types";
+var READ_COUNT = 10;
+var TAIL_BLOCK_MS = 5e3;
+var ACK_POLL_MS = 25;
+function compilePattern(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\*]/g, "\\$&").replace(/\\\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+}
+function compareIds(a, b) {
+  const [am = 0, as = 0] = a.split("-").map(Number);
+  const [bm = 0, bs = 0] = b.split("-").map(Number);
+  return am !== bm ? am - bm : as - bs;
+}
+function fieldsOf(raw) {
+  const out = {};
+  if (!Array.isArray(raw)) return out;
+  for (let i = 0; i + 1 < raw.length; i += 2) out[String(raw[i])] = String(raw[i + 1]);
+  return out;
+}
+function entriesOf(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (!Array.isArray(item) || typeof item[0] !== "string") continue;
+    const json = fieldsOf(item[1])["event"];
+    let event = null;
+    if (json !== void 0) {
+      try {
+        event = JSON.parse(json);
+      } catch {
+        event = null;
+      }
+    }
+    out.push({ id: item[0], event });
+  }
+  return out;
+}
+function streamEntries(reply) {
+  if (!Array.isArray(reply)) return [];
+  return reply.flatMap((stream) => Array.isArray(stream) ? entriesOf(stream[1]) : []);
+}
+var RedisStreamsEventBus = class {
+  #cmd;
+  #reader;
+  #url;
+  #stream;
+  #consumer = randomUUID();
+  #logger;
+  #ackTimeoutMs;
+  #claimIdleMs;
+  #streamMaxLen;
+  #subs = /* @__PURE__ */ new Map();
+  #groups = /* @__PURE__ */ new Map();
+  #waits = /* @__PURE__ */ new Map();
+  #tail = null;
+  #tailStarted = null;
+  #tailFrom = "0-0";
+  #tick = null;
+  #poll = null;
+  #closed = false;
+  constructor(cmd, reader, options) {
+    this.#cmd = cmd;
+    this.#reader = reader;
+    this.#url = options.url;
+    this.#stream = `${options.prefix}:events`;
+    this.#logger = options.logger;
+    this.#ackTimeoutMs = options.ackTimeoutMs ?? 15e3;
+    this.#claimIdleMs = options.claimIdleMs ?? 5e3;
+    this.#streamMaxLen = options.streamMaxLen ?? 1e4;
+  }
+  capabilities() {
+    return ["publish", "subscribe", "wildcard", "replay", "consumer-groups", "fan-out"];
+  }
+  healthCheck() {
+    return pingRedis(this.#url);
+  }
+  async publish(event) {
+    await this.publishBatch([event]);
+  }
+  async publishBatch(events) {
+    for (const event of events) validate(event);
+    this.#assertOpen();
+    if (events.length === 0) return;
+    const waits = events.map((event) => this.#wait(event));
+    const pipeline = this.#cmd.pipeline();
+    for (const event of events) {
+      pipeline.xadd(
+        this.#stream,
+        "MAXLEN",
+        "~",
+        this.#streamMaxLen,
+        "*",
+        "type",
+        event.type,
+        "event",
+        JSON.stringify(event)
+      );
+    }
+    let replies;
+    try {
+      replies = await pipeline.exec();
+    } catch (error) {
+      for (const wait of waits) this.#drop(wait);
+      throw error;
+    }
+    const failed = replies === null ? new AdapterError("publish_failed", "the stream write was aborted") : replies.find(([error]) => error !== null)?.[0];
+    if (failed !== void 0 && failed !== null) {
+      for (const wait of waits) this.#drop(wait);
+      throw failed;
+    }
+    replies?.forEach(([, id], i) => {
+      waits[i].entryId = String(id);
+    });
+    this.#signalGroups();
+    this.#schedulePoll();
+    await Promise.all(waits.map((w) => w.promise));
+  }
+  async replay(events) {
+    for (const event of events) {
+      validate(event);
+      const derived = [...this.#subs.values()].filter((s) => s.derived && matches(s, event.type));
+      await Promise.all(derived.map((s) => this.#run(s, event)));
+    }
+  }
+  async subscribe(eventPattern, handler, config) {
+    this.#assertOpen();
+    await this.#startTail();
+    const patterns = Array.isArray(eventPattern) ? eventPattern : [eventPattern];
+    const sub = {
+      id: randomUUID(),
+      patterns,
+      regexes: patterns.map(compilePattern),
+      handler,
+      derived: config?.derived === true,
+      live: true,
+      starting: false,
+      queue: [],
+      running: null
+    };
+    const name = config?.name;
+    if (name !== void 0) {
+      let group = this.#groups.get(name);
+      if (group === void 0) {
+        group = {
+          name,
+          subs: /* @__PURE__ */ new Set(),
+          ready: this.#createGroup(name),
+          draining: null,
+          again: false,
+          claimDue: false
+        };
+        this.#groups.set(name, group);
+      }
+      try {
+        await group.ready;
+      } catch (error) {
+        if (group.subs.size === 0) this.#groups.delete(name);
+        throw error;
+      }
+      group.subs.add(sub);
+      this.#subs.set(sub.id, sub);
+      group.claimDue = true;
+      void this.#drainGroup(group);
+    } else {
+      sub.since = this.#tailFrom;
+      sub.starting = true;
+      this.#subs.set(sub.id, sub);
+      let last;
+      try {
+        last = await this.#lastId();
+      } catch (error) {
+        sub.live = false;
+        this.#subs.delete(sub.id);
+        throw error;
+      }
+      sub.since = last;
+      sub.starting = false;
+      const later = sub.queue.filter((q) => compareIds(q.entryId, last) > 0);
+      sub.queue.splice(0, sub.queue.length, ...later);
+      if (sub.queue.length > 0 && sub.running === null) sub.running = this.#runQueue(sub);
+    }
+    this.#startTick();
+    const self = this;
+    return {
+      id: sub.id,
+      patterns,
+      async unsubscribe() {
+        await self.#unsubscribe(sub.id);
+      }
+    };
+  }
+  async unsubscribe(subscription) {
+    await this.#unsubscribe(subscription.id);
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    if (this.#tick !== null) clearInterval(this.#tick);
+    if (this.#poll !== null) clearTimeout(this.#poll);
+    this.#tick = null;
+    this.#poll = null;
+    for (const waits of [...this.#waits.values()]) {
+      for (const wait of [...waits]) {
+        this.#drop(wait);
+        wait.resolve();
+      }
+    }
+    this.#reader.disconnect();
+    await this.#tail?.catch(() => void 0);
+    const groups = [...this.#groups.values()];
+    await Promise.all([
+      ...groups.map((g) => g.draining?.catch(() => void 0)),
+      ...[...this.#subs.values()].map((s) => s.running?.catch(() => void 0))
+    ]);
+    for (const sub of this.#subs.values()) sub.live = false;
+    this.#subs.clear();
+    await Promise.all(groups.map((g) => this.#leaveGroup(g.name)));
+    this.#groups.clear();
+    await this.#cmd.quit().catch(() => this.#cmd.disconnect());
+  }
+  // ── Waiting ────────────────────────────────────────────────────────────────
+  #wait(event) {
+    const targets = /* @__PURE__ */ new Set();
+    for (const group of this.#groups.values()) {
+      if ([...group.subs].some((s) => s.live && matches(s, event.type)))
+        targets.add(`g:${group.name}`);
+    }
+    for (const sub of this.#subs.values()) {
+      if (sub.since !== void 0 && sub.live && !sub.starting && matches(sub, event.type))
+        targets.add(`s:${sub.id}`);
+    }
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const wait = {
+      event,
+      entryId: null,
+      targets,
+      startedAt: Date.now(),
+      resolve,
+      reject,
+      promise,
+      timer: void 0
+    };
+    if (targets.size === 0) {
+      resolve();
+      return wait;
+    }
+    wait.timer = setTimeout(() => this.#timeout(wait), this.#ackTimeoutMs);
+    const forEvent = this.#waits.get(event.id) ?? /* @__PURE__ */ new Set();
+    forEvent.add(wait);
+    this.#waits.set(event.id, forEvent);
+    return wait;
+  }
+  #timeout(wait) {
+    if (!this.#drop(wait)) return;
+    const pending = [...wait.targets];
+    this.#logger?.error(
+      {
+        eventId: wait.event.id,
+        eventType: wait.event.type,
+        entryId: wait.entryId,
+        unacknowledged: pending
+      },
+      "redis streams publish timed out waiting for its handlers"
+    );
+    wait.reject(
+      new AdapterError(
+        "publish_timeout",
+        `publish of ${wait.event.type} (${wait.event.id}) was not handled within ${this.#ackTimeoutMs} ms by ${pending.join(", ")}`,
+        { context: { eventId: wait.event.id, unacknowledged: pending } }
+      )
+    );
+  }
+  /** Forgets `wait`; false when it was already settled. */
+  #drop(wait) {
+    const forEvent = this.#waits.get(wait.event.id);
+    if (forEvent === void 0 || !forEvent.delete(wait)) return false;
+    if (forEvent.size === 0) this.#waits.delete(wait.event.id);
+    clearTimeout(wait.timer);
+    return true;
+  }
+  /** `target` has finished with `eventId`: a wait left with nothing to wait on resolves. */
+  #settle(eventId, target) {
+    for (const wait of [...this.#waits.get(eventId) ?? []]) this.#remove(wait, target);
+  }
+  #settleEverywhere(target) {
+    for (const waits of [...this.#waits.values()]) {
+      for (const wait of [...waits]) this.#remove(wait, target);
+    }
+  }
+  #remove(wait, target) {
+    if (!wait.targets.delete(target) || wait.targets.size > 0) return;
+    if (this.#drop(wait)) wait.resolve();
+  }
+  /**
+   * A group's entry may be handled by another instance's consumer: asks Redis, for each wait still on a group, whether
+   * the group has delivered the entry and holds it pending no more.
+   */
+  #schedulePoll() {
+    if (this.#poll !== null || this.#closed || this.#waits.size === 0) return;
+    this.#poll = setTimeout(() => {
+      this.#poll = null;
+      void this.#pollAcks().finally(() => this.#schedulePoll());
+    }, ACK_POLL_MS);
+  }
+  async #pollAcks() {
+    const due = [];
+    const now = Date.now();
+    for (const waits of this.#waits.values()) {
+      for (const wait of waits) {
+        if (wait.entryId === null || now - wait.startedAt < ACK_POLL_MS) continue;
+        for (const target of wait.targets) {
+          if (target.startsWith("g:")) due.push({ wait, group: target.slice(2) });
+        }
+      }
+    }
+    if (due.length === 0) return;
+    try {
+      const pipeline = this.#cmd.pipeline().xinfo("GROUPS", this.#stream);
+      for (const { wait, group } of due) {
+        pipeline.xpending(this.#stream, group, wait.entryId, wait.entryId, 1);
+      }
+      const replies = await pipeline.exec() ?? [];
+      const delivered = /* @__PURE__ */ new Map();
+      const [infoError, info] = replies[0] ?? [null, []];
+      if (infoError !== null) return;
+      for (const raw of info ?? []) {
+        const fields = fieldsOf(raw);
+        if (fields["name"] !== void 0) {
+          delivered.set(fields["name"], fields["last-delivered-id"] ?? "0-0");
+        }
+      }
+      due.forEach(({ wait, group }, i) => {
+        const [error, pending] = replies[i + 1] ?? [null, null];
+        const last = delivered.get(group);
+        if (error !== null || last === void 0 || !Array.isArray(pending)) return;
+        if (pending.length === 0 && compareIds(last, wait.entryId) >= 0) {
+          this.#remove(wait, `g:${group}`);
+        }
+      });
+    } catch (err) {
+      if (!this.#closed) this.#logger?.warn({ err }, "redis streams: acknowledgement poll failed");
+    }
+  }
+  // ── Reading ────────────────────────────────────────────────────────────────
+  async #createGroup(name) {
+    try {
+      await this.#cmd.xgroup("CREATE", this.#stream, name, "$", "MKSTREAM");
+    } catch (error) {
+      if (!String(error.message).includes("BUSYGROUP")) throw error;
+    }
+  }
+  async #lastId() {
+    const last = await this.#cmd.xrevrange(this.#stream, "+", "-", "COUNT", 1);
+    return last[0]?.[0] ?? "0-0";
+  }
+  /** One reader per instance tails the stream: it feeds the unnamed subscriptions and wakes the groups. */
+  #startTail() {
+    this.#tailStarted ??= this.#lastId().then((last) => {
+      this.#tailFrom = last;
+      this.#tail = this.#runTail();
+    });
+    return this.#tailStarted;
+  }
+  async #runTail() {
+    while (!this.#closed) {
+      let reply;
+      try {
+        reply = await this.#reader.xread(
+          "COUNT",
+          100,
+          "BLOCK",
+          TAIL_BLOCK_MS,
+          "STREAMS",
+          this.#stream,
+          this.#tailFrom
+        );
+      } catch (err) {
+        if (this.#closed) return;
+        this.#logger?.warn({ err }, "redis streams: reading the stream failed; retrying");
+        await new Promise((r) => setTimeout(r, 200));
+        continue;
+      }
+      const entries = streamEntries(reply);
+      for (const entry of entries) {
+        this.#tailFrom = entry.id;
+        if (entry.event !== null) this.#feedUnnamed(entry.id, entry.event);
+      }
+      if (entries.length > 0) this.#signalGroups();
+    }
+  }
+  #feedUnnamed(entryId, event) {
+    for (const sub of this.#subs.values()) {
+      if (sub.since === void 0 || !sub.live || compareIds(entryId, sub.since) <= 0) continue;
+      if (!matches(sub, event.type)) continue;
+      sub.queue.push({ entryId, event });
+      if (sub.running === null && !sub.starting) sub.running = this.#runQueue(sub);
+    }
+  }
+  /** An unnamed subscription takes its events one at a time, in stream order. */
+  async #runQueue(sub) {
+    try {
+      for (let next = sub.queue.shift(); next !== void 0; next = sub.queue.shift()) {
+        if (!sub.live || this.#closed) break;
+        await this.#run(sub, next.event);
+        this.#settle(next.event.id, `s:${sub.id}`);
+      }
+    } finally {
+      sub.running = null;
+      sub.queue.length = 0;
+    }
+  }
+  #startTick() {
+    if (this.#tick !== null || this.#closed) return;
+    const every = Math.min(1e3, Math.max(50, Math.floor(this.#claimIdleMs / 4)));
+    this.#tick = setInterval(() => {
+      for (const group of this.#groups.values()) {
+        group.claimDue = true;
+        void this.#drainGroup(group);
+      }
+    }, every);
+    this.#tick.unref();
+  }
+  #signalGroups() {
+    for (const group of this.#groups.values()) void this.#drainGroup(group);
+  }
+  /**
+   * A group's consumer on this instance, one pass at a time: entries a dead consumer left pending past `claimIdleMs`
+   * first (when due), then new ones, each handled and acknowledged in stream order.
+   */
+  #drainGroup(group) {
+    if (group.draining !== null) {
+      group.again = true;
+      return group.draining;
+    }
+    group.draining = (async () => {
+      do {
+        group.again = false;
+        if (group.claimDue) {
+          group.claimDue = false;
+          await this.#claim(group);
+        }
+        await this.#readNew(group);
+      } while (group.again && !this.#closed && group.subs.size > 0);
+    })().catch((err) => {
+      if (!this.#closed)
+        this.#logger?.warn({ err, group: group.name }, "redis streams: group read failed");
+    }).finally(() => {
+      group.draining = null;
+      if (group.again && !this.#closed && group.subs.size > 0) void this.#drainGroup(group);
+    });
+    return group.draining;
+  }
+  async #readNew(group) {
+    for (; ; ) {
+      if (this.#closed || group.subs.size === 0) return;
+      let reply;
+      try {
+        reply = await this.#cmd.xreadgroup(
+          "GROUP",
+          group.name,
+          this.#consumer,
+          "COUNT",
+          READ_COUNT,
+          "STREAMS",
+          this.#stream,
+          ">"
+        );
+      } catch (error) {
+        if (String(error.message).includes("NOGROUP")) {
+          await this.#createGroup(group.name);
+          return;
+        }
+        throw error;
+      }
+      const entries = streamEntries(reply);
+      await this.#handle(group, entries);
+      if (entries.length < READ_COUNT) return;
+    }
+  }
+  async #claim(group) {
+    let start = "0-0";
+    do {
+      if (this.#closed || group.subs.size === 0) return;
+      const reply = await this.#cmd.xautoclaim(
+        this.#stream,
+        group.name,
+        this.#consumer,
+        this.#claimIdleMs,
+        start,
+        "COUNT",
+        READ_COUNT
+      );
+      start = reply[0];
+      const entries = entriesOf(reply[1]);
+      if (entries.length > 0) {
+        this.#logger?.info(
+          { group: group.name, entries: entries.map((e) => e.id) },
+          "redis streams: took over entries a consumer left pending"
+        );
+      }
+      await this.#handle(group, entries);
+    } while (start !== "0-0");
+  }
+  /**
+   * Handles each entry for the group's matching subscriptions, then acknowledges it; non-matching ones in bulk. Once
+   * the group has no live subscription here, the rest stay pending, for a live consumer of the group to take over.
+   */
+  async #handle(group, entries) {
+    const skipped = [];
+    for (const entry of entries) {
+      if (![...group.subs].some((s) => s.live)) break;
+      const event = entry.event;
+      const subs = event === null ? [] : [...group.subs].filter((s) => s.live && matches(s, event.type));
+      if (event === null || subs.length === 0) {
+        if (event === null)
+          this.#logger?.error({ entryId: entry.id }, "redis streams: unreadable entry");
+        skipped.push(entry.id);
+        continue;
+      }
+      await Promise.all(subs.map((s) => this.#run(s, event)));
+      await this.#cmd.xack(this.#stream, group.name, entry.id);
+      this.#settle(event.id, `g:${group.name}`);
+    }
+    if (skipped.length > 0) await this.#cmd.xack(this.#stream, group.name, ...skipped);
+  }
+  /** Runs one handler; an error is logged and acknowledged like a success, as the in-process bus does. */
+  async #run(sub, event) {
+    try {
+      await sub.handler(event);
+    } catch (err) {
+      this.#logger?.error(
+        { err, subscriptionId: sub.id, eventType: event.type, eventId: event.id },
+        "Event handler failed"
+      );
+    }
+  }
+  // ── Leaving ────────────────────────────────────────────────────────────────
+  async #unsubscribe(id) {
+    const sub = this.#subs.get(id);
+    if (sub === void 0) return;
+    sub.live = false;
+    this.#subs.delete(id);
+    if (sub.since !== void 0) {
+      sub.queue.length = 0;
+      this.#settleEverywhere(`s:${id}`);
+      return;
+    }
+    for (const group of this.#groups.values()) {
+      if (!group.subs.delete(sub) || group.subs.size > 0) continue;
+      this.#groups.delete(group.name);
+      this.#settleEverywhere(`g:${group.name}`);
+      await group.draining?.catch(() => void 0);
+      if (!this.#closed) await this.#leaveGroup(group.name);
+    }
+  }
+  /** Removes this instance's consumer from the group when it holds nothing pending, which would be lost with it. */
+  async #leaveGroup(name) {
+    if (this.#groups.has(name) && !this.#closed) return;
+    try {
+      const summary = await this.#cmd.xpending(
+        this.#stream,
+        name,
+        "-",
+        "+",
+        1,
+        this.#consumer
+      );
+      if (summary.length === 0) {
+        await this.#cmd.xgroup("DELCONSUMER", this.#stream, name, this.#consumer);
+      }
+    } catch (err) {
+      this.#logger?.debug({ err, group: name }, "redis streams: consumer left in place");
+    }
+  }
+  #assertOpen() {
+    if (this.#closed) {
+      throw new AdapterError("closed", "the redis streams event bus is closed");
+    }
+  }
+};
+function matches(sub, type) {
+  return sub.regexes.some((re) => re.test(type));
+}
+function validate(event) {
+  if (!event.id || !event.type || !event.timestamp || !event.source) {
+    throw new ValidationError("Event is missing required envelope fields", { context: { event } });
+  }
+  if (!event.metadata || !event.metadata.storeId || !event.metadata.environment) {
+    throw new ValidationError("Event metadata is missing required fields", { context: { event } });
+  }
+}
+function pingRedis(url, timeoutMs = HEALTH_CHECK_TIMEOUT_MS) {
+  const client = new Redis(url, {
+    lazyConnect: true,
+    retryStrategy: () => null,
+    maxRetriesPerRequest: 0,
+    enableOfflineQueue: false,
+    connectTimeout: timeoutMs
+  });
+  client.on("error", () => void 0);
+  return boundedHealthCheck(
+    async () => {
+      await client.connect();
+      await client.ping();
+      return { status: "healthy" };
+    },
+    { timeoutMs, redact: connectionSecrets(url) }
+  ).finally(() => client.disconnect());
+}
+async function connect(url, logger, role) {
+  const client = new Redis(
+    url,
+    role === "reader" ? { lazyConnect: true, maxRetriesPerRequest: null } : {
+      lazyConnect: true,
+      maxRetriesPerRequest: 1,
+      retryStrategy: (times) => Math.min(times * 200, 1e3),
+      connectTimeout: 2e3
+    }
+  );
+  client.on("error", (err) => logger?.warn({ err, role }, "redis connection error"));
+  try {
+    await client.connect();
+  } catch (error) {
+    client.disconnect();
+    throw error;
+  }
+  return client;
+}
+async function createRedisStreamsEventBus(options) {
+  const cmd = await connect(options.url, options.logger, "commands");
+  try {
+    const reader = await connect(options.url, options.logger, "reader");
+    return new RedisStreamsEventBus(cmd, reader, options);
+  } catch (error) {
+    cmd.disconnect();
+    throw error;
+  }
+}
+
+// src/index.ts
+function positive(value, name) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+  throw new ConfigError(`@nymbalhq/event-bus-redis-streams: ${name} must be a positive integer`, {
+    code: "config.invalid",
+    context: { slot: "eventBus", [name]: value }
+  });
+}
+async function createAdapter(ctx) {
+  if (ctx.slot !== "eventBus") {
+    throw new ConfigError(`@nymbalhq/event-bus-redis-streams serves eventBus, not ${ctx.slot}`, {
+      code: "adapter.wrong_slot",
+      context: { slot: ctx.slot }
+    });
+  }
+  const { url, prefix } = ctx.config;
+  if (typeof url !== "string" || url === "" || typeof prefix !== "string" || prefix === "") {
+    throw new ConfigError("@nymbalhq/event-bus-redis-streams needs a Redis url and a key prefix", {
+      code: "config.invalid",
+      context: { slot: ctx.slot }
+    });
+  }
+  const ackTimeoutMs = positive(ctx.config["ackTimeoutMs"], "ackTimeoutMs");
+  const claimIdleMs = positive(ctx.config["claimIdleMs"], "claimIdleMs");
+  const streamMaxLen = positive(ctx.config["streamMaxLen"], "streamMaxLen");
+  return createRedisStreamsEventBus({
+    url,
+    prefix,
+    logger: ctx.logger,
+    ...ackTimeoutMs !== void 0 && { ackTimeoutMs },
+    ...claimIdleMs !== void 0 && { claimIdleMs },
+    ...streamMaxLen !== void 0 && { streamMaxLen }
+  });
+}
+export {
+  RedisStreamsEventBus,
+  createAdapter,
+  createRedisStreamsEventBus
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/redis-streams-event-bus.ts"],"sourcesContent":["import { ConfigError, type AdapterContext, type EventBusAdapter } from '@nymbalhq/types'\nimport {\n  createRedisStreamsEventBus,\n  RedisStreamsEventBus,\n  type RedisStreamsEventBusOptions,\n} from './redis-streams-event-bus.js'\n\nexport { createRedisStreamsEventBus, RedisStreamsEventBus, type RedisStreamsEventBusOptions }\n\nfunction positive(value: unknown, name: string): number | undefined {\n  if (value === undefined) return undefined\n  if (typeof value === 'number' && Number.isInteger(value) && value > 0) return value\n  throw new ConfigError(`@nymbalhq/event-bus-redis-streams: ${name} must be a positive integer`, {\n    code: 'config.invalid',\n    context: { slot: 'eventBus', [name]: value },\n  })\n}\n\n/**\n * The kernel's entry: `infrastructure.eventBus: 'redis-streams'`, with `{ url, prefix, ackTimeoutMs, claimIdleMs,\n * streamMaxLen }` from the `redis` block.\n */\nexport async function createAdapter(ctx: AdapterContext): Promise<EventBusAdapter> {\n  if (ctx.slot !== 'eventBus') {\n    throw new ConfigError(`@nymbalhq/event-bus-redis-streams serves eventBus, not ${ctx.slot}`, {\n      code: 'adapter.wrong_slot',\n      context: { slot: ctx.slot },\n    })\n  }\n  const { url, prefix } = ctx.config\n  if (typeof url !== 'string' || url === '' || typeof prefix !== 'string' || prefix === '') {\n    throw new ConfigError('@nymbalhq/event-bus-redis-streams needs a Redis url and a key prefix', {\n      code: 'config.invalid',\n      context: { slot: ctx.slot },\n    })\n  }\n  const ackTimeoutMs = positive(ctx.config['ackTimeoutMs'], 'ackTimeoutMs')\n  const claimIdleMs = positive(ctx.config['claimIdleMs'], 'claimIdleMs')\n  const streamMaxLen = positive(ctx.config['streamMaxLen'], 'streamMaxLen')\n  return createRedisStreamsEventBus({\n    url,\n    prefix,\n    logger: ctx.logger,\n    ...(ackTimeoutMs !== undefined && { ackTimeoutMs }),\n    ...(claimIdleMs !== undefined && { claimIdleMs }),\n    ...(streamMaxLen !== undefined && { streamMaxLen }),\n  })\n}\n","import { randomUUID } from 'node:crypto'\nimport { Redis } from 'ioredis'\nimport {\n  AdapterError,\n  boundedHealthCheck,\n  connectionSecrets,\n  HEALTH_CHECK_TIMEOUT_MS,\n  ValidationError,\n  type EventBusAdapter,\n  type EventHandler,\n  type HealthReport,\n  type Logger,\n  type NymbalEvent,\n  type Subscription,\n  type SubscriptionConfig,\n} from '@nymbalhq/types'\n\nexport interface RedisStreamsEventBusOptions {\n  /** `redis://[user:password@]host:port[/db]`; the db index in the path is honoured. */\n  url: string\n  /** Namespaces the stream (`<prefix>:events`) and so every consumer group on it. */\n  prefix: string\n  logger?: Logger\n  /** How long `publish` waits for the groups it delivers to before it rejects (default 15 000). */\n  ackTimeoutMs?: number\n  /** How long an entry may stay pending on a consumer before a live consumer of its group takes it over (5 000). */\n  claimIdleMs?: number\n  /** The approximate length the stream is trimmed to (`XADD MAXLEN ~`, default 10 000). */\n  streamMaxLen?: number\n}\n\ninterface Sub {\n  id: string\n  patterns: string[]\n  regexes: RegExp[]\n  handler: EventHandler\n  derived: boolean\n  live: boolean\n  /** Unnamed only: the stream's last entry when it subscribed; it receives what comes after. */\n  since?: string\n  /** Unnamed only: its starting point is still being read; what the tail feeds it meanwhile waits in the queue. */\n  starting: boolean\n  queue: Array<{ entryId: string; event: NymbalEvent }>\n  running: Promise<void> | null\n}\n\ninterface Group {\n  name: string\n  subs: Set<Sub>\n  ready: Promise<void>\n  draining: Promise<void> | null\n  again: boolean\n  claimDue: boolean\n}\n\ninterface Wait {\n  event: NymbalEvent<unknown>\n  entryId: string | null\n  /** `g:<group>` for a named group, `s:<subscription>` for an unnamed subscription of this instance. */\n  targets: Set<string>\n  startedAt: number\n  resolve(): void\n  reject(error: unknown): void\n  timer: NodeJS.Timeout\n}\n\ntype Entry = { id: string; event: NymbalEvent | null }\n\nconst READ_COUNT = 10\nconst TAIL_BLOCK_MS = 5_000\n/** How often a wait on another instance's consumer asks Redis whether its group acknowledged the entry. */\nconst ACK_POLL_MS = 25\n\nfunction compilePattern(pattern: string): RegExp {\n  const escaped = pattern.replace(/[.+?^${}()|[\\]\\\\*]/g, '\\\\$&').replace(/\\\\\\*/g, '.*')\n  return new RegExp(`^${escaped}$`)\n}\n\n/** Stream ids are `<ms>-<seq>`; ordered by both parts. */\nfunction compareIds(a: string, b: string): number {\n  const [am = 0, as = 0] = a.split('-').map(Number)\n  const [bm = 0, bs = 0] = b.split('-').map(Number)\n  return am !== bm ? am - bm : as - bs\n}\n\nfunction fieldsOf(raw: unknown): Record<string, string> {\n  const out: Record<string, string> = {}\n  if (!Array.isArray(raw)) return out\n  for (let i = 0; i + 1 < raw.length; i += 2) out[String(raw[i])] = String(raw[i + 1])\n  return out\n}\n\n/** `[[id, fields], …]` from XREAD, XREADGROUP or XAUTOCLAIM; an entry trimmed away has no fields. */\nfunction entriesOf(raw: unknown): Entry[] {\n  if (!Array.isArray(raw)) return []\n  const out: Entry[] = []\n  for (const item of raw) {\n    if (!Array.isArray(item) || typeof item[0] !== 'string') continue\n    const json = fieldsOf(item[1])['event']\n    let event: NymbalEvent | null = null\n    if (json !== undefined) {\n      try {\n        event = JSON.parse(json) as NymbalEvent\n      } catch {\n        event = null\n      }\n    }\n    out.push({ id: item[0], event })\n  }\n  return out\n}\n\nfunction streamEntries(reply: unknown): Entry[] {\n  if (!Array.isArray(reply)) return []\n  return reply.flatMap((stream: unknown) => (Array.isArray(stream) ? entriesOf(stream[1]) : []))\n}\n\n/**\n * An event bus on Redis Streams that keeps the in-process delivery contract. Every event is one entry on\n * `<prefix>:events`. A named subscription is a durable consumer group, shared by every instance, so each event is\n * handled once per name; an unnamed subscription reads the stream from where it subscribed, so every subscriber on\n * every instance receives every event. `publish` resolves once every matching group this instance reads, and every\n * matching unnamed subscription it holds, has handled the event.\n */\nexport class RedisStreamsEventBus implements EventBusAdapter {\n  readonly #cmd: Redis\n  readonly #reader: Redis\n  readonly #url: string\n  readonly #stream: string\n  readonly #consumer = randomUUID()\n  readonly #logger: Logger | undefined\n  readonly #ackTimeoutMs: number\n  readonly #claimIdleMs: number\n  readonly #streamMaxLen: number\n  readonly #subs = new Map<string, Sub>()\n  readonly #groups = new Map<string, Group>()\n  readonly #waits = new Map<string, Set<Wait>>()\n  #tail: Promise<void> | null = null\n  #tailStarted: Promise<void> | null = null\n  #tailFrom = '0-0'\n  #tick: NodeJS.Timeout | null = null\n  #poll: NodeJS.Timeout | null = null\n  #closed = false\n\n  constructor(cmd: Redis, reader: Redis, options: RedisStreamsEventBusOptions) {\n    this.#cmd = cmd\n    this.#reader = reader\n    this.#url = options.url\n    this.#stream = `${options.prefix}:events`\n    this.#logger = options.logger\n    this.#ackTimeoutMs = options.ackTimeoutMs ?? 15_000\n    this.#claimIdleMs = options.claimIdleMs ?? 5_000\n    this.#streamMaxLen = options.streamMaxLen ?? 10_000\n  }\n\n  capabilities(): readonly string[] {\n    return ['publish', 'subscribe', 'wildcard', 'replay', 'consumer-groups', 'fan-out']\n  }\n\n  healthCheck(): Promise<HealthReport> {\n    return pingRedis(this.#url)\n  }\n\n  async publish<T>(event: NymbalEvent<T>): Promise<void> {\n    await this.publishBatch([event as NymbalEvent<unknown>])\n  }\n\n  async publishBatch(events: NymbalEvent<unknown>[]): Promise<void> {\n    for (const event of events) validate(event)\n    this.#assertOpen()\n    if (events.length === 0) return\n    // Registered before the entry exists: a reader may finish with it before XADD's reply is read.\n    const waits = events.map((event) => this.#wait(event))\n    const pipeline = this.#cmd.pipeline()\n    for (const event of events) {\n      pipeline.xadd(\n        this.#stream,\n        'MAXLEN',\n        '~',\n        this.#streamMaxLen,\n        '*',\n        'type',\n        event.type,\n        'event',\n        JSON.stringify(event),\n      )\n    }\n    let replies: Array<[Error | null, unknown]> | null\n    try {\n      replies = await pipeline.exec()\n    } catch (error) {\n      for (const wait of waits) this.#drop(wait)\n      throw error\n    }\n    const failed =\n      replies === null\n        ? new AdapterError('publish_failed', 'the stream write was aborted')\n        : replies.find(([error]) => error !== null)?.[0]\n    if (failed !== undefined && failed !== null) {\n      // The relay records the failure and publishes the whole set again later.\n      for (const wait of waits) this.#drop(wait)\n      throw failed\n    }\n    replies?.forEach(([, id], i) => {\n      waits[i]!.entryId = String(id)\n    })\n    this.#signalGroups()\n    this.#schedulePoll()\n    await Promise.all(waits.map((w) => w.promise))\n  }\n\n  async replay(events: NymbalEvent<unknown>[]): Promise<void> {\n    for (const event of events) {\n      validate(event)\n      const derived = [...this.#subs.values()].filter((s) => s.derived && matches(s, event.type))\n      await Promise.all(derived.map((s) => this.#run(s, event)))\n    }\n  }\n\n  async subscribe(\n    eventPattern: string | string[],\n    handler: EventHandler,\n    config?: SubscriptionConfig,\n  ): Promise<Subscription> {\n    this.#assertOpen()\n    // The tail starts before an unnamed subscription takes its starting point, so it reads everything after it.\n    await this.#startTail()\n    const patterns = Array.isArray(eventPattern) ? eventPattern : [eventPattern]\n    const sub: Sub = {\n      id: randomUUID(),\n      patterns,\n      regexes: patterns.map(compilePattern),\n      handler,\n      derived: config?.derived === true,\n      live: true,\n      starting: false,\n      queue: [],\n      running: null,\n    }\n    const name = config?.name\n    if (name !== undefined) {\n      let group = this.#groups.get(name)\n      if (group === undefined) {\n        group = {\n          name,\n          subs: new Set(),\n          ready: this.#createGroup(name),\n          draining: null,\n          again: false,\n          claimDue: false,\n        }\n        this.#groups.set(name, group)\n      }\n      try {\n        await group.ready\n      } catch (error) {\n        if (group.subs.size === 0) this.#groups.delete(name)\n        throw error\n      }\n      group.subs.add(sub)\n      this.#subs.set(sub.id, sub)\n      // A durable group may hold entries from before this subscription, or ones a dead consumer left pending.\n      group.claimDue = true\n      void this.#drainGroup(group)\n    } else {\n      // Joins before its starting point is read: an entry the tail reads meanwhile is queued, then kept if it is later.\n      sub.since = this.#tailFrom\n      sub.starting = true\n      this.#subs.set(sub.id, sub)\n      let last: string\n      try {\n        last = await this.#lastId()\n      } catch (error) {\n        sub.live = false\n        this.#subs.delete(sub.id)\n        throw error\n      }\n      sub.since = last\n      sub.starting = false\n      const later = sub.queue.filter((q) => compareIds(q.entryId, last) > 0)\n      sub.queue.splice(0, sub.queue.length, ...later)\n      if (sub.queue.length > 0 && sub.running === null) sub.running = this.#runQueue(sub)\n    }\n    this.#startTick()\n    const self = this\n    return {\n      id: sub.id,\n      patterns,\n      async unsubscribe() {\n        await self.#unsubscribe(sub.id)\n      },\n    }\n  }\n\n  async unsubscribe(subscription: Subscription): Promise<void> {\n    await this.#unsubscribe(subscription.id)\n  }\n\n  async close(): Promise<void> {\n    if (this.#closed) return\n    this.#closed = true\n    if (this.#tick !== null) clearInterval(this.#tick)\n    if (this.#poll !== null) clearTimeout(this.#poll)\n    this.#tick = null\n    this.#poll = null\n    // A wait on this instance's readers ends with them.\n    for (const waits of [...this.#waits.values()]) {\n      for (const wait of [...waits]) {\n        this.#drop(wait)\n        wait.resolve()\n      }\n    }\n    this.#reader.disconnect()\n    await this.#tail?.catch(() => undefined)\n    const groups = [...this.#groups.values()]\n    await Promise.all([\n      ...groups.map((g) => g.draining?.catch(() => undefined)),\n      ...[...this.#subs.values()].map((s) => s.running?.catch(() => undefined)),\n    ])\n    for (const sub of this.#subs.values()) sub.live = false\n    this.#subs.clear()\n    await Promise.all(groups.map((g) => this.#leaveGroup(g.name)))\n    this.#groups.clear()\n    await this.#cmd.quit().catch(() => this.#cmd.disconnect())\n  }\n\n  // ── Waiting ────────────────────────────────────────────────────────────────\n\n  #wait(event: NymbalEvent<unknown>): Wait & { promise: Promise<void> } {\n    const targets = new Set<string>()\n    for (const group of this.#groups.values()) {\n      if ([...group.subs].some((s) => s.live && matches(s, event.type)))\n        targets.add(`g:${group.name}`)\n    }\n    for (const sub of this.#subs.values()) {\n      if (sub.since !== undefined && sub.live && !sub.starting && matches(sub, event.type))\n        targets.add(`s:${sub.id}`)\n    }\n    let resolve!: () => void\n    let reject!: (error: unknown) => void\n    const promise = new Promise<void>((res, rej) => {\n      resolve = res\n      reject = rej\n    })\n    const wait = {\n      event,\n      entryId: null,\n      targets,\n      startedAt: Date.now(),\n      resolve,\n      reject,\n      promise,\n      timer: undefined as unknown as NodeJS.Timeout,\n    }\n    if (targets.size === 0) {\n      resolve()\n      return wait\n    }\n    wait.timer = setTimeout(() => this.#timeout(wait), this.#ackTimeoutMs)\n    const forEvent = this.#waits.get(event.id) ?? new Set<Wait>()\n    forEvent.add(wait)\n    this.#waits.set(event.id, forEvent)\n    return wait\n  }\n\n  #timeout(wait: Wait): void {\n    if (!this.#drop(wait)) return\n    const pending = [...wait.targets]\n    this.#logger?.error(\n      {\n        eventId: wait.event.id,\n        eventType: wait.event.type,\n        entryId: wait.entryId,\n        unacknowledged: pending,\n      },\n      'redis streams publish timed out waiting for its handlers',\n    )\n    wait.reject(\n      new AdapterError(\n        'publish_timeout',\n        `publish of ${wait.event.type} (${wait.event.id}) was not handled within ${this.#ackTimeoutMs} ms by ${pending.join(', ')}`,\n        { context: { eventId: wait.event.id, unacknowledged: pending } },\n      ),\n    )\n  }\n\n  /** Forgets `wait`; false when it was already settled. */\n  #drop(wait: Wait): boolean {\n    const forEvent = this.#waits.get(wait.event.id)\n    if (forEvent === undefined || !forEvent.delete(wait)) return false\n    if (forEvent.size === 0) this.#waits.delete(wait.event.id)\n    clearTimeout(wait.timer)\n    return true\n  }\n\n  /** `target` has finished with `eventId`: a wait left with nothing to wait on resolves. */\n  #settle(eventId: string, target: string): void {\n    for (const wait of [...(this.#waits.get(eventId) ?? [])]) this.#remove(wait, target)\n  }\n\n  #settleEverywhere(target: string): void {\n    for (const waits of [...this.#waits.values()]) {\n      for (const wait of [...waits]) this.#remove(wait, target)\n    }\n  }\n\n  #remove(wait: Wait, target: string): void {\n    if (!wait.targets.delete(target) || wait.targets.size > 0) return\n    if (this.#drop(wait)) wait.resolve()\n  }\n\n  /**\n   * A group's entry may be handled by another instance's consumer: asks Redis, for each wait still on a group, whether\n   * the group has delivered the entry and holds it pending no more.\n   */\n  #schedulePoll(): void {\n    if (this.#poll !== null || this.#closed || this.#waits.size === 0) return\n    this.#poll = setTimeout(() => {\n      this.#poll = null\n      void this.#pollAcks().finally(() => this.#schedulePoll())\n    }, ACK_POLL_MS)\n  }\n\n  async #pollAcks(): Promise<void> {\n    const due: Array<{ wait: Wait; group: string }> = []\n    const now = Date.now()\n    for (const waits of this.#waits.values()) {\n      for (const wait of waits) {\n        if (wait.entryId === null || now - wait.startedAt < ACK_POLL_MS) continue\n        for (const target of wait.targets) {\n          if (target.startsWith('g:')) due.push({ wait, group: target.slice(2) })\n        }\n      }\n    }\n    if (due.length === 0) return\n    try {\n      const pipeline = this.#cmd.pipeline().xinfo('GROUPS', this.#stream)\n      for (const { wait, group } of due) {\n        pipeline.xpending(this.#stream, group, wait.entryId!, wait.entryId!, 1)\n      }\n      const replies = (await pipeline.exec()) ?? []\n      const delivered = new Map<string, string>()\n      const [infoError, info] = replies[0] ?? [null, []]\n      if (infoError !== null) return\n      for (const raw of (info as unknown[]) ?? []) {\n        const fields = fieldsOf(raw)\n        if (fields['name'] !== undefined) {\n          delivered.set(fields['name'], fields['last-delivered-id'] ?? '0-0')\n        }\n      }\n      due.forEach(({ wait, group }, i) => {\n        const [error, pending] = replies[i + 1] ?? [null, null]\n        const last = delivered.get(group)\n        if (error !== null || last === undefined || !Array.isArray(pending)) return\n        if (pending.length === 0 && compareIds(last, wait.entryId!) >= 0) {\n          this.#remove(wait, `g:${group}`)\n        }\n      })\n    } catch (err) {\n      if (!this.#closed) this.#logger?.warn({ err }, 'redis streams: acknowledgement poll failed')\n    }\n  }\n\n  // ── Reading ────────────────────────────────────────────────────────────────\n\n  async #createGroup(name: string): Promise<void> {\n    try {\n      await this.#cmd.xgroup('CREATE', this.#stream, name, '$', 'MKSTREAM')\n    } catch (error) {\n      if (!String((error as Error).message).includes('BUSYGROUP')) throw error\n    }\n  }\n\n  async #lastId(): Promise<string> {\n    const last = (await this.#cmd.xrevrange(this.#stream, '+', '-', 'COUNT', 1)) as Array<\n      [string, string[]]\n    >\n    return last[0]?.[0] ?? '0-0'\n  }\n\n  /** One reader per instance tails the stream: it feeds the unnamed subscriptions and wakes the groups. */\n  #startTail(): Promise<void> {\n    this.#tailStarted ??= this.#lastId().then((last) => {\n      this.#tailFrom = last\n      this.#tail = this.#runTail()\n    })\n    return this.#tailStarted\n  }\n\n  async #runTail(): Promise<void> {\n    while (!this.#closed) {\n      let reply: unknown\n      try {\n        reply = await this.#reader.xread(\n          'COUNT',\n          100,\n          'BLOCK',\n          TAIL_BLOCK_MS,\n          'STREAMS',\n          this.#stream,\n          this.#tailFrom,\n        )\n      } catch (err) {\n        if (this.#closed) return\n        this.#logger?.warn({ err }, 'redis streams: reading the stream failed; retrying')\n        await new Promise((r) => setTimeout(r, 200))\n        continue\n      }\n      const entries = streamEntries(reply)\n      for (const entry of entries) {\n        this.#tailFrom = entry.id\n        if (entry.event !== null) this.#feedUnnamed(entry.id, entry.event)\n      }\n      if (entries.length > 0) this.#signalGroups()\n    }\n  }\n\n  #feedUnnamed(entryId: string, event: NymbalEvent): void {\n    for (const sub of this.#subs.values()) {\n      if (sub.since === undefined || !sub.live || compareIds(entryId, sub.since) <= 0) continue\n      if (!matches(sub, event.type)) continue\n      sub.queue.push({ entryId, event })\n      if (sub.running === null && !sub.starting) sub.running = this.#runQueue(sub)\n    }\n  }\n\n  /** An unnamed subscription takes its events one at a time, in stream order. */\n  async #runQueue(sub: Sub): Promise<void> {\n    try {\n      for (let next = sub.queue.shift(); next !== undefined; next = sub.queue.shift()) {\n        if (!sub.live || this.#closed) break\n        await this.#run(sub, next.event)\n        this.#settle(next.event.id, `s:${sub.id}`)\n      }\n    } finally {\n      sub.running = null\n      sub.queue.length = 0\n    }\n  }\n\n  #startTick(): void {\n    if (this.#tick !== null || this.#closed) return\n    const every = Math.min(1_000, Math.max(50, Math.floor(this.#claimIdleMs / 4)))\n    this.#tick = setInterval(() => {\n      for (const group of this.#groups.values()) {\n        group.claimDue = true\n        void this.#drainGroup(group)\n      }\n    }, every)\n    this.#tick.unref()\n  }\n\n  #signalGroups(): void {\n    for (const group of this.#groups.values()) void this.#drainGroup(group)\n  }\n\n  /**\n   * A group's consumer on this instance, one pass at a time: entries a dead consumer left pending past `claimIdleMs`\n   * first (when due), then new ones, each handled and acknowledged in stream order.\n   */\n  #drainGroup(group: Group): Promise<void> {\n    if (group.draining !== null) {\n      group.again = true\n      return group.draining\n    }\n    group.draining = (async () => {\n      do {\n        group.again = false\n        if (group.claimDue) {\n          group.claimDue = false\n          await this.#claim(group)\n        }\n        await this.#readNew(group)\n      } while (group.again && !this.#closed && group.subs.size > 0)\n    })()\n      .catch((err: unknown) => {\n        if (!this.#closed)\n          this.#logger?.warn({ err, group: group.name }, 'redis streams: group read failed')\n      })\n      .finally(() => {\n        group.draining = null\n        // Asked for again after the last pass looked: one more.\n        if (group.again && !this.#closed && group.subs.size > 0) void this.#drainGroup(group)\n      })\n    return group.draining\n  }\n\n  async #readNew(group: Group): Promise<void> {\n    for (;;) {\n      if (this.#closed || group.subs.size === 0) return\n      let reply: unknown\n      try {\n        reply = await this.#cmd.xreadgroup(\n          'GROUP',\n          group.name,\n          this.#consumer,\n          'COUNT',\n          READ_COUNT,\n          'STREAMS',\n          this.#stream,\n          '>',\n        )\n      } catch (error) {\n        // The stream or the group was deleted under us: create it again and read on the next pass.\n        if (String((error as Error).message).includes('NOGROUP')) {\n          await this.#createGroup(group.name)\n          return\n        }\n        throw error\n      }\n      const entries = streamEntries(reply)\n      await this.#handle(group, entries)\n      if (entries.length < READ_COUNT) return\n    }\n  }\n\n  async #claim(group: Group): Promise<void> {\n    let start = '0-0'\n    do {\n      if (this.#closed || group.subs.size === 0) return\n      const reply = (await this.#cmd.xautoclaim(\n        this.#stream,\n        group.name,\n        this.#consumer,\n        this.#claimIdleMs,\n        start,\n        'COUNT',\n        READ_COUNT,\n      )) as [string, unknown, unknown?]\n      start = reply[0]\n      const entries = entriesOf(reply[1])\n      if (entries.length > 0) {\n        this.#logger?.info(\n          { group: group.name, entries: entries.map((e) => e.id) },\n          'redis streams: took over entries a consumer left pending',\n        )\n      }\n      await this.#handle(group, entries)\n    } while (start !== '0-0')\n  }\n\n  /**\n   * Handles each entry for the group's matching subscriptions, then acknowledges it; non-matching ones in bulk. Once\n   * the group has no live subscription here, the rest stay pending, for a live consumer of the group to take over.\n   */\n  async #handle(group: Group, entries: Entry[]): Promise<void> {\n    const skipped: string[] = []\n    for (const entry of entries) {\n      if (![...group.subs].some((s) => s.live)) break\n      const event = entry.event\n      const subs =\n        event === null ? [] : [...group.subs].filter((s) => s.live && matches(s, event.type))\n      if (event === null || subs.length === 0) {\n        if (event === null)\n          this.#logger?.error({ entryId: entry.id }, 'redis streams: unreadable entry')\n        skipped.push(entry.id)\n        continue\n      }\n      await Promise.all(subs.map((s) => this.#run(s, event)))\n      await this.#cmd.xack(this.#stream, group.name, entry.id)\n      this.#settle(event.id, `g:${group.name}`)\n    }\n    if (skipped.length > 0) await this.#cmd.xack(this.#stream, group.name, ...skipped)\n  }\n\n  /** Runs one handler; an error is logged and acknowledged like a success, as the in-process bus does. */\n  async #run(sub: Sub, event: NymbalEvent): Promise<void> {\n    try {\n      await sub.handler(event)\n    } catch (err) {\n      this.#logger?.error(\n        { err, subscriptionId: sub.id, eventType: event.type, eventId: event.id },\n        'Event handler failed',\n      )\n    }\n  }\n\n  // ── Leaving ────────────────────────────────────────────────────────────────\n\n  async #unsubscribe(id: string): Promise<void> {\n    const sub = this.#subs.get(id)\n    if (sub === undefined) return\n    sub.live = false\n    this.#subs.delete(id)\n    if (sub.since !== undefined) {\n      sub.queue.length = 0\n      this.#settleEverywhere(`s:${id}`)\n      return\n    }\n    for (const group of this.#groups.values()) {\n      if (!group.subs.delete(sub) || group.subs.size > 0) continue\n      // No live reader of the group on this instance: no publish here waits on it any more.\n      this.#groups.delete(group.name)\n      this.#settleEverywhere(`g:${group.name}`)\n      await group.draining?.catch(() => undefined)\n      if (!this.#closed) await this.#leaveGroup(group.name)\n    }\n  }\n\n  /** Removes this instance's consumer from the group when it holds nothing pending, which would be lost with it. */\n  async #leaveGroup(name: string): Promise<void> {\n    if (this.#groups.has(name) && !this.#closed) return\n    try {\n      const summary = (await this.#cmd.xpending(\n        this.#stream,\n        name,\n        '-',\n        '+',\n        1,\n        this.#consumer,\n      )) as unknown[]\n      if (summary.length === 0) {\n        await this.#cmd.xgroup('DELCONSUMER', this.#stream, name, this.#consumer)\n      }\n    } catch (err) {\n      this.#logger?.debug({ err, group: name }, 'redis streams: consumer left in place')\n    }\n  }\n\n  #assertOpen(): void {\n    if (this.#closed) {\n      throw new AdapterError('closed', 'the redis streams event bus is closed')\n    }\n  }\n}\n\nfunction matches(sub: Sub, type: string): boolean {\n  return sub.regexes.some((re) => re.test(type))\n}\n\nfunction validate(event: NymbalEvent<unknown>): void {\n  if (!event.id || !event.type || !event.timestamp || !event.source) {\n    throw new ValidationError('Event is missing required envelope fields', { context: { event } })\n  }\n  if (!event.metadata || !event.metadata.storeId || !event.metadata.environment) {\n    throw new ValidationError('Event metadata is missing required fields', { context: { event } })\n  }\n}\n\n/**\n * PING on a client of its own that never retries and queues nothing, disconnected afterwards: the store's or bus's own\n * clients retry a closed port for as long as the process lives, so they cannot answer within the bound.\n */\nfunction pingRedis(url: string, timeoutMs = HEALTH_CHECK_TIMEOUT_MS): Promise<HealthReport> {\n  const client = new Redis(url, {\n    lazyConnect: true,\n    retryStrategy: () => null,\n    maxRetriesPerRequest: 0,\n    enableOfflineQueue: false,\n    connectTimeout: timeoutMs,\n  })\n  // connect() rejects with the same error, and the report carries it; without a listener ioredis would throw it.\n  client.on('error', () => undefined)\n  return boundedHealthCheck(\n    async () => {\n      await client.connect()\n      await client.ping()\n      return { status: 'healthy' }\n    },\n    { timeoutMs, redact: connectionSecrets(url) },\n  ).finally(() => client.disconnect())\n}\n\nasync function connect(\n  url: string,\n  logger: Logger | undefined,\n  role: 'commands' | 'reader',\n): Promise<Redis> {\n  // The reader blocks on the stream and retries for as long as it takes. A command waits out at most two reconnect\n  // attempts (each a connect of at most 2 s, a second apart) and then rejects, so a publish on a dead server fails\n  // within the bound; the client keeps reconnecting, so publishes succeed again once the server is back.\n  const client = new Redis(\n    url,\n    role === 'reader'\n      ? { lazyConnect: true, maxRetriesPerRequest: null }\n      : {\n          lazyConnect: true,\n          maxRetriesPerRequest: 1,\n          retryStrategy: (times: number) => Math.min(times * 200, 1000),\n          connectTimeout: 2000,\n        },\n  )\n  client.on('error', (err: Error) => logger?.warn({ err, role }, 'redis connection error'))\n  try {\n    await client.connect()\n  } catch (error) {\n    client.disconnect()\n    throw error\n  }\n  return client\n}\n\n/** Connects the bus's two clients: one for commands, one for the blocking read of the stream. */\nexport async function createRedisStreamsEventBus(\n  options: RedisStreamsEventBusOptions,\n): Promise<RedisStreamsEventBus> {\n  const cmd = await connect(options.url, options.logger, 'commands')\n  try {\n    const reader = await connect(options.url, options.logger, 'reader')\n    return new RedisStreamsEventBus(cmd, reader, options)\n  } catch (error) {\n    cmd.disconnect()\n    throw error\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@nymbalhq/event-bus-redis-streams",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.2.0",
+  "description": "The Redis Streams event bus for Nymbal: `infrastructure.eventBus: 'redis-streams'`",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nymbalhq/nymbal.git",
+    "directory": "packages/event-bus-redis-streams"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nymbalhq/types": "1.2.0"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.4.0 || ^6.0.0"
+  },
+  "devDependencies": {
+    "@nymbalhq/contract-tests": "1.2.0",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "fast-check": "^4.10.2",
+    "ioredis": "^6.0.0",
+    "tsup": "^9.0.0",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit --rootDir ../.."
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.