evstream 1.0.3 → 1.0.4

package/dist/adapters/pub-sub.d.ts

@@ -1,14 +1,40 @@
 import { RedisOptions } from 'ioredis';
-interface EvRedisPubSubOptions {
-    subject?: string;
+/**
+ * Configuration options for EvRedisPubSub
+ */
+interface EvRedisPubSubOptions<T> {
+    /** Redis Pub/Sub channel name */
+    subject: string;
+    /** Redis connection options */
     options: RedisOptions;
-    onMessage?: (message: Object) => void;
+    /** Optional initial message handler */
+    onMessage?: (message: T) => void;
 }
-export declare class EvRedisPubSub {
+/**
+ * Redis-based Pub/Sub helper for cross-process communication.
+ *
+ * - Uses separate publisher and subscriber connections
+ * - Prevents self-message delivery using instance UID
+ * - Typed message payload via generics
+ */
+export declare class EvRedisPubSub<T = unknown> {
     #private;
-    constructor({ options, subject, onMessage }: EvRedisPubSubOptions);
+    constructor({ options, subject, onMessage }: EvRedisPubSubOptions<T>);
+    /**
+     * Initializes Redis subscriptions and listeners.
+     */
     private init;
-    send(msg: Object): Promise<void>;
-    onMessage(callback: (msg: Object) => void): void;
+    /**
+     * Publishes a message to the Redis channel.
+     */
+    send(msg: T): Promise<void>;
+    /**
+     * Registers or replaces the message handler.
+     */
+    onMessage(callback: (msg: T) => void): void;
+    /**
+     * Gracefully closes Redis connections.
+     */
+    close(): Promise<void>;
 }
 export {};

package/dist/adapters/pub-sub.js

@@ -18,12 +18,18 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EvRedisPubSub_options, _EvRedisPubSub_subject, _EvRedisPubSub_pub, _EvRedisPubSub_sub, _EvRedisPubSub_instanceId, _EvRedisPubSub_onMessage;
+var _EvRedisPubSub_subject, _EvRedisPubSub_pub, _EvRedisPubSub_sub, _EvRedisPubSub_instanceId, _EvRedisPubSub_onMessage;
 import Redis from 'ioredis';
 import { uid } from '../utils.js';
+/**
+ * Redis-based Pub/Sub helper for cross-process communication.
+ *
+ * - Uses separate publisher and subscriber connections
+ * - Prevents self-message delivery using instance UID
+ * - Typed message payload via generics
+ */
 export class EvRedisPubSub {
     constructor({ options, subject, onMessage }) {
-        _EvRedisPubSub_options.set(this, void 0);
         _EvRedisPubSub_subject.set(this, void 0);
         _EvRedisPubSub_pub.set(this, void 0);
         _EvRedisPubSub_sub.set(this, void 0);
@@ -31,36 +37,55 @@ export class EvRedisPubSub {
         _EvRedisPubSub_onMessage.set(this, void 0);
         __classPrivateFieldSet(this, _EvRedisPubSub_pub, new Redis(options), "f");
         __classPrivateFieldSet(this, _EvRedisPubSub_sub, new Redis(options), "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_subject, subject, "f");
         __classPrivateFieldSet(this, _EvRedisPubSub_onMessage, onMessage, "f");
         __classPrivateFieldSet(this, _EvRedisPubSub_instanceId, uid({ prefix: subject, counter: Math.random() }), "f");
-        __classPrivateFieldSet(this, _EvRedisPubSub_subject, subject, "f");
         this.init();
     }
+    /**
+     * Initializes Redis subscriptions and listeners.
+     */
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            __classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").on('error', (err) => { });
-            __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").on('error', (err) => { });
+            __classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").on('error', () => { });
+            __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").on('error', () => { });
             yield __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").subscribe(__classPrivateFieldGet(this, _EvRedisPubSub_subject, "f"));
             __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").on('message', (_, raw) => {
+                var _a;
                 try {
-                    const msg = JSON.parse(raw);
-                    console.log("Incoming Message");
-                    console.log(msg);
-                    if ((msg === null || msg === void 0 ? void 0 : msg.uid) !== __classPrivateFieldGet(this, _EvRedisPubSub_instanceId, "f")) {
-                        __classPrivateFieldGet(this, _EvRedisPubSub_onMessage, "f").call(this, msg === null || msg === void 0 ? void 0 : msg.msg);
+                    const data = JSON.parse(raw);
+                    // Ignore messages from the same instance
+                    if ((data === null || data === void 0 ? void 0 : data.uid) !== __classPrivateFieldGet(this, _EvRedisPubSub_instanceId, "f")) {
+                        (_a = __classPrivateFieldGet(this, _EvRedisPubSub_onMessage, "f")) === null || _a === void 0 ? void 0 : _a.call(this, data.msg);
                     }
                 }
-                catch (_a) { }
+                catch (_b) {
+                    // Ignore malformed payloads
+                }
             });
         });
     }
+    /**
+     * Publishes a message to the Redis channel.
+     */
     send(msg) {
         return __awaiter(this, void 0, void 0, function* () {
             yield __classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").publish(__classPrivateFieldGet(this, _EvRedisPubSub_subject, "f"), JSON.stringify({ uid: __classPrivateFieldGet(this, _EvRedisPubSub_instanceId, "f"), msg }));
         });
     }
+    /**
+     * Registers or replaces the message handler.
+     */
     onMessage(callback) {
         __classPrivateFieldSet(this, _EvRedisPubSub_onMessage, callback, "f");
     }
+    /**
+     * Gracefully closes Redis connections.
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([__classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").quit(), __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").quit()]);
+        });
+    }
 }
-_EvRedisPubSub_options = new WeakMap(), _EvRedisPubSub_subject = new WeakMap(), _EvRedisPubSub_pub = new WeakMap(), _EvRedisPubSub_sub = new WeakMap(), _EvRedisPubSub_instanceId = new WeakMap(), _EvRedisPubSub_onMessage = new WeakMap();
+_EvRedisPubSub_subject = new WeakMap(), _EvRedisPubSub_pub = new WeakMap(), _EvRedisPubSub_sub = new WeakMap(), _EvRedisPubSub_instanceId = new WeakMap(), _EvRedisPubSub_onMessage = new WeakMap();

package/dist/adapters/redis.d.ts

@@ -1,12 +1,55 @@
 import { RedisOptions } from 'ioredis';
 import { EvRedisPubSub } from './pub-sub.js';
 import { EvStateAdapter } from '../types.js';
+/**
+ * Redis-based implementation of {@link EvStateAdapter}.
+ *
+ * This adapter enables distributed state updates using Redis Pub/Sub.
+ * It supports:
+ * - Channel-based subscriptions
+ * - Multiple listeners per channel
+ * - Self-message filtering via instance ID
+ *
+ * Designed to be used by EvState / EvStateManager for
+ * cross-process state synchronization.
+ */
 declare class EvRedisAdapter implements EvStateAdapter {
     #private;
+    /**
+     * Creates a new Redis state adapter.
+     *
+     * @param options - Optional Redis connection options
+     */
     constructor(options?: RedisOptions);
+    /**
+     * Publishes a message to a Redis channel.
+     *
+     * The payload is wrapped with the instance ID to
+     * prevent self-delivery.
+     *
+     * @param channel - Redis channel name
+     * @param message - Message payload
+     */
     publish(channel: string, message: any): Promise<void>;
+    /**
+     * Subscribes to a Redis channel.
+     *
+     * Multiple listeners can be registered per channel.
+     * The Redis subscription is created only once per channel.
+     *
+     * @param channel - Redis channel name
+     * @param onMessage - Callback invoked on incoming messages
+     */
     subscribe(channel: string, onMessage: (message: any) => void): Promise<void>;
+    /**
+     * Unsubscribes from a Redis channel and removes all listeners.
+     *
+     * @param channel - Redis channel name
+     */
     unsubscribe(channel: string): Promise<void>;
+    /**
+     * Gracefully closes Redis connections.
+     */
     quit(): void;
 }
 export { EvRedisPubSub, EvRedisAdapter };

package/dist/adapters/redis.js

@@ -22,11 +22,35 @@ var _EvRedisAdapter_pub, _EvRedisAdapter_sub, _EvRedisAdapter_listeners, _EvRedi
 import Redis from 'ioredis';
 import { EvRedisPubSub } from './pub-sub.js';
 import { uid } from '../utils.js';
+/**
+ * Redis-based implementation of {@link EvStateAdapter}.
+ *
+ * This adapter enables distributed state updates using Redis Pub/Sub.
+ * It supports:
+ * - Channel-based subscriptions
+ * - Multiple listeners per channel
+ * - Self-message filtering via instance ID
+ *
+ * Designed to be used by EvState / EvStateManager for
+ * cross-process state synchronization.
+ */
 class EvRedisAdapter {
+    /**
+     * Creates a new Redis state adapter.
+     *
+     * @param options - Optional Redis connection options
+     */
     constructor(options) {
+        /** Publisher Redis client */
         _EvRedisAdapter_pub.set(this, void 0);
+        /** Subscriber Redis client */
         _EvRedisAdapter_sub.set(this, void 0);
+        /**
+         * Channel → listeners mapping.
+         * Each channel may have multiple local handlers.
+         */
         _EvRedisAdapter_listeners.set(this, void 0);
+        /** Unique identifier for this adapter instance */
         _EvRedisAdapter_instanceId.set(this, void 0);
         __classPrivateFieldSet(this, _EvRedisAdapter_pub, new Redis(options), "f");
         __classPrivateFieldSet(this, _EvRedisAdapter_sub, new Redis(options), "f");
@@ -34,26 +58,45 @@ class EvRedisAdapter {
         __classPrivateFieldSet(this, _EvRedisAdapter_instanceId, uid({ counter: Math.ceil(Math.random() * 100) }), "f");
         __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").on('message', (channel, message) => {
             const handlers = __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").get(channel);
-            if (handlers) {
-                let parsed;
-                let canHandle;
-                try {
-                    parsed = JSON.parse(message);
-                    canHandle = (parsed === null || parsed === void 0 ? void 0 : parsed.id) !== __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f");
-                }
-                catch (_a) {
-                    return;
-                }
-                if (canHandle)
-                    handlers.forEach((handler) => handler(parsed === null || parsed === void 0 ? void 0 : parsed.message));
+            if (!handlers)
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(message);
             }
+            catch (_a) {
+                // Ignore malformed payloads
+                return;
+            }
+            // Ignore messages published by this instance
+            if ((parsed === null || parsed === void 0 ? void 0 : parsed.id) === __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f"))
+                return;
+            handlers.forEach((handler) => handler(parsed === null || parsed === void 0 ? void 0 : parsed.message));
         });
     }
+    /**
+     * Publishes a message to a Redis channel.
+     *
+     * The payload is wrapped with the instance ID to
+     * prevent self-delivery.
+     *
+     * @param channel - Redis channel name
+     * @param message - Message payload
+     */
     publish(channel, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").publish(channel, JSON.stringify({ id: __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f"), message: message }));
