redweb 0.1.1 → 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Arkam Mazrui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+# 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.
+
+## Installation
+
+To install RedWeb, use npm:
+
+```bash
+npm install redweb
+```
+
+## Usage
+
+### Basic Example
+
+To get started with RedWeb, simply initialize your RedWeb instance with the default options:
+
+```javascript
+const { HttpServer } = require('redweb');
+
+const app = new HttpServer();
+```
+
+### Custom Configuration
+
+You can also configure RedWeb according to your needs:
+
+```javascript
+const { HttpServer, METHODS } = require('redweb');
+
+const 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' });
+            }
+            // Implement your logic here
+            res.status(200).json({ success: 'Form submitted successfully' });
+        }
+    }
+];
+
+const options = {
+    port: 3000,
+    publicPaths: [
+        './pages/my_public_html',
+        './content/my_public_images',
+        './styles/styles.css'
+    ],
+    encoding: 'urlencoded',
+    services: services
+};
+
+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:
+
+```javascript
+const { HttpsServer } = require('redweb');
+
+const options = {
+    port: 3443,
+    ssl: {
+        key: './path/to/key.pem',
+        cert: './path/to/cert.pem'
+    },
+    publicPaths: ['./public']
+};
+
+const app = new HttpsServer(options);
+```
+
+### WebSocket Server
+
+To create a WebSocket server, use the `SocketServer` function:
+
+```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);
+        });
+    }
+};
+
+const socketServer = new SocketServer(options);
+```
+
+### Secure WebSocket Server
+
+To create a secure WebSocket server, provide the SSL options:
+
+```javascript
+const { SecureSocketServer } = require('redweb');
+
+const options = {
+    port: 4443,
+    ssl: {
+        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);
+        });
+    }
+};
+
+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
+
+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
+
+```javascript
+const options = {
+    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!' });
+            }
+        }
+    ],
+    listenCallback: () => console.log('Server is running...'),
+    encoding: 'json'
+};
+```
+
+## Methods
+
+RedWeb provides a `METHODS` object that contains the HTTP methods you can use for defining services:
+
+- `METHODS.POST` - 'post'
+- `METHODS.GET` - 'get'
+
+## License
+
+MIT License

package/index.js

@@ -1,70 +1,13 @@
-const express = require('express');
-const bodyParser = require('body-parser');
-const path = require('path');
-
-/**
- * @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').
- */
-
-const ENCODINGS = { json: 'json', urlencoded: 'urlencoded' };
-const METHODS = { POST: 'post', GET: 'get' };
-
-const DEFAULT_OPTIONS = {
-    port: 80,
-    bind: '0.0.0.0',
-    publicPaths: ['./public'],
-    services: [],
-    listenCallback: undefined,
-    encoding: ENCODINGS.json
-};
-
-/**
- * To get started with RedWeb, simply initialize your RedWeb instance:
- * ```javascript
- * const app = new RedWeb();
- * ```
- * You can also configure it according to your needs:
- * ```javascript
- * const app = new RedWeb({
- *     port: 3000,
- *     publicPaths: [
- *         './pages/my_public_html',
- *         './content/my_public_images',
- *         './styles/styles.css'
- *     ],
- *     encoding: 'urlencoded'
- * });
- * ```
- * @param {RedWebOptions} options - Configuration options for RedWeb.
- * @return {RedWeb}
- */
-function RedWeb(options = {}) {
-    options = { ...DEFAULT_OPTIONS, ...options };
-    const app = express();
-    const { publicPaths, port, listenCallback, services, encoding } = options;
-
-    // Middleware to parse request bodies based on the specified encoding
-    if (encoding === ENCODINGS.json) {
-        app.use(bodyParser.json());
-    } else if (encoding === ENCODINGS.urlencoded) {
-        app.use(bodyParser.urlencoded({ extended: true }));
-    }
-
-    services.forEach(service => app[service.method](service.serviceName, service.function));
-    publicPaths.forEach(public_path => app.use(express.static(path.join(process.cwd(), public_path))));
-    app.listen(port, listenCallback ? listenCallback : () => console.log(`RedWeb listening on port ${port}`));
-    return app;
-}
-
-module.exports = { RedWeb, METHODS, DEFAULT_OPTIONS };
+const { HttpServer, HttpsServer, ENCODINGS, METHODS, HTTP_OPTIONS } = require('./HttpServer');
+const { SocketServer, SecureSocketServer, SOCKET_OPTIONS } = require('./SocketServer');
+
+module.exports = {
+    HttpServer,
+    HttpsServer,
+    SocketServer,
+    SecureSocketServer,
+    ENCODINGS,
+    METHODS,
+    HTTP_OPTIONS,
+    SOCKET_OPTIONS
+};

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "redweb",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "A way to quickly set up an express server",
   "main": "index.js",
   "scripts": {
     "test": "jest"
   },
+  "files": [
+    "index.js"
+  ],
   "keywords": [],
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "express": "^4.19.2"
+    "express": "^4.19.2",
+    "socket.io": "^4.7.5"
   },
   "devDependencies": {
     "@types/express": "^4.17.21",

package/index.test.js

@@ -1,15 +0,0 @@
-const { RedWeb } = require('.');
-const path = require('path');
-
-jest.mock('express', () => {
-    const self = () => ({
-        use: jest.fn(),
-        listen: jest.fn()
-    });
-    self.static = jest.fn();
-    return self;
-})
-
-test('it should create a RedWeb instance', () => {
-    expect(RedWeb()).toBeDefined();
-});