redweb 0.7.3 → 0.7.5

package/src/ws/SocketRegistry.js

@@ -1,37 +1,37 @@
-// handlers/SocketRegistry.js
-const { EventEmitter } = require("events");
-
-class SocketRegistry extends EventEmitter {
-    constructor() {
-        super();
-        this.items = [];
-    }
-
-    add(item) {
-        this.items.push(item);
-        this.emit("added", item);
-    }
-
-    remove(itemOrId, by = "id") {
-        const idx = typeof itemOrId === "object"
-            ? this.items.findIndex(i => i === itemOrId)
-            : this.items.findIndex(i => i[by] === itemOrId);
-
-        if (idx !== -1) {
-            const [removed] = this.items.splice(idx, 1);
-            this.emit("removed", removed);
-            return true;
-        }
-        return false;
-    }
-
-    all() {
-        return [...this.items];
-    }
-
-    count() {
-        return this.all().length;
-    }
-}
-
-module.exports = SocketRegistry;
+// handlers/SocketRegistry.js
+const { EventEmitter } = require("events");
+
+class SocketRegistry extends EventEmitter {
+    constructor() {
+        super();
+        this.items = [];
+    }
+
+    add(item) {
+        this.items.push(item);
+        this.emit("added", item);
+    }
+
+    remove(itemOrId, by = "id") {
+        const idx = typeof itemOrId === "object"
+            ? this.items.findIndex(i => i === itemOrId)
+            : this.items.findIndex(i => i[by] === itemOrId);
+
+        if (idx !== -1) {
+            const [removed] = this.items.splice(idx, 1);
+            this.emit("removed", removed);
+            return true;
+        }
+        return false;
+    }
+
+    all() {
+        return [...this.items];
+    }
+
+    count() {
+        return this.all().length;
+    }
+}
+
+module.exports = SocketRegistry;

package/src/ws/SocketRoute.js

@@ -1,93 +1,105 @@
-const { WebSocketServer } = require("ws");
-const { sendJson, broadcast } = require("./util");
-const { randomUUID } = require("crypto");
-
-/**
- * Represents a WebSocket route configuration.
- * This class is used to define a specific WebSocket endpoint (`path`) and its associated handlers.
- */
-class SocketRoute {
-    /**
-     * Creates a new instance of `SocketRoute`.
-     * @param {Object} options - Configuration options for the WebSocket route.
-     * @param {string} options.path - The path of the WebSocket route (e.g., `/chat`, `/lobby`).
+const { WebSocketServer } = require("ws");
+const { sendJson, broadcast } = require("./util");
+const { randomUUID } = require("crypto");
+
+/**
+ * Represents a WebSocket route configuration.
+ * This class is used to define a specific WebSocket endpoint (`path`) and its associated handlers.
+ */
+class SocketRoute {
+    /**
+     * Creates a new instance of `SocketRoute`.
+     * @param {Object} options - Configuration options for the WebSocket route.
+     * @param {string} options.path - The path of the WebSocket route (e.g., `/chat`, `/lobby`).
      * @param {boolean} options.allowDuplicateConnections - Whether to allow multiple connections from the same client IP address.
      * @param {import('./BaseHandler').BaseHandler[]} options.handlers - An array of handler instances that manage connections and messages for this route.
      * @param {Array<new () => SocketService>} [options.services] 
+     * @param {import('ws').ServerOptions} [options.websocketOptions] - Options passed to the underlying WebSocketServer.
     */
-    constructor({ path, handlers, services = [], allowDuplicateConnections } = {}) {
-        if (!path) {
-            throw new Error('A `path` must be specified for the SocketRoute.');
-        }
-        if (!handlers || !Array.isArray(handlers) || handlers.length === 0) {
-            throw new Error('At least one handler must be specified for the SocketRoute.');
-        }
-        /**
-         * The path of the WebSocket route.
-         * This determines the endpoint that clients must connect to (e.g., `ws://localhost:3000/chat`).
-         * @type {string}
-         */
+    constructor({ path, handlers, services = [], allowDuplicateConnections, websocketOptions = {} } = {}) {
+        if (!path) {
+            throw new Error('A `path` must be specified for the SocketRoute.');
+        }
+        if (!handlers || !Array.isArray(handlers) || handlers.length === 0) {
+            throw new Error('At least one handler must be specified for the SocketRoute.');
+        }
+        /**
+         * The path of the WebSocket route.
+         * This determines the endpoint that clients must connect to (e.g., `ws://localhost:3000/chat`).
+         * @type {string}
+         */
         this.path = path;
-        /**
-         * The array of handler instances associated with this route.
-         * Each handler is responsible for managing WebSocket connections and message handling logic.
-         * @type {import('./BaseHandler').BaseHandler[]}
-         */
+        this.websocketOptions = websocketOptions;
+        /**
+         * The array of handler instances associated with this route.
+         * Each handler is responsible for managing WebSocket connections and message handling logic.
+         * @type {import('./BaseHandler').BaseHandler[]}
+         */
         this.handlers = handlers.map(HandlerClass => new HandlerClass());
         this.clients = new Map();
-        this.server = new WebSocketServer({ noServer: true, path });
+        this.server = new WebSocketServer({ noServer: true, path, ...websocketOptions });
         this.server.on('connection', this.handleConnection.bind(this));
         this.allowDuplicateConnections = allowDuplicateConnections;
-
-        /* ─── ROUTE‑SCOPED SERVICES ─────────────────────────── */
-        this.services = services.map(SvcClass => {
-            const svc = new SvcClass();
-            if (typeof svc.onInit === 'function') svc.onInit(this);
-            return svc;
-        });
-    }
-    /**
-     * Adds a new handler to the WebSocket server.
-     * @param {new () => BaseHandler} HandlerClass - The handler class to add.
-     */
-    addHandler(HandlerClass) {
-        const newHandler = new HandlerClass();
-        if (this.handlers.find(handler => handler.name === newHandler.name)) {
-            console.warn(`Handler with name '${newHandler.name}' already exists.`);
-            return;
-        }
-        this.handlers.push(newHandler);
-        console.log(`Handler '${newHandler.name}' added successfully.`);
-    }
-    /**
-     * Handles a new WebSocket connection.
-     * @param {WebSocket} socket - The WebSocket connection instance.
-     * @param {import('http').IncomingMessage} req - The HTTP request object associated with the connection.
-     */
+
+        /* ─── ROUTE‑SCOPED SERVICES ─────────────────────────── */
+        this.services = services.map(SvcClass => {
+            const svc = new SvcClass();
+            if (typeof svc.onInit === 'function') svc.onInit(this);
+            return svc;
+        });
+    }
+    /**
+     * Adds a new handler to the WebSocket server.
+     * @param {new () => BaseHandler} HandlerClass - The handler class to add.
+     */
+    addHandler(HandlerClass) {
+        const newHandler = new HandlerClass();
+        if (this.handlers.find(handler => handler.name === newHandler.name)) {
+            console.warn(`Handler with name '${newHandler.name}' already exists.`);
+            return;
+        }
+        this.handlers.push(newHandler);
+        console.log(`Handler '${newHandler.name}' added successfully.`);
+    }
+    /**
+     * Handles a new WebSocket connection.
+     * @param {WebSocket} socket - The WebSocket connection instance.
+     * @param {import('http').IncomingMessage} req - The HTTP request object associated with the connection.
+     */
     handleConnection(socket, req) {
-        const ip = req.socket.remoteAddress;
+        const ip = req?.socket?.remoteAddress || 'unknown';
+        const clientKey = this.allowDuplicateConnections ? randomUUID() : ip;
+
         console.log(`New client connected: ${ip}`);
-        if (this.allowDuplicateConnections) {
-            this.clients.set(randomUUID(), socket);
-        } else {
-            if (this.clients.get(ip) !== undefined) {
-                const oldClient = this.clients.get(ip);
+
+        if (!this.allowDuplicateConnections) {
+            const existing = this.clients.get(clientKey);
+            if (existing) {
                 console.warn(`Client ${ip} already connected, disconnecting existing connection.`);
-                oldClient.send(
+                existing.send(
                     JSON.stringify({ msg: 'You are being disconnected because a new client is connected with your IP address.' })
                 );
-                oldClient.close();
+                existing.close();
             }
-            this.clients.set(ip, socket);
         }
+
+        this.clients.set(clientKey, socket);
+        socket.clientKey = clientKey;
+        socket.__redwebClientKey = clientKey;
+        socket.remoteAddress = socket.remoteAddress || ip;
         socket.isAssigned = false; // Tracks whether the socket has been assigned a handler.
         socket.sendJson = (data) => sendJson(socket, data);
         socket.broadcast = (data) => broadcast([...this.clients.values()].filter(sock => sock !== socket), data);
 
         this.connectionOpenCallback(socket);
-        socket.on('close', this.handleClose.bind(this));
-        socket.on('error', this.handleError.bind(this));
-        socket.on('message', (message) => {
+        socket.on('close', () => this.handleClose(socket));
+        socket.on('error', (error) => this.handleError(socket, error));
+        socket.on('message', (message, isBinary) => {
+            if (isBinary) {
+                this.handleBinaryMessage(socket, message);
+                return;
+            }
+
             try {
                 const parsed = JSON.parse(message);
                 this.handleMessage(socket, parsed);
@@ -99,52 +111,77 @@ class SocketRoute {
             }
         });
     }
-
-    connectionOpenCallback(socket) {
-        console.log(`Opening new connection: ${socket.remoteAddress}`);
+
+    connectionOpenCallback(socket) {
+        console.log(`Opening new connection: ${socket.remoteAddress}`);
+    }
+
+    handleMessage(sock, data) {
+        const handler = this.handlers.find((handler) => handler.name == data.type);
+        if (!handler) {
+            sendJson(sock, { error: `No such handler ${data.type}` });
+            sock.close();
+        } else {
+            try {
+                handler.handleMessage(sock, data);
+            } catch (error) {
+                console.error(`Error handling message in handler ${handler.name}:`, error);
+                sendJson(sock, { error: `${error.message}` });
+                sock.close();
+            }
+        }
     }
 
-    handleMessage(sock, data) {
-        const handler = this.handlers.find((handler) => handler.name == data.type);
-        if (!handler) {
-            sendJson(sock, { error: `No such handler ${data.type}` });
-            sock.close();
-        } else {
+    handleBinaryMessage(socket, buffer) {
+        const hasBinaryPredicate = this.handlers.some(handler => typeof handler.acceptsBinary === 'function');
+        const handler = hasBinaryPredicate
+            ? this.handlers.find(handler => handler.acceptsBinary?.(socket, buffer))
+            : this.handlers.find(handler => typeof handler.handleBinaryMessage === 'function');
+
+        if (handler) {
             try {
-                handler.handleMessage(sock, data);
+                handler.handleBinaryMessage(socket, buffer);
             } catch (error) {
-                console.error(`Error handling message in handler ${handler.name}:`, error);
-                sendJson(sock, { error: `${error.message}` });
-                sock.close();
+                console.error(`Error handling binary message in handler ${handler.name}:`, error);
+                sendJson(socket, { error: `${error.message}` });
+                socket.close();
             }
+            return;
         }
-    }
 
-    /**
-     * Handles socket disconnection.
-     * @param {WebSocket} socket - The WebSocket connection instance.
-     * @param {string} ip - The client's IP address.
-     */
-    handleClose(socket, ip) {
+        sendJson(socket, {
+            error: 'Binary messages are not supported on this route'
+        });
+    }
+
+    /**
+     * Handles socket disconnection.
+     * @param {WebSocket} socket - The WebSocket connection instance.
+     * @param {string} ip - The client's IP address.
+     */
+    handleClose(socket) {
+        const key = socket.clientKey || socket.__redwebClientKey;
+        const ip = socket.remoteAddress || 'unknown';
         console.log(`Client disconnected: ${ip}`);
-        this.clients.delete(ip);
+        if (key && this.clients.get(key) === socket) this.clients.delete(key);
         if (this.connectionCloseCallback) this.connectionCloseCallback(socket);
     }
-
-    shutdown() {
-        this.services.forEach(svc => svc.onShutdown && svc.onShutdown());
-        this.server.close();
-    }
-
-    /**
-     * Handles socket errors.
-     * @param {WebSocket} socket - The WebSocket connection instance.
-     * @param {Error} error - The error object.
-     * @param {string} ip - The client's IP address.
-     */
-    handleError(socket, error, ip) {
+
+    shutdown() {
+        this.services.forEach(svc => svc.onShutdown && svc.onShutdown());
+        this.server.close();
+    }
+
+    /**
+     * Handles socket errors.
+     * @param {WebSocket} socket - The WebSocket connection instance.
+     * @param {Error} error - The error object.
+     * @param {string} ip - The client's IP address.
+     */
+    handleError(socket, error) {
+        const ip = socket.remoteAddress || 'unknown';
         console.error(`Socket error from ${ip}:`, error);
     }
 }
-
-module.exports = SocketRoute;
+
+module.exports = SocketRoute;

package/src/ws/SocketServer.js

@@ -1,18 +1,18 @@
-const http = require('http');
-const { BaseSocketServer } = require('./BaseSocketServer');
-
-/**
- * WebSocket Server
- * @param {SocketServerOptions} options - Configuration options for SocketServer.
- * @return {Object} WebSocket server instance.
- */
-class SocketServer extends BaseSocketServer {
-    constructor(options = {}) {
-        const server = options?.server || http.createServer();
-        super(server, options);
-        server.listen(this.port, () => console.log(`RedWeb SocketServer listening on port ${this.port}`));
-        return this;
-    }
-}
-
-module.exports = SocketServer;
+const http = require('http');
+const { BaseSocketServer } = require('./BaseSocketServer');
+
+/**
+ * WebSocket Server
+ * @param {SocketServerOptions} options - Configuration options for SocketServer.
+ * @return {Object} WebSocket server instance.
+ */
+class SocketServer extends BaseSocketServer {
+    constructor(options = {}) {
+        const server = options?.server || http.createServer();
+        super(server, options);
+        server.listen(this.port, () => console.log(`RedWeb SocketServer listening on port ${this.port}`));
+        return this;
+    }
+}
+
+module.exports = SocketServer;

package/src/ws/SocketService.js

@@ -1,33 +1,33 @@
-// handlers/SocketService.js
-class SocketService {
-    /**
-     * @param {string} name            – service identifier
-     * @param {?number} tickRateMs     – optional tick interval (ms)
-     */
-    constructor(name, tickRateMs = null) {
-      this.name        = name;
-      this.tickRateMs  = tickRateMs;
-      this._tickHandle = null;
-    }
-  
-    /**
-     * Called once by the owning SocketRoute.
-     * @param {import('../SocketRoute')} route – the route this service belongs to
-     */
-    onInit(route) {
-      this.route = route;                        // full access to route, clients, broadcast…
-      if (this.tickRateMs && this.onTick) {
-        this._tickHandle = setInterval(() => this.onTick(), this.tickRateMs);
-      }
-    }
-  
-    /* Optional */
-    // onTick() {}
-  
-    onShutdown() {
-      if (this._tickHandle) clearInterval(this._tickHandle);
-    }
-  }
-  
-  module.exports = SocketService;
+// handlers/SocketService.js
+class SocketService {
+    /**
+     * @param {string} name            – service identifier
+     * @param {?number} tickRateMs     – optional tick interval (ms)
+     */
+    constructor(name, tickRateMs = null) {
+      this.name        = name;
+      this.tickRateMs  = tickRateMs;
+      this._tickHandle = null;
+    }
+  
+    /**
+     * Called once by the owning SocketRoute.
+     * @param {import('../SocketRoute')} route – the route this service belongs to
+     */
+    onInit(route) {
+      this.route = route;                        // full access to route, clients, broadcast…
+      if (this.tickRateMs && this.onTick) {
+        this._tickHandle = setInterval(() => this.onTick(), this.tickRateMs);
+      }
+    }
+  
+    /* Optional */
+    // onTick() {}
+  
+    onShutdown() {
+      if (this._tickHandle) clearInterval(this._tickHandle);
+    }
+  }
+  
+  module.exports = SocketService;
   

package/src/ws/index.js

@@ -1,9 +1,9 @@
-const { SOCKET_OPTIONS } = require('./BaseSocketServer');
-module.exports = { 
-    SecureSocketServer: require('./SecureSocketServer'),
-    SocketServer: require('./SocketServer'),
-    SocketRoute: require('./SocketRoute'),
-    SocketService: require('./SocketService'),
-    SocketRegistry: require('./SocketRegistry'),
-    SOCKET_OPTIONS
+const { SOCKET_OPTIONS } = require('./BaseSocketServer');
+module.exports = { 
+    SecureSocketServer: require('./SecureSocketServer'),
+    SocketServer: require('./SocketServer'),
+    SocketRoute: require('./SocketRoute'),
+    SocketService: require('./SocketService'),
+    SocketRegistry: require('./SocketRegistry'),
+    SOCKET_OPTIONS
 }

package/src/ws/util.js

@@ -1,9 +1,9 @@
-function sendJson(socket, data) {
-    socket.send(JSON.stringify(data));
-}
-
-function broadcast(sockets, data) {
-    sockets.forEach(socket => sendJson(socket, data));
-}
-
-module.exports = { sendJson, broadcast }
+function sendJson(socket, data) {
+    socket.send(JSON.stringify(data));
+}
+
+function broadcast(sockets, data) {
+    sockets.forEach(socket => sendJson(socket, data));
+}
+
+module.exports = { sendJson, broadcast }