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

package/README.md

@@ -26,6 +26,10 @@ Related packages:
 
 - [Installation](#installation)
 - [Usage](#usage)
+  - [With the `redis` package](#with-the-redis-package)
+  - [With the `redis` package and a Redis cluster](#with-the-redis-package-and-a-redis-cluster)
+  - [With the `ioredis` package](#with-the-ioredis-package)
+  - [With the `ioredis` package and a Redis cluster](#with-the-ioredis-package-and-a-redis-cluster)
 - [Options](#options)
 - [How it works](#how-it-works)
 - [License](#license)
@@ -38,6 +42,8 @@ npm install @socket.io/redis-streams-adapter redis
 
 ## Usage
 
+### With the `redis` package
+
 ```js
 import { createClient } from "redis";
 import { Server } from "socket.io";
@@ -54,6 +60,81 @@ const io = new Server({
 io.listen(3000);
 ```
 
+### With the `redis` package and a Redis cluster
+
+```js
+import { createCluster } from "redis";
+import { Server } from "socket.io";
+import { createAdapter } from "@socket.io/redis-streams-adapter";
+
+const redisClient = createCluster({
+  rootNodes: [
+    {
+      url: "redis://localhost:7000",
+    },
+    {
+      url: "redis://localhost:7001",
+    },
+    {
+      url: "redis://localhost:7002",
+    },
+  ],
+});
+
+await redisClient.connect();
+
+const io = new Server({
+  adapter: createAdapter(redisClient)
+});
+
+io.listen(3000);
+```
+
+### With the `ioredis` package
+
+```js
+import { Redis } from "ioredis";
+import { Server } from "socket.io";
+import { createAdapter } from "@socket.io/redis-streams-adapter";
+
+const redisClient = new Redis();
+
+const io = new Server({
+  adapter: createAdapter(redisClient)
+});
+
+io.listen(3000);
+```
+
+### With the `ioredis` package and a Redis cluster
+
+```js
+import { Cluster } from "ioredis";
+import { Server } from "socket.io";
+import { createAdapter } from "@socket.io/redis-streams-adapter";
+
+const redisClient = new Cluster([
+  {
+    host: "localhost",
+    port: 7000,
+  },
+  {
+    host: "localhost",
+    port: 7001,
+  },
+  {
+    host: "localhost",
+    port: 7002,
+  },
+]);
+
+const io = new Server({
+  adapter: createAdapter(redisClient)
+});
+
+io.listen(3000);
+```
+
 ## Options
 
 | Name                | Description                                                                                                       | Default value  |

package/dist/adapter.d.ts

@@ -1,16 +1,5 @@
-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;
-}
+import { ClusterAdapterWithHeartbeat } from "socket.io-adapter";
+import type { ClusterAdapterOptions, ClusterMessage, PrivateSessionId, Session, ServerId, ClusterResponse } from "socket.io-adapter";
 export interface RedisStreamsAdapterOptions {
     /**
      * The name of the Redis stream.

package/dist/adapter.js

@@ -97,13 +97,12 @@ class RedisStreamsAdapter extends socket_io_adapter_1.ClusterAdapterWithHeartbea
         };
         // @ts-ignore
         if (message.data) {
-            // TODO MessageType should be exported by the socket.io-adapter package
             const mayContainBinary = [
-                3,
-                8,
-                9,
-                10,
-                12, // MessageType.BROADCAST_ACK,
+                socket_io_adapter_1.MessageType.BROADCAST,
+                socket_io_adapter_1.MessageType.FETCH_SOCKETS_RESPONSE,
+                socket_io_adapter_1.MessageType.SERVER_SIDE_EMIT,
+                socket_io_adapter_1.MessageType.SERVER_SIDE_EMIT_RESPONSE,
+                socket_io_adapter_1.MessageType.BROADCAST_ACK,
             ].includes(message.type);
             // @ts-ignore
             if (mayContainBinary && (0, util_1.hasBinary)(message.data)) {
@@ -149,9 +148,7 @@ class RedisStreamsAdapter extends socket_io_adapter_1.ClusterAdapterWithHeartbea
         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(sessionKey, encodedSession, {
-            PX: this.nsp.server.opts.connectionStateRecovery.maxDisconnectionDuration,
-        });
+        (0, util_1.SET)(this.#redisClient, sessionKey, encodedSession, this.nsp.server.opts.connectionStateRecovery.maxDisconnectionDuration);
     }
     async restoreSession(pid, offset) {
         debug("restoring session %s from offset %s", pid, offset);
@@ -159,12 +156,12 @@ class RedisStreamsAdapter extends socket_io_adapter_1.ClusterAdapterWithHeartbea
             return Promise.reject("invalid offset");
         }
         const sessionKey = this.#opts.sessionKeyPrefix + pid;
-        const [rawSession, offsetExists] = await this.#redisClient
-            .multi()
-            .get(sessionKey)
-            .del(sessionKey) // GETDEL was added in Redis version 6.2
-            .xRange(this.#opts.streamName, offset, offset)
-            .exec();
+        const results = await Promise.all([
+            (0, util_1.GETDEL)(this.#redisClient, sessionKey),
+            (0, util_1.XRANGE)(this.#redisClient, this.#opts.streamName, offset, offset),
+        ]);
+        const rawSession = results[0][0];
+        const offsetExists = results[1][0];
         if (!rawSession || !offsetExists) {
             return Promise.reject("session or offset not found");
         }
@@ -174,9 +171,7 @@ class RedisStreamsAdapter extends socket_io_adapter_1.ClusterAdapterWithHeartbea
         // FIXME we need to add an arbitrary limit here, because if entries are added faster than what we can consume, then
         // we will loop endlessly. But if we stop before reaching the end of the stream, we might lose messages.
         for (let i = 0; i < RESTORE_SESSION_MAX_XRANGE_CALLS; i++) {
-            const entries = await this.#redisClient.xRange(this.#opts.streamName, RedisStreamsAdapter.nextOffset(offset), "+", {
-                COUNT: this.#opts.readCount,
-            });
+            const entries = await (0, util_1.XRANGE)(this.#redisClient, this.#opts.streamName, RedisStreamsAdapter.nextOffset(offset), "+");
             if (entries.length === 0) {
                 break;
             }

package/dist/util.d.ts

@@ -8,3 +8,15 @@ export declare function XREAD(redisClient: any, streamName: string, offset: stri
  * @see https://redis.io/commands/xadd/
  */
 export declare function XADD(redisClient: any, streamName: string, payload: any, maxLenThreshold: number): any;
+/**
+ * @see https://redis.io/commands/xrange/
+ */
+export declare function XRANGE(redisClient: any, streamName: string, start: string, end: string): any;
+/**
+ * @see https://redis.io/commands/set/
+ */
+export declare function SET(redisClient: any, key: string, value: string, expiryInSeconds: number): any;
+/**
+ * @see https://redis.io/commands/getdel/
+ */
+export declare function GETDEL(redisClient: any, key: string): any;

package/dist/util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XADD = exports.XREAD = exports.randomId = exports.hasBinary = void 0;
+exports.GETDEL = exports.SET = exports.XRANGE = exports.XADD = exports.XREAD = exports.randomId = exports.hasBinary = void 0;
 const crypto_1 = require("crypto");
 const redis_1 = require("redis");
 function hasBinary(obj, toJSON) {
@@ -43,6 +43,22 @@ exports.randomId = randomId;
 function isRedisV4Client(redisClient) {
     return typeof redisClient.sSubscribe === "function";
 }
+/**
+ * Map the output of the XREAD/XRANGE command with the ioredis package to the format of the redis package
+ * @param result
+ */
+function mapResult(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,
+    };
+}
 /**
  * @see https://redis.io/commands/xread/
  */
@@ -69,18 +85,7 @@ function XREAD(redisClient, streamName, offset, readCount) {
             }
             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,
-                        };
-                    }),
+                    messages: results[0][1].map(mapResult),
                 },
             ];
         });
@@ -109,3 +114,51 @@ function XADD(redisClient, streamName, payload, maxLenThreshold) {
     }
 }
 exports.XADD = XADD;
+/**
+ * @see https://redis.io/commands/xrange/
+ */
+function XRANGE(redisClient, streamName, start, end) {
+    if (isRedisV4Client(redisClient)) {
+        return redisClient.xRange(streamName, start, end);
+    }
+    else {
+        return redisClient.xrange(streamName, start, end).then((res) => {
+            return res.map(mapResult);
+        });
+    }
+}
+exports.XRANGE = XRANGE;
+/**
+ * @see https://redis.io/commands/set/
+ */
+function SET(redisClient, key, value, expiryInSeconds) {
+    if (isRedisV4Client(redisClient)) {
+        return redisClient.set(key, value, {
+            PX: expiryInSeconds,
+        });
+    }
+    else {
+        return redisClient.set(key, value, "PX", expiryInSeconds);
+    }
+}
+exports.SET = SET;
+/**
+ * @see https://redis.io/commands/getdel/
+ */
+function GETDEL(redisClient, key) {
+    if (isRedisV4Client(redisClient)) {
+        // note: GETDEL was added in Redis version 6.2
+        return redisClient.multi().get(key).del(key).exec();
+    }
+    else {
+        return redisClient
+            .multi()
+            .get(key)
+            .del(key)
+            .exec()
+            .then((res) => {
+            return [res[0][1]];
+        });
+    }
+}
+exports.GETDEL = GETDEL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@socket.io/redis-streams-adapter",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The Socket.IO adapter based on Redis Streams, allowing to broadcast events between several Socket.IO servers",
   "license": "MIT",
   "repository": {
@@ -13,7 +13,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "compile": "tsc",
+    "compile": "rimraf ./dist && tsc",
     "format:check": "prettier --parser typescript --check \"lib/**/*.ts\" \"test/**/*.ts\"",
     "format:fix": "prettier --parser typescript --write \"lib/**/*.ts\" \"test/**/*.ts\"",
     "prepack": "npm run compile",
@@ -31,7 +31,7 @@
     "debug": "~4.3.1"
   },
   "peerDependencies": {
-    "socket.io-adapter": "^2.5.3"
+    "socket.io-adapter": "^2.5.4"
   },
   "devDependencies": {
     "@types/expect.js": "^0.3.29",
@@ -44,6 +44,7 @@
     "nyc": "^15.1.0",
     "prettier": "^2.8.7",
     "redis": "^4.6.5",
+    "rimraf": "^5.0.5",
     "socket.io": "^4.6.1",
     "socket.io-client": "^4.6.1",
     "ts-node": "^10.9.1",

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

@@ -1,184 +0,0 @@
-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 {};