redweb 0.6.8 → 0.7.0

package/README.md

@@ -1,219 +1,192 @@
+Here is the **fully updated and cleaned-up `README.md`** for RedWeb, now featuring a **working broadcast chat example** using `allowDuplicateConnections`:
+
+---
+
 # RedWeb
 
-RedWeb is a simple and flexible Node.js framework built on top of Express.js and WebSocket. It allows you to quickly set up web servers and WebSocket servers with customizable options.
+**RedWeb** is a flexible Node.js framework built on top of **Express.js** and **WebSocket**. It enables quick setup of HTTP(S) and WebSocket servers with a modular route and handler system.
 
-## Installation
+---
 
-To install RedWeb, use npm:
+## 📦 Installation
 
 ```bash
 npm install redweb
 ```
 
-## Usage
-
-### Basic Example
+---
 
-Initialize your RedWeb instance with the default options:
+## 🚀 Quick Start
 
-```javascript
+```js
 const { HttpServer, SocketServer } = require('redweb');
 
-// HTTP server with default configuration
 const httpServer = new HttpServer();
-
-// WebSocket server with default configuration
 const socketServer = new SocketServer();
 ```
 
-### Custom Configuration
+---
 
-#### HTTP Server
+## 🌐 HTTP Server Example (HTMX Support)
 
-```javascript
+```js
 const { HttpServer, METHODS } = require('redweb');
 
-const services = [
+new HttpServer({
+  port: 3000,
+  publicPaths: ['./public'],
+  enableHtmxRendering: true,
+  services: [
     {
-        serviceName: '/submit-form',
-        method: METHODS.POST,
-        function: (req, res) => {
-            const { name, email, message } = req.body;
-            if (!name || !email || !message) {
-                return res.status(400).json({ error: 'All fields are required' });
-            }
-            res.status(200).json({ success: 'Form submitted successfully' });
-        }
+      serviceName: '/submit',
+      method: METHODS.POST,
+      function: (req, res) => {
+        if (!req.body.name) return res.status(400).json({ error: 'Missing name' });
+        res.status(200).json({ message: `Thanks, ${req.body.name}!` });
+      }
     }
-];
-
-const options = {
-    port: 3000,
-    publicPaths: ['./public'],
-    encoding: 'urlencoded',
-    services: services
-};
-
-const app = new HttpServer(options);
+  ]
+});
 ```
 
-#### HTTPS Server
-
-```javascript
-const { HttpsServer } = require('redweb');
+`.htmx` files under `public/` will render server-side.
+Example:
 
-const options = {
-    port: 3443,
-    ssl: {
-        key: './path/to/key.pem',
-        cert: './path/to/cert.pem'
-    },
-    publicPaths: ['./public']
-};
-
-const app = new HttpsServer(options);
+```html
+<!-- public/hello.htmx -->
+<@>
+  <h1>Hello, {{name}}!</h1>
+<@/>
 ```
 
-### WebSocket Server with Routes and Handlers
-
-RedWeb uses **route-based architecture** for WebSocket connections, allowing you to modularize and secure your WebSocket message handling logic.
+---
 
-#### Defining a Custom Handler
+## 🔌 WebSocket Broadcast Chat (🔥 Instant Testing)
 
-Handlers extend the `BaseHandler` class and manage their own connections and message types.
+### 1. `ChatHandler.js`
 
-```javascript
+```js
 const { BaseHandler } = require('redweb');
 
 class ChatHandler extends BaseHandler {
-    constructor() {
-        super('chat');
-    }
-
-    onMessage(socket, message) {
-        console.log(`Received chat message: ${message.text}`);
-        socket.send(JSON.stringify({ type: 'chatResponse', message: 'Hello!' }));
-    }
+  constructor() {
+    super('chat');
+  }
+
+  onMessage(socket, message) {
+    const text = message.text;
+    console.log(`Broadcasting: ${text}`);
+    socket.broadcast({ type: 'chat', text });
+  }
 }
 
 module.exports = ChatHandler;
 ```
 
-#### Defining a WebSocket Route
+---
 
