slower 1.1.19 → 1.1.21

package/LICENSE

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2024 Tomás Luchesi
+
+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/lib/router.js

@@ -1,7 +1,7 @@
 const http = require('http');
 const https = require('https');
 const fs = require('fs');
-const { clone, noop, slugify, isSparseEqual, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders } = require('./utils');
+const { clone, noop, slugify, isSparseEqual, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders, setResponseAssessors } = require('./utils');
 const mimetable = require('./mimetable.json');
 
 class Route {
@@ -43,7 +43,6 @@ class SlowerRouter {
         this.fallback = noop;
         this.allowedMethods = clone(SlowerRouter.http_methods);
         this.blockedMethodCallback = noop;
-        this.mime_table = SlowerRouter.mime_table;
         this.tls = { use: false, key: null, cert: null };
     }
 
@@ -281,8 +280,9 @@ class SlowerRouter {
      * app.setAllowedMethods(['GET', 'POST']);
     */
     setAllowedMethods = function (methods = []) {
+        this.allowedMethods = [];
         // If not specified, all methods are allowed
-        if (methods.length == 0 || methods  == '*') {
+        if (methods.length == 0 || methods == '*') {
             return this.allowedMethods = JSON.parse(JSON.stringify(SlowerRouter.http_methods));
         }
         for (let i = 0; i < methods.length; i++) {
@@ -297,6 +297,67 @@ class SlowerRouter {
         return this;
     }
 
+/*
+    Route Objects looks like:
+
+    { 
+        type: "route",
+        path: "/",
+        method: "GET",
+        handle: someFunction
+    }
+
+    {
+        type: "middleware",
+        handle: someFunction
+    }
+
+    {
+        type: "fallback",
+        handle: someFunction
+    }
+
+    {
+        type: "static",
+        path: "/style.css",
+        file: "./www/assets/style.css"
+    }
+
+    {
+        type: "dynamic",
+        path: "/client.html",
+        file: "./www/templates/client.html",
+        data: {
+            "CLIENTID": someRenderingFunction
+        }
+    }
+
+    {
+        type: "fallbackfile",
+        file: "./www/pages/404.html"
+        data: {
+            "CUSTOM_ERROR_MESSAGE": () => { return err.message },
+            "CUSTOM_ERROR_CODE": someErrorCodeFetchingFunction
+        }
+    }
+
+*/
+    // Converts a series of objectRoutes into actual internal routes
+    parse = function (routeObjectList) {
+        for (let entry of routeObjectList) {
+            const { type, path, method, file, data, handle } = entry;
+            switch (type) {
+                case 'route':           this.setRoute(path, method, handle);            break;
+                case 'middleware':      this.setMiddleware(handle);                     break;
+                case 'fallback':        this.setFallback(handle);                       break;
+                case 'static':          this.setStatic(path, file, undefined);          break;
+                case 'dynamic':         this.setDynamic(path, file, undefined, data);   break;
+                case 'fallbackfile':    this.setFallbackFile(file, undefined, data);    break;
+            }
+        }
+        return this;
+    }
+
     // Starts the server - listening at <host>:<port>
     /**
      * @category Router
@@ -325,15 +386,18 @@ class SlowerRouter {
             try {
                 // Sets local req.session object
                 setSocketLocals(req);
+                setResponseAssessors(res);
                 // Sets security headers in req.headers
                 // This is set before custom callbacks are applies
                 // so it is possible to override all of the headers
                 if (!!this.strictHeaders) setSocketSecurityHeaders(req); 
                 // Runs all middlewares
-                for (let i = 0; i < middle.length; i++) { middle[i](req, res); }
+                for (let i = 0; i < middle.length; i++) { 
+                    middle[i](req, res); 
+                    if (res.writableEnded) return; // if res.end() is caller early in a middleware
+                }
                 // Only respond to allowed methods with callbacks, else, use the default empty response.
-                if (
-                    allowedMethods.includes(req.method)) {
+                if (allowedMethods.includes(req.method)) {
                     for (let i = 0; i < routes.length; i++) {
                         let route = routes[i];
                         if (
@@ -345,12 +409,16 @@ class SlowerRouter {
                         ) {
                             i = routes.length;
                             route.callback(req, res);
+                            // if (res.writableEnded) return; // if res.end() was called
+                            // else res.end(); // if res.end() was not called
                             return;
                         }
                     }
                     fallback(req,res);
+                    if (!res.writableEnded) res.end(); 
                 } else {
                     blockedMethodCallback(req, res);
+                    if (!res.writableEnded) res.end();
                 }
             } catch(err) {
                 console.log(err);

package/lib/utils.js

@@ -69,21 +69,39 @@ const renderDynamicHTML = (html, patterns) => {
     return template;
 }
 
-const setSocketLocals = (socket) => {
-    socket.session = {};
-    socket.session.port = socket.socket.localPort;
-    socket.session.rport = socket.socket.remotePort;
-    socket.session.host = (
-        socket.socket.localAddress.startsWith('::') ? 
-        socket.socket.localAddress.substring(
-            socket.socket.localAddress.indexOf(':',2)+1
-        ) : socket.socket.localAddress);
-        socket.session.rhost = (
-        socket.socket.remoteAddress.startsWith('::') ? 
-        socket.socket.remoteAddress.substring(
-            socket.socket.remoteAddress.indexOf(':',2)+1
-        ) : socket.socket.remoteAddress);
-    return socket;
+const setSocketLocals = (reqSocket) => {
+    reqSocket.session = {};
+    reqSocket.session.port = reqSocket.socket.localPort;
+    reqSocket.session.rport = reqSocket.socket.remotePort;
+    reqSocket.session.host = (
+        reqSocket.socket.localAddress.startsWith('::') ? 
+        reqSocket.socket.localAddress.substring(
+            reqSocket.socket.localAddress.indexOf(':',2)+1
+        ) : reqSocket.socket.localAddress);
+        reqSocket.session.rhost = (
+        reqSocket.socket.remoteAddress.startsWith('::') ? 
+        reqSocket.socket.remoteAddress.substring(
+            reqSocket.socket.remoteAddress.indexOf(':',2)+1
+        ) : reqSocket.socket.remoteAddress);
+    return reqSocket;
+}
+
+const setResponseAssessors = (resSocket) => {
+    resSocket.sendText = (data, code = 200) => {
+        resSocket.writeHead(code, { 'Content-Type': 'text/plain' }); 
+        resSocket.write(data);
+        resSocket.end();
+    };
+    resSocket.sendJSON = (data, code = 200) => {
+        resSocket.writeHead(code, { 'Content-Type': 'application/json' }); 
+        resSocket.write(typeof data === 'string' ? data : JSON.stringify(data));
+        resSocket.end();
+    };
+    resSocket.sendHTML = (data, code = 200) => {
+        resSocket.writeHead(code, { 'Content-Type': 'text/html' }); 
+        resSocket.write(data);
+        resSocket.end();
+    };
 }
 
 const setSocketSecurityHeaders = (req) => {
@@ -143,4 +161,4 @@ const toBool = [() => true, () => false];
 
 const clone = (object) => JSON.parse(JSON.stringify(object));
 
-module.exports = { clone, noop, slugify, isSparseEqual, toBool, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders };
+module.exports = { clone, noop, slugify, isSparseEqual, toBool, last, renderDynamicHTML, setSocketLocals, setSocketSecurityHeaders, setResponseAssessors };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "slower",
-	"version": "1.1.19",
+	"version": "1.1.21",
 	"description": "A package for simple HTTP server routing.",
 	"main": "index.js",
 	"directories": {
@@ -10,6 +10,6 @@
 		"test": "echo \"Error: no test specified\" && exit 1"
 	},
 	"keywords": [],
-	"author": "no.mad.devtech@gmail.com",
-	"license": "ISC"
+	"author": "Tomás Luchesi <no.mad.devtech@gmail.com>",
+	"license": "MIT"
 }

package/readme.md

@@ -146,8 +146,7 @@ app.setDynamic('/download/{?}/', './main-download.txt', { DowloadName: generateD
 // Responds to download routes such as '/download/2/'
 
 app.setFallback((req, res) => {
-    res.writeHead(200, { 'Content-Type': 'text/html' }); 
-    res.write('<html><body><p>This is the fallback page.</p></body></html>');
+    res.sendHTML('<html><body><p>This is the fallback page.</p></body></html>', 404);
     res.end();
 });
 
@@ -170,7 +169,13 @@ a socket will receive the modified socket instead.
  <socket>.session.host: String      => The local host interface address
  <socket>.session.rhost: String     => The remote host interface address
 ```
-- It is possible to use the ```socket.session``` object to append data that will persist 
+ - Only on 'response' ```net.Socket```:
+ ```
+ <socket>.sendText: Function (data, code) => A helper for responding with plaintext data. No need to declare writeHead() or end() if using this.
+ <socket>.sendJSON: Function (data, code) => A helper for responding with JSON data. No need to declare writeHead() or end() if using this.
+
+```
+ - It is possible to use the ```socket.session``` object to append data that will persist 
 during the lifetime of a single connection. Useful for keeping short-life local variables.
 
 - In HTTP ```http.IncomingMessage``` instances, the 'socket' instance is found over 'request'.