redweb 0.6.2 → 0.6.5

package/src/http/BaseHttpServer.js

@@ -1,69 +1,69 @@
-const express = require('express');
-const bodyParser = require('body-parser');
-const path = require('path');
-const cors = require('cors');
-
-/**
- * @typedef {'json' | 'urlencoded'} RedWebEncoding
- */
-
-/**
- * RedWeb options object.
- * @typedef {Object} RedWebOptions
- * @property {number} [port=80] - The port number to bind the server.
- * @property {string} [bind='0.0.0.0'] - The bind address for the server.
- * @property {string[]} [publicPaths=['./public']] - An array of paths to serve static files from.
- * @property {Array<{serviceName: string, method: string, function: Function}>} [services=[]] - An array of services with their endpoints and handlers.
- * @property {Function} [listenCallback] - Callback function to execute once the server starts listening.
- * @property {RedWebEncoding} [encoding='json'] - The encoding type for the request bodies ('json' or 'urlencoded').
- * @property {Object} [ssl] - SSL configuration for HTTPS server.
- * @property {string} [ssl.key] - Path to the SSL key file.
- * @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.
- */
-
-const ENCODINGS = { json: 'json', urlencoded: 'urlencoded' };
-const HTTP_OPTIONS = {
-    port: 80,
-    bind: '0.0.0.0',
-    publicPaths: ['./public'],
-    services: [],
-    listenCallback: undefined,
-    encoding: ENCODINGS.json,
-    ssl: null,
-    server: undefined,
-    corsOptions: undefined,
-};
-
-/**
- * Base HTTP Server
- * @param {RedWebOptions} options - Configuration options for RedWeb.
- * @return {Object} Express application instance.
- */
-function BaseHttpServer(options = {}) {
-    this.options = { ...HTTP_OPTIONS, ...options };
-    this.app = express() || this.options.server;
-    Object.assign(this, this.options);
-
-    // Middleware to parse request bodies based on the specified encoding
-    if (this.encoding === ENCODINGS.json) {
-        this.app.use(bodyParser.json());
-    } 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))));
-    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;
-}
-
-module.exports = {
-    BaseHttpServer,
-    ENCODINGS,
-    HTTP_OPTIONS,
-    METHODS: {GET: 'get', POST: 'post', PUT: 'put', DELETE: 'delete'}
-};
+const express = require('express');
+const bodyParser = require('body-parser');
+const path = require('path');
+const cors = require('cors');
+
+/**
+ * @typedef {'json' | 'urlencoded'} RedWebEncoding
+ */
+
+/**
+ * RedWeb options object.
+ * @typedef {Object} RedWebOptions
+ * @property {number} [port=80] - The port number to bind the server.
+ * @property {string} [bind='0.0.0.0'] - The bind address for the server.
+ * @property {string[]} [publicPaths=['./public']] - An array of paths to serve static files from.
+ * @property {Array<{serviceName: string, method: string, function: Function}>} [services=[]] - An array of services with their endpoints and handlers.
+ * @property {Function} [listenCallback] - Callback function to execute once the server starts listening.
+ * @property {RedWebEncoding} [encoding='json'] - The encoding type for the request bodies ('json' or 'urlencoded').
+ * @property {Object} [ssl] - SSL configuration for HTTPS server.
+ * @property {string} [ssl.key] - Path to the SSL key file.
+ * @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.
+ */
+
+const ENCODINGS = { json: 'json', urlencoded: 'urlencoded' };
+const HTTP_OPTIONS = {
+    port: 80,
+    bind: '0.0.0.0',
+    publicPaths: ['./public'],
+    services: [],
+    listenCallback: undefined,
+    encoding: ENCODINGS.json,
+    ssl: null,
+    server: undefined,
+    corsOptions: undefined,
+};
+
+/**
+ * Base HTTP Server
+ * @param {RedWebOptions} options - Configuration options for RedWeb.
+ * @return {Object} Express application instance.
+ */
+function BaseHttpServer(options = {}) {
+    this.options = { ...HTTP_OPTIONS, ...options };
+    this.app = express() || this.options.server;
+    Object.assign(this, this.options);
+
+    // Middleware to parse request bodies based on the specified encoding
+    if (this.encoding === ENCODINGS.json) {
+        this.app.use(bodyParser.json());
+    } 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))));
+    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;
+}
+
+module.exports = {
+    BaseHttpServer,
+    ENCODINGS,
+    HTTP_OPTIONS,
+    METHODS: {GET: 'get', POST: 'post', PUT: 'put', DELETE: 'delete'}
+};

package/src/http/HttpServer.js

@@ -1,14 +1,14 @@
-const { BaseHttpServer } = require('./BaseHttpServer');
-
-/**
- * HTTP Server
- * @param {RedWebOptions} options - Configuration options for RedWeb.
- * @return {Object} Express application instance.
- */
-function HttpServer(options = {}) {
-    BaseHttpServer.call(this, options);
-    this.server = this.app.listen(this.port, this.listenCallback ? this.listenCallback : () => console.log(`RedWeb HttpServer listening on port ${this.port}`));
-    return this;
-}
-
-module.exports = HttpServer;
+const { BaseHttpServer } = require('./BaseHttpServer');
+
+/**
+ * HTTP Server
+ * @param {RedWebOptions} options - Configuration options for RedWeb.
+ * @return {Object} Express application instance.
+ */
+function HttpServer(options = {}) {
+    BaseHttpServer.call(this, options);
+    this.server = this.app.listen(this.port, this.listenCallback ? this.listenCallback : () => console.log(`RedWeb HttpServer listening on port ${this.port}`));
+    return this;
+}
+
+module.exports = HttpServer;

package/src/http/HttpsServer.js

@@ -1,17 +1,17 @@
-const https = require('https');
-const { BaseHttpServer } = require('./BaseHttpServer');
-const loadSslConfig = require('../sslConfig');
-
-/**
- * HTTPS Server
- * @param {RedWebOptions} options - Configuration options for RedWeb.
- * @return {Object} Express application instance.
- */
-function HttpsServer(options = {}) {
-    BaseHttpServer.call(this, options);
-    const sslOptions = loadSslConfig(this.ssl);
-    https.createServer(sslOptions, this.app).listen(this.port, this.listenCallback ? this.listenCallback : () => console.log(`RedWeb HttpsServer listening on port ${this.port}`));
-    return this;
-}
-
-module.exports = HttpsServer;
+const https = require('https');
+const { BaseHttpServer } = require('./BaseHttpServer');
+const loadSslConfig = require('../sslConfig');
+
+/**
+ * HTTPS Server
+ * @param {RedWebOptions} options - Configuration options for RedWeb.
+ * @return {Object} Express application instance.
+ */
+function HttpsServer(options = {}) {
+    BaseHttpServer.call(this, options);
+    const sslOptions = loadSslConfig(this.ssl);
+    https.createServer(sslOptions, this.app).listen(this.port, this.listenCallback ? this.listenCallback : () => console.log(`RedWeb HttpsServer listening on port ${this.port}`));
+    return this;
+}
+
+module.exports = HttpsServer;

package/src/http/index.js

@@ -1,2 +1,2 @@
-const { METHODS } = require('./BaseHttpServer');
+const { METHODS } = require('./BaseHttpServer');
 module.exports = { HttpServer: require('./HttpServer'), HttpsServer: require('./HttpsServer'), METHODS}

package/src/sslConfig.js

@@ -1,20 +1,20 @@
-const fs = require('fs');
-
-/**
- * Load SSL configuration
- * @param {Object} sslOptions - The SSL options object containing the paths to key and cert files.
- * @param {string} sslOptions.key - Path to the SSL key file.
- * @param {string} sslOptions.cert - Path to the SSL certificate file.
- * @return {Object} - The loaded SSL options containing key and cert.
- */
-function loadSslConfig(sslOptions) {
-    if (!sslOptions || !sslOptions.key || !sslOptions.cert) {
-        throw new Error('SSL key and certificate paths must be provided');
-    }
-    return {
-        key: fs.readFileSync(sslOptions.key),
-        cert: fs.readFileSync(sslOptions.cert)
-    };
-}
-
-module.exports = loadSslConfig;
+const fs = require('fs');
+
+/**
+ * Load SSL configuration
+ * @param {Object} sslOptions - The SSL options object containing the paths to key and cert files.
+ * @param {string} sslOptions.key - Path to the SSL key file.
+ * @param {string} sslOptions.cert - Path to the SSL certificate file.
+ * @return {Object} - The loaded SSL options containing key and cert.
+ */
+function loadSslConfig(sslOptions) {
+    if (!sslOptions || !sslOptions.key || !sslOptions.cert) {
+        throw new Error('SSL key and certificate paths must be provided');
+    }
+    return {
+        key: fs.readFileSync(sslOptions.key),
+        cert: fs.readFileSync(sslOptions.cert)
+    };
+}
+
+module.exports = loadSslConfig;

package/src/ws/BaseHandler.js

@@ -1,93 +1,39 @@
-/**
- * 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 = [];
-    }
-
-    handleSocketMessages(socket) {
-        socket.on('message', (message) => this.handleMessage(socket, message));
-    }
-
-    handleSocketClose(socket) {
-        socket.on('close', () => {
-            this.connections = this.connections.filter((conn) => conn !== socket);
-            console.log(`Connection closed for handler "${this.name}".`);
-        });
-    }
-
-    handleNewConnection(socket) {
-        this.connections.push(socket);
-        this.handleSocketMessages(socket);
-        this.handleSocketClose(socket);
-        socket.isAssigned = true;
-        console.log(`New connection added to handler "${this.name}".`);
-    }
-
-    /**
-     * Adds a new WebSocket connection and sets up message handling for this handler.
-     * @param {WebSocket} socket - The WebSocket connection to add.
-     */
-    newConnection(socket, data) {
-        console.log(`Received newConnection data ${data}`);
-        this.handleNewConnection(socket);
-    }
-
-    /**
-     * 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 };
+/**
+ * Represents the base class for a WebSocket message handler.
+ */
+class BaseHandler {
+    /**
+     * Creates a new handler instance.
+     * @param {string} name - The name of the Handler, used in the client 'type' arg of request e.g {"type": "<handler-name>", ...}
+     */
+    constructor(name) {
+        /**
+         * he name of the Handler, used in the client 'type' arg of request e.g {"type": "<handler-name>", ...}.
+         * @type {string}
+         */
+        this.name = name;
+    }
+    /**
+     * 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.
+     */
+    handleMessage(socket, message) {
+        this.onMessage(socket, message);
+    }
+
+    /**
+     * 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.
+     */
+    onMessage(socket, message) {
+        throw "Not yet implemented!";
+    }
+
+    onInitialContact(socket) {
+
+    }
+}
+
+module.exports = { BaseHandler };

package/src/ws/BaseSocketServer.js

@@ -1,203 +1,57 @@
-const WebSocket = require('ws');
-
-/**
- * @typedef {Object} SocketServerOptions
- * @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 = {
-    port: 3000,
-    connectionOpenCallback: undefined,
-    connectionCloseCallback: undefined,
-    messageCallback: undefined,
-    messageHandlers: {
-        ping: (socket, data) => socket.send(JSON.stringify({ type: 'pong' }))
-    },
-    ssl: null
-};
-
-/**
- * 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 {
-    /**
-     * @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(); // 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());
-    }
-
-    /**
-     * 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;
-        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();
-        }
-        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.initialMessageHandler(socket, message, ip));
-        socket.on('close', () => this.handleClose(socket, ip));
-        socket.on('error', error => this.handleError(socket, error, 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 {
-            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;
-            }
-
-            // 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 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, connectMessage.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);
-    }
-
-    /**
-     * Broadcasts a message to all connected clients.
-     * @param {object} message - The message to broadcast.
-     */
-    broadcast(message) {
-        broadcast(this, message);
-    }
-}
-
-module.exports = { BaseSocketServer, SOCKET_OPTIONS };
+/**
+ * @typedef {Object} SocketServerOptions
+ * @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 {Array<new () => import('./SocketRoute').SocketRoute>} [routes] - An array of handler classes to use for routing.
+ */
+
+const DefaultRoute = require('./DefaultRoute');
+
+const SOCKET_OPTIONS = {
+    port: 3000,
+    ssl: null,
+    routes: []
+};
+
+/**
+ * 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 {
+    /**
+     * @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.clients = new Map(); // Map of clients by their IP addresses.
+        Object.assign(this, { ...SOCKET_OPTIONS, ...options });
+        this.server = server;
+        if (!options.routes?.length) options.routes = [ DefaultRoute ];
+        this.routes = options.routes.map((route) => new route(server));
+        this.server.on('upgrade', this.handleUpgrade.bind(this));
+    }
+
+    handleUpgrade(req, sock, head) {
+        const route = this.routes.find(route => route.path == req.url);
+        if (!route) sock.destroy();
+        else route.server.handleUpgrade(req, sock, head, (s, r) => route.server.emit('connection', s, r));
+    }
+
+    /**
+     * 
+     * @param {new () => import('./SocketRoute')} route 
+     */
+    addRoute(route) {
+        this.routes.push(new route(this.server));
+    }
+}
+
+module.exports = { BaseSocketServer, SOCKET_OPTIONS };

package/src/ws/DefaultHandler.js

@@ -0,0 +1,14 @@
+const { BaseHandler } = require("./BaseHandler");
+const { sendJson } = require("./util");
+
+class DefaultHandler extends BaseHandler {
+    constructor() {
+        super("DefaultHandler");
+    }
+
+    onMessage(socket, message) {
+        socket.send(sendJson(`I got your message of ${JSON.stringify(message)}`));
+    }
+}
+
+module.exports = DefaultHandler;