-Routes group handlers and specify the WebSocket path.
+### 2. `ChatRoute.js`
 
-```javascript
+```js
 const { SocketRoute } = require('redweb');
 const ChatHandler = require('./ChatHandler');
 
 class ChatRoute extends SocketRoute {
-    constructor() {
-        super({
-            path: '/chat',
-            handlers: [ChatHandler]
-        });
-    }
+  constructor() {
+    super({
+      path: '/chat',
+      handlers: [ChatHandler],
+      allowDuplicateConnections: true // key for local testing!
+    });
+  }
 }
 
 module.exports = ChatRoute;
 ```
 
-#### Setting Up a WebSocket Server with Routes
+---
+
+### 3. `server.js`
 
-```javascript
+```js
 const { SocketServer } = require('redweb');
 const ChatRoute = require('./ChatRoute');
 
 new SocketServer({
-    port: 3000,
-    routes: [ChatRoute]
+  port: 3000,
+  routes: [ChatRoute]
 });
 ```
 
-### Adding Routes Dynamically
-
-Routes can be added to the WebSocket server after initialization.
-
-```javascript
-const { SocketServer, SocketRoute } = require('redweb');
-const ChatHandler = require('./ChatHandler');
-
-class ChatRoute extends SocketRoute {
-    constructor() {
-        super({
-            path: '/chat',
-            handlers: [ChatHandler]
-        });
-    }
-}
-
-const socketServer = new SocketServer({ port: 3000 });
-
-// Dynamically add a new route
-const chatRoute = new ChatRoute();
-socketServer.routes.push(chatRoute);
+---
+
+### 4. `client.html`
+
+```html
+<!DOCTYPE html>
+<html>
+  <body>
+    <h1>Broadcast Chat</h1>
+    <input id="msg" placeholder="Type message..." />
+    <button onclick="send()">Send</button>
+    <pre id="log"></pre>
+
+    <script>
+      const log = document.getElementById('log');
+      const ws = new WebSocket('ws://localhost:3000/chat');
+
+      ws.onmessage = (e) => {
+        const msg = JSON.parse(e.data);
+        log.textContent += `\n${msg.text}`;
+      };
+
+      function send() {
+        const text = document.getElementById('msg').value;
+        ws.send(JSON.stringify({ type: 'chat', text }));
+      }
+    </script>
+  </body>
+</html>
 ```
 
-### Client Communication with a Route
-
-The client connects to the WebSocket server using the specified route.
+Open multiple tabs to test!
 
-```javascript
-const WebSocket = require('ws');
+---
 
-const ws = new WebSocket('ws://localhost:3000/chat');
+## 🔧 Options
 
-ws.on('open', () => {
-    ws.send(JSON.stringify({ type: 'chat', text: 'Hello there!' }));
-});
+### HTTP / HTTPS Server Options
 