+            yield __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").publish(channel, JSON.stringify({ id: __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f"), message }));
         });
     }
+    /**
+     * Subscribes to a Redis channel.
+     *
+     * Multiple listeners can be registered per channel.
+     * The Redis subscription is created only once per channel.
+     *
+     * @param channel - Redis channel name
+     * @param onMessage - Callback invoked on incoming messages
+     */
     subscribe(channel, onMessage) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!__classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").has(channel)) {
@@ -63,12 +106,20 @@ class EvRedisAdapter {
             __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").get(channel).add(onMessage);
         });
     }
+    /**
+     * Unsubscribes from a Redis channel and removes all listeners.
+     *
+     * @param channel - Redis channel name
+     */
     unsubscribe(channel) {
         return __awaiter(this, void 0, void 0, function* () {
             yield __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").unsubscribe(channel);
             __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").delete(channel);
         });
     }
+    /**
+     * Gracefully closes Redis connections.
+     */
     quit() {
         __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").quit();
         __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").quit();

package/dist/extensions/state-manager.d.ts

@@ -2,20 +2,94 @@ import type { EvStreamManager } from '../manager.js';
 import type { EvRedisAdapter } from '../adapters/redis.js';
 import type { EvRedisPubSub } from '../adapters/pub-sub.js';
 import { EvState } from '../state.js';
+/**
+ * Options for creating an {@link EvStateManager}.
+ */
 interface EvStateManagerOptions {
+    /**
+     * Stream manager responsible for managing client connections
+     * and broadcasting state updates.
+     */
     manager: EvStreamManager;
+    /**
+     * Optional distributed state adapter (e.g. Redis).
+     * Enables cross-process state propagation.
+     */
     adapter?: EvRedisAdapter;
+    /**
+     * Optional Pub/Sub instance used to synchronize
+     * state creation and removal across instances.
+     */
     pubsub?: EvRedisPubSub;
 }
+/**
+ * Manages a collection of named {@link EvState} instances.
+ *
+ * Responsibilities:
+ * - Create and cache state objects locally
+ * - Synchronize state lifecycle (create/remove) across processes
+ * - Bridge EvState with stream manager and adapters
+ *
+ * Internally, all state keys are converted to strings to remain
+ * Redis-safe and transport-friendly.
+ *
+ * @typeParam S - Mapping of state keys to their value types
+ */
 export declare class EvStateManager<S extends Record<string, any>> {
     #private;
+    /**
+     * Creates a new state manager.
+     *
+     * @param options - Initialization options
+     */
     constructor({ manager, adapter, pubsub }: EvStateManagerOptions);
+    /**
+     * Creates a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     * @param initialValue - Initial state value
+     */
     private createLocalState;
+    /**
+     * Removes a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     */
     private removeLocalState;
+    /**
+     * Creates or returns an existing state.
+     *
+     * If Pub/Sub is enabled, the creation is broadcast
+     * to other instances.
+     *
+     * @param key - State key
+     * @param initialValue - Initial state value
+     */
     createState<K extends keyof S>(key: K, initialValue: S[K]): EvState<S[K]>;
+    /**
+     * Retrieves an existing state.
+     *
+     * @param key - State key
+     */
     getState<K extends keyof S>(key: K): EvState<S[K]> | undefined;
+    /**
+     * Checks whether a state exists.
+     *
+     * @param key - State key
+     */
     hasState<K extends keyof S>(key: K): boolean;
+    /**
+     * Removes a state locally and propagates the removal
+     * to other instances via Pub/Sub.
+     *
+     * @param key - State key
+     */
     removeState<K extends keyof S>(key: K): void;
+    /**
+     * Handles incoming Pub/Sub lifecycle events.
+     *
+     * @param msg - Pub/Sub message payload
+     */
     private pubSubCallback;
 }
 export {};

package/dist/extensions/state-manager.js

@@ -11,12 +11,38 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _EvStateManager_states, _EvStateManager_manager, _EvStateManager_adapter, _EvStateManager_pubsub;
 import { EvState } from '../state.js';
+/**
+ * Manages a collection of named {@link EvState} instances.
+ *
+ * Responsibilities:
+ * - Create and cache state objects locally
+ * - Synchronize state lifecycle (create/remove) across processes
+ * - Bridge EvState with stream manager and adapters
+ *
+ * Internally, all state keys are converted to strings to remain
+ * Redis-safe and transport-friendly.
+ *
+ * @typeParam S - Mapping of state keys to their value types
+ */
 export class EvStateManager {
+    /**
+     * Creates a new state manager.
+     *
+     * @param options - Initialization options
+     */
     constructor({ manager, adapter, pubsub }) {
-        // 🔑 Internally everything is string-based (Redis-safe)
-        _EvStateManager_states.set(this, new Map());
+        /**
+         * Internal state registry.
+         * Keyed by string channel name.
+         */
+        _EvStateManager_states.set(this, new Map()
+        /** Stream manager used by all states */
+        );
+        /** Stream manager used by all states */
         _EvStateManager_manager.set(this, void 0);
+        /** Optional distributed adapter */
         _EvStateManager_adapter.set(this, void 0);
+        /** Optional Pub/Sub synchronizer */
         _EvStateManager_pubsub.set(this, void 0);
         __classPrivateFieldSet(this, _EvStateManager_manager, manager, "f");
         __classPrivateFieldSet(this, _EvStateManager_adapter, adapter, "f");
@@ -26,6 +52,12 @@ export class EvStateManager {
             __classPrivateFieldGet(this, _EvStateManager_pubsub, "f").onMessage(this.pubSubCallback);
         }
     }
+    /**
+     * Creates a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     * @param initialValue - Initial state value
+     */
     createLocalState(channel, initialValue) {
         const state = new EvState({
             channel,
@@ -36,9 +68,23 @@ export class EvStateManager {
         __classPrivateFieldGet(this, _EvStateManager_states, "f").set(channel, state);
         return state;
     }
+    /**
+     * Removes a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     */
     removeLocalState(channel) {
         __classPrivateFieldGet(this, _EvStateManager_states, "f").delete(channel);
     }
+    /**
+     * Creates or returns an existing state.
+     *
+     * If Pub/Sub is enabled, the creation is broadcast
+     * to other instances.
+     *
+     * @param key - State key
+     * @param initialValue - Initial state value
+     */
     createState(key, initialValue) {
         var _a;
         const channel = String(key);
@@ -53,12 +99,28 @@ export class EvStateManager {
         });
         return state;
     }
+    /**
+     * Retrieves an existing state.
+     *
+     * @param key - State key
+     */
     getState(key) {
         return __classPrivateFieldGet(this, _EvStateManager_states, "f").get(String(key));
     }
+    /**
+     * Checks whether a state exists.
+     *
+     * @param key - State key
+     */
     hasState(key) {
         return __classPrivateFieldGet(this, _EvStateManager_states, "f").has(String(key));
     }
+    /**
+     * Removes a state locally and propagates the removal
+     * to other instances via Pub/Sub.
+     *
+     * @param key - State key
+     */
     removeState(key) {
         var _a;
         const channel = String(key);
@@ -68,6 +130,11 @@ export class EvStateManager {
             channel,
         });
     }
+    /**
+     * Handles incoming Pub/Sub lifecycle events.
+     *
+     * @param msg - Pub/Sub message payload
+     */
     pubSubCallback(msg) {
         if (!msg || typeof msg.channel !== 'string')
             return;

package/dist/manager.d.ts

@@ -3,31 +3,41 @@ import type { EvManagerOptions, EvMessage, EvOnClose, EvOptions } from './types.
 /**
  * `EvStreamManager` manages multiple SSE connections.
  * Handles client creation, broadcasting messages, and channel-based listeners.
- *
- * Example :
- *
- * ```javascript
- * const evManager = new EvStreamManager();
- *
- * const stream = evManager.createStream(req, res);
- * ```
- *
  */
 export declare class EvStreamManager {
     #private;
     constructor(opts?: EvManagerOptions);
     /**
-     * Creates a new SSE stream, tracks it, and returns control methods.
-     * Enforces max connection limit.
+     * Creates a new SSE stream
      */
     createStream(req: IncomingMessage, res: ServerResponse, opts?: EvOptions): {
+        id: string;
         authenticate: any;
         message: any;
         close: (onClose?: EvOnClose) => void;
         listen: (name: string) => void;
     };
     /**
-     * Sends a message to all clients listening to a specific channel.
+     * Sends a message directly to a local client by ID.
+     *
+     * This method only targets clients connected to the current process.
+     * It does not forward the message to Redis.
+     */
+    private toLocal;
+    /**
+     * Sends a message to a specific client by ID.
+     *
+     * If the client exists locally, the message is delivered immediately.
+     * If not, the message is forwarded through Redis so another instance
+     * can deliver it to the target client.
+     */
+    to(id: string, msg: EvMessage): void;
+    /**
+     * Send message locally to listeners
+     */
+    private sendLocal;
+    /**
+     * Sends message to channel (local + Redis)
      */
     send(name: string, msg: EvMessage): void;
 }

package/dist/manager.js

@@ -9,22 +9,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EvStreamManager_instances, _EvStreamManager_clients, _EvStreamManager_listeners, _EvStreamManager_count, _EvStreamManager_maxConnections, _EvStreamManager_maxListeners, _EvStreamManager_id, _EvStreamManager_listen, _EvStreamManager_unlisten;
+var _EvStreamManager_instances, _EvStreamManager_clients, _EvStreamManager_listeners, _EvStreamManager_count, _EvStreamManager_maxConnections, _EvStreamManager_maxListeners, _EvStreamManager_pubSub, _EvStreamManager_id, _EvStreamManager_listen, _EvStreamManager_unlisten, _EvStreamManager_onMessage;
 import { Evstream } from './stream.js';
 import { uid } from './utils.js';
 import { EvMaxConnectionsError, EvMaxListenerError } from './errors.js';
 /**
  * `EvStreamManager` manages multiple SSE connections.
  * Handles client creation, broadcasting messages, and channel-based listeners.
- *
- * Example :
- *
- * ```javascript
- * const evManager = new EvStreamManager();
- *
- * const stream = evManager.createStream(req, res);
- * ```
- *
  */
 export class EvStreamManager {
     constructor(opts) {
@@ -34,6 +25,7 @@ export class EvStreamManager {
         _EvStreamManager_count.set(this, void 0);
         _EvStreamManager_maxConnections.set(this, void 0);
         _EvStreamManager_maxListeners.set(this, void 0);
+        _EvStreamManager_pubSub.set(this, void 0);
         _EvStreamManager_id.set(this, void 0);
         __classPrivateFieldSet(this, _EvStreamManager_clients, new Map(), "f");
         __classPrivateFieldSet(this, _EvStreamManager_listeners, new Map(), "f");
@@ -41,10 +33,13 @@ export class EvStreamManager {
         __classPrivateFieldSet(this, _EvStreamManager_maxConnections, (opts === null || opts === void 0 ? void 0 : opts.maxConnection) || 5000, "f");
         __classPrivateFieldSet(this, _EvStreamManager_maxListeners, (opts === null || opts === void 0 ? void 0 : opts.maxListeners) || 5000, "f");
         __classPrivateFieldSet(this, _EvStreamManager_id, opts === null || opts === void 0 ? void 0 : opts.id, "f");
+        __classPrivateFieldSet(this, _EvStreamManager_pubSub, opts === null || opts === void 0 ? void 0 : opts.pubSub, "f");
+        if (__classPrivateFieldGet(this, _EvStreamManager_pubSub, "f")) {
+            __classPrivateFieldGet(this, _EvStreamManager_pubSub, "f").onMessage((msg) => __classPrivateFieldGet(this, _EvStreamManager_instances, "m", _EvStreamManager_onMessage).call(this, msg));
+        }
     }
     /**
-     * Creates a new SSE stream, tracks it, and returns control methods.
-     * Enforces max connection limit.
+     * Creates a new SSE stream
      */
     createStream(req, res, opts) {
         if (__classPrivateFieldGet(this, _EvStreamManager_count, "f") >= __classPrivateFieldGet(this, _EvStreamManager_maxConnections, "f")) {
@@ -52,70 +47,99 @@ export class EvStreamManager {
         }
         const client = new Evstream(req, res, opts);
         const id = uid({ counter: __classPrivateFieldGet(this, _EvStreamManager_count, "f"), prefix: __classPrivateFieldGet(this, _EvStreamManager_id, "f") });
-        const channel = [];
+        const channels = [];
         let isClosed = false;
         __classPrivateFieldSet(this, _EvStreamManager_count, __classPrivateFieldGet(this, _EvStreamManager_count, "f") + 1, "f");
         __classPrivateFieldGet(this, _EvStreamManager_clients, "f").set(id, client);
         const close = (onClose) => {
             if (isClosed)
                 return;
+            isClosed = true;
             if (typeof onClose === 'function') {
-                onClose(channel);
+                onClose(channels);
             }
-            isClosed = true;
-            // Remove close event listener to prevent memory leaks
             res.removeAllListeners('close');
-            // Clean up client
             client.close();
-            // Decrement count
             __classPrivateFieldSet(this, _EvStreamManager_count, __classPrivateFieldGet(this, _EvStreamManager_count, "f") - 1, "f");
-            // Remove from all channels
-            channel.forEach(chan => __classPrivateFieldGet(this, _EvStreamManager_instances, "m", _EvStreamManager_unlisten).call(this, chan, id));
-            // Clear channel array to release references
-            channel.length = 0;
-            // Remove client from map
+            channels.forEach((ch) => __classPrivateFieldGet(this, _EvStreamManager_instances, "m", _EvStreamManager_unlisten).call(this, ch, id));
+            channels.length = 0;
             __classPrivateFieldGet(this, _EvStreamManager_clients, "f").delete(id);
-            // End response if not already ended
-            if (!res.writableEnded) {
+            if (!res.writableEnded)
                 res.end();
-            }
-        };
-        const onCloseHandler = () => {
-            if (!isClosed) {
-                close();
-            }
         };
-        res.on('close', onCloseHandler);
+        res.on('close', close);
         return {
+            id: id,
             authenticate: client.authenticate.bind(client),
             message: client.message.bind(client),
-            close: close,
+            close,
             listen: (name) => {
                 if (isClosed)
                     return;
-                channel.push(name);
+                channels.push(name);
                 __classPrivateFieldGet(this, _EvStreamManager_instances, "m", _EvStreamManager_listen).call(this, name, id);
             },
         };
     }
     /**
-     * Sends a message to all clients listening to a specific channel.
+     * Sends a message directly to a local client by ID.
+     *
+     * This method only targets clients connected to the current process.
+     * It does not forward the message to Redis.
      */
-    send(name, msg) {
+    toLocal(id, msg) {
+        const client = __classPrivateFieldGet(this, _EvStreamManager_clients, "f").get(id);
+        if (client) {
+            client.message({
+                data: msg,
+            });
+        }
+        return client;
+    }
+    /**
+     * Sends a message to a specific client by ID.
+     *
+     * If the client exists locally, the message is delivered immediately.
+     * If not, the message is forwarded through Redis so another instance
+     * can deliver it to the target client.
+     */
+    to(id, msg) {
+        const client = this.toLocal(id, msg);
+        if (!client) {
+            if (__classPrivateFieldGet(this, _EvStreamManager_pubSub, "f")) {
+                __classPrivateFieldGet(this, _EvStreamManager_pubSub, "f").send({ type: 'to', data: { id: id, message: msg } });
+            }
+        }
+    }
+    /**
+     * Send message locally to listeners
+     */
+    sendLocal(name, msg) {
         const listeners = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name);
         if (!listeners)
-            return;
-        for (const [_, id] of listeners.entries()) {
+            return msg;
+        for (const id of listeners) {
             const client = __classPrivateFieldGet(this, _EvStreamManager_clients, "f").get(id);
-            if (client) {
-                client.message(Object.assign(Object.assign({}, msg), { data: typeof msg.data === 'string'
-                        ? { ch: name, data: msg }
-                        : Object.assign({ ch: name }, msg.data) }));
+            if (!client) {
+                continue;
             }
+            client.message(Object.assign(Object.assign({}, msg), { data: typeof msg.data === 'string'
+                    ? { ch: name, data: msg }
+                    : Object.assign({ ch: name }, msg.data) }));
+        }
+        return msg;
+    }
+    /**
+     * Sends message to channel (local + Redis)
+     */
+    send(name, msg) {
+        this.sendLocal(name, msg);
+        if (__classPrivateFieldGet(this, _EvStreamManager_pubSub, "f")) {
+            __classPrivateFieldGet(this, _EvStreamManager_pubSub, "f").send({ type: 'send', data: { name, message: msg } });
         }
     }
 }
-_EvStreamManager_clients = new WeakMap(), _EvStreamManager_listeners = new WeakMap(), _EvStreamManager_count = new WeakMap(), _EvStreamManager_maxConnections = new WeakMap(), _EvStreamManager_maxListeners = new WeakMap(), _EvStreamManager_id = new WeakMap(), _EvStreamManager_instances = new WeakSet(), _EvStreamManager_listen = function _EvStreamManager_listen(name, id) {
+_EvStreamManager_clients = new WeakMap(), _EvStreamManager_listeners = new WeakMap(), _EvStreamManager_count = new WeakMap(), _EvStreamManager_maxConnections = new WeakMap(), _EvStreamManager_maxListeners = new WeakMap(), _EvStreamManager_pubSub = new WeakMap(), _EvStreamManager_id = new WeakMap(), _EvStreamManager_instances = new WeakSet(), _EvStreamManager_listen = function _EvStreamManager_listen(name, id) {
     let listeners = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name);
     if (!listeners) {
         listeners = new Set();
@@ -126,11 +150,28 @@ _EvStreamManager_clients = new WeakMap(), _EvStreamManager_listeners = new WeakM
     }
     listeners.add(id);
 }, _EvStreamManager_unlisten = function _EvStreamManager_unlisten(name, id) {
-    const isListenerExists = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name);
-    if (isListenerExists) {
-        isListenerExists.delete(id);
-        if (isListenerExists.size === 0) {
-            __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").delete(name);
-        }
+    const listeners = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name);
+    if (!listeners)
+        return;
+    listeners.delete(id);
+    if (listeners.size === 0) {
+        __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").delete(name);
+    }
+}, _EvStreamManager_onMessage = function _EvStreamManager_onMessage(msg) {
+    var _a, _b, _c, _d;
+    const type = msg === null || msg === void 0 ? void 0 : msg.type;
+    switch (type) {
+        case 'send':
+            const name = (_a = msg === null || msg === void 0 ? void 0 : msg.data) === null || _a === void 0 ? void 0 : _a.name;
+            const message = (_b = msg === null || msg === void 0 ? void 0 : msg.data) === null || _b === void 0 ? void 0 : _b.message;
+            if (!name || !message)
+                return;
+            this.sendLocal(name, message);
+            break;
+        case 'to':
+            const data = (_c = msg === null || msg === void 0 ? void 0 : msg.data) === null || _c === void 0 ? void 0 : _c.message;
+            const id = (_d = msg === null || msg === void 0 ? void 0 : msg.data) === null || _d === void 0 ? void 0 : _d.id;
+            this.toLocal(id, data);
+            break;
     }
 };

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { EvRedisPubSub } from './adapters/pub-sub.js';
 import type { EvStreamManager } from './manager.js';
 export type EvEventsType = 'data' | 'error' | 'end';
 export interface EvMessage {
@@ -18,6 +19,7 @@ export interface EvManagerOptions {
     id?: string;
     maxConnection?: number;
     maxListeners?: number;
+    pubSub?: EvRedisPubSub;
 }
 export interface EvStateAdapter {
     publish(channel: string, message: any): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "evstream",
-	"version": "1.0.3",
+	"version": "1.0.4",
 	"description": "A simple and easy to implement server sent event library for express.js",
 	"keywords": [
 		"sse",

package/src/manager.ts

@@ -5,167 +5,220 @@ import { uid } from './utils.js'
 import { EvMaxConnectionsError, EvMaxListenerError } from './errors.js'
 
 import type {
-    EvManagerOptions,
-    EvMessage,
-    EvOnClose,
-    EvOptions,
+	EvManagerOptions,
+	EvMessage,
+	EvOnClose,
+	EvOptions,
 } from './types.js'
+import type { EvRedisPubSub } from './adapters/pub-sub.js'
 
 /**
  * `EvStreamManager` manages multiple SSE connections.
  * Handles client creation, broadcasting messages, and channel-based listeners.
- *
- * Example :
- *
- * ```javascript
- * const evManager = new EvStreamManager();
- *
- * const stream = evManager.createStream(req, res);
- * ```
- *
  */
 export class EvStreamManager {
-    #clients: Map<string, Evstream>
-    #listeners: Map<string, Set<string>>
-    #count: number
-    #maxConnections: number
-    #maxListeners: number
-    #id?: string
-    constructor(opts?: EvManagerOptions) {
-        this.#clients = new Map()
-        this.#listeners = new Map()
-        this.#count = 0
-
-        this.#maxConnections = opts?.maxConnection || 5000
-        this.#maxListeners = opts?.maxListeners || 5000
-        this.#id = opts?.id
-    }
-
-    /**
-     * Creates a new SSE stream, tracks it, and returns control methods.
-     * Enforces max connection limit.
-     */
-    createStream(req: IncomingMessage, res: ServerResponse, opts?: EvOptions) {
-        if (this.#count >= this.#maxConnections) {
-            throw new EvMaxConnectionsError(this.#maxConnections)
-        }
-
-        const client = new Evstream(req, res, opts)
-        const id = uid({ counter: this.#count, prefix: this.#id })
-        const channel: string[] = []
-        let isClosed = false
-
-        this.#count += 1
-        this.#clients.set(id, client)
-
-        const close = (onClose?: EvOnClose) => {
-            if (isClosed) return
-
-            if (typeof onClose === 'function') {
-                onClose(channel)
-            }
-
-            isClosed = true
-
-            // Remove close event listener to prevent memory leaks
-            res.removeAllListeners('close')
-
-            // Clean up client
-            client.close()
-
-            // Decrement count
-            this.#count -= 1
-
-            // Remove from all channels
-            channel.forEach(chan => this.#unlisten(chan, id))
-
-            // Clear channel array to release references
-            channel.length = 0
-
-            // Remove client from map
-            this.#clients.delete(id)
-
-            // End response if not already ended
-            if (!res.writableEnded) {
-                res.end()
-            }
-        }
-
-        const onCloseHandler = () => {
-            if (!isClosed) {
-                close()
-            }
-        }
-
-        res.on('close', onCloseHandler)
-
-        return {
-            authenticate: client.authenticate.bind(client),
-            message: client.message.bind(client),
-            close: close,
-            listen: (name: string) => {
-                if (isClosed) return
-                channel.push(name)
-                this.#listen(name, id)
-            },
-        }
-    }
-
-    /**
-     * Sends a message to all clients listening to a specific channel.
-     */
-    send(name: string, msg: EvMessage) {
-        const listeners = this.#listeners.get(name)
-
-        if (!listeners) return
-
-        for (const [_, id] of listeners.entries()) {
-            const client = this.#clients.get(id)
-
-            if (client) {
-                client.message({
-                    ...msg,
-                    data:
-                        typeof msg.data === 'string'
-                            ? { ch: name, data: msg }
-                            : { ch: name, ...msg.data },
-                })
-            }
-        }
-    }
-
-    /**
-     * Adds a client to a specific channel.
-     * Enforces max listeners per channel.
-     */
-    #listen(name: string, id: string) {
-        let listeners = this.#listeners.get(name)
-
-        if (!listeners) {
-            listeners = new Set<string>()
-            this.#listeners.set(name, listeners)
-        }
-
-        if (listeners.size >= this.#maxListeners) {
-            throw new EvMaxListenerError(listeners.size, name)
-        }
-
-        listeners.add(id)
-    }
-
-    /**
-     * Removes a client from a specific channel.
-     * Deletes the channel if no listeners remain.
-     */
-    #unlisten(name: string, id: string) {
-        const isListenerExists = this.#listeners.get(name)
-
-        if (isListenerExists) {
-            isListenerExists.delete(id)
-
-            if (isListenerExists.size === 0) {
-                this.#listeners.delete(name)
-            }
-        }
-    }
+	#clients: Map<string, Evstream>
+	#listeners: Map<string, Set<string>>
+	#count: number
+	#maxConnections: number
+	#maxListeners: number
+	#pubSub?: EvRedisPubSub
+	#id?: string
+
+	constructor(opts?: EvManagerOptions) {
+		this.#clients = new Map()
+		this.#listeners = new Map()
+		this.#count = 0
+
+		this.#maxConnections = opts?.maxConnection || 5000
+		this.#maxListeners = opts?.maxListeners || 5000
+		this.#id = opts?.id
+
+		this.#pubSub = opts?.pubSub
+
+		if (this.#pubSub) {
+			this.#pubSub.onMessage((msg) => this.#onMessage(msg))
+		}
+	}
+
+	/**
+	 * Creates a new SSE stream
+	 */
+	createStream(req: IncomingMessage, res: ServerResponse, opts?: EvOptions) {
+		if (this.#count >= this.#maxConnections) {
+			throw new EvMaxConnectionsError(this.#maxConnections)
+		}
+
+		const client = new Evstream(req, res, opts)
+		const id = uid({ counter: this.#count, prefix: this.#id })
+		const channels: string[] = []
+		let isClosed = false
+
+		this.#count += 1
+		this.#clients.set(id, client)
+
+		const close = (onClose?: EvOnClose) => {
+			if (isClosed) return
+			isClosed = true
+
+			if (typeof onClose === 'function') {
+				onClose(channels)
+			}
+
+			res.removeAllListeners('close')
+			client.close()
+
+			this.#count -= 1
+			channels.forEach((ch) => this.#unlisten(ch, id))
+			channels.length = 0
+			this.#clients.delete(id)
+
+			if (!res.writableEnded) res.end()
+		}
+
+		res.on('close', close)
+
+		return {
+			id: id,
+			authenticate: client.authenticate.bind(client),
+			message: client.message.bind(client),
+			close,
+			listen: (name: string) => {
+				if (isClosed) return
+				channels.push(name)
+				this.#listen(name, id)
+			},
+		}
+	}
+
+	/**
+	 * Sends a message directly to a local client by ID.
+	 *
+	 * This method only targets clients connected to the current process.
+	 * It does not forward the message to Redis.
+	 */
+	private toLocal(id: string, msg: EvMessage) {
+		const client = this.#clients.get(id)
+
+		if (client) {
+			client.message({
+				data: msg,
+			})
+		}
+
+		return client
+	}
+
+	/**
+	 * Sends a message to a specific client by ID.
+	 *
+	 * If the client exists locally, the message is delivered immediately.
+	 * If not, the message is forwarded through Redis so another instance
+	 * can deliver it to the target client.
+	 */
+	to(id: string, msg: EvMessage) {
+		const client = this.toLocal(id, msg)
+
+		if (!client) {
+			if (this.#pubSub) {
+				this.#pubSub.send({ type: 'to', data: { id: id, message: msg } })
+			}
+		}
+	}
+
+	/**
+	 * Send message locally to listeners
+	 */
+	private sendLocal(name: string, msg: EvMessage) {
+		const listeners = this.#listeners.get(name)
+
+		if (!listeners) return msg
+
+		for (const id of listeners) {
+			const client = this.#clients.get(id)
+
+			if (!client) {
+				continue
+			}
+
+			client.message({
+				...msg,
+				data:
+					typeof msg.data === 'string'
+						? { ch: name, data: msg }
+						: { ch: name, ...msg.data },
+			})
+		}
+
+		return msg
+	}
+
+	/**
+	 * Sends message to channel (local + Redis)
+	 */
+	send(name: string, msg: EvMessage) {
+		this.sendLocal(name, msg)
+
+		if (this.#pubSub) {
+			this.#pubSub.send({ type: 'send', data: { name, message: msg } })
+		}
+	}
+
+	/**
+	 * Subscribe client to channel
+	 */
+	#listen(name: string, id: string) {
+		let listeners = this.#listeners.get(name)
+
+		if (!listeners) {
+			listeners = new Set()
+			this.#listeners.set(name, listeners)
+		}
+
+		if (listeners.size >= this.#maxListeners) {
+			throw new EvMaxListenerError(listeners.size, name)
+		}
+
+		listeners.add(id)
+	}
+
+	/**
+	 * Unsubscribe client from channel
+	 */
+	#unlisten(name: string, id: string) {
+		const listeners = this.#listeners.get(name)
+
+		if (!listeners) return
+
+		listeners.delete(id)
+
+		if (listeners.size === 0) {
+			this.#listeners.delete(name)
+		}
+	}
+
+	/**
+	 * Redis → process entry
+	 */
+	#onMessage(msg: Record<string, any>) {
+		const type = msg?.type
+
+		switch (type) {
+			case 'send':
+				const name = msg?.data?.name
+				const message = msg?.data?.message
+
+				if (!name || !message) return
+
+				this.sendLocal(name, message)
+				break
+
+			case 'to':
+				const data = msg?.data?.message
+				const id = msg?.data?.id
+
+				this.toLocal(id, data)
+				break
+		}
+	}
 }

package/src/types.ts

@@ -1,3 +1,4 @@
+import type { EvRedisPubSub } from './adapters/pub-sub.js'
 import type { EvStreamManager } from './manager.js'
 
 // Built-in event types.
@@ -5,52 +6,54 @@ export type EvEventsType = 'data' | 'error' | 'end'
 
 // Represents a message sent to the client over SSE.
 export interface EvMessage {
-    // Optional event name.
-    event?: string | EvEventsType
-    // Data to send; can be a string or object.
-    data: string | object
-    // Optional ID of the event.
-    id?: string
+	// Optional event name.
+	event?: string | EvEventsType
+	// Data to send; can be a string or object.
+	data: string | object
+	// Optional ID of the event.
+	id?: string
 }
 
 // Options for token-based authentication from query parameters.
 export interface EvAuthenticationOptions {
-    method: 'query'
-    param: string
-    verify: (token: string) => Promise<EvMessage> | undefined | null | boolean
+	method: 'query'
+	param: string
+	verify: (token: string) => Promise<EvMessage> | undefined | null | boolean
 }
 
 // Options for configuring a single SSE stream.
 export interface EvOptions {
-    authentication?: EvAuthenticationOptions
-    heartbeat?: number
+	authentication?: EvAuthenticationOptions
+	heartbeat?: number
 }
 
 // Configuration options for EvStreamManager.
 export interface EvManagerOptions {
-    // Unique ID for the manager
-    id?: string
+	// Unique ID for the manager
+	id?: string
 
-    // Max Connection which a manager can handle. If this limit exceeds it throws `EvMaxConnectionsError`
-    maxConnection?: number
+	// Max Connection which a manager can handle. If this limit exceeds it throws `EvMaxConnectionsError`
+	maxConnection?: number
 
-    // Max Listeners which a listener can broadcast a message to. If this limit exceeds it throw `EvMaxListenerError`
-    maxListeners?: number
+	// Max Listeners which a listener can broadcast a message to. If this limit exceeds it throw `EvMaxListenerError`
+	maxListeners?: number
+
+	pubSub?: EvRedisPubSub
 }
 
 // Options for initializing EvState.
 export interface EvStateAdapter {
-    publish(channel: string, message: any): Promise<void>
-    subscribe(channel: string, onMessage: (message: any) => void): Promise<void>
-    unsubscribe(channel: string): Promise<void>
+	publish(channel: string, message: any): Promise<void>
+	subscribe(channel: string, onMessage: (message: any) => void): Promise<void>
+	unsubscribe(channel: string): Promise<void>
 }
 
 export interface EvStateOptions<T> {
-    initialValue: T
-    channel: string
-    manager: EvStreamManager
-    key?: string
-    adapter?: EvStateAdapter
+	initialValue: T
+	channel: string
+	manager: EvStreamManager
+	key?: string
+	adapter?: EvStateAdapter
 }
 
 export type EvOnClose = (channels: string[]) => Promise<void>