@zucker-framework/event 1.0.0 → 1.0.5

package/dist/index.d.mts

@@ -1,5 +1,7 @@
 import { ClassConstructor } from 'class-transformer';
 import { OnModuleInit, OnModuleDestroy, DynamicModule } from '@nestjs/common';
+import { ReplaySubject, Observable } from 'rxjs';
+import { EventEmitter } from 'node:events';
 
 declare enum EntityEventType {
     CREATE = "create",
@@ -810,4 +812,77 @@ declare class OperationHookRegistry {
     clear(): void;
 }
 
-export { ALL_EVENT_PHASES, type AsyncEvent, CLUSTER_TRANSPORT, CREATE_GROUP, type ClusterTransport, CompositeEventListener, CreatorEventListener, type CurrentUser, DefaultTopicEventBus, ENTITY_EVENT_CONFIG_KEY, ENTITY_EVENT_LISTENER_CUSTOMIZER, EVENT_STORE, EnableEntityEvent, type EntityEvent, type EntityEventConfig, type EntityEventListener, EntityEventListenerConfigure, type EntityEventListenerCustomizer, EntityEventPhase, EntityEventType, type EventHandler, type EventQueryOptions, type EventStore, type HookHandler, type HookPhase, type LegacyEventHandler, type OperationContext, OperationHookRegistry, SAVE_GROUP, SUBSCRIBE_KEY, SUBSCRIBE_METHODS_KEY, type StoredEvent, Subscribe, SubscribeFeature, type SubscribeOptions, type Subscription, SubscriptionBuilder, type SubscriptionInfo, type SubscriptionInfoBuilder, TOPIC_EVENT_BUS, type TopicEventBus, type TopicPayload, UPDATE_GROUP, UnifiedEventBus, ValidateEventListener, ZuckerEventModule, createAsyncEvent, createBatchEntityEvent, createCreatedEntityEvent, createDeletedEntityEvent, createEntityEvent, createModifyEntityEvent, createSavedEntityEvent, createSingleEntityEvent, createTopicPayload, getEntityEventConfig, getEntityEventName, getSubscriptions, isDoFireEvent, isEntityEventEnabled, matchesTopic, tryFireEvent, withFireEvent, withoutFireEvent };
+interface ReplayEventBusOptions<TContext, TPayload> {
+    channel: (context: TContext) => string;
+    isTerminal: (payload: TPayload) => boolean;
+    channelTtlMs: number;
+    cleanupIntervalMs: number;
+    beforePublish?: (context: TContext, payload: TPayload) => void;
+}
+/**
+ * Process-local progress notification with replay(1). Terminal events reach
+ * existing subscribers before their channel completes and is removed. Stale
+ * channels expire only when unobserved; slow work cannot evict an active stream.
+ * This is reconstructable delivery state, not durable task state or a queue.
+ */
+declare class ReplayEventBus<TContext, TPayload> {
+    protected readonly options: ReplayEventBusOptions<TContext, TPayload>;
+    protected readonly channels: Map<string, {
+        subject: ReplaySubject<TPayload>;
+        updatedAt: number;
+    }>;
+    protected closed: boolean;
+    private readonly cleanupTimer;
+    constructor(options: ReplayEventBusOptions<TContext, TPayload>);
+    publish(context: TContext, payload: TPayload): void;
+    stream(context: TContext): Observable<TPayload>;
+    protected channelStream(channel: string): Observable<TPayload>;
+    protected emitLocal(channel: string, payload: TPayload): void;
+    protected removeChannel(channel: string): void;
+    protected stop(): void;
+    onModuleDestroy(): Promise<void>;
+    private getOrCreateChannel;
+    private cleanupStaleChannels;
+}
+
+interface ReplayEventRedisClient extends Pick<EventEmitter, 'on' | 'off'> {
+    duplicate(): ReplayEventRedisClient;
+    publish(channel: string, message: string): Promise<unknown>;
+    subscribe(channel: string): Promise<unknown>;
+    unsubscribe(channel: string): Promise<unknown>;
+    quit(): Promise<unknown>;
+}
+interface RedisReplayEventBusOptions<TContext, TPayload> extends ReplayEventBusOptions<TContext, TPayload> {
+    /** The bus owns this connection and its duplicate, and closes each exactly once. */
+    createClient: () => ReplayEventRedisClient;
+    /** Validate the deserialized wire payload at the application boundary. */
+    parsePayload: (value: unknown) => TPayload;
+    logger?: {
+        error(message: string): void;
+        warn(message: string): void;
+    };
+}
+/**
+ * Redis Pub/Sub transport with process-local replay(1). Notifications published
+ * before subscription are not persisted. Subscribe failures allow a later stream
+ * call to try again; the Redis client owns network reconnect/retry configuration.
+ */
+declare class RedisReplayEventBus<TContext, TPayload> extends ReplayEventBus<TContext, TPayload> {
+    private readonly redisOptions;
+    private publisher?;
+    private subscriber?;
+    private readonly subscriptions;
+    private closePromise?;
+    private readonly onPublisherError;
+    private readonly onSubscriberError;
+    private readonly onMessage;
+    constructor(redisOptions: RedisReplayEventBusOptions<TContext, TPayload>);
+    onModuleInit(): void;
+    publish(context: TContext, payload: TPayload): void;
+    stream(context: TContext): Observable<TPayload>;
+    protected removeChannel(channel: string): void;
+    onModuleDestroy(): Promise<void>;
+    private ensureSubscribed;
+}
+
+export { ALL_EVENT_PHASES, type AsyncEvent, CLUSTER_TRANSPORT, CREATE_GROUP, type ClusterTransport, CompositeEventListener, CreatorEventListener, type CurrentUser, DefaultTopicEventBus, ENTITY_EVENT_CONFIG_KEY, ENTITY_EVENT_LISTENER_CUSTOMIZER, EVENT_STORE, EnableEntityEvent, type EntityEvent, type EntityEventConfig, type EntityEventListener, EntityEventListenerConfigure, type EntityEventListenerCustomizer, EntityEventPhase, EntityEventType, type EventHandler, type EventQueryOptions, type EventStore, type HookHandler, type HookPhase, type LegacyEventHandler, type OperationContext, OperationHookRegistry, RedisReplayEventBus, type RedisReplayEventBusOptions, ReplayEventBus, type ReplayEventBusOptions, type ReplayEventRedisClient, SAVE_GROUP, SUBSCRIBE_KEY, SUBSCRIBE_METHODS_KEY, type StoredEvent, Subscribe, SubscribeFeature, type SubscribeOptions, type Subscription, SubscriptionBuilder, type SubscriptionInfo, type SubscriptionInfoBuilder, TOPIC_EVENT_BUS, type TopicEventBus, type TopicPayload, UPDATE_GROUP, UnifiedEventBus, ValidateEventListener, ZuckerEventModule, createAsyncEvent, createBatchEntityEvent, createCreatedEntityEvent, createDeletedEntityEvent, createEntityEvent, createModifyEntityEvent, createSavedEntityEvent, createSingleEntityEvent, createTopicPayload, getEntityEventConfig, getEntityEventName, getSubscriptions, isDoFireEvent, isEntityEventEnabled, matchesTopic, tryFireEvent, withFireEvent, withoutFireEvent };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { ClassConstructor } from 'class-transformer';
 import { OnModuleInit, OnModuleDestroy, DynamicModule } from '@nestjs/common';
+import { ReplaySubject, Observable } from 'rxjs';
+import { EventEmitter } from 'node:events';
 
 declare enum EntityEventType {
     CREATE = "create",
@@ -810,4 +812,77 @@ declare class OperationHookRegistry {
     clear(): void;
 }
 
-export { ALL_EVENT_PHASES, type AsyncEvent, CLUSTER_TRANSPORT, CREATE_GROUP, type ClusterTransport, CompositeEventListener, CreatorEventListener, type CurrentUser, DefaultTopicEventBus, ENTITY_EVENT_CONFIG_KEY, ENTITY_EVENT_LISTENER_CUSTOMIZER, EVENT_STORE, EnableEntityEvent, type EntityEvent, type EntityEventConfig, type EntityEventListener, EntityEventListenerConfigure, type EntityEventListenerCustomizer, EntityEventPhase, EntityEventType, type EventHandler, type EventQueryOptions, type EventStore, type HookHandler, type HookPhase, type LegacyEventHandler, type OperationContext, OperationHookRegistry, SAVE_GROUP, SUBSCRIBE_KEY, SUBSCRIBE_METHODS_KEY, type StoredEvent, Subscribe, SubscribeFeature, type SubscribeOptions, type Subscription, SubscriptionBuilder, type SubscriptionInfo, type SubscriptionInfoBuilder, TOPIC_EVENT_BUS, type TopicEventBus, type TopicPayload, UPDATE_GROUP, UnifiedEventBus, ValidateEventListener, ZuckerEventModule, createAsyncEvent, createBatchEntityEvent, createCreatedEntityEvent, createDeletedEntityEvent, createEntityEvent, createModifyEntityEvent, createSavedEntityEvent, createSingleEntityEvent, createTopicPayload, getEntityEventConfig, getEntityEventName, getSubscriptions, isDoFireEvent, isEntityEventEnabled, matchesTopic, tryFireEvent, withFireEvent, withoutFireEvent };
+interface ReplayEventBusOptions<TContext, TPayload> {
+    channel: (context: TContext) => string;
+    isTerminal: (payload: TPayload) => boolean;
+    channelTtlMs: number;
+    cleanupIntervalMs: number;
+    beforePublish?: (context: TContext, payload: TPayload) => void;
+}
+/**
+ * Process-local progress notification with replay(1). Terminal events reach
+ * existing subscribers before their channel completes and is removed. Stale
+ * channels expire only when unobserved; slow work cannot evict an active stream.
+ * This is reconstructable delivery state, not durable task state or a queue.
+ */
+declare class ReplayEventBus<TContext, TPayload> {
+    protected readonly options: ReplayEventBusOptions<TContext, TPayload>;
+    protected readonly channels: Map<string, {
+        subject: ReplaySubject<TPayload>;
+        updatedAt: number;
+    }>;
+    protected closed: boolean;
+    private readonly cleanupTimer;
+    constructor(options: ReplayEventBusOptions<TContext, TPayload>);
+    publish(context: TContext, payload: TPayload): void;
+    stream(context: TContext): Observable<TPayload>;
+    protected channelStream(channel: string): Observable<TPayload>;
+    protected emitLocal(channel: string, payload: TPayload): void;
+    protected removeChannel(channel: string): void;
+    protected stop(): void;
+    onModuleDestroy(): Promise<void>;
+    private getOrCreateChannel;
+    private cleanupStaleChannels;
+}
+
+interface ReplayEventRedisClient extends Pick<EventEmitter, 'on' | 'off'> {
+    duplicate(): ReplayEventRedisClient;
+    publish(channel: string, message: string): Promise<unknown>;
+    subscribe(channel: string): Promise<unknown>;
+    unsubscribe(channel: string): Promise<unknown>;
+    quit(): Promise<unknown>;
+}
+interface RedisReplayEventBusOptions<TContext, TPayload> extends ReplayEventBusOptions<TContext, TPayload> {
+    /** The bus owns this connection and its duplicate, and closes each exactly once. */
+    createClient: () => ReplayEventRedisClient;
+    /** Validate the deserialized wire payload at the application boundary. */
+    parsePayload: (value: unknown) => TPayload;
+    logger?: {
+        error(message: string): void;
+        warn(message: string): void;
+    };
+}
+/**
+ * Redis Pub/Sub transport with process-local replay(1). Notifications published
+ * before subscription are not persisted. Subscribe failures allow a later stream
+ * call to try again; the Redis client owns network reconnect/retry configuration.
+ */
+declare class RedisReplayEventBus<TContext, TPayload> extends ReplayEventBus<TContext, TPayload> {
+    private readonly redisOptions;
+    private publisher?;
+    private subscriber?;
+    private readonly subscriptions;
+    private closePromise?;
+    private readonly onPublisherError;
+    private readonly onSubscriberError;
+    private readonly onMessage;
+    constructor(redisOptions: RedisReplayEventBusOptions<TContext, TPayload>);
+    onModuleInit(): void;
+    publish(context: TContext, payload: TPayload): void;
+    stream(context: TContext): Observable<TPayload>;
+    protected removeChannel(channel: string): void;
+    onModuleDestroy(): Promise<void>;
+    private ensureSubscribed;
+}
+
+export { ALL_EVENT_PHASES, type AsyncEvent, CLUSTER_TRANSPORT, CREATE_GROUP, type ClusterTransport, CompositeEventListener, CreatorEventListener, type CurrentUser, DefaultTopicEventBus, ENTITY_EVENT_CONFIG_KEY, ENTITY_EVENT_LISTENER_CUSTOMIZER, EVENT_STORE, EnableEntityEvent, type EntityEvent, type EntityEventConfig, type EntityEventListener, EntityEventListenerConfigure, type EntityEventListenerCustomizer, EntityEventPhase, EntityEventType, type EventHandler, type EventQueryOptions, type EventStore, type HookHandler, type HookPhase, type LegacyEventHandler, type OperationContext, OperationHookRegistry, RedisReplayEventBus, type RedisReplayEventBusOptions, ReplayEventBus, type ReplayEventBusOptions, type ReplayEventRedisClient, SAVE_GROUP, SUBSCRIBE_KEY, SUBSCRIBE_METHODS_KEY, type StoredEvent, Subscribe, SubscribeFeature, type SubscribeOptions, type Subscription, SubscriptionBuilder, type SubscriptionInfo, type SubscriptionInfoBuilder, TOPIC_EVENT_BUS, type TopicEventBus, type TopicPayload, UPDATE_GROUP, UnifiedEventBus, ValidateEventListener, ZuckerEventModule, createAsyncEvent, createBatchEntityEvent, createCreatedEntityEvent, createDeletedEntityEvent, createEntityEvent, createModifyEntityEvent, createSavedEntityEvent, createSingleEntityEvent, createTopicPayload, getEntityEventConfig, getEntityEventName, getSubscriptions, isDoFireEvent, isEntityEventEnabled, matchesTopic, tryFireEvent, withFireEvent, withoutFireEvent };

package/dist/index.js

@@ -35,6 +35,8 @@ __export(index_exports, {
   EntityEventPhase: () => EntityEventPhase,
   EntityEventType: () => EntityEventType,
   OperationHookRegistry: () => OperationHookRegistry,
+  RedisReplayEventBus: () => RedisReplayEventBus,
+  ReplayEventBus: () => ReplayEventBus,
   SAVE_GROUP: () => SAVE_GROUP,
   SUBSCRIBE_KEY: () => SUBSCRIBE_KEY,
   SUBSCRIBE_METHODS_KEY: () => SUBSCRIBE_METHODS_KEY,
@@ -1053,6 +1055,168 @@ var OperationHookRegistry = class _OperationHookRegistry {
     this.hooks.length = 0;
   }
 };
+
+// src/replay-event-bus.ts
+var import_rxjs = require("rxjs");
+var ReplayEventBus = class {
+  static {
+    __name(this, "ReplayEventBus");
+  }
+  options;
+  channels = /* @__PURE__ */ new Map();
+  closed = false;
+  cleanupTimer;
+  constructor(options) {
+    this.options = options;
+    this.cleanupTimer = setInterval(() => this.cleanupStaleChannels(), options.cleanupIntervalMs);
+    this.cleanupTimer.unref?.();
+  }
+  publish(context, payload) {
+    if (this.closed) return;
+    this.options.beforePublish?.(context, payload);
+    this.emitLocal(this.options.channel(context), payload);
+  }
+  stream(context) {
+    return this.channelStream(this.options.channel(context));
+  }
+  channelStream(channel) {
+    if (this.closed) return new import_rxjs.Observable((subscriber) => subscriber.complete());
+    return this.getOrCreateChannel(channel).subject.asObservable();
+  }
+  emitLocal(channel, payload) {
+    if (this.closed) return;
+    const entry = this.getOrCreateChannel(channel);
+    entry.updatedAt = Date.now();
+    entry.subject.next(payload);
+    if (this.options.isTerminal(payload)) this.removeChannel(channel);
+  }
+  removeChannel(channel) {
+    const entry = this.channels.get(channel);
+    this.channels.delete(channel);
+    entry?.subject.complete();
+  }
+  stop() {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.cleanupTimer);
+    for (const entry of this.channels.values()) entry.subject.complete();
+    this.channels.clear();
+  }
+  async onModuleDestroy() {
+    this.stop();
+  }
+  getOrCreateChannel(channel) {
+    let entry = this.channels.get(channel);
+    if (!entry) {
+      entry = {
+        subject: new import_rxjs.ReplaySubject(1),
+        updatedAt: Date.now()
+      };
+      this.channels.set(channel, entry);
+    }
+    return entry;
+  }
+  cleanupStaleChannels() {
+    const now = Date.now();
+    for (const [channel, entry] of this.channels) {
+      if (now - entry.updatedAt > this.options.channelTtlMs && !entry.subject.observed) {
+        this.removeChannel(channel);
+      }
+    }
+  }
+};
+
+// src/redis-replay-event-bus.ts
+var RedisReplayEventBus = class extends ReplayEventBus {
+  static {
+    __name(this, "RedisReplayEventBus");
+  }
+  redisOptions;
+  publisher;
+  subscriber;
+  subscriptions = /* @__PURE__ */ new Map();
+  closePromise;
+  onPublisherError = /* @__PURE__ */ __name(() => this.redisOptions.logger?.error("Redis event publisher connection failed"), "onPublisherError");
+  onSubscriberError = /* @__PURE__ */ __name(() => this.redisOptions.logger?.error("Redis event subscriber connection failed"), "onSubscriberError");
+  onMessage = /* @__PURE__ */ __name((channel, message) => {
+    if (this.closed || !this.subscriptions.has(channel) || !this.channels.has(channel)) return;
+    try {
+      const payload = this.redisOptions.parsePayload(JSON.parse(message));
+      this.emitLocal(channel, payload);
+    } catch {
+      this.redisOptions.logger?.warn("Invalid Redis progress event");
+    }
+  }, "onMessage");
+  constructor(redisOptions) {
+    super(redisOptions), this.redisOptions = redisOptions;
+  }
+  onModuleInit() {
+    if (this.closed || this.publisher) return;
+    const publisher = this.redisOptions.createClient();
+    publisher.on("error", this.onPublisherError);
+    this.publisher = publisher;
+    try {
+      this.subscriber = publisher.duplicate();
+      this.subscriber.on("error", this.onSubscriberError);
+      this.subscriber.on("message", this.onMessage);
+      for (const channel of this.channels.keys()) this.ensureSubscribed(channel);
+    } catch (error) {
+      void this.onModuleDestroy();
+      throw error;
+    }
+  }
+  publish(context, payload) {
+    if (this.closed || !this.publisher) return;
+    this.options.beforePublish?.(context, payload);
+    const channel = this.options.channel(context);
+    const message = JSON.stringify(payload);
+    void this.publisher.publish(channel, message).catch(() => {
+      this.redisOptions.logger?.error("Redis event publish failed");
+    });
+  }
+  stream(context) {
+    const channel = this.options.channel(context);
+    const stream = this.channelStream(channel);
+    this.ensureSubscribed(channel);
+    return stream;
+  }
+  removeChannel(channel) {
+    const subscribed = this.subscriptions.delete(channel);
+    if (subscribed && this.subscriber) {
+      void this.subscriber.unsubscribe(channel).catch(() => {
+        this.redisOptions.logger?.warn("Redis event unsubscribe failed");
+      });
+    }
+    super.removeChannel(channel);
+  }
+  onModuleDestroy() {
+    if (this.closePromise) return this.closePromise;
+    this.stop();
+    this.subscriptions.clear();
+    this.subscriber?.off("message", this.onMessage);
+    const publisher = this.publisher;
+    const subscriber = this.subscriber;
+    this.closePromise = Promise.allSettled([
+      Promise.resolve().then(() => subscriber?.quit()),
+      Promise.resolve().then(() => publisher?.quit())
+    ]).then(() => {
+      subscriber?.off("error", this.onSubscriberError);
+      publisher?.off("error", this.onPublisherError);
+      this.subscriber = void 0;
+      this.publisher = void 0;
+    });
+    return this.closePromise;
+  }
+  ensureSubscribed(channel) {
+    if (this.closed || !this.subscriber || this.subscriptions.has(channel)) return;
+    const token = {};
+    this.subscriptions.set(channel, token);
+    void this.subscriber.subscribe(channel).catch(() => {
+      if (this.subscriptions.get(channel) === token) this.subscriptions.delete(channel);
+      this.redisOptions.logger?.error("Redis event subscribe failed");
+    });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_EVENT_PHASES,
@@ -1069,6 +1233,8 @@ var OperationHookRegistry = class _OperationHookRegistry {
   EntityEventPhase,
   EntityEventType,
   OperationHookRegistry,
+  RedisReplayEventBus,
+  ReplayEventBus,
   SAVE_GROUP,
   SUBSCRIBE_KEY,
   SUBSCRIBE_METHODS_KEY,

package/dist/index.mjs

@@ -987,6 +987,168 @@ var OperationHookRegistry = class _OperationHookRegistry {
     this.hooks.length = 0;
   }
 };
+
+// src/replay-event-bus.ts
+import { Observable, ReplaySubject } from "rxjs";
+var ReplayEventBus = class {
+  static {
+    __name(this, "ReplayEventBus");
+  }
+  options;
+  channels = /* @__PURE__ */ new Map();
+  closed = false;
+  cleanupTimer;
+  constructor(options) {
+    this.options = options;
+    this.cleanupTimer = setInterval(() => this.cleanupStaleChannels(), options.cleanupIntervalMs);
+    this.cleanupTimer.unref?.();
+  }
+  publish(context, payload) {
+    if (this.closed) return;
+    this.options.beforePublish?.(context, payload);
+    this.emitLocal(this.options.channel(context), payload);
+  }
+  stream(context) {
+    return this.channelStream(this.options.channel(context));
+  }
+  channelStream(channel) {
+    if (this.closed) return new Observable((subscriber) => subscriber.complete());
+    return this.getOrCreateChannel(channel).subject.asObservable();
+  }
+  emitLocal(channel, payload) {
+    if (this.closed) return;
+    const entry = this.getOrCreateChannel(channel);
+    entry.updatedAt = Date.now();
+    entry.subject.next(payload);
+    if (this.options.isTerminal(payload)) this.removeChannel(channel);
+  }
+  removeChannel(channel) {
+    const entry = this.channels.get(channel);
+    this.channels.delete(channel);
+    entry?.subject.complete();
+  }
+  stop() {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.cleanupTimer);
+    for (const entry of this.channels.values()) entry.subject.complete();
+    this.channels.clear();
+  }
+  async onModuleDestroy() {
+    this.stop();
+  }
+  getOrCreateChannel(channel) {
+    let entry = this.channels.get(channel);
+    if (!entry) {
+      entry = {
+        subject: new ReplaySubject(1),
+        updatedAt: Date.now()
+      };
+      this.channels.set(channel, entry);
+    }
+    return entry;
+  }
+  cleanupStaleChannels() {
+    const now = Date.now();
+    for (const [channel, entry] of this.channels) {
+      if (now - entry.updatedAt > this.options.channelTtlMs && !entry.subject.observed) {
+        this.removeChannel(channel);
+      }
+    }
+  }
+};
+
+// src/redis-replay-event-bus.ts
+var RedisReplayEventBus = class extends ReplayEventBus {
+  static {
+    __name(this, "RedisReplayEventBus");
+  }
+  redisOptions;
+  publisher;
+  subscriber;
+  subscriptions = /* @__PURE__ */ new Map();
+  closePromise;
+  onPublisherError = /* @__PURE__ */ __name(() => this.redisOptions.logger?.error("Redis event publisher connection failed"), "onPublisherError");
+  onSubscriberError = /* @__PURE__ */ __name(() => this.redisOptions.logger?.error("Redis event subscriber connection failed"), "onSubscriberError");
+  onMessage = /* @__PURE__ */ __name((channel, message) => {
+    if (this.closed || !this.subscriptions.has(channel) || !this.channels.has(channel)) return;
+    try {
+      const payload = this.redisOptions.parsePayload(JSON.parse(message));
+      this.emitLocal(channel, payload);
+    } catch {
+      this.redisOptions.logger?.warn("Invalid Redis progress event");
+    }
+  }, "onMessage");
+  constructor(redisOptions) {
+    super(redisOptions), this.redisOptions = redisOptions;
+  }
+  onModuleInit() {
+    if (this.closed || this.publisher) return;
+    const publisher = this.redisOptions.createClient();
+    publisher.on("error", this.onPublisherError);
+    this.publisher = publisher;
+    try {
+      this.subscriber = publisher.duplicate();
+      this.subscriber.on("error", this.onSubscriberError);
+      this.subscriber.on("message", this.onMessage);
+      for (const channel of this.channels.keys()) this.ensureSubscribed(channel);
+    } catch (error) {
+      void this.onModuleDestroy();
+      throw error;
+    }
+  }
+  publish(context, payload) {
+    if (this.closed || !this.publisher) return;
+    this.options.beforePublish?.(context, payload);
+    const channel = this.options.channel(context);
+    const message = JSON.stringify(payload);
+    void this.publisher.publish(channel, message).catch(() => {
+      this.redisOptions.logger?.error("Redis event publish failed");
+    });
+  }
+  stream(context) {
+    const channel = this.options.channel(context);
+    const stream = this.channelStream(channel);
+    this.ensureSubscribed(channel);
+    return stream;
+  }
+  removeChannel(channel) {
+    const subscribed = this.subscriptions.delete(channel);
+    if (subscribed && this.subscriber) {
+      void this.subscriber.unsubscribe(channel).catch(() => {
+        this.redisOptions.logger?.warn("Redis event unsubscribe failed");
+      });
+    }
+    super.removeChannel(channel);
+  }
+  onModuleDestroy() {
+    if (this.closePromise) return this.closePromise;
+    this.stop();
+    this.subscriptions.clear();
+    this.subscriber?.off("message", this.onMessage);
+    const publisher = this.publisher;
+    const subscriber = this.subscriber;
+    this.closePromise = Promise.allSettled([
+      Promise.resolve().then(() => subscriber?.quit()),
+      Promise.resolve().then(() => publisher?.quit())
+    ]).then(() => {
+      subscriber?.off("error", this.onSubscriberError);
+      publisher?.off("error", this.onPublisherError);
+      this.subscriber = void 0;
+      this.publisher = void 0;
+    });
+    return this.closePromise;
+  }
+  ensureSubscribed(channel) {
+    if (this.closed || !this.subscriber || this.subscriptions.has(channel)) return;
+    const token = {};
+    this.subscriptions.set(channel, token);
+    void this.subscriber.subscribe(channel).catch(() => {
+      if (this.subscriptions.get(channel) === token) this.subscriptions.delete(channel);
+      this.redisOptions.logger?.error("Redis event subscribe failed");
+    });
+  }
+};
 export {
   ALL_EVENT_PHASES,
   CLUSTER_TRANSPORT,
@@ -1002,6 +1164,8 @@ export {
   EntityEventPhase,
   EntityEventType,
   OperationHookRegistry,
+  RedisReplayEventBus,
+  ReplayEventBus,
   SAVE_GROUP,
   SUBSCRIBE_KEY,
   SUBSCRIBE_METHODS_KEY,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zucker-framework/event",
-  "version": "1.0.0",
+  "version": "1.0.5",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
     "THIRD_PARTY_NOTICES"
   ],
   "dependencies": {
-    "@zucker-framework/core": "1.0.0",
+    "@zucker-framework/core": "1.0.5",
     "eventemitter2": "^6.4.9"
   },
   "peerDependencies": {
@@ -31,12 +31,14 @@
     "@nestjs/core": "^12.0.0",
     "@nestjs/event-emitter": "^12.0.0",
     "class-transformer": "^0.5.0",
-    "class-validator": "^0.14.0 || ^0.15.0"
+    "class-validator": "^0.14.0 || ^0.15.0",
+    "rxjs": "^7.8.2"
   },
   "devDependencies": {
     "@types/node": "^20.19.43",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.15.1"
+    "class-validator": "^0.15.1",
+    "rxjs": "^7.8.2"
   },
   "license": "Apache-2.0",
   "author": "Lind",
@@ -50,7 +52,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --external @nestjs/common --external @nestjs/core --external @nestjs/event-emitter --external class-transformer --external class-validator --external @zucker-framework/core",
+    "build": "tsup src/index.ts --format cjs,esm --dts --external @nestjs/common --external @nestjs/core --external @nestjs/event-emitter --external class-transformer --external class-validator --external @zucker-framework/core --external rxjs",
     "clean": "rm -rf dist",
     "lint": "eslint src/"
   }