-ws.on('message', (message) => {
-    console.log('Received:', message);
-});
-```
+| Option                | Type      | Default        | Description                    |
+| --------------------- | --------- | -------------- | ------------------------------ |
+| `port`                | number    | `80`           | Port to listen on              |
+| `bind`                | string    | `'0.0.0.0'`    | Bind address                   |
+| `publicPaths`         | string\[] | `['./public']` | Serve static and `.htmx` files |
+| `services`            | object\[] | `[]`           | REST endpoints                 |
+| `enableHtmxRendering` | boolean   | `false`        | Enables `.htmx` file rendering |
+| `ssl`                 | object    | `undefined`    | Used in `HttpsServer`          |
 
-### Managing Connected Clients
+---
 
-RedWeb's WebSocket server maintains a list of connected clients by their IP addresses for each route. This list is automatically updated when clients connect or disconnect.
-
-```javascript
-const { SocketRoute } = require('redweb');
-
-class ChatRoute extends SocketRoute {
-    constructor() {
-        super({
-            path: '/chat',
-            handlers: []
-        });
-    }
-
-    onConnection(socket) {
-        console.log('New client connected:', socket.remoteAddress);
-    }
-}
-
-module.exports = ChatRoute;
-```
+### WebSocket Server Options
 
-## Options
+| Option                      | Type                | Default | Description                         |
+| --------------------------- | ------------------- | ------- | ----------------------------------- |
+| `port`                      | number              | `3000`  | WebSocket port                      |
+| `routes`                    | `SocketRoute[]`     | `[]`    | List of custom route classes        |
+| `allowDuplicateConnections` | boolean (per route) | `false` | Allow multiple clients from same IP |
 
-### HttpServer and HttpsServer Options
+---
 
-- **port**: Port number (default: `80`).
-- **bind**: Bind address (default: `0.0.0.0`).
-- **publicPaths**: Array of paths to serve static files (default: `['./public']`).
-- **services**: Array of services with endpoints and handlers (default: `[]`).
-- **listenCallback**: Function to execute once the server starts listening.
-- **encoding**: Encoding type for request bodies (`'json'` or `'urlencoded'`).
-- **ssl**: SSL configuration for HTTPS server (`{ key: './path/to/key.pem', cert: './path/to/cert.pem' }`).
+## 🆕 0.7.0 Update Highlights
 
-### SocketServer Options
+* ✅ `allowDuplicateConnections` for multi-tab testing
+* ✅ Robust message validation
+* ✅ `socket.broadcast()` now excludes sender
+* ✅ Better error handling
 
-- **port**: Port number (default: `3000`).
-- **routes**: Array of `SocketRoute` classes to define WebSocket routes and handlers.
-- **ssl**: SSL configuration for SecureSocketServer (`{ key: './path/to/key.pem', cert: './path/to/cert.pem' }`).
+---
 
-## License
+## 🪪 License
 
-MIT License
+MIT

package/index.d.ts

@@ -1,255 +1,98 @@
 declare module 'redweb' {
-    import { Request, Response } from 'express';
-    import { Server as HTTPServer } from 'http';
-    import { Server as HTTPSServer } from 'https';
-    import WebSocket from 'ws';
-
-    /**
-     * RedWeb encoding types.
-     */
+    import { Application } from 'express';
+    import { CorsOptions } from 'cors';
+    import { Server as HttpServer } from 'http';
+    import { WebSocket } from 'ws';
+  
     export type RedWebEncoding = 'json' | 'urlencoded';
-
-    /**
-     * Service configuration for RedWeb.
-     */
-    export interface Service {
-        serviceName: string;
-        method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
-        function: (req: Request, res: Response) => void;
-    }
-
-    /**
-     * Options for configuring a RedWeb server.
-     */
+  
     export interface RedWebOptions {
-        port?: number;
-        bind?: string;
-        publicPaths?: string[];
-        services?: Service[];
-        listenCallback?: () => void;
-        encoding?: RedWebEncoding;
-        ssl?: {
-            key: string;
-            cert: string;
-        };
-    }
-
-    /**
-     * Configuration for a WebSocket handler.
-     */
-    export interface HandlerConfig {
-        name: string;
-        handlers: {
-            [type: string]: (socket: WebSocket, data: any) => void;
-        };
+      port?: number;
+      bind?: string;
+      publicPaths?: string[];
+      services?: Array<{ serviceName: string; method: string; function: Function }>;
+      listenCallback?: () => void;
+      encoding?: RedWebEncoding;
+      ssl?: { key: string; cert: string };
+      server?: Application;
+      corsOptions?: CorsOptions;
+      enableHtmxRendering?: boolean;
     }
-
-    /**
-     * Options for configuring a WebSocket server.
-     */
+  
     export interface SocketServerOptions {
-        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;
-        };
-        routes?: Array<new () => SocketRoute>;
+      server?: HttpServer;
+      port?: number;
+      routes?: Array<new () => SocketRoute>;
+      ssl?: { key: string; cert: string };
     }
-
-    /**
-     * WebSocket route configuration.
-     */
+  
     export interface SocketRouteConfig {
-        path: string; // The WebSocket route path (e.g., "/chat").
-        handlers: Array<new () => BaseHandler>; // Array of handler classes for the route.
+      path: string;
+      handlers: Array<new () => BaseHandler>;
+      allowDuplicateConnections?: boolean;
     }
-
-    /**
-     * Represents a WebSocket route.
-     */
-    export class SocketRoute {
-        /**
-         * The path for the WebSocket route.
-         */
-        path: string;
-
-        /**
-         * Handlers associated with the route.
-         */
-        handlers: BaseHandler[];
-
-        /**
-         * Creates a new `SocketRoute` instance.
-         * @param config - Configuration options for the route.
-         */
-        constructor(config: SocketRouteConfig);
-
-        /**
-         * Adds a new handler dynamically.
-         * @param HandlerClass - A class extending `BaseHandler`.
-         */
-        addHandler(HandlerClass: new () => BaseHandler): void;
-
-        /**
-         * Handles a new WebSocket connection.
-         * @param socket - The WebSocket connection instance.
-         * @param req - The HTTP request associated with the connection.
-         */
-        handleConnection(socket: WebSocket, req: import('http').IncomingMessage): void;
-
-        /**
-         * Handles incoming WebSocket messages.
-         * @param socket - The WebSocket connection instance.
-         * @param data - The message data.
-         */
-        handleMessage(socket: WebSocket, data: any): void;
-
-        /**
-         * Handles WebSocket disconnections.
-         * @param socket - The WebSocket connection instance.
-         */
-        handleClose(socket: WebSocket): void;
-
-        /**
-         * Handles WebSocket errors.
-         * @param socket - The WebSocket connection instance.
-         * @param error - The error object.
-         */
-        handleError(socket: WebSocket, error: Error): void;
-    }
-
-    /**
-     * Base class for WebSocket handlers.
-     */
+  
     export class BaseHandler {
-        /**
-         * The name of the handler (used to identify it in the server).
-         */
-        name: string;
-        /**
-         * Creates a new handler instance.
-         * @param name - The name of the handler.
-         */
-        constructor(name: string);
-
-        /**
-         * Handles an incoming message.
-         * @param socket - The WebSocket connection that sent the message.
-         * @param message - The message data.
-         */
-        onMessage(socket: WebSocket, message: Object): void;
-
-        /**
-         * Called during the first contact with a new WebSocket connection.
-         * @param socket - The WebSocket connection instance.
-         */
-        onInitialContact(socket: WebSocket): void;
-
-        /**
-         * Called when a WebSocket connection closes.
-         * @param socket - The WebSocket connection instance.
-         */
-        onClose(socket: WebSocket): void;
+      name: string;
+      constructor(name: string);
+      handleMessage(
+        socket: WebSocket & {
+          sendJson: (message: object) => void;
+          broadcast: (message: object) => void;
+        },
+        message: any
+      ): void;
+      onMessage(socket: WebSocket, message: any): void;
+      onInitialContact(socket: WebSocket): void;
     }
-
-    /**
-     * Base WebSocket server class.
-     */
-    export class BaseSocketServer {
-        /**
-         * List of WebSocket routes.
-         */
-        routes: SocketRoute[];
-
-        /**
-         * Creates a new `BaseSocketServer`.
-         * @param server - The HTTP server instance.
-         * @param options - Configuration options.
-         */
-        constructor(server: HTTPServer | HTTPSServer, options?: SocketServerOptions);
-
-        /**
-         * Handles WebSocket upgrade requests.
-         * @param req - The incoming HTTP upgrade request.
-         * @param socket - The raw network socket.
-         * @param head - The initial data chunk.
-         */
-        handleUpgrade(req: import('http').IncomingMessage, socket: import('net').Socket, head: Buffer): void;
-
-        /**
-         * 
-         * @param route 
-         */
-        addRoute(route: new () => SocketRoute);
-    }
-
-    /**
-     * HTTP server class.
-     */
-    export class HttpServer {
-        constructor(options?: RedWebOptions);
+  
+    export class SocketRoute {
+      path: string;
+      handlers: BaseHandler[];
+      clients: Map<string, WebSocket>;
+      allowDuplicateConnections?: boolean;
+      constructor(config: SocketRouteConfig);
+      addHandler(handler: new () => BaseHandler): void;
+      handleMessage(sock: WebSocket, data: any): void;
     }
-
-    /**
-     * HTTPS server class.
-     */
-    export class HttpsServer {
-        constructor(options?: RedWebOptions);
+  
+    export class BaseSocketServer {
+      clients: Map<string, WebSocket>;
+      server: HttpServer;
+      routes: SocketRoute[];
+      constructor(server: HttpServer, options?: SocketServerOptions);
+      addRoute(route: new () => SocketRoute): void;
     }
-
-    /**
-     * WebSocket server class.
-     */
+  
     export class SocketServer extends BaseSocketServer {
-        constructor(options?: SocketServerOptions);
+      constructor(options?: SocketServerOptions);
     }
-
-    /**
-     * Secure WebSocket server class.
-     */
+  
     export class SecureSocketServer extends BaseSocketServer {
-        constructor(options?: SocketServerOptions);
+      constructor(options?: SocketServerOptions);
     }
-
-    /**
-     * SSL configuration loader.
-     */
-    export function loadSslConfig(sslOptions: { key: string; cert: string }): { key: string; cert: string };
-
-    /**
-     * Constants for encoding types.
-     */
-    export const ENCODINGS: {
-        json: 'json';
-        urlencoded: 'urlencoded';
-    };
-
-    /**
-     * Constants for HTTP methods.
-     */
+  
+    export class HttpServer {
+      constructor(options?: RedWebOptions);
+    }
+  
+    export class HttpsServer {
+      constructor(options?: RedWebOptions);
+    }
+  
     export const METHODS: {
-        POST: 'post';
-        GET: 'get';
-        PUT: 'put';
-        DELETE: 'delete';
-        PATCH: 'patch';
-        OPTIONS: 'options';
-        HEAD: 'head';
+      GET: 'get';
+      POST: 'post';
+      PUT: 'put';
+      DELETE: 'delete';
+    };
+  
+    export const ENCODINGS: {
+      json: 'json';
+      urlencoded: 'urlencoded';
     };
-
-    /**
-     * Default HTTP options.
-     */
+  
     export const HTTP_OPTIONS: RedWebOptions;
-
-    /**
-     * Default socket options.
-     */
     export const SOCKET_OPTIONS: SocketServerOptions;
-}
+  }
+  

package/package.json

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

package/src/htmx/HtmxRenderer.js

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const vm = require('vm');
+const path = require('path');
+
+class HtmxRenderer {
+    /**
+     * Render an .htmx file as JavaScript with embedded print statements.
+     * @param {string} filePath - Path to the .htmx file.
+     * @returns {string} Rendered HTML string with normalized whitespace.
+     */
+    static render(filePath) {
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`Template file not found: ${filePath}`);
+        }
+
+        let output = '';
+        const templateContent = fs.readFileSync(filePath, 'utf-8');
+
+        // Transform <@ ... @/> blocks into print() calls
+        const transformedTemplate = templateContent.replace(
+            /<@>([\s\S]*?)<@\/>/g,
+            (_, content) => `print(\`${content.replace(/{{\s*(.*?)\s*}}/g, '${$1}')}\`);`
+        );
+
+        // Wrap the script in an IIFE
+        const wrappedScript = `
+        (() => {
+            const print = (html) => output += html;
+            ${transformedTemplate}
+            return output;
+        })();
+        `;
+
+        // Create a custom require function that resolves paths relative to the template
+        const customRequire = (modulePath) => {
+            const absolutePath = path.resolve(path.dirname(filePath), modulePath);
+            return require(absolutePath);
+        };
+
+        // Execute the script in a sandbox
+        const script = new vm.Script(wrappedScript);
+        const sandbox = {
+            output: '',
+            require: customRequire, // Add custom require
+            __dirname: path.dirname(filePath),
+            __filename: filePath,
+        };
+        vm.createContext(sandbox);
+
+        // Get the rendered output
+        let result = script.runInContext(sandbox);
+
+        // Normalize spaces but preserve those in content
+        result = result
+            .replace(/>\s+</g, '><')       // Remove spaces between tags
+            .replace(/\s+/g, ' ')         // Collapse multiple spaces to one
+            .replace(/>\s+/g, '>')        // Remove spaces after tags
+            .replace(/\s+</g, '<')        // Remove spaces before tags
+            .trim();                      // Trim leading and trailing spaces
+
+        return result;
+    }
+}
+
+module.exports = HtmxRenderer;

