@socket.io/redis-streams-adapter 0.1.0 → 0.2.0

package/README.md

@@ -43,7 +43,7 @@ import { createClient } from "redis";
 import { Server } from "socket.io";
 import { createAdapter } from "@socket.io/redis-streams-adapter";
 
-const redisClient = createClient({ host: "localhost", port: 6379 });
+const redisClient = createClient({ url: "redis://localhost:6379" });
 
 await redisClient.connect();
 
@@ -56,13 +56,14 @@ io.listen(3000);
 
 ## Options
 
-| Name                | Description                                                        | Default value |
-|---------------------|--------------------------------------------------------------------|---------------|
-| `streamName`        | The name of the Redis stream.                                      | `socket.io`   |
-| `maxLen`            | The maximum size of the stream. Almost exact trimming (~) is used. | `10_000`      |
-| `readCount`         | The number of elements to fetch per XREAD call.                    | `100`         |
-| `heartbeatInterval` | The number of ms between two heartbeats.                           | `5_000`       |
-| `heartbeatTimeout`  | The number of ms without heartbeat before we consider a node down. | `10_000`      |
+| Name                | Description                                                                                                       | Default value  |
+|---------------------|-------------------------------------------------------------------------------------------------------------------|----------------|
+| `streamName`        | The name of the Redis stream.                                                                                     | `socket.io`    |
+| `maxLen`            | The maximum size of the stream. Almost exact trimming (~) is used.                                                | `10_000`       |
+| `readCount`         | The number of elements to fetch per XREAD call.                                                                   | `100`          |
+| `sessionKeyPrefix`  | The prefix of the key used to store the Socket.IO session, when the connection state recovery feature is enabled. | `sio:session:` |
+| `heartbeatInterval` | The number of ms between two heartbeats.                                                                          | `5_000`        |
+| `heartbeatTimeout`  | The number of ms without heartbeat before we consider a node down.                                                | `10_000`       |
 
 ## How it works
 

package/dist/adapter.d.ts

