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

package/dist/cluster-adapter-v2.js

@@ -1,488 +0,0 @@
-"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/cluster-adapter.d.ts

@@ -1,54 +0,0 @@
-import { Adapter, 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;
-}
-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 interface ClusterMessage {
-    uid: string;
-    nsp: string;
-    type: MessageType;
-    data?: Record<string, unknown>;
-}
-export declare abstract class ClusterAdapter extends Adapter {
-    #private;
-    protected constructor(nsp: any, opts: Required<ClusterAdapterOptions>);
-    protected initHeartbeat(): void;
-    close(): Promise<void> | void;
-    onMessage(message: ClusterMessage, offset: string): Promise<any>;
-    broadcast(packet: any, opts: BroadcastOptions): Promise<any>;
-    broadcastWithAck(packet: any, opts: BroadcastOptions, clientCountCallback: (clientCount: number) => void, ack: (...args: any[]) => void): void;
-    serverCount(): Promise<number>;
-    /**
-     *
-     * @param opts
-     * @param rooms
-     */
-    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[]): any;
-    abstract doPublish(message: ClusterMessage): Promise<string>;
-}