@eleven-am/pondsocket 0.1.200 → 0.1.202

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.200",
+  "version": "0.1.202",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -23,7 +23,7 @@
     "remove": "rm -r dist/tests && rm dist/distIndex.js",
     "copy": "cp src/types.d.ts dist/types.d.ts && cp src/distIndex.ts dist/index.d.ts && cp package.json dist && cp README.md dist && cp LICENSE dist",
     "push": "npm version patch && npm run copy && cd dist && npm publish && cd ..",
-    "pipeline": "npm run lint && npm run test && npm run build && npm run push"
+    "pipeline": "npm run lint:fix && npm run lint && npm run test && npm run build && npm run push"
   },
   "author": "Roy OSSAI",
   "license": "GPL-3.0",
@@ -35,31 +35,31 @@
   },
   "dependencies": {
     "@eleven-am/pondsocket-common": "^0.0.26",
-    "ioredis": "^5.6.1",
-    "ws": "^8.18.1"
+    "redis": "^5.5.6",
+    "ws": "^8.18.2"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.2.8",
+    "@eslint/compat": "^1.2.9",
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.25.1",
-    "@stylistic/eslint-plugin-ts": "^4.2.0",
+    "@eslint/js": "^9.28.0",
+    "@stylistic/eslint-plugin-ts": "^4.4.1",
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.15.3",
+    "@types/node": "^22.15.30",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.31.1",
-    "@typescript-eslint/parser": "^8.31.1",
-    "eslint": "^9.25.1",
-    "eslint-config-prettier": "^10.1.2",
+    "@typescript-eslint/eslint-plugin": "^8.33.1",
+    "@typescript-eslint/parser": "^8.33.1",
+    "eslint": "^9.28.0",
+    "eslint-config-prettier": "^10.1.5",
     "eslint-import-resolver-node": "^0.3.9",
     "eslint-plugin-file-progress": "^3.0.2",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-prettier": "^5.2.6",
-    "globals": "^16.0.0",
+    "eslint-plugin-prettier": "^5.4.1",
+    "globals": "^16.2.0",
     "jest": "^29.7.0",
     "prettier": "^3.5.3",
     "source-map-support": "^0.5.21",
-    "supertest": "^7.1.0",
-    "ts-jest": "^29.3.2",
+    "supertest": "^7.1.1",
+    "ts-jest": "^29.3.4",
     "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",

package/server/server.js

@@ -10,7 +10,7 @@ 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 _PondSocket_instances, _PondSocket_exclusiveServer, _PondSocket_server, _PondSocket_socketServer, _PondSocket_middleware, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
+var _PondSocket_instances, _PondSocket_server, _PondSocket_exclusiveServer, _PondSocket_socketServer, _PondSocket_backend, _PondSocket_middleware, _PondSocket_handleUpgrade, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 const http_1 = require("http");
@@ -22,15 +22,17 @@ const endpointEngine_1 = require("../engines/endpointEngine");
 const matcher_1 = require("../matcher/matcher");
 const endpoint_1 = require("../wrappers/endpoint");
 class PondSocket {
-    constructor({ server, socketServer, exclusiveServer = true, } = {}) {
+    constructor({ server, socketServer, exclusiveServer = true, distributedBackend, } = {}) {
         _PondSocket_instances.add(this);
-        _PondSocket_exclusiveServer.set(this, void 0);
         _PondSocket_server.set(this, void 0);
+        _PondSocket_exclusiveServer.set(this, void 0);
         _PondSocket_socketServer.set(this, void 0);
+        _PondSocket_backend.set(this, void 0);
         _PondSocket_middleware.set(this, void 0);
         __classPrivateFieldSet(this, _PondSocket_middleware, new middleware_1.Middleware(), "f");
         __classPrivateFieldSet(this, _PondSocket_exclusiveServer, exclusiveServer, "f");
         __classPrivateFieldSet(this, _PondSocket_server, server !== null && server !== void 0 ? server : new http_1.Server(), "f");
+        __classPrivateFieldSet(this, _PondSocket_backend, distributedBackend !== null && distributedBackend !== void 0 ? distributedBackend : null, "f");
         __classPrivateFieldSet(this, _PondSocket_socketServer, socketServer !== null && socketServer !== void 0 ? socketServer : new ws_1.WebSocketServer({ noServer: true }), "f");
         __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_init).call(this);
     }
@@ -50,7 +52,7 @@ class PondSocket {
      * Create a new endpoint
      */
     createEndpoint(path, handler) {
-        const endpoint = new endpointEngine_1.EndpointEngine();
+        const endpoint = new endpointEngine_1.EndpointEngine(String(path), __classPrivateFieldGet(this, _PondSocket_backend, "f"));
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, params, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
             if (!event) {
@@ -67,38 +69,34 @@ class PondSocket {
         });
         return new endpoint_1.Endpoint(endpoint);
     }
-    /**
-     * Handle WebSocket upgrade requests
-     */
-    handleUpgrade(req, socket, head) {
-        const clientId = req.headers['sec-websocket-key'];
-        const request = {
-            id: clientId,
-            headers: req.headers,
-            address: req.url || '',
-        };
-        const params = {
-            head,
-            socket,
-            request: req,
-            requestId: (0, pondsocket_common_1.uuid)(),
-        };
-        __classPrivateFieldGet(this, _PondSocket_middleware, "f").run(request, params, (error) => {
-            if (error) {
-                const code = (error === null || error === void 0 ? void 0 : error.statusCode) || 400;
-                const message = (error === null || error === void 0 ? void 0 : error.message) || 'Unauthorized connection';
-                socket.write(`HTTP/1.1 ${code} ${message}\r\n\r\n`);
-                socket.destroy();
-            }
-            else if (__classPrivateFieldGet(this, _PondSocket_exclusiveServer, "f")) {
-                socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
-                socket.destroy();
-            }
-        });
-    }
 }
 exports.PondSocket = PondSocket;
-_PondSocket_exclusiveServer = new WeakMap(), _PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
+_PondSocket_server = new WeakMap(), _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_backend = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_handleUpgrade = function _PondSocket_handleUpgrade(req, socket, head) {
+    const clientId = req.headers['sec-websocket-key'];
+    const request = {
+        id: clientId,
+        headers: req.headers,
+        address: req.url || '',
+    };
+    const params = {
+        head,
+        socket,
+        request: req,
+        requestId: (0, pondsocket_common_1.uuid)(),
+    };
+    __classPrivateFieldGet(this, _PondSocket_middleware, "f").run(request, params, (error) => {
+        if (error) {
+            const code = (error === null || error === void 0 ? void 0 : error.statusCode) || 400;
+            const message = (error === null || error === void 0 ? void 0 : error.message) || 'Unauthorized connection';
+            socket.write(`HTTP/1.1 ${code} ${message}\r\n\r\n`);
+            socket.destroy();
+        }
+        else if (__classPrivateFieldGet(this, _PondSocket_exclusiveServer, "f")) {
+            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+            socket.destroy();
+        }
+    });
+}, _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
     __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('connection', (socket) => {
         socket.on('pong', () => {
             socket.isAlive = true;
@@ -122,7 +120,7 @@ _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_server = new WeakMap(),
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('close', () => {
         clearInterval(timeout);
     });
-    __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', this.handleUpgrade.bind(this));
+    __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_handleUpgrade).bind(this));
 }, _PondSocket_getCookies = function _PondSocket_getCookies(headers) {
     const cookieHeader = headers.cookie;
     if (!cookieHeader) {

package/types.d.ts

@@ -1,19 +1,20 @@
-import { Server, ServerResponse, IncomingMessage, IncomingHttpHeaders } from 'http';
+import { IncomingHttpHeaders, IncomingMessage, Server as HTTPServer, Server, ServerResponse } from 'http';
 
 import {
+    EventParams,
     IncomingConnection,
+    JoinParams,
+    Params,
     PondAssigns,
     PondEvent,
     PondEventMap,
     PondMessage,
     PondPath,
     PondPresence,
+    Unsubscribe,
+    UserAssigns,
     UserData,
     UserPresences,
-    UserAssigns,
-    JoinParams,
-    EventParams,
-    Params,
 } from '@eleven-am/pondsocket-common';
 import { WebSocket, WebSocketServer } from 'ws';
 
@@ -24,22 +25,126 @@ export interface LeaveEvent<EventTypes extends PondEventMap = PondEventMap, Pres
     channel: Channel<EventTypes, PresenceType, AssignType>;
 }
 
-export interface OutgoingEvent<Event extends string, EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
-    payload: PondMessage;
-    event: EventParams<Event>;
-    channel: Channel<EventTypes, PresenceType, AssignType>;
-}
-
 export type LeaveCallback<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> = (event: LeaveEvent<EventTypes, PresenceType, AssignType>) => void;
 
-export type OutgoingHandler<Event extends string, EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> = (event: OutgoingEvent<Event, EventTypes, PresenceType, AssignType>) => PondMessage | Promise<PondMessage> | void | Promise<void>;
-
 export type RequestHandler<Request> = (request: Request) => void | Promise<void>;
 
+export interface RedisDistributedBackendOptions {
+    host?: string;
+    port?: number;
+    password?: string;
+    database?: number;
+    url?: string;
+    keyPrefix?: string;
+}
+
 export interface PondSocketOptions {
-    server?: Server;
-    exclusiveServer?: boolean;
+    server?: HTTPServer;
     socketServer?: WebSocketServer;
+    exclusiveServer?: boolean;
+    distributedBackend?: IDistributedBackend;
+}
+
+export enum DistributedMessageType {
+    STATE_REQUEST = 'STATE_REQUEST',
+    STATE_RESPONSE = 'STATE_RESPONSE',
+    USER_JOINED = 'USER_JOINED',
+    USER_LEFT = 'USER_LEFT',
+    USER_MESSAGE = 'USER_MESSAGE',
+    PRESENCE_UPDATE = 'PRESENCE_UPDATE',
+    PRESENCE_REMOVED = 'PRESENCE_REMOVED',
+    ASSIGNS_UPDATE = 'ASSIGNS_UPDATE',
+    ASSIGNS_REMOVED = 'ASSIGNS_REMOVED',
+    EVICT_USER = 'EVICT_USER'
+}
+
+export interface DistributedMessage {
+    type: DistributedMessageType;
+    endpointName: string;
+    channelName: string;
+    timestamp?: number;
+}
+
+export interface StateRequest extends DistributedMessage {
+    type: DistributedMessageType.STATE_REQUEST;
+    fromNode: string;
+}
+
+export interface StateResponse extends DistributedMessage {
+    type: DistributedMessageType.STATE_RESPONSE;
+    users: Array<{
+        id: string;
+        presence: PondPresence;
+        assigns: PondAssigns;
+    }>;
+}
+
+export interface UserJoined extends DistributedMessage {
+    type: DistributedMessageType.USER_JOINED;
+    userId: string;
+    presence: PondPresence;
+    assigns: PondAssigns;
+}
+
+export interface UserLeft extends DistributedMessage {
+    type: DistributedMessageType.USER_LEFT;
+    userId: string;
+}
+
+export interface UserMessage extends DistributedMessage {
+    type: DistributedMessageType.USER_MESSAGE;
+    fromUserId: string;
+    event: string;
+    payload: PondMessage;
+    requestId: string;
+    recipients: string[];
+}
+
+export interface PresenceUpdate extends DistributedMessage {
+    type: DistributedMessageType.PRESENCE_UPDATE;
+    userId: string;
+    presence: PondPresence;
+}
+
+export interface PresenceRemoved extends DistributedMessage {
+    type: DistributedMessageType.PRESENCE_REMOVED;
+    userId: string;
+}
+
+export interface AssignsUpdate extends DistributedMessage {
+    type: DistributedMessageType.ASSIGNS_UPDATE;
+    userId: string;
+    assigns: PondAssigns;
+}
+
+export interface AssignsRemoved extends DistributedMessage {
+    type: DistributedMessageType.ASSIGNS_REMOVED;
+    userId: string;
+}
+
+export interface EvictUser extends DistributedMessage {
+    type: DistributedMessageType.EVICT_USER;
+    userId: string;
+    reason: string;
+    fromNode?: string;
+}
+
+export type DistributedChannelMessage =
+   | StateRequest
+   | StateResponse
+   | UserJoined
+   | UserLeft
+   | UserMessage
+   | PresenceUpdate
+   | PresenceRemoved
+   | AssignsUpdate
+   | AssignsRemoved
+   | EvictUser;
+
+export interface IDistributedBackend {
+    broadcast(endpointName: string, channelName: string, message: DistributedChannelMessage): Promise<void>;
+    subscribe(endpointName: string, channelName: string, handler: (message: DistributedChannelMessage) => void): Unsubscribe;
+    cleanup(): Promise<void>;
 }
 
 export declare class PondSocket {
@@ -130,15 +235,15 @@ export declare class PondChannel<EventType extends PondEventMap = PondEventMap,
     /**
      * @desc Handles an outgoing event, this is useful for modifying the event before it is sent to the client
      * @param {PondPath<string>} event - The event to handle
-     * @param {OutgoingHandler} handler - The handler to execute when the event is sent
+     * @param {RequestHandler} handler - The handler to execute when the event is sent
      * @example
-     * pond.onOutgoing('echo', (event) => {
+     * pond.handleOutgoingEvent('echo', (event) => {
      *     return {
      *         message: 'Hello, world!'
      *     };
      * });
      */
-    onOutgoing<Event extends string> (event: PondPath<Event>, handler: OutgoingHandler<Event, EventType, PresenceType, AssignType>): void;
+    handleOutgoingEvent<Event extends string> (event: PondPath<Event>, handler: RequestHandler<OutgoingContext<Event, PresenceType, AssignType>>): void;
 
     /**
      * @desc Gets a channel by name
@@ -360,7 +465,7 @@ export declare class ConnectionContext<Path extends string> {
     reply(event: string, payload: PondMessage): ConnectionContext<Path>;
 }
 
-export declare class JoinContext<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
+export declare class BaseContext<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * @desc Get the event information.
      */
@@ -376,11 +481,6 @@ export declare class JoinContext<Path extends string, EventType extends PondEven
      */
     get channel(): Channel;
 
-    /**
-     * @desc Get the join parameters.
-     */
-    get joinParams(): JoinParams;
-
     /**
      * @desc Get all current presences in the channel.
      */
@@ -392,9 +492,21 @@ export declare class JoinContext<Path extends string, EventType extends PondEven
     get assigns(): UserAssigns;
 
     /**
-     * @desc Get the user data.
+     * @desc Get the user who sent the request.
      */
     get user(): UserData<PresenceType, AssignType>;
+}
+
+export declare class JoinContext<
+    Path extends string,
+    EventType extends PondEventMap = PondEventMap,
+    PresenceType extends PondPresence = PondPresence,
+    AssignType extends PondAssigns = PondAssigns
+> extends BaseContext<Path, PresenceType, AssignType> {
+    /**
+     * @desc Get the join parameters.
+     */
+    get joinParams(): JoinParams;
 
     /**
      * @desc Checks if the server has responded to the join request.
@@ -456,37 +568,12 @@ export declare class JoinContext<Path extends string, EventType extends PondEven
     trackPresence(presence: PresenceType): JoinContext<Path, PresenceType, AssignType>;
 }
 
-export declare class EventContext<Path extends string, EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
-    /**
-     * @desc Get the event information.
-     */
-    get event(): PondEvent<Path>;
-
-    /**
-     * @desc Get the channel name.
-     */
-    get channelName(): string;
-
-    /**
-     * @desc Get the channel instance.
-     */
-    get channel(): Channel;
-
-    /**
-     * @desc Get all current presences in the channel.
-     */
-    get presences(): UserPresences;
-
-    /**
-     * @desc Get all current assigns in the channel.
-     */
-    get assigns(): UserAssigns;
-
-    /**
-     * @desc Get the user who sent the request.
-     */
-    get user(): UserData<PresenceType, AssignType>;
-
+export declare class EventContext<
+    Path extends string,
+    EventType extends PondEventMap = PondEventMap,
+    PresenceType extends PondPresence = PondPresence,
+    AssignType extends PondAssigns = PondAssigns
+> extends BaseContext<Path, PresenceType, AssignType> {
     /**
      * @desc Assigns data to the client.
      * @param {PondAssigns} assigns - The data to assign to the client.
@@ -558,3 +645,50 @@ export declare class EventContext<Path extends string, EventType extends PondEve
      */
     evictUser(reason: string, userId?: string): EventContext<Path, EventType, PresenceType, AssignType>;
 }
+
+export class OutgoingContext<
+    Path extends string,
+    PresenceType extends PondPresence = PondPresence,
+    AssignType extends PondAssigns = PondAssigns
+> extends BaseContext<Path, PresenceType, AssignType> {
+    /**
+     * @desc Get the join parameters.
+     */
+    get payload(): PondMessage;
+
+    /**
+     * @desc Blocks the outgoing context, preventing further processing of the event.
+     */
+    block(): OutgoingContext<Path, PresenceType, AssignType>;
+
+    /**
+     * desc Transforms the outgoing context with a new payload.
+     * @param payload - The new payload to set for the context.
+     */
+    transform(payload: PondMessage): OutgoingContext<Path, PresenceType, AssignType>;
+}
+
+export declare class RedisDistributedBackend implements IDistributedBackend {
+    constructor(options?: RedisDistributedBackendOptions);
+
+    /**
+     * @desc Gets the subject for subscribing to distributed messages
+     * @param endpointName - The name of the endpoint to subscribe to
+     * @param channelName - The name of the channel to subscribe to
+     * @param message - The message to send
+     */
+    broadcast (endpointName: string, channelName: string, message: DistributedChannelMessage): Promise<void>;
+
+    /**
+     * @desc Cleans up the distributed backend, closing any connections and cleaning up resources
+     */
+    cleanup (): Promise<void>;
+
+    /**
+     * @desc Subscribe to messages for a specific endpoint and channel
+     * @param endpointName - The name of the endpoint to subscribe to
+     * @param channelName - The name of the channel to subscribe to
+     * @param handler - The handler function to call when a message is received
+     */
+    subscribe (endpointName: string, channelName: string, handler: (message: DistributedChannelMessage) => void): Unsubscribe;
+}

package/wrappers/pondChannel.js

@@ -28,7 +28,7 @@ class PondChannel {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").onLeave(callback);
         return this;
     }
-    onOutgoing(event, handler) {
+    handleOutgoingEvent(event, handler) {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").handleOutgoingEvent(event, handler);
         return this;
     }