@@ -1,8 +1,20 @@
-import type { PrivateSessionId, Session } from "socket.io-adapter";
-import { ClusterAdapter, ClusterAdapterOptions, ClusterMessage } from "./cluster-adapter";
-export interface RedisStreamsAdapterOptions extends ClusterAdapterOptions {
+import { ClusterAdapterWithHeartbeat, type ClusterMessage, type PrivateSessionId, type Session, type ServerId, type ClusterResponse } from "socket.io-adapter";
+interface ClusterAdapterOptions {
+    /**
+     * The number of ms between two heartbeats.
+     * @default 5_000
+     */
+    heartbeatInterval?: number;
+    /**
+     * The number of ms without heartbeat before we consider a node down.
+     * @default 10_000
+     */
+    heartbeatTimeout?: number;
+}
+export interface RedisStreamsAdapterOptions {
     /**
      * The name of the Redis stream.
+     * @default "socket.io"
      */
     streamName?: string;
     /**
@@ -15,6 +27,11 @@ export interface RedisStreamsAdapterOptions extends ClusterAdapterOptions {
      * @default 100
      */
     readCount?: number;
+    /**
+     * The prefix of the key used to store the Socket.IO session, when the connection state recovery feature is enabled.
+     * @default "sio:session:"
+     */
+    sessionKeyPrefix?: string;
 }
 interface RawClusterMessage {
     uid: string;
@@ -28,11 +45,12 @@ interface RawClusterMessage {
  * @param redisClient - a Redis client that will be used to publish messages
  * @param opts - additional options
  */
-export declare function createAdapter(redisClient: any, opts?: RedisStreamsAdapterOptions): (nsp: any) => RedisStreamsAdapter;
-declare class RedisStreamsAdapter extends ClusterAdapter {
+export declare function createAdapter(redisClient: any, opts?: RedisStreamsAdapterOptions & ClusterAdapterOptions): (nsp: any) => RedisStreamsAdapter;
+declare class RedisStreamsAdapter extends ClusterAdapterWithHeartbeat {
     #private;
-    constructor(nsp: any, redisClient: any, opts: Required<RedisStreamsAdapterOptions>);
+    constructor(nsp: any, redisClient: any, opts: Required<RedisStreamsAdapterOptions> & ClusterAdapterOptions);
     doPublish(message: ClusterMessage): any;
+    protected doPublishResponse(requesterUid: ServerId, response: ClusterResponse): Promise<void>;
     static encode(message: ClusterMessage): RawClusterMessage;
     onRawMessage(rawMessage: RawClusterMessage, offset: string): any;
     static decode(rawMessage: RawClusterMessage): ClusterMessage;

package/dist/adapter.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAdapter = void 0;
+const socket_io_adapter_1 = require("socket.io-adapter");
 const msgpack_1 = require("@msgpack/msgpack");
-const redis_1 = require("redis");
-const cluster_adapter_1 = require("./cluster-adapter");
 const debug_1 = require("debug");
 const util_1 = require("./util");
 const debug = (0, debug_1.default)("socket.io-redis-streams-adapter");
@@ -20,24 +19,16 @@ function createAdapter(redisClient, opts) {
         streamName: "socket.io",
         maxLen: 10000,
         readCount: 100,
+        sessionKeyPrefix: "sio:session:",
         heartbeatInterval: 5000,
         heartbeatTimeout: 10000,
     }, opts);
     let offset = "$";
     let polling = false;
+    let shouldClose = false;
     async function poll() {
         try {
-            let response = await redisClient.xRead((0, redis_1.commandOptions)({
-                isolated: true,
-            }), [
-                {
-                    key: options.streamName,
-                    id: offset,
-                },
-            ], {
-                COUNT: options.readCount,
-                BLOCK: 5000,
-            });
+            let response = await (0, util_1.XREAD)(redisClient, options.streamName, offset, options.readCount);
             if (response) {
                 for (const entry of response[0].messages) {
                     debug("reading entry %s", entry.id);
@@ -54,7 +45,7 @@ function createAdapter(redisClient, opts) {
         catch (e) {
             debug("something went wrong while consuming the stream: %s", e.message);
         }
-        if (namespaceToAdapters.size > 0 && redisClient.isOpen) {
+        if (namespaceToAdapters.size > 0 && !shouldClose) {
             poll();
         }
         else {
@@ -66,35 +57,37 @@ function createAdapter(redisClient, opts) {
         namespaceToAdapters.set(nsp.name, adapter);
         if (!polling) {
             polling = true;
+            shouldClose = false;
             poll();
         }
         const defaultClose = adapter.close;
         adapter.close = () => {
             namespaceToAdapters.delete(nsp.name);
+            if (namespaceToAdapters.size === 0) {
+                shouldClose = true;
+            }
             defaultClose.call(adapter);
         };
         return adapter;
     };
 }
 exports.createAdapter = createAdapter;
-class RedisStreamsAdapter extends cluster_adapter_1.ClusterAdapter {
+class RedisStreamsAdapter extends socket_io_adapter_1.ClusterAdapterWithHeartbeat {
     #redisClient;
     #opts;
     constructor(nsp, redisClient, opts) {
         super(nsp, opts);
         this.#redisClient = redisClient;
         this.#opts = opts;
-        this.initHeartbeat();
+        this.init();
     }
     doPublish(message) {
         debug("publishing %o", message);
-        return this.#redisClient.xAdd(this.#opts.streamName, "*", RedisStreamsAdapter.encode(message), {
-            TRIM: {
-                strategy: "MAXLEN",
-                strategyModifier: "~",
-                threshold: this.#opts.maxLen,
-            },
-        });
+        return (0, util_1.XADD)(this.#redisClient, this.#opts.streamName, RedisStreamsAdapter.encode(message), this.#opts.maxLen);
+    }
+    doPublishResponse(requesterUid, response) {
+        // @ts-ignore
+        return this.doPublish(response);
     }
     static encode(message) {
         const rawMessage = {
@@ -102,18 +95,23 @@ class RedisStreamsAdapter extends cluster_adapter_1.ClusterAdapter {
             nsp: message.nsp,
             type: message.type.toString(),
         };
+        // @ts-ignore
         if (message.data) {
+            // TODO MessageType should be exported by the socket.io-adapter package
             const mayContainBinary = [
-                cluster_adapter_1.MessageType.BROADCAST,
-                cluster_adapter_1.MessageType.BROADCAST_ACK,
-                cluster_adapter_1.MessageType.FETCH_SOCKETS_RESPONSE,
-                cluster_adapter_1.MessageType.SERVER_SIDE_EMIT,
-                cluster_adapter_1.MessageType.SERVER_SIDE_EMIT_RESPONSE,
+                3,
+                8,
+                9,
+                10,
+                12, // MessageType.BROADCAST_ACK,
             ].includes(message.type);
+            // @ts-ignore
             if (mayContainBinary && (0, util_1.hasBinary)(message.data)) {
+                // @ts-ignore
                 rawMessage.data = Buffer.from((0, msgpack_1.encode)(message.data)).toString("base64");
             }
             else {
+                // @ts-ignore
                 rawMessage.data = JSON.stringify(message.data);
             }
         }
@@ -137,9 +135,11 @@ class RedisStreamsAdapter extends cluster_adapter_1.ClusterAdapter {
         };
         if (rawMessage.data) {
             if (rawMessage.data.startsWith("{")) {
+                // @ts-ignore
                 message.data = JSON.parse(rawMessage.data);
             }
             else {
+                // @ts-ignore
                 message.data = (0, msgpack_1.decode)(Buffer.from(rawMessage.data, "base64"));
             }
         }
@@ -147,8 +147,9 @@ class RedisStreamsAdapter extends cluster_adapter_1.ClusterAdapter {
     }
     persistSession(session) {
         debug("persisting session %o", session);
+        const sessionKey = this.#opts.sessionKeyPrefix + session.pid;
         const encodedSession = Buffer.from((0, msgpack_1.encode)(session)).toString("base64");
-        this.#redisClient.set(`sio:session:${session.pid}`, encodedSession, {
+        this.#redisClient.set(sessionKey, encodedSession, {
             PX: this.nsp.server.opts.connectionStateRecovery.maxDisconnectionDuration,
         });
     }
@@ -157,7 +158,7 @@ class RedisStreamsAdapter extends cluster_adapter_1.ClusterAdapter {
         if (!/^[0-9]+-[0-9]+$/.test(offset)) {
             return Promise.reject("invalid offset");
         }
-        const sessionKey = `sio:session:${pid}`;
+        const sessionKey = this.#opts.sessionKeyPrefix + pid;
         const [rawSession, offsetExists] = await this.#redisClient
             .multi()
             .get(sessionKey)
@@ -182,6 +183,7 @@ class RedisStreamsAdapter extends cluster_adapter_1.ClusterAdapter {
             for (const entry of entries) {
                 if (entry.message.nsp === this.nsp.name && entry.message.type === "3") {
                     const message = RedisStreamsAdapter.decode(entry.message);
+                    // @ts-ignore
                     if (shouldIncludePacket(session.rooms, message.data.opts)) {
                         // @ts-ignore
                         session.missedPackets.push(message.data.packet.data);

package/dist/cluster-adapter-v2.d.ts

@@ -0,0 +1,184 @@
+import { Adapter, BroadcastFlags, BroadcastOptions, Room } from "socket.io-adapter";
+export interface ClusterAdapterOptions {
+    /**
+     * The number of ms between two heartbeats.
+     * @default 5_000
+     */
+    heartbeatInterval?: number;
+    /**
+     * The number of ms without heartbeat before we consider a node down.
+     * @default 10_000
+     */
+    heartbeatTimeout?: number;
+}
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export declare enum MessageType {
+    INITIAL_HEARTBEAT = 1,
+    HEARTBEAT = 2,
+    BROADCAST = 3,
+    SOCKETS_JOIN = 4,
+    SOCKETS_LEAVE = 5,
+    DISCONNECT_SOCKETS = 6,
+    FETCH_SOCKETS = 7,
+    FETCH_SOCKETS_RESPONSE = 8,
+    SERVER_SIDE_EMIT = 9,
+    SERVER_SIDE_EMIT_RESPONSE = 10,
+    BROADCAST_CLIENT_COUNT = 11,
+    BROADCAST_ACK = 12
+}
+export type ClusterMessage = {
+    uid: string;
+    nsp: string;
+} & ({
+    type: MessageType.INITIAL_HEARTBEAT | MessageType.HEARTBEAT;
+} | {
+    type: MessageType.BROADCAST;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        packet: unknown;
+        requestId?: string;
+    };
+} | {
+    type: MessageType.SOCKETS_JOIN | MessageType.SOCKETS_LEAVE;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        rooms: string[];
+    };
+} | {
+    type: MessageType.DISCONNECT_SOCKETS;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        close?: boolean;
+    };
+} | {
+    type: MessageType.FETCH_SOCKETS;
+    data: {
+        opts: {
+            rooms: string[];
+            except: string[];
+            flags: BroadcastFlags;
+        };
+        requestId: string;
+    };
+} | {
+    type: MessageType.SERVER_SIDE_EMIT;
+    data: {
+        requestId?: string;
+        packet: unknown;
+    };
+});
+export type ClusterResponse = {
+    uid: string;
+    nsp: string;
+} & ({
+    type: MessageType.FETCH_SOCKETS_RESPONSE;
+    data: {
+        requestId: string;
+        sockets: unknown[];
+    };
+} | {
+    type: MessageType.SERVER_SIDE_EMIT_RESPONSE;
+    data: {
+        requestId: string;
+        packet: unknown;
+    };
+} | {
+    type: MessageType.BROADCAST_CLIENT_COUNT;
+    data: {
+        requestId: string;
+        clientCount: number;
+    };
+} | {
+    type: MessageType.BROADCAST_ACK;
+    data: {
+        requestId: string;
+        packet: unknown;
+    };
+});
+/**
+ * A cluster-ready adapter. Any extending class must:
+ *
+ * - implement {@link ClusterAdapter#publishMessage} and {@link ClusterAdapter#publishResponse}
+ * - call {@link ClusterAdapter#onMessage} and {@link ClusterAdapter#onResponse}
+ */
+export declare abstract class ClusterAdapter extends Adapter {
+    protected readonly uid: string;
+    private requests;
+    private ackRequests;
+    protected constructor(nsp: unknown);
+    /**
+     * Called when receiving a message from another member of the cluster.
+     *
+     * @param message
+     * @param offset
+     * @protected
+     */
+    protected onMessage(message: ClusterMessage, offset?: string): Promise<void>;
+    /**
+     * Called when receiving a response from another member of the cluster.
+     *
+     * @param response
+     * @protected
+     */
+    protected onResponse(response: ClusterResponse): void;
+    broadcast(packet: any, opts: BroadcastOptions): Promise<any>;
+    /**
+     * Adds an offset at the end of the data array in order to allow the client to receive any missed packets when it
+     * reconnects after a temporary disconnection.
+     *
+     * @param packet
+     * @param opts
+     * @param offset
+     * @private
+     */
+    private addOffsetIfNecessary;
+    broadcastWithAck(packet: any, opts: BroadcastOptions, clientCountCallback: (clientCount: number) => void, ack: (...args: any[]) => void): void;
+    addSockets(opts: BroadcastOptions, rooms: Room[]): void;
+    delSockets(opts: BroadcastOptions, rooms: Room[]): void;
+    disconnectSockets(opts: BroadcastOptions, close: boolean): void;
+    fetchSockets(opts: BroadcastOptions): Promise<any[]>;
+    serverSideEmit(packet: any[]): Promise<any>;
+    protected publish(message: DistributiveOmit<ClusterMessage, "uid" | "nsp">): Promise<string>;
+    /**
+     * Send a message to the other members of the cluster.
+     *
+     * @param message
+     * @protected
+     * @return an offset, if applicable
+     */
+    protected abstract publishMessage(message: ClusterMessage): Promise<string>;
+    private publishResponse;
+    /**
+     * Send a response to the given member of the cluster.
+     *
+     * @param requesterUid
+     * @param response
+     * @protected
+     */
+    protected abstract doPublishResponse(requesterUid: string, response: ClusterResponse): void;
+}
+export declare abstract class ClusterAdapterWithHeartbeat extends ClusterAdapter {
+    private readonly _opts;
+    private heartbeatTimer;
+    private nodesMap;
+    protected constructor(nsp: unknown, opts: ClusterAdapterOptions);
+    init(): Promise<void> | void;
+    private scheduleHeartbeat;
+    close(): Promise<void> | void;
+    onMessage(message: ClusterMessage, offset?: string): Promise<any>;
+    serverCount(): Promise<number>;
+    publish(message: DistributiveOmit<ClusterMessage, "nsp" | "uid">): Promise<string>;
+}
+export {};

package/dist/cluster-adapter-v2.js

@@ -0,0 +1,488 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterAdapterWithHeartbeat = exports.ClusterAdapter = exports.MessageType = void 0;
+const socket_io_adapter_1 = require("socket.io-adapter");
+const debug_1 = require("debug");
+const crypto_1 = require("crypto");
+const debug = (0, debug_1.default)("socket.io-adapter");
+const EMITTER_UID = "emitter";
+const DEFAULT_TIMEOUT = 5000;
+const randomId = () => (0, crypto_1.randomBytes)(8).toString("hex");
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["INITIAL_HEARTBEAT"] = 1] = "INITIAL_HEARTBEAT";
+    MessageType[MessageType["HEARTBEAT"] = 2] = "HEARTBEAT";
+    MessageType[MessageType["BROADCAST"] = 3] = "BROADCAST";
+    MessageType[MessageType["SOCKETS_JOIN"] = 4] = "SOCKETS_JOIN";
+    MessageType[MessageType["SOCKETS_LEAVE"] = 5] = "SOCKETS_LEAVE";
+    MessageType[MessageType["DISCONNECT_SOCKETS"] = 6] = "DISCONNECT_SOCKETS";
+    MessageType[MessageType["FETCH_SOCKETS"] = 7] = "FETCH_SOCKETS";
+    MessageType[MessageType["FETCH_SOCKETS_RESPONSE"] = 8] = "FETCH_SOCKETS_RESPONSE";
+    MessageType[MessageType["SERVER_SIDE_EMIT"] = 9] = "SERVER_SIDE_EMIT";
+    MessageType[MessageType["SERVER_SIDE_EMIT_RESPONSE"] = 10] = "SERVER_SIDE_EMIT_RESPONSE";
+    MessageType[MessageType["BROADCAST_CLIENT_COUNT"] = 11] = "BROADCAST_CLIENT_COUNT";
+    MessageType[MessageType["BROADCAST_ACK"] = 12] = "BROADCAST_ACK";
+})(MessageType = exports.MessageType || (exports.MessageType = {}));
+function encodeOptions(opts) {
+    return {
+        rooms: [...opts.rooms],
+        except: [...opts.except],
+        flags: opts.flags,
+    };
+}
+function decodeOptions(opts) {
+    return {
+        rooms: new Set(opts.rooms),
+        except: new Set(opts.except),
+        flags: opts.flags,
+    };
+}
+/**
+ * A cluster-ready adapter. Any extending class must:
+ *
+ * - implement {@link ClusterAdapter#publishMessage} and {@link ClusterAdapter#publishResponse}
+ * - call {@link ClusterAdapter#onMessage} and {@link ClusterAdapter#onResponse}
+ */
+class ClusterAdapter extends socket_io_adapter_1.Adapter {
+    uid;
+    requests = new Map();
+    ackRequests = new Map();
+    constructor(nsp) {
+        super(nsp);
+        this.uid = randomId();
+    }
+    /**
+     * Called when receiving a message from another member of the cluster.
+     *
+     * @param message
+     * @param offset
+     * @protected
+     */
+    async onMessage(message, offset) {
+        if (message.uid === this.uid) {
+            debug("ignore message from self");
+        }
+        debug("new event of type %d from %s", message.type, message.uid);
+        switch (message.type) {
+            case MessageType.BROADCAST: {
+                const withAck = message.data.requestId !== undefined;
+                if (withAck) {
+                    super.broadcastWithAck(message.data.packet, decodeOptions(message.data.opts), (clientCount) => {
+                        debug("waiting for %d client acknowledgements", clientCount);
+                        this.publishResponse(message.uid, {
+                            type: MessageType.BROADCAST_CLIENT_COUNT,
+                            data: {
+                                requestId: message.data.requestId,
+                                clientCount,
+                            },
+                        });
+                    }, (arg) => {
+                        debug("received acknowledgement with value %j", arg);
+                        this.publishResponse(message.uid, {
+                            type: MessageType.BROADCAST_ACK,
+                            data: {
+                                requestId: message.data.requestId,
+                                packet: arg,
+                            },
+                        });
+                    });
+                }
+                else {
+                    const packet = message.data.packet;
+                    const opts = decodeOptions(message.data.opts);
+                    this.addOffsetIfNecessary(packet, opts, offset);
+                    super.broadcast(packet, opts);
+                }
+                break;
+            }
+            case MessageType.SOCKETS_JOIN:
+                super.addSockets(decodeOptions(message.data.opts), message.data.rooms);
+                break;
+            case MessageType.SOCKETS_LEAVE:
+                super.delSockets(decodeOptions(message.data.opts), message.data.rooms);
+                break;
+            case MessageType.DISCONNECT_SOCKETS:
+                super.disconnectSockets(decodeOptions(message.data.opts), message.data.close);
+                break;
+            case MessageType.FETCH_SOCKETS: {
+                debug("calling fetchSockets with opts %j", message.data.opts);
+                const localSockets = await super.fetchSockets(decodeOptions(message.data.opts));
+                this.publishResponse(message.uid, {
+                    type: MessageType.FETCH_SOCKETS_RESPONSE,
+                    data: {
+                        requestId: message.data.requestId,
+                        sockets: localSockets.map((socket) => {
+                            // remove sessionStore from handshake, as it may contain circular references
+                            const { sessionStore, ...handshake } = socket.handshake;
+                            return {
+                                id: socket.id,
+                                handshake,
+                                rooms: [...socket.rooms],
+                                data: socket.data,
+                            };
+                        }),
+                    },
+                });
+                break;
+            }
+            case MessageType.SERVER_SIDE_EMIT: {
+                const packet = message.data.packet;
+                const withAck = message.data.requestId !== undefined;
+                if (!withAck) {
+                    this.nsp._onServerSideEmit(packet);
+                    return;
+                }
+                let called = false;
+                const callback = (arg) => {
+                    // only one argument is expected
+                    if (called) {
+                        return;
+                    }
+                    called = true;
+                    debug("calling acknowledgement with %j", arg);
+                    this.publishResponse(message.uid, {
+                        type: MessageType.SERVER_SIDE_EMIT_RESPONSE,
+                        data: {
+                            requestId: message.data.requestId,
+                            packet: arg,
+                        },
+                    });
+                };
+                packet.push(callback);
+                this.nsp._onServerSideEmit(packet);
+                break;
+            }
+            // @ts-ignore
+            case MessageType.BROADCAST_CLIENT_COUNT:
+            // @ts-ignore
+            case MessageType.BROADCAST_ACK:
+            // @ts-ignore
+            case MessageType.FETCH_SOCKETS_RESPONSE:
+            // @ts-ignore
+            case MessageType.SERVER_SIDE_EMIT_RESPONSE:
+                this.onResponse(message);
+                break;
+            default:
+                debug("unknown message type: %s", message.type);
+        }
+    }
+    /**
+     * Called when receiving a response from another member of the cluster.
+     *
+     * @param response
+     * @protected
+     */
+    onResponse(response) {
+        const requestId = response.data.requestId;
+        debug("received response %s to request %s", response.type, requestId);
+        switch (response.type) {
+            case MessageType.BROADCAST_CLIENT_COUNT: {
+                this.ackRequests
+                    .get(requestId)
+                    ?.clientCountCallback(response.data.clientCount);
+                break;
+            }
+            case MessageType.BROADCAST_ACK: {
+                this.ackRequests.get(requestId)?.ack(response.data.packet);
+                break;
+            }
+            case MessageType.FETCH_SOCKETS_RESPONSE: {
+                const request = this.requests.get(requestId);
+                if (!request) {
+                    return;
+                }
+                request.current++;
+                response.data.sockets.forEach((socket) => request.responses.push(socket));
+                if (request.current === request.expected) {
+                    clearTimeout(request.timeout);
+                    request.resolve(request.responses);
+                    this.requests.delete(requestId);
+                }
+                break;
+            }
+            case MessageType.SERVER_SIDE_EMIT_RESPONSE: {
+                const request = this.requests.get(requestId);
+                if (!request) {
+                    return;
+                }
+                request.current++;
+                request.responses.push(response.data.packet);
+                if (request.current === request.expected) {
+                    clearTimeout(request.timeout);
+                    request.resolve(null, request.responses);
+                    this.requests.delete(requestId);
+                }
+                break;
+            }
+            default:
+                // @ts-ignore
+                debug("unknown response type: %s", response.type);
+        }
+    }
+    async broadcast(packet, opts) {
+        const onlyLocal = opts.flags?.local;
+        if (!onlyLocal) {
+            try {
+                const offset = await this.publish({
+                    type: MessageType.BROADCAST,
+                    data: {
+                        packet,
+                        opts: encodeOptions(opts),
+                    },
+                });
+                this.addOffsetIfNecessary(packet, opts, offset);
+            }
+            catch (e) {
+                return debug("error while broadcasting message: %s", e.message);
+            }
+        }
+        super.broadcast(packet, opts);
+    }
+    /**
+     * Adds an offset at the end of the data array in order to allow the client to receive any missed packets when it
+     * reconnects after a temporary disconnection.
+     *
+     * @param packet
+     * @param opts
+     * @param offset
+     * @private
+     */
+    addOffsetIfNecessary(packet, opts, offset) {
+        if (!this.nsp.server.opts.connectionStateRecovery) {
+            return;
+        }
+        const isEventPacket = packet.type === 2;
+        // packets with acknowledgement are not stored because the acknowledgement function cannot be serialized and
+        // restored on another server upon reconnection
+        const withoutAcknowledgement = packet.id === undefined;
+        const notVolatile = opts.flags?.volatile === undefined;
+        if (isEventPacket && withoutAcknowledgement && notVolatile) {
+            packet.data.push(offset);
+        }
+    }
+    broadcastWithAck(packet, opts, clientCountCallback, ack) {
+        const onlyLocal = opts?.flags?.local;
+        if (!onlyLocal) {
+            const requestId = randomId();
+            this.publish({
+                type: MessageType.BROADCAST,
+                data: {
+                    packet,
+                    requestId,
+                    opts: encodeOptions(opts),
+                },
+            });
+            this.ackRequests.set(requestId, {
+                clientCountCallback,
+                ack,
+            });
+            // we have no way to know at this level whether the server has received an acknowledgement from each client, so we
+            // will simply clean up the ackRequests map after the given delay
+            setTimeout(() => {
+                this.ackRequests.delete(requestId);
+            }, opts.flags.timeout);
+        }
+        super.broadcastWithAck(packet, opts, clientCountCallback, ack);
+    }
+    addSockets(opts, rooms) {
+        super.addSockets(opts, rooms);
+        const onlyLocal = opts.flags?.local;
+        if (onlyLocal) {
+            return;
+        }
+        this.publish({
+            type: MessageType.SOCKETS_JOIN,
+            data: {
+                opts: encodeOptions(opts),
+                rooms,
+            },
+        });
+    }
+    delSockets(opts, rooms) {
+        super.delSockets(opts, rooms);
+        const onlyLocal = opts.flags?.local;
+        if (onlyLocal) {
+            return;
+        }
+        this.publish({
+            type: MessageType.SOCKETS_LEAVE,
+            data: {
+                opts: encodeOptions(opts),
+                rooms,
+            },
+        });
+    }
+    disconnectSockets(opts, close) {
+        super.disconnectSockets(opts, close);
+        const onlyLocal = opts.flags?.local;
+        if (onlyLocal) {
+            return;
+        }
+        this.publish({
+            type: MessageType.DISCONNECT_SOCKETS,
+            data: {
+                opts: encodeOptions(opts),
+                close,
+            },
+        });
+    }
+    async fetchSockets(opts) {
+        const [localSockets, serverCount] = await Promise.all([
+            super.fetchSockets(opts),
+            this.serverCount(),
+        ]);
+        const expectedResponseCount = serverCount - 1;
+        if (opts.flags?.local || expectedResponseCount === 0) {
+            return localSockets;
+        }
+        const requestId = randomId();
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                const storedRequest = this.requests.get(requestId);
+                if (storedRequest) {
+                    reject(new Error(`timeout reached: only ${storedRequest.current} responses received out of ${storedRequest.expected}`));
+                    this.requests.delete(requestId);
+                }
+            }, opts.flags.timeout || DEFAULT_TIMEOUT);
+            const storedRequest = {
+                type: MessageType.FETCH_SOCKETS,
+                resolve,
+                timeout,
+                current: 0,
+                expected: expectedResponseCount,
+                responses: localSockets,
+            };
+            this.requests.set(requestId, storedRequest);
+            this.publish({
+                type: MessageType.FETCH_SOCKETS,
+                data: {
+                    opts: encodeOptions(opts),
+                    requestId,
+                },
+            });
+        });
+    }
+    async serverSideEmit(packet) {
+        const withAck = typeof packet[packet.length - 1] === "function";
+        if (!withAck) {
+            return this.publish({
+                type: MessageType.SERVER_SIDE_EMIT,
+                data: {
+                    packet,
+                },
+            });
+        }
+        const ack = packet.pop();
+        const expectedResponseCount = (await this.serverCount()) - 1;
+        debug('waiting for %d responses to "serverSideEmit" request', expectedResponseCount);
+        if (expectedResponseCount <= 0) {
+            return ack(null, []);
+        }
+        const requestId = randomId();
+        const timeout = setTimeout(() => {
+            const storedRequest = this.requests.get(requestId);
+            if (storedRequest) {
+                ack(new Error(`timeout reached: only ${storedRequest.current} responses received out of ${storedRequest.expected}`), storedRequest.responses);
+                this.requests.delete(requestId);
+            }
+        }, DEFAULT_TIMEOUT);
+        const storedRequest = {
+            type: MessageType.SERVER_SIDE_EMIT,
+            resolve: ack,
+            timeout,
+            current: 0,
+            expected: expectedResponseCount,
+            responses: [],
+        };
+        this.requests.set(requestId, storedRequest);
+        this.publish({
+            type: MessageType.SERVER_SIDE_EMIT,
+            data: {
+                requestId,
+                packet,
+            },
+        });
+    }
+    publish(message) {
+        return this.publishMessage({
+            uid: this.uid,
+            nsp: this.nsp.name,
+            ...message,
+        });
+    }
+    publishResponse(requesterUid, message) {
+        const response = message;
+        response.uid = this.uid;
+        response.nsp = this.nsp.name;
+        return this.doPublishResponse(requesterUid, response);
+    }
+}
+exports.ClusterAdapter = ClusterAdapter;
+class ClusterAdapterWithHeartbeat extends ClusterAdapter {
+    _opts;
+    heartbeatTimer;
+    nodesMap = new Map(); // uid => timestamp of last message
+    constructor(nsp, opts) {
+        super(nsp);
+        this._opts = Object.assign({
+            heartbeatInterval: 5000,
+            heartbeatTimeout: 10000,
+        }, opts);
+    }
+    init() {
+        this.publish({
+            type: MessageType.INITIAL_HEARTBEAT,
+        });
+    }
+    scheduleHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearTimeout(this.heartbeatTimer);
+        }
+        this.heartbeatTimer = setTimeout(() => {
+            this.publish({
+                type: MessageType.HEARTBEAT,
+            });
+        }, this._opts.heartbeatInterval);
+    }
+    close() {
+        if (this.heartbeatTimer)
+            clearTimeout(this.heartbeatTimer);
+    }
+    async onMessage(message, offset) {
+        if (message.uid === this.uid) {
+            return debug("ignore message from self");
+        }
+        if (message.uid && message.uid !== EMITTER_UID) {
+            // we track the UID of each sender, in order to know how many servers there are in the cluster
+            this.nodesMap.set(message.uid, Date.now());
+        }
+        switch (message.type) {
+            case MessageType.INITIAL_HEARTBEAT:
+                this.publish({
+                    type: MessageType.HEARTBEAT,
+                });
+                break;
+            case MessageType.HEARTBEAT:
+                // nothing to do
+                break;
+            default:
+                return super.onMessage(message, offset);
+        }
+    }
+    serverCount() {
+        const now = Date.now();
+        this.nodesMap.forEach((lastSeen, uid) => {
+            const nodeSeemsDown = now - lastSeen > this._opts.heartbeatTimeout;
+            if (nodeSeemsDown) {
+                debug("node %s seems down", uid);
+                this.nodesMap.delete(uid);
+            }
+        });
+        return Promise.resolve(1 + this.nodesMap.size);
+    }
+    publish(message) {
+        this.scheduleHeartbeat();
+        return super.publish(message);
+    }
+}
+exports.ClusterAdapterWithHeartbeat = ClusterAdapterWithHeartbeat;

package/dist/util.d.ts

@@ -1,2 +1,10 @@
 export declare function hasBinary(obj: any, toJSON?: boolean): boolean;
 export declare function randomId(): string;
+/**
+ * @see https://redis.io/commands/xread/
+ */
+export declare function XREAD(redisClient: any, streamName: string, offset: string, readCount: number): any;
+/**
+ * @see https://redis.io/commands/xadd/
+ */
+export declare function XADD(redisClient: any, streamName: string, payload: any, maxLenThreshold: number): any;

package/dist/util.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomId = exports.hasBinary = void 0;
+exports.XADD = exports.XREAD = exports.randomId = exports.hasBinary = void 0;
 const crypto_1 = require("crypto");
+const redis_1 = require("redis");
 function hasBinary(obj, toJSON) {
     if (!obj || typeof obj !== "object") {
         return false;
@@ -32,3 +33,79 @@ function randomId() {
     return (0, crypto_1.randomBytes)(8).toString("hex");
 }
 exports.randomId = randomId;
+/**
+ * Whether the client comes from the `redis` package
+ *
+ * @param redisClient
+ *
+ * @see https://github.com/redis/node-redis
+ */
+function isRedisV4Client(redisClient) {
+    return typeof redisClient.sSubscribe === "function";
+}
+/**
+ * @see https://redis.io/commands/xread/
+ */
+function XREAD(redisClient, streamName, offset, readCount) {
+    if (isRedisV4Client(redisClient)) {
+        return redisClient.xRead((0, redis_1.commandOptions)({
+            isolated: true,
+        }), [
+            {
+                key: streamName,
+                id: offset,
+            },
+        ], {
+            COUNT: readCount,
+            BLOCK: 5000,
+        });
+    }
+    else {
+        return redisClient
+            .xread("BLOCK", 100, "COUNT", readCount, "STREAMS", streamName, offset)
+            .then((results) => {
+            if (results === null) {
+                return null;
+            }
+            return [
+                {
+                    messages: results[0][1].map((result) => {
+                        const id = result[0];
+                        const inlineValues = result[1];
+                        const message = {};
+                        for (let i = 0; i < inlineValues.length; i += 2) {
+                            message[inlineValues[i]] = inlineValues[i + 1];
+                        }
+                        return {
+                            id,
+                            message,
+                        };
+                    }),
+                },
+            ];
+        });
+    }
+}
+exports.XREAD = XREAD;
+/**
+ * @see https://redis.io/commands/xadd/
+ */
+function XADD(redisClient, streamName, payload, maxLenThreshold) {
+    if (isRedisV4Client(redisClient)) {
+        return redisClient.xAdd(streamName, "*", payload, {
+            TRIM: {
+                strategy: "MAXLEN",
+                strategyModifier: "~",
+                threshold: maxLenThreshold,
+            },
+        });
+    }
+    else {
+        const args = [streamName, "MAXLEN", "~", maxLenThreshold, "*"];
+        Object.keys(payload).forEach((k) => {
+            args.push(k, payload[k]);
+        });
+        return redisClient.xadd.call(redisClient, args);
+    }
+}
+exports.XADD = XADD;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socket.io/redis-streams-adapter",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "The Socket.IO adapter based on Redis Streams, allowing to broadcast events between several Socket.IO servers",
   "license": "MIT",
   "repository": {
@@ -14,23 +14,32 @@
   "types": "./dist/index.d.ts",
   "scripts": {
     "compile": "tsc",
-    "format:check": "prettier --parser typescript --check lib/**/*.ts test/**/*.ts",
-    "format:fix": "prettier --parser typescript --write lib/**/*.ts test/**/*.ts",
+    "format:check": "prettier --parser typescript --check \"lib/**/*.ts\" \"test/**/*.ts\"",
+    "format:fix": "prettier --parser typescript --write \"lib/**/*.ts\" \"test/**/*.ts\"",
     "prepack": "npm run compile",
-    "test": "npm run format:check && npm run compile && nyc mocha --bail --require ts-node/register test/**/*.ts"
+    "test": "npm run format:check && npm run compile && npm run test:redis-standalone && npm run test:redis-cluster && npm run test:ioredis-standalone && npm run test:ioredis-cluster",
+    "test:redis-standalone": "nyc mocha --require ts-node/register test/**/*.ts",
+    "test:redis-cluster": "cross-env REDIS_CLUSTER=1 mocha --require ts-node/register test/**/*.ts",
+    "test:ioredis-standalone": "cross-env REDIS_LIB=ioredis mocha --require ts-node/register test/**/*.ts",
+    "test:ioredis-cluster": "cross-env REDIS_LIB=ioredis REDIS_CLUSTER=1 mocha --require ts-node/register test/**/*.ts"
+  },
+  "prettier": {
+    "endOfLine": "auto"
   },
   "dependencies": {
     "@msgpack/msgpack": "~2.8.0",
     "debug": "~4.3.1"
   },
   "peerDependencies": {
-    "socket.io-adapter": "^2.5.2"
+    "socket.io-adapter": "^2.5.3"
   },
   "devDependencies": {
     "@types/expect.js": "^0.3.29",
     "@types/mocha": "^8.2.1",
     "@types/node": "^18.15.11",
+    "cross-env": "7.0.3",
     "expect.js": "0.3.1",
+    "ioredis": "^5.3.2",
     "mocha": "^10.1.0",
     "nyc": "^15.1.0",
     "prettier": "^2.8.7",

package/dist/redis-streams-adapter.d.ts

@@ -1,47 +0,0 @@
-import type { PrivateSessionId, Session } from "socket.io-adapter";
-import { ClusterAdapter, ClusterAdapterOptions, ClusterMessage } from "./cluster-adapter";
-export interface RedisAdapterOptions extends ClusterAdapterOptions {
-    /**
-     * The name of the stream.
-     */
-    streamName?: string;
-    /**
-     * The maximum size of the stream. Almost exact trimming (~) is used.
-     * @default 10_000
-     */
-    maxLen?: number;
-    /**
-     * The number of elements to return per XREAD call
-     * @default 100
-     */
-    readCount?: number;
-}
-interface RawClusterMessage {
-    uid: string;
-    nsp: string;
-    type: string;
-    data?: string;
-}
-/**
- * Returns a function that will create a RedisAdapter instance.
- *
- * @param redisClient - a Redis client that will be used to publish messages
- * @param opts - additional options
- */
-export declare function createAdapter(redisClient: any, opts?: RedisAdapterOptions): (nsp: any) => RedisStreamsAdapter;
-declare class RedisStreamsAdapter extends ClusterAdapter {
-    #private;
-    constructor(nsp: any, redisClient: any, opts: Required<RedisAdapterOptions>);
-    doPublish(message: ClusterMessage): any;
-    static encode(message: ClusterMessage): RawClusterMessage;
-    onRawMessage(rawMessage: RawClusterMessage, offset: string): any;
-    static decode(rawMessage: RawClusterMessage): ClusterMessage;
-    persistSession(session: any): void;
-    restoreSession(pid: PrivateSessionId, offset: string): Promise<Session>;
-    /**
-     * Exclusive ranges were added in Redis 6.2, so this is necessary for previous versions.
-     * @param offset
-     */
-    static nextOffset(offset: any): string;
-}
-export {};

package/dist/redis-streams-adapter.js

@@ -1,212 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAdapter = void 0;
-const msgpack_1 = require("@msgpack/msgpack");
-const redis_1 = require("redis");
-const cluster_adapter_1 = require("./cluster-adapter");
-const debug_1 = require("debug");
-const util_1 = require("./util");
-// TODO
-// BROADCAST / other channels
-// MAXLEN
-const debug = (0, debug_1.default)("socket.io-redis-streams-adapter");
-/**
- * Returns a function that will create a RedisAdapter instance.
- *
- * @param redisClient - a Redis client that will be used to publish messages
- * @param opts - additional options
- */
-function createAdapter(redisClient, opts) {
-    const namespaceToAdapters = new Map();
-    const options = Object.assign({
-        streamName: "socket.io",
-        maxLen: 1000,
-        readCount: 100,
-        heartbeatInterval: 5000,
-        heartbeatTimeout: 10000,
-    }, opts);
-    let offset = "$";
-    let polling = false;
-    async function poll() {
-        try {
-            let response = await redisClient.xRead((0, redis_1.commandOptions)({
-                isolated: true,
-            }), [
-                {
-                    key: options.streamName,
-                    id: offset,
-                },
-            ], {
-                COUNT: options.readCount,
-                BLOCK: 5000,
-            });
-            if (response) {
-                for (const entry of response[0].messages) {
-                    debug("reading entry %s", entry.id);
-                    const message = entry.message;
-                    if (message.nsp) {
-                        namespaceToAdapters
-                            .get(message.nsp)
-                            ?.onRawMessage(message, entry.id);
-                    }
-                    offset = entry.id;
-                }
-            }
-        }
-        catch (e) {
-            debug("something went wrong while consuming the stream: %s", e.message);
-        }
-        if (namespaceToAdapters.size > 0 && redisClient.isOpen) {
-            poll();
-        }
-        else {
-            polling = false;
-        }
-    }
-    return function (nsp) {
-        const adapter = new RedisStreamsAdapter(nsp, redisClient, options);
-        namespaceToAdapters.set(nsp.name, adapter);
-        if (!polling) {
-            polling = true;
-            poll();
-        }
-        const defaultClose = adapter.close;
-        adapter.close = () => {
-            namespaceToAdapters.delete(nsp.name);
-            defaultClose.call(adapter);
-        };
-        return adapter;
-    };
-}
-exports.createAdapter = createAdapter;
-class RedisStreamsAdapter extends cluster_adapter_1.ClusterAdapter {
-    #redisClient;
-    #opts;
-    constructor(nsp, redisClient, opts) {
-        super(nsp, opts);
-        this.#redisClient = redisClient;
-        this.#opts = opts;
-        this.initHeartbeat();
-    }
-    doPublish(message) {
-        debug("publishing %o", message);
-        return this.#redisClient.xAdd(this.#opts.streamName, "*", RedisStreamsAdapter.encode(message), {
-            TRIM: {
-                strategy: "MAXLEN",
-                strategyModifier: "~",
-                threshold: this.#opts.maxLen,
-            },
-        });
-    }
-    static encode(message) {
-        const rawMessage = {
-            uid: message.uid,
-            nsp: message.nsp,
-            type: message.type.toString(),
-        };
-        if (message.data) {
-            const mayContainBinary = [
-                cluster_adapter_1.MessageType.BROADCAST,
-                cluster_adapter_1.MessageType.BROADCAST_ACK,
-                cluster_adapter_1.MessageType.FETCH_SOCKETS_RESPONSE,
-                cluster_adapter_1.MessageType.SERVER_SIDE_EMIT,
-                cluster_adapter_1.MessageType.SERVER_SIDE_EMIT_RESPONSE,
-            ].includes(message.type);
-            if (mayContainBinary && (0, util_1.hasBinary)(message.data)) {
-                rawMessage.data = Buffer.from((0, msgpack_1.encode)(message.data)).toString("base64");
-            }
-            else {
-                rawMessage.data = JSON.stringify(message.data);
-            }
-        }
-        return rawMessage;
-    }
-    onRawMessage(rawMessage, offset) {
-        let message;
-        try {
-            message = RedisStreamsAdapter.decode(rawMessage);
-        }
-        catch (e) {
-            return debug("invalid format: %s", e.message);
-        }
-        this.onMessage(message, offset);
-    }
-    static decode(rawMessage) {
-        const message = {
-            uid: rawMessage.uid,
-            nsp: rawMessage.nsp,
-            type: parseInt(rawMessage.type, 10),
-        };
-        if (rawMessage.data) {
-            if (rawMessage.data.startsWith("{")) {
-                message.data = JSON.parse(rawMessage.data);
-            }
-            else {
-                message.data = (0, msgpack_1.decode)(Buffer.from(rawMessage.data, "base64"));
-            }
-        }
-        return message;
-    }
-    persistSession(session) {
-        debug("persist session %o", session);
-        this.#redisClient.set(session.pid, JSON.stringify(session), {
-            PX: this.nsp.server.opts.connectionStateRecovery.maxDisconnectionDuration,
-        });
-    }
-    async restoreSession(pid, offset) {
-        console.log("restoreSession", pid);
-        console.log("offset", offset);
-        if (!/^[0-9]+-[0-9]+$/.test(offset)) {
-            console.log("invalid offset");
-            return Promise.reject("invalid offset");
-        }
-        const value = await this.#redisClient.get(pid);
-        if (!value) {
-            console.log("session or offset not found");
-            return Promise.reject("session or offset not found");
-        }
-        const session = JSON.parse(value);
-        console.log("session", session);
-        session.missedPackets = [];
-        // FIXME si les messages sont ajoutés plus vite que consommés, problème !
-        for (let i = 0; i < 10; i++) {
-            const entries = await this.#redisClient.xRange(this.#opts.streamName, RedisStreamsAdapter.nextOffset(offset), "+", {
-                COUNT: 100,
-            });
-            console.log("entries", entries.length);
-            console.log("offset", offset);
-            if (entries.length === 0) {
-                break;
-            }
-            for (const entry of entries) {
-                if (entry.message.nsp === this.nsp.name && entry.message.type === "3") {
-                    const message = RedisStreamsAdapter.decode(entry.message);
-                    console.log("message from the log", message);
-                    if (message.type === cluster_adapter_1.MessageType.BROADCAST &&
-                        shouldIncludePacket(session.rooms, message.data.opts)) {
-                        // TODO match rooms
-                        // @ts-ignore
-                        session.missedPackets.push(message.data.packet.data);
-                    }
-                }
-                offset = entry.id;
-            }
-        }
-        console.log("restored", session);
-        return session;
-    }
-    /**
-     * Exclusive ranges were added in Redis 6.2, so this is necessary for previous versions.
-     * @param offset
-     */
-    static nextOffset(offset) {
-        const [timestamp, sequence] = offset.split("-");
-        return timestamp + "-" + (parseInt(sequence) + 1);
-    }
-}
-function shouldIncludePacket(sessionRooms, opts) {
-    const included = opts.rooms.length === 0 ||
-        sessionRooms.some((room) => opts.rooms.indexOf(room) !== -1);
-    const notExcluded = sessionRooms.every((room) => opts.except.indexOf(room) === -1);
-    return included && notExcluded;
-}

package/dist/test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const socket_io_1 = require("socket.io");
-const redis_1 = require("redis");
-const index_1 = require("./index");
-const io = new socket_io_1.Server();
-const pubClient = (0, redis_1.createClient)({ host: 'localhost', port: 6379 });
-const subClient = pubClient.duplicate();
-Promise.all([pubClient.connect(), subClient.connect()]).then(() => {
-    io.adapter((0, index_1.createAdapter)(pubClient, subClient));
-    io.listen(3000);
-});