package/src/htmx/RedWebHtmxComponent.js

@@ -0,0 +1,11 @@
+class RedWebHtmxComponent {
+    constructor(props = {}) {
+        this.props = props;
+    }
+
+    render() {
+        throw new Error('Render method must be implemented in derived components');
+    }
+}
+
+module.exports = RedWebHtmxComponent;

package/src/http/BaseHttpServer.js

@@ -2,6 +2,8 @@ const express = require('express');
 const bodyParser = require('body-parser');
 const path = require('path');
 const cors = require('cors');
+const fs = require('fs');
+const HtmxRenderer = require('../htmx/HtmxRenderer'); // Import the HtmxRenderer module
 
 /**
  * @typedef {'json' | 'urlencoded'} RedWebEncoding
@@ -21,6 +23,7 @@ const cors = require('cors');
  * @property {string} [ssl.cert] - Path to the SSL certificate file.
  * @property {import('express').Application} [server] - Whether to automatically start listening.
  * @property {import('cors').CorsOptions} [corsOptions] - The CORS Options.
+ * @property {boolean} [enableHtmxRendering=false] - Enable dynamic HTMX file rendering.
  */
 
 const ENCODINGS = { json: 'json', urlencoded: 'urlencoded' };
@@ -34,6 +37,7 @@ const HTTP_OPTIONS = {
     ssl: null,
     server: undefined,
     corsOptions: undefined,
+    enableHtmxRendering: false, // New option for HTMX rendering
 };
 
 /**
@@ -52,18 +56,50 @@ function BaseHttpServer(options = {}) {
     } else if (this.encoding === ENCODINGS.urlencoded) {
         this.app.use(bodyParser.urlencoded({ extended: true }));
     }
+
     this.app.use(cors(this.options.corsOptions));
-    this.publicPaths.forEach(public_path => this.app.use(express.static(path.join(process.cwd(), public_path))));
+
+    // Enable HTMX rendering if the flag is set
+    if (this.enableHtmxRendering) {
+        this.app.get('*.htmx', (req, res) => {
+            // Find the file in one of the publicPaths
+            const filePath = this.publicPaths
+                .map(publicPath => path.join(process.cwd(), publicPath, req.path))
+                .find(fullPath => fs.existsSync(fullPath)); // Check if the file exists
+    
+            if (!filePath) {
+                return res.status(404).send(`Error rendering HTMX file: Template file not found: ${req.path}`);
+            }
+    
+            try {
+                const renderedContent = HtmxRenderer.render(filePath);
+                res.type('html').send(renderedContent);
+            } catch (error) {
+                res.status(500).send(`Error rendering HTMX file: ${error.message}`);
+            }
+        });
+    }
+    
+
+    // Serve static files from public paths
+    this.publicPaths.forEach((publicPath) =>
+        this.app.use(express.static(path.join(process.cwd(), publicPath)))
+    );
+
     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));
+    this.services.forEach((service) =>
+        this.app[service.method](service.serviceName, service.function)
+    );
     if (catchAll) this.app[catchAll.method](catchAll.serviceName, catchAll.function);
+
     return this;
 }
 
+
 module.exports = {
     BaseHttpServer,
     ENCODINGS,
     HTTP_OPTIONS,
-    METHODS: {GET: 'get', POST: 'post', PUT: 'put', DELETE: 'delete'}
+    METHODS: { GET: 'get', POST: 'post', PUT: 'put', DELETE: 'delete' },
 };

package/src/ws/BaseHandler.js

@@ -16,7 +16,7 @@ class BaseHandler {
     /**
      * Handles an incoming message and routes it to the appropriate handler function.
      * @param {WebSocket & {sendJson: (message: Object) => void, broadcast: (message: Object) => void}} socket - The WebSocket connection that sent the message.
-     * @param {string} message - The incoming message in JSON string format.
+     * @param {any} message - The incoming message in parsed JSON.
      */
     handleMessage(socket, message) {
         this.onMessage(socket, message);
@@ -25,7 +25,7 @@ class BaseHandler {
     /**
      * Method to be overriden to process messages.
      * @param {WebSocket} socket - The WebSocket connection that sent the message.
-     * @param {string} message - The incoming message in JSON string format.
+     * @param {any} message - The incoming message in parsed JSON.
      */
     onMessage(socket, message) {
         throw "Not yet implemented!";

package/src/ws/SocketRoute.js

@@ -1,5 +1,6 @@
 const { WebSocketServer } = require("ws");
 const { sendJson, broadcast } = require("./util");
+const { randomUUID } = require("crypto");
 
 /**
  * Represents a WebSocket route configuration.
@@ -10,9 +11,10 @@ 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.
      */
-    constructor({path, handlers } = {}) {
+    constructor({path, handlers, allowDuplicateConnections } = {}) {
         if (!path) {
             throw new Error('A `path` must be specified for the SocketRoute.');
         }
@@ -34,6 +36,7 @@ class SocketRoute {
         this.clients = new Map();
         this.server = new WebSocketServer({ noServer: true, path });
         this.server.on('connection', this.handleConnection.bind(this));
+        this.allowDuplicateConnections = allowDuplicateConnections;
     }
     /**
      * Adds a new handler to the WebSocket server.
@@ -56,23 +59,37 @@ class SocketRoute {
     handleConnection(socket, req) {
         const ip = req.socket.remoteAddress;
         console.log(`New client connected: ${ip}`);
-        if (this.clients.get(ip) !== undefined) {
-            const oldClient = this.clients.get(ip);
-            console.warn(`Client ${ip} already connected, disconnecting existing connection.`);
-            oldClient.send(
-                JSON.stringify({ msg: 'You are being disconnected because a new client is connected with your IP address.' })
-            );
-            oldClient.close();
+        if (this.allowDuplicateConnections) {
+            this.clients.set(randomUUID(), socket);
+        } else {
+            if (this.clients.get(ip) !== undefined) {
+                const oldClient = this.clients.get(ip);
+                console.warn(`Client ${ip} already connected, disconnecting existing connection.`);
+                oldClient.send(
+                    JSON.stringify({ msg: 'You are being disconnected because a new client is connected with your IP address.' })
+                );
+                oldClient.close();
+            }
+            this.clients.set(ip, socket);
         }
-        this.clients.set(ip, socket);
         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()], data);
+        socket.broadcast = (data) => broadcast([...this.clients.values()].filter(sock => sock !== socket), data);
 
         this.connectionOpenCallback(socket);
-        socket.on('message', (message) => this.handleMessage(socket, JSON.parse(message)));
         socket.on('close', this.handleClose.bind(this));
         socket.on('error', this.handleError.bind(this));
+        socket.on('message', (message) => {
+            try {
+                const parsed = JSON.parse(message);
+                this.handleMessage(socket, parsed);
+            } catch (error) {
+                console.error(`Error parsing message from ${ip}:`, error);
+                socket.sendJson({ error: 'Invalid JSON format' });
+                socket.close();
+                return;
+            }
+        });
     }
 
     connectionOpenCallback(socket) {
@@ -85,7 +102,13 @@ class SocketRoute {
             sendJson(sock, {error: `No such handler ${data.type}`});
             sock.close();
         } else {
-            handler.handleMessage(sock, data);
+            try {
+                handler.handleMessage(sock, data);
+            } catch (error) {
+                console.error(`Error handling message in handler ${handler.name}:`, error);
+                sendJson(sock, { error: `${error.message}` });
+                sock.close();
+            }
         }
     }