redweb 0.2.4 → 0.2.6

package/README.md

@@ -1,6 +1,9 @@
+Sure, here is a concise version of the `README.md`:
+
+```markdown
 # RedWeb
 
-RedWeb is a simple and flexible Node.js framework built on top of Express.js. It allows you to quickly set up a web server with customizable options, including serving static files, defining custom API endpoints, and integrating WebSocket communication.
+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.
 
 ## Installation
 
@@ -14,17 +17,21 @@ npm install redweb
 
 ### Basic Example
 
-To get started with RedWeb, simply initialize your RedWeb instance with the default options:
+Initialize your RedWeb instance with the default options:
 
 ```javascript
-const { HttpServer } = require('redweb');
+const { HttpServer, SocketServer } = require('redweb');
+
+// HTTP server with default configuration
+const httpServer = new HttpServer();
 
-const app = new HttpServer();
+// WebSocket server with default configuration
+const socketServer = new SocketServer();
 ```
 
 ### Custom Configuration
 
-You can also configure RedWeb according to your needs:
+#### HTTP Server
 
 ```javascript
 const { HttpServer, METHODS } = require('redweb');
@@ -33,12 +40,11 @@ const services = [
     {
         serviceName: '/submit-form',
         method: METHODS.POST,
-        function: (req, res) => {
+        'function': (req, res) => {
             const { name, email, message } = req.body;
             if (!name || !email || !message) {
                 return res.status(400).json({ error: 'All fields are required' });
             }
-            // Implement your logic here
             res.status(200).json({ success: 'Form submitted successfully' });
         }
     }
@@ -46,11 +52,7 @@ const services = [
 
 const options = {
     port: 3000,
-    publicPaths: [
-        './pages/my_public_html',
-        './content/my_public_images',
-        './styles/styles.css'
-    ],
+    publicPaths: ['./public'],
     encoding: 'urlencoded',
     services: services
 };
@@ -58,9 +60,7 @@ const options = {
 const app = new HttpServer(options);
 ```
 
-### HTTPS Server
-
-To create an HTTPS server, provide the SSL options including the paths to your SSL key and certificate files:
+#### HTTPS Server
 
 ```javascript
 const { HttpsServer } = require('redweb');
@@ -77,29 +77,31 @@ const options = {
 const app = new HttpsServer(options);
 ```
 
-### WebSocket Server
-
-To create a WebSocket server, use the `SocketServer` function:
+#### WebSocket Server
 
 ```javascript
 const { SocketServer } = require('redweb');
 
 const options = {
     port: 3000,
-    connectionCallback: (socket) => {
-        console.log('New client connected');
-        socket.on('message', (data) => {
-            console.log('Message received:', data);
-        });
+    connectionOpenCallback: (socket) => {
+        console.log('WebSocket client connected');
+    },
+    connectionCloseCallback: (socket) => {
+        console.log('WebSocket client disconnected');
+    },
+    messageHandlers: {
+        'msg': () => (socket, data) => {
+            console.log(data);
+            socket.send('guuuuuurl');
+        }
     }
 };
 
 const socketServer = new SocketServer(options);
 ```
 
-### Secure WebSocket Server
-
-To create a secure WebSocket server, provide the SSL options:
+#### Secure WebSocket Server
 
 ```javascript
 const { SecureSocketServer } = require('redweb');
@@ -110,67 +112,74 @@ const options = {
         key: './path/to/key.pem',
         cert: './path/to/cert.pem'
     },
-    connectionCallback: (socket) => {
-        console.log('New client connected');
-        socket.on('message', (data) => {
-            console.log('Message received:', data);
-        });
+    connectionOpenCallback: (socket) => {
+        console.log('WebSocket client connected');
+    },
+    connectionCloseCallback: (socket) => {
+        console.log('WebSocket client disconnected');
+    },
+    messageHandlers: {
+        'msg': () (socket, data) => {
+            console.log(data);
+            socket.send('guuuuuurl');
+        }
     }
 };
 
 const secureSocketServer = new SecureSocketServer(options);
 ```
 
-## Options
-
-### HTTP/HTTPS Options
-
-The `HttpServer` and `HttpsServer` constructors accept an options object with the following properties:
-
-- **port**: The port number to bind the server (default: `80`).
-- **bind**: The bind address for the server (default: `0.0.0.0`).
-- **publicPaths**: An array of paths to serve static files from (default: `['./public']`).
-- **services**: An array of services with their endpoints and handlers (default: `[]`).
-- **listenCallback**: A callback function to execute once the server starts listening (default: `undefined`).
-- **encoding**: The encoding type for the request bodies. It can be either `'json'` or `'urlencoded'` (default: `'json'`).
-- **ssl**: SSL configuration for the HTTPS server. It should include `key` and `cert` paths.
-
-### WebSocket/Secure WebSocket Options
+### Managing Connected Clients
 
-The `SocketServer` and `SecureSocketServer` constructors accept an options object with the following properties:
-
-- **port**: The port number to bind the socket server (default: `3000`).
-- **connectionCallback**: A callback function to execute once a client connects (default: `undefined`).
-- **ssl**: SSL configuration for the secure WebSocket server. It should include `key` and `cert` paths.
-
-### Example Options Object
+RedWeb's WebSocket server maintains a list of connected clients by their IP addresses. This list is automatically updated when clients connect or disconnect.
 
 ```javascript
-const options = {
+const { SocketServer } = require('redweb');
+
+const socketServer = new SocketServer({
     port: 3000,
-    bind: '127.0.0.1',
-    publicPaths: ['./public', './assets'],
-    services: [
-        {
-            serviceName: '/api/data',
-            method: METHODS.GET,
-            function: (req, res) => {
-                res.json({ message: 'Hello, world!' });
-            }
+    connectionOpenCallback: (socket) => {
+        console.log('WebSocket client connected');
+    },
+    connectionCloseCallback: (socket) => {
+        console.log('WebSocket client disconnected');
+    },
+    messageHandlers: {
+        'msg': () => (socket, data) {
+            console.log(data);
+            socket.send('guuuuuurl');
         }
-    ],
-    listenCallback: () => console.log('Server is running...'),
-    encoding: 'json'
-};
+    }
+});
+
+// Access the list of connected clients
+console.log(socketServer.clients); // Map of clients by their IP addresses
 ```
 
-## Methods
+## Options
+
+### 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' }`).
 
-RedWeb provides a `METHODS` object that contains the HTTP methods you can use for defining services:
+### SocketServer and SecureSocketServer Options
 
-- `METHODS.POST` - 'post'
-- `METHODS.GET` - 'get'
+- **port**: Port number (default: `3000`).
+- **connectionOpenCallback**: Function to execute once a client connects.
+- **connectionCloseCallback**: Function to execute once a client disconnects.
+- **messageCallback**: Function to execute for every message received.
+- **messageHandlers**: Object containing message handlers based on message type.
+- **ssl**: SSL configuration for SecureSocketServer (`{ key: './path/to/key.pem', cert: './path/to/cert.pem' }`).
 
 ## License
 
-MIT License
+MIT License
+```
+
+This `README.md` is now more concise, providing a clear overview of the basic and custom configurations for both HTTP and WebSocket servers, along with their available options.

package/SocketServer.js

@@ -21,7 +21,7 @@ const SOCKET_OPTIONS = {
     connectionCloseCallback: undefined,
     messageCallback: undefined,
     messageHandlers: {
-        'ping': (socket) => socket.send(JSON.stringify({ type: 'pong' }))
+        'ping': function(socket, data) { socket.send(JSON.stringify({ type: 'pong' })); }
     },
     ssl: null
 };
@@ -33,34 +33,39 @@ const SOCKET_OPTIONS = {
  */
 function BaseSocketServer(server, options = {}) {
     this.wss = new WebSocket.Server({ server });
+    this.clients = new Map();  // Use a Map to store clients by their IP addresses
     Object.assign(this, { ...SOCKET_OPTIONS, ...options });
 
-    this.wss.on('connection', (socket) => {
-        console.log('New client connected');
+    this.wss.on('connection', (socket, req) => {
+        const ip = req.socket.remoteAddress;
+        console.log(`New client connected: ${ip}`);
+        this.clients.set(ip, socket);
+
         if (this.connectionOpenCallback) this.connectionOpenCallback(socket);
 
         socket.on('message', (message) => {
             try {
-                console.info(`Received message: ${message}`);
-                if (this.messageCallback) this.messageCallback(message);
+                console.info(`Received message from ${ip}: ${message}`);
+                if (this.messageCallback) this.messageCallback(socket, message);
                 const parsedMessage = JSON.parse(message);
                 const { type, data } = parsedMessage;
 
                 if (this.messageHandlers[type]) {
-                    this.messageHandlers[type](data);
+                    this.messageHandlers[type](socket, data);
                 }
             } catch (error) {
-                console.error('Error handling message:', error);
+                console.error(`Error handling message from ${ip}:`, error);
             }
         });
 
         socket.on('close', () => {
-            console.log('Client disconnected');
+            console.log(`Client disconnected: ${ip}`);
+            this.clients.delete(ip);
             if (this.connectionCloseCallback) this.connectionCloseCallback(socket);
         });
 
         socket.on('error', (error) => {
-            console.error('Socket error:', error);
+            console.error(`Socket error from ${ip}:`, error);
         });
     });
 

package/package.json

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