redweb 0.5.1 → 0.5.3

package/index.d.ts

@@ -34,6 +34,16 @@ declare module 'redweb' {
         };
     }
 
+    /**
+     * Handler configuration for WebSocket.
+     */
+    export interface HandlerConfig {
+        name: string;
+        handlers: {
+            [type: string]: (socket: WebSocket, data: any) => void;
+        };
+    }
+
     /**
      * Options for configuring a WebSocket server.
      */
@@ -49,78 +59,88 @@ declare module 'redweb' {
             key: string;
             cert: string;
         };
+        handlerConfig?: Array<new () => BaseHandler>;
     }
 
     /**
-     * Base class for HTTP servers.
+     * Base class for WebSocket handlers.
      */
-    export class BaseHttpServer {
-        app: any;
-        port: number;
-        publicPaths: string[];
-        services: Service[];
-        listenCallback?: () => void;
-        encoding: RedWebEncoding;
-        ssl?: { key: string; cert: string; };
-
-        constructor(options?: RedWebOptions);
+    export class BaseHandler {
+        /**
+         * The name of the handler (used to identify it in the server).
+         */
+        name: string;
+
+        /**
+         * Dictionary of message handlers for this handler.
+         */
+        messageHandlers: {
+            [type: string]: (socket: WebSocket, data: any) => void;
+        };
 
-        // Additional methods can be added as needed.
+        /**
+         * List of active WebSocket connections managed by this handler.
+         */
+        connections: WebSocket[];
+
+        /**
+         * Creates a new handler instance.
+         * @param config - Configuration for the handler.
+         */
+        constructor(config: HandlerConfig);
+
+        /**
+         * Adds a new WebSocket connection and sets up message handling for this handler.
+         * @param socket - The WebSocket connection to add.
+         */
+        newConnection(socket: WebSocket): void;
+
+        /**
+         * Handles an incoming message and routes it to the appropriate handler function.
+         * @param socket - The WebSocket connection that sent the message.
+         * @param message - The incoming message in JSON string format.
+         */
+        handleMessage(socket: WebSocket, message: string): void;
+
+        /**
+         * Broadcasts a message to all connections managed by this handler.
+         * @param message - The message to broadcast.
+         */
+        broadcast(message: object): void;
     }
 
     /**
      * HTTP server class.
      */
-    export class HttpServer extends BaseHttpServer {
+    export class HttpServer {
         constructor(options?: RedWebOptions);
     }
 
     /**
      * HTTPS server class.
      */
-    export class HttpsServer extends BaseHttpServer {
+    export class HttpsServer {
         constructor(options?: RedWebOptions);
     }
 
-    /**
-     * Base class for WebSocket servers.
-     */
-    export class BaseSocketServer {
-        wss: WebSocket.Server;
-        clients: Map<string, WebSocket>;
-        port: number;
-        connectionOpenCallback?: (socket: WebSocket) => void;
-        connectionCloseCallback?: (socket: WebSocket) => void;
-        messageCallback?: (socket: WebSocket, message: string) => void;
-        messageHandlers?: { [type: string]: (socket: WebSocket, data: any) => void; };
-        ssl?: { key: string; cert: string; };
-
-        constructor(server: HTTPServer | HTTPSServer, options?: SocketServerOptions);
-
-        handleConnection(socket: WebSocket, req: Request): void;
-        handleMessage(socket: WebSocket, message: string, ip: string): void;
-        handleClose(socket: WebSocket, ip: string): void;
-        handleError(socket: WebSocket, error: Error, ip: string): void;
-    }
-
     /**
      * WebSocket server class.
      */
-    export class SocketServer extends BaseSocketServer {
+    export class SocketServer {
         constructor(options?: SocketServerOptions);
     }
 
     /**
      * Secure WebSocket server class.
      */
-    export class SecureSocketServer extends BaseSocketServer {
+    export class SecureSocketServer {
         constructor(options?: SocketServerOptions);
     }
 
     /**
      * SSL configuration loader.
      */
-    export function loadSslConfig(sslOptions: { key: string; cert: string; }): { key: string; cert: string; };
+    export function loadSslConfig(sslOptions: { key: string; cert: string }): { key: string; cert: string };
 
     /**
      * Constants for encoding types.

package/index.js

@@ -1,8 +1,10 @@
 const { HttpServer, HttpsServer, METHODS } = require('./src/http');
 const { SocketServer, SecureSocketServer, SOCKET_OPTIONS } = require('./src/ws');
+const { BaseHandler } = require('./src/ws/BaseHandler');
 module.exports = {
     SocketServer,
     SecureSocketServer,
+    BaseHandler,
     HttpServer,
     HttpsServer,
     SOCKET_OPTIONS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redweb",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "A way to quickly set up an express server",
   "main": "index.js",
   "scripts": {

package/src/http/BaseHttpServer.js

@@ -53,9 +53,11 @@ function BaseHttpServer(options = {}) {
         this.app.use(bodyParser.urlencoded({ extended: true }));
     }
     this.app.use(cors(this.options.corsOptions));
-
-    this.services.forEach(service => this.app[service.method](service.serviceName, service.function));
     this.publicPaths.forEach(public_path => this.app.use(express.static(path.join(process.cwd(), public_path))));
+    const catchAll = this.services.find((service) => service.serviceName === '*');
+    if (catchAll) this.services.splice(this.services.indexOf(catchAll), 1);
+    this.services.forEach(service => this.app[service.method](service.serviceName, service.function));
+    if (catchAll) this.app[catchAll.method](catchAll.serviceName, catchAll.function);
     return this;
 }
 

package/src/ws/BaseHandler.js

@@ -0,0 +1,83 @@
+/**
+ * Represents the base class for a WebSocket message handler.
+ */
+class BaseHandler {
+    /**
+     * Creates a new handler instance.
+     * @param {{ name: string, handlers: Record<string, (socket: WebSocket, data: object) => void> }} config
+     * - `name`: The unique name of the handler.
+     * - `handlers`: A dictionary of message types and their corresponding handler functions.
+     */
+    constructor(config) {
+        /**
+         * The name of the handler (used to identify this handler in the server).
+         * @type {string}
+         */
+        this.name = config.name;
+
+        /**
+         * The dictionary of message handlers for this handler.
+         * @type {Record<string, (socket: WebSocket, data: object) => void>}
+         */
+        this.messageHandlers = config.handlers || {};
+
+        /**
+         * The list of active WebSocket connections managed by this handler.
+         * @type {WebSocket[]}
+         */
+        this.connections = [];
+    }
+
+    /**
+     * Adds a new WebSocket connection and sets up message handling for this handler.
+     * @param {WebSocket} socket - The WebSocket connection to add.
+     */
+    newConnection(socket) {
+        this.connections.push(socket);
+
+        socket.on('message', (message) => this.handleMessage(socket, message));
+
+        socket.on('close', () => {
+            this.connections = this.connections.filter((conn) => conn !== socket);
+            console.log(`Connection closed for handler "${this.name}".`);
+        });
+
+        socket.isAssigned = true;
+        console.log(`New connection added to handler "${this.name}".`);
+    }
+
+    /**
+     * Handles an incoming message and routes it to the appropriate handler function.
+     * @param {WebSocket} socket - The WebSocket connection that sent the message.
+     * @param {string} message - The incoming message in JSON string format.
+     */
+    handleMessage(socket, message) {
+        try {
+            const parsedMessage = JSON.parse(message);
+            const { type, ...data } = parsedMessage;
+
+            if (this.messageHandlers[type]) {
+                this.messageHandlers[type](socket, data);
+            } else {
+                console.warn(`Unhandled message type: "${type}" in handler "${this.name}".`);
+                socket.close();
+            }
+        } catch (error) {
+            console.error(`Error processing message in handler "${this.name}":`, error);
+        }
+    }
+
+    /**
+     * Broadcasts a message to all connections managed by this handler.
+     * @param {object} message - The message to broadcast.
+     */
+    broadcast(message) {
+        this.connections.forEach((socket) => {
+            if (socket.readyState === WebSocket.OPEN) {
+                socket.send(JSON.stringify(message));
+            }
+        });
+    }
+}
+
+module.exports = { BaseHandler };

package/src/ws/BaseSocketServer.js

@@ -2,15 +2,14 @@ const WebSocket = require('ws');
 
 /**
  * @typedef {Object} SocketServerOptions
- * @property {import('express').Application} [server] - The existing server instance.
- * @property {number} [port=3000] - The port number to bind the socket server.
- * @property {Function} [connectionOpenCallback] - Callback function to execute once a client connects.
- * @property {Function} [connectionCloseCallback] - Callback function to execute once a client disconnects.
- * @property {Function} [messageCallback] - Callback function to execute for every message received.
- * @property {Object} [messageHandlers] - Object containing message handlers based on message type.
- * @property {Object} [ssl] - SSL configuration for SecureSocketServer.
- * @property {string} [ssl.key] - Path to the SSL key file.
- * @property {string} [ssl.cert] - Path to the SSL certificate file.
+ * @property {import('http').Server} [server] - The HTTP server instance to bind the WebSocket server to.
+ * @property {number} [port=3000] - The port number for the WebSocket server.
+ * @property {(socket: WebSocket) => void} [connectionOpenCallback] - Callback executed when a client connects.
+ * @property {(socket: WebSocket) => void} [connectionCloseCallback] - Callback executed when a client disconnects.
+ * @property {(socket: WebSocket, message: object) => void} [messageCallback] - Callback executed when a message is received.
+ * @property {Record<string, (socket: WebSocket, data: object) => void>} [messageHandlers] - A dictionary of message types and their corresponding handler functions.
+ * @property {{ key: string, cert: string } | null} [ssl] - SSL configuration for a secure WebSocket server.
+ * @property {Array<new () => BaseHandler>} [handlerConfig] - An array of handler classes to use for routing.
  */
 
 const SOCKET_OPTIONS = {
@@ -25,72 +24,158 @@ const SOCKET_OPTIONS = {
 };
 
 /**
- * 
- * @param {BaseSocketServer} socketServer 
- * @param {Object} message 
+ * Broadcasts a message to all connected clients.
+ * @param {BaseSocketServer} socketServer - The WebSocket server instance.
+ * @param {object} message - The message to broadcast.
  */
 function broadcast(socketServer, message) {
     socketServer.clients.forEach(client => client.send(JSON.stringify(message)));
 }
 
+/**
+ * Represents the base WebSocket server.
+ */
 class BaseSocketServer {
     /**
-     * Base Socket Server
-     * @param {import('express').Application} server - The express application instance.
-     * @param {SocketServerOptions} options - Configuration options for SocketServer.
+     * @param {import('http').Server} server - The HTTP server instance to bind the WebSocket server to.
+     * @param {SocketServerOptions} options - The configuration options for the WebSocket server.
      */
     constructor(server, options = {}) {
         this.wss = new WebSocket.Server({ server });
-        this.clients = new Map();  // Use a Map to store clients by their IP addresses
+        this.clients = new Map(); // Map of clients by their IP addresses.
         Object.assign(this, { ...SOCKET_OPTIONS, ...options });
 
+        this.handlers = this.initHandlers(options.handlerConfig || []);
         this.wss.on('connection', this.handleConnection.bind(this));
     }
 
+    /**
+     * Initializes the handler classes.
+     * @param {Array<new () => BaseHandler>} handlerConfig - Array of handler classes.
+     * @returns {BaseHandler[]} - Array of handler instances.
+     */
+    initHandlers(handlerConfig) {
+        return handlerConfig.map(HandlerClass => new HandlerClass());
+    }
+
+    /**
+     * 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;
         console.log(`New client connected: ${ip}`);
         this.clients.set(ip, socket);
+        socket.isAssigned = false; // Tracks whether the socket has been assigned a handler.
 
         if (this.connectionOpenCallback) this.connectionOpenCallback(socket);
 
-        socket.on('message', (message) => this.handleMessage(socket, message, ip));
+        socket.on('message', (message) => this.initialMessageHandler(socket, message, ip));
         socket.on('close', () => this.handleClose(socket, ip));
         socket.on('error', (error) => this.handleError(socket, error, ip));
     }
 
-    handleMessage(socket, message, ip) {
+    /**
+     * Processes the initial message to determine if a handler assignment is required.
+     * @param {WebSocket} socket - The WebSocket connection instance.
+     * @param {string} message - The received message.
+     * @param {string} ip - The client's IP address.
+     */
+    initialMessageHandler(socket, message, ip) {
         try {
-            console.info(`Received message from ${ip}: ${message}`);
-            if (this.messageCallback) this.messageCallback(socket, message);
+            const parsedMessage = JSON.parse(message);
+
+            // If the first message is '__handlerConnect', attempt to assign a handler
+            if (parsedMessage.type === '__handlerConnect') {
+                this.assignToHandler(socket, parsedMessage);
+                return;
+            }
 
-            const { type, ...data } = JSON.parse(message);
-            if (this.messageHandlers[type]) {
-                this.messageHandlers[type](socket, data);
+            // If no handler is assigned, use the default messageHandlers or fallback
+            if (!socket.isAssigned) {
+                this.handleMessage(socket, parsedMessage, ip);
+            } else {
+                throw new Error('Unexpected message after handler assignment');
             }
         } catch (error) {
-            console.error(`Error handling message from ${ip}:`, error);
+            console.error(`Error handling initial message from ${ip}:`, error);
+            socket.close(); // Optionally close the socket for invalid behavior.
         }
     }
 
+    /**
+     * Assigns the socket to a specific handler.
+     * @param {WebSocket} socket - The WebSocket connection instance.
+     * @param {{ handlerName: string, key?: string }} data - Data containing the handler name and optional authentication key.
+     */
+    assignToHandler(socket, connectMessage) {
+        if (!connectMessage.data) {
+            console.warn(`No data provided for handlerConnect message.`);
+            socket.close();
+            return;
+        }
+        const { handlerName, data } = connectMessage.data;
+        const handler = this.handlers.find(h => h.name === handlerName);
+        if (!handler) {
+            console.warn(`Handler not found: ${handlerName}`);
+            socket.send(JSON.stringify({ error: `Handler '${handlerName}' not found` }));
+            socket.close();
+            return;
+        }
+
+        // Optional: Perform authentication with `key`
+        socket.removeAllListeners('message');
+        handler.newConnection(socket, data);
+    }
+
+    /**
+     * Handles a message using the default messageHandlers.
+     * @param {WebSocket} socket - The WebSocket connection instance.
+     * @param {{ type: string, [key: string]: any }} parsedMessage - The parsed message object.
+     * @param {string} ip - The client's IP address.
+     */
+    handleMessage(socket, parsedMessage, ip) {
+        const { type, ...data } = parsedMessage;
+
+        if (this.messageCallback) this.messageCallback(socket, parsedMessage);
+
+        if (this.messageHandlers[type]) {
+            this.messageHandlers[type](socket, data);
+        } else {
+            console.warn(`Unhandled message type from ${ip}: ${type}`);
+            socket.close();
+        }
+    }
+
+    /**
+     * Handles socket disconnection.
+     * @param {WebSocket} socket - The WebSocket connection instance.
+     * @param {string} ip - The client's IP address.
+     */
     handleClose(socket, ip) {
         console.log(`Client disconnected: ${ip}`);
         this.clients.delete(ip);
         if (this.connectionCloseCallback) this.connectionCloseCallback(socket);
     }
 
+    /**
+     * 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) {
         console.error(`Socket error from ${ip}:`, error);
     }
-    
-/**
- * 
- * This sends the same message to all clients.
- * @param {Object} message 
- */
+
+    /**
+     * Broadcasts a message to all connected clients.
+     * @param {object} message - The message to broadcast.
+     */
     broadcast(message) {
         broadcast(this, message);
     }
 }
 
-module.exports = {BaseSocketServer, SOCKET_OPTIONS};
+module.exports = { BaseSocketServer, SOCKET_OPTIONS };