slower 2.1.8 → 2.2.0

package/src/slower.js

@@ -1,4 +1,3 @@
-
 const http = require('node:http');
 const https = require('node:https');
 const path = require('node:path');
@@ -6,8 +5,6 @@ const fs = require('node:fs');
 const { createReadStream } = require('node:fs');
 const { pipeline } = require('node:stream/promises');
 
-const { match } = require('path-to-regexp');
-
 const { setupRequest, setupResponse } = require('./decorators');
 const utils = require('./utils');
 
@@ -20,16 +17,16 @@ class SlowerRouter {
 
     // You can create it with HTTPS options here
     /**
-     * Use HTTPS server instead of HTTP. 
+     * Use HTTPS server instead of HTTP.
      * Pass in all regular HTTPS options as parameters.
      * 'key' and 'cert' options are required for HTTPS.
-     * @param {object} options 
+     * @param {object} options
      * @returns {http.Server|https.Server}
      * @example
      *  SlowerRouter({https:true, key:'...', cert:'...'}); // Create HTTPS server
      *  SlowerRouter(); // Create regular HTTP
      */
-    constructor (options = {}) {
+    constructor(options = {}) {
         this.METHODS = HTTP_VERBS;
         this.layers = new Map();
 
@@ -42,7 +39,7 @@ class SlowerRouter {
          * or
          *  app.get({handler})                          ->  apply handlers for any route for a specific method
          *  app.get({handler}, {handler}, ...)          ->  apply handlers for any route for a specific method
-         * 
+         *
          */
         for (let verb of HTTP_VERBS) {
             this.layers.set(verb, new Map());
@@ -55,22 +52,24 @@ class SlowerRouter {
             };
         }
 
-        if (options.https) 
-            this.#server = https.createServer(options);
-        else
-            this.#server = http.createServer(options);
+        if (options.https) this.#server = https.createServer(options);
+        else this.#server = http.createServer(options);
 
         this.#server.on('request', this.#requestHandlerWrapper(this));
     }
-    
-    #requestHandlerWrapper () {
+
+    #requestHandlerWrapper() {
         // Save the 'this' scope
         // Inside the requestHandler function, 'this' corresponds to the http.Server instance
         const self = this;
 
-        return (async function requestHandler (req, res) {
+        return async function requestHandler(req, res) {
             // Get all routes that match the URL and join with middlewares to cycle
-            let foundRoutes = utils.getMatchingRoute(req.url, req.method, self.layers);
+            let foundRoutes = utils.getMatchingRoute(
+                req.url,
+                req.method,
+                self.layers
+            );
             let layers = foundRoutes;
             // Add an Error:404 special layer to the end of the layers list
             // This prevents accidental requests hanging
@@ -78,34 +77,47 @@ class SlowerRouter {
 
             // Set properties on request and response objects
             req = await setupRequest(req);
-            res = await setupResponse(res);
+            res = await setupResponse(res, req);
 
             // Cycle throught all middlewares and proper routes and call with 'next()' as third argument
-            ;(async function cycleMatching (routes) {
+            (async function cycleMatching(routes) {
                 if (routes.length === 0) return;
                 let route = routes[0];
                 if (route.params) req.params = route.params;
                 if (route.callback) route = route.callback;
                 route(req, res, async () => cycleMatching(routes.slice(1)));
             })(layers);
-        });
+        };
     }
 
-    listen (...v) { return this.#server.listen(...v); }
-    close (callback) { return this.#server.close(callback); }
+    listen(...v) {
+        return this.#server.listen(...v);
+    }
+    close(callback) {
+        return this.#server.close(callback);
+    }
 
     // Add any type of route
-    #setRoute (method, path, handler) {
-        if (typeof method !== 'string') 
-            throw new Error('<SlowerRouter>.route :: "method" parameter must be of type String');
-        if (typeof path !== 'string' && typeof path !== 'function' && path?.constructor?.name !== 'RegExp')
-            throw new Error('<SlowerRouter>.route :: "path" parameter must be of type Function, String or RegExp');
+    #setRoute(method, path, handler) {
+        if (typeof method !== 'string')
+            throw new Error(
+                '<SlowerRouter>.route :: "method" parameter must be of type String'
+            );
+        if (
+            typeof path !== 'string' &&
+            typeof path !== 'function' &&
+            path?.constructor?.name !== 'RegExp'
+        )
+            throw new Error(
+                '<SlowerRouter>.route :: "path" parameter must be of type Function, String or RegExp'
+            );
         if (typeof handler !== 'function')
-            throw new Error('<SlowerRouter>.route :: "handler" parameter must be of type Function');
-        if (!this.layers.get(method))
-            this.layers.set(method, new Map());
-        if (typeof path === 'string' || path?.constructor?.name !== 'RegExp') 
-            path = match(path, { decode: decodeURIComponent }); // 'path' is a function now
+            throw new Error(
+                '<SlowerRouter>.route :: "handler" parameter must be of type Function'
+            );
+        if (!this.layers.get(method)) this.layers.set(method, new Map());
+        if (typeof path === 'string' || path?.constructor?.name !== 'RegExp')
+            path = utils.buildURLPatternFunction(path); // 'path' is a function now
         this.layers.get(method).set(path, handler);
         return this;
     }
@@ -114,7 +126,7 @@ class SlowerRouter {
     /**
      * Create a middleware for all HTTP methods, for a specific path
      * @overload
-     * @param {String} path 
+     * @param {String} path
      * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all methods, for a specific path
@@ -123,7 +135,7 @@ class SlowerRouter {
     /**
      * Create a global middleware for a specific verb (all paths for that method)
      * @info This is the same as using "app[method]({callback})", without a path. Like: app.get(() => {});
-     * @overload 
+     * @overload
      * @param {string} verb (one of the HTTP verbs)
      * @param {...Function} handlers
      * @returns {SlowerRouter}
@@ -132,44 +144,44 @@ class SlowerRouter {
      */
     /**
      * Create a global middleware (all paths and all HTTP methods)
-     * @overload 
-     * @param {...Function} handlers 
+     * @overload
+     * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all HTTP requests (of any method)
      *   app.all((req, res, next) => {console.log(...); next()})
      */
-    all (path, ...handlers) {
-
+    all(path, ...handlers) {
         // function signature:      app.all({METHOD}, ...{HANDLERS})
         // example:     app.all('post', () => {});
         if (typeof path === 'string' && HTTP_VERBS.includes(path.toLowerCase()))
             for (let handler of handlers)
                 this.#setRoute(path, MATCH_ANY, handler);
-    
-
         // function signature:      app.all({PATH}, ...{HANDLERS})
         // example:     app.all('/api', () => {});
         else if (typeof path === 'string')
             for (let handler of handlers)
-                for (let verb of HTTP_VERBS) 
+                for (let verb of HTTP_VERBS)
                     this.#setRoute(verb, path, handler);
-
         // function signature:      app.all(...{HANDLERS})
-        // example:     app.all(() => {}); 
+        // example:     app.all(() => {});
         else if (typeof path === 'function')
             for (let verb of HTTP_VERBS) {
                 this.#setRoute(verb, MATCH_ANY, path);
                 for (let handler of handlers)
                     this.#setRoute(verb, MATCH_ANY, handler);
             }
-
-        
-        else throw new Error('<SlowerRouter>.use :: "handler" parameter must be of type Function');
+        else
+            throw new Error(
+                '<SlowerRouter>.use :: "handler" parameter must be of type Function'
+            );
 
         return this;
     }
     // Just a more comprehensive call to app.all for defining middlewares
-    use (...b) { this.all(...b); return this; };
+    use(...b) {
+        this.all(...b);
+        return this;
+    }
 
     /**
      * Serve static files from a directory
@@ -179,33 +191,46 @@ class SlowerRouter {
      * @example
      * // Using a mounting poing:
      *  app.static('./public', '/files') // Access with 'GET /files/{filename}'
-     * 
+     *
      * // Not using a mounting point:
      *  app.static('./public') // Access with 'GET /public/{filename}'
-     * 
+     *
      * // Using root ('/') as mounting point:
      *  app.static('./public', '/') // Access with 'GET /{filename}'
      */
-    static (directoryPath, mountPath = '') {
+    static(directoryPath, mountPath = '') {
         const absoluteDir = path.resolve(directoryPath);
         if (!fs.existsSync(absoluteDir))
-            throw new Error(`Invalid directory provided for [SlowerRouter].static(): [${directoryPath}]`);
+            throw new Error(
+                `Invalid directory provided for [SlowerRouter].static(): [${directoryPath}]`
+            );
 
         for (const file of utils.getFiles(absoluteDir)) {
             // Get only the file name from the absolute file path 'c:\u\a.txt' -> 'a.txt'
-            let fileAsURLPath = file.replaceAll(/\\/g, '/').split('/').slice(-1)[0];
+            let fileAsURLPath = file
+                .replaceAll(/\\/g, '/')
+                .split('/')
+                .slice(-1)[0];
             // If there is a mount path, merge it with the file and remove duplicate bars '//'
-            if (!mountPath) mountPath = directoryPath.replaceAll(/\\/g, '/').split('/').slice(-1)[0];
-                fileAsURLPath = ('/' + mountPath + '/' + fileAsURLPath).replaceAll(/\/+/g,'/');
-
-
-            async function staticfhandle (req, res, next) {
+            if (!mountPath)
+                mountPath = directoryPath
+                    .replaceAll(/\\/g, '/')
+                    .split('/')
+                    .slice(-1)[0];
+            fileAsURLPath = ('/' + mountPath + '/' + fileAsURLPath).replaceAll(
+                /\/+/g,
+                '/'
+            );
+
+            async function staticfhandle(req, res /*next*/) {
                 try {
                     const fileStream = createReadStream(file);
-                    res.setHeader('Content-Type', MIME_TABLE[extension] || MIME_TABLE['default']);
+                    res.setHeader(
+                        'Content-Type',
+                        MIME_TABLE[extension] || MIME_TABLE['default']
+                    );
                     return await pipeline(fileStream, res);
-
-                } catch (err) {
+                } catch {
                     // In case the file does not exist, return a 404 and prevent it from breaking
                     res.status(404).end();
                 }
@@ -216,7 +241,7 @@ class SlowerRouter {
             // If the file is an html file, also add a path for using it without the '.html' extension
             // both 'GET /files/somefile.html' and 'GET /files/somefile' would work
             const extension = utils.getFileExtension(file);
-            if (extension === 'html') 
+            if (extension === 'html')
                 this.get(fileAsURLPath.replace('.html', ''), staticfhandle);
         }
         return this;
@@ -225,13 +250,14 @@ class SlowerRouter {
     /**
      * Import and use another SlowerRouter, mounted at a specific path
      * @param {string} mountPath Mount the router at a specific path
-     * @param {SlowerRouter} SlowerRouterInstance 
+     * @param {SlowerRouter} SlowerRouterInstance
      */
-    useRouter (SlowerSubRouterInstance, mountPath = '/') {
-        const mount = p => mountPath ? (mountPath + '/' + p).replace(/\/{2,}/g, '/') : p;
+    useRouter(SlowerSubRouterInstance, mountPath = '/') {
+        const mount = p =>
+            mountPath ? (mountPath + '/' + p).replace(/\/{2,}/g, '/') : p;
         const layers = SlowerSubRouterInstance.layers;
         for (let layer of layers) {
-            if (!!layer.static) {
+            if (layer.static) {
                 this.static(layer.directoryPath, mount(layer.mountPath));
                 continue;
             }
@@ -243,38 +269,36 @@ class SlowerRouter {
     /**
      * Creates a temporary synced mini-router for a specific path
      * Allows to declare multiple handlers for methods of a specific path
-     * @param {string} path 
+     * @param {string} path
      * @returns {SlowerMicroRouter}
-     * @example 
+     * @example
      *  app.route('/books')
      *      .get((req, res) => console.log('you retrieved a book with GET'))
      *      .post((req, res) => console.log('you added a book with POST'))
      *  ;
      */
-    route (path) {
+    route(path) {
         return new SlowerMicroRouter(path, this.layers);
     }
 }
 
-
 /**
  * Used as the class for modular routers
  * used in "slower.Router()"
  */
 class SlowerSubRouter {
-    constructor () {
+    constructor() {
         this.METHODS = HTTP_VERBS;
         this.layers = new Array();
 
         // OLD version: (Do not delete until new version is properly tested)
-            // Create basic route shortcuts
-            // get(), post(), put(), delete()
-            // for (let verb of HTTP_VERBS) {
-            //     this[verb] = function (path, callback) {
-            //         return this.#setRoute(verb, path, callback);
-            //     };
-            // }
-
+        // Create basic route shortcuts
+        // get(), post(), put(), delete()
+        // for (let verb of HTTP_VERBS) {
+        //     this[verb] = function (path, callback) {
+        //         return this.#setRoute(verb, path, callback);
+        //     };
+        // }
 
         // Create basic route shortcuts
         // get(), post(), put(), delete(), ...
@@ -285,7 +309,7 @@ class SlowerSubRouter {
          * or
          *  app.get({handler})                          ->  apply handlers for any route for a specific method
          *  app.get({handler}, {handler}, ...)          ->  apply handlers for any route for a specific method
-         * 
+         *
          */
         for (let verb of HTTP_VERBS) {
             this[verb] = function (path, ...callbacks) {
@@ -298,13 +322,19 @@ class SlowerSubRouter {
         }
     }
 
-    #setRoute (method, path, handler) {
-        if (typeof method !== 'string') 
-            throw new Error('<SlowerSubRouter>.route :: "method" parameter must be of type String');
+    #setRoute(method, path, handler) {
+        if (typeof method !== 'string')
+            throw new Error(
+                '<SlowerSubRouter>.route :: "method" parameter must be of type String'
+            );
         if (typeof path !== 'string' && path?.constructor?.name !== 'RegExp')
-            throw new Error('<SlowerSubRouter>.route :: "path" parameter must be of type Function, String or RegExp');
+            throw new Error(
+                '<SlowerSubRouter>.route :: "path" parameter must be of type Function, String or RegExp'
+            );
         if (typeof handler !== 'function')
-            throw new Error('<SlowerSubRouter>.route :: "handler" parameter must be of type Function');
+            throw new Error(
+                '<SlowerSubRouter>.route :: "handler" parameter must be of type Function'
+            );
         this.layers.push({ method, path, handler });
         return this;
     }
@@ -313,8 +343,8 @@ class SlowerSubRouter {
     /**
      * Create a middleware for all HTTP methods, for a specific path
      * @overload
-     * @param {String} path 
-     * @param {...Function} handlers 
+     * @param {String} path
+     * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all methods, for a specific path
      *   app.all('/img/:id', (req, res, next) => {console.log(...); next()})
@@ -322,7 +352,7 @@ class SlowerSubRouter {
     /**
      * Create a global middleware for a specific verb (all paths for that method)
      * @info This is the same as using "app[method]({callback})", without a path. Like: app.get(() => {});
-     * @overload 
+     * @overload
      * @param {string} verb (one of the HTTP verbs)
      * @param {...Function} handlers
      * @returns {SlowerRouter}
@@ -331,46 +361,46 @@ class SlowerSubRouter {
      */
     /**
      * Create a global middleware (all paths and all HTTP methods)
-     * @overload 
+     * @overload
      * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all HTTP requests (of any method)
      *   app.all((req, res, next) => {console.log(...); next()})
      */
-    all (path, ...handlers) {
-
+    all(path, ...handlers) {
         // function signature:      app.all({METHOD}, ...{HANDLERS})
         // example:     app.all('post', () => {});
         if (typeof path === 'string' && HTTP_VERBS.includes(path.toLowerCase()))
             for (let handler of handlers)
                 this.#setRoute(path, MATCH_ANY, handler);
-    
-
         // function signature:      app.all({PATH}, ...{HANDLERS})
         // example:     app.all('/api', () => {});
         else if (typeof path === 'string')
             for (let handler of handlers)
-                for (let verb of HTTP_VERBS) 
+                for (let verb of HTTP_VERBS)
                     this.#setRoute(verb, path, handler);
-
         // function signature:      app.all(...{HANDLERS})
-        // example:     app.all(() => {}); 
+        // example:     app.all(() => {});
         else if (typeof path === 'function')
             for (let verb of HTTP_VERBS) {
                 this.#setRoute(verb, MATCH_ANY, path);
                 for (let handler of handlers)
                     this.#setRoute(verb, MATCH_ANY, handler);
             }
-
-        
-        else throw new Error('<SlowerSubRouter>.use :: "handler" parameter must be of type Function');
+        else
+            throw new Error(
+                '<SlowerSubRouter>.use :: "handler" parameter must be of type Function'
+            );
 
         return this;
     }
     // Just a more comprehensive call to app.all for defining middlewares
-    use (...b) { this.all(...b); return this; };
+    use(...b) {
+        this.all(...b);
+        return this;
+    }
 
-    static (directoryPath, mountPath = '') {
+    static(directoryPath, mountPath = '') {
         this.layers.push({ static: true, directoryPath, mountPath });
         return this;
     }
@@ -378,31 +408,29 @@ class SlowerSubRouter {
     /**
      * Creates a temporary synced mini-router for a specific path
      * Allows to declare multiple handlers for methods of a specific path
-     * @param {string} path 
+     * @param {string} path
      * @returns {SlowerMicroRouter}
-     * @example 
+     * @example
      *  app.route('/books')
      *      .get((req, res) => console.log('you retrieved a book with GET'))
      *      .post((req, res) => console.log('you added a book with POST'))
      *  ;
      */
-    route (path) {
+    route(path) {
         return new SlowerMicroRouter(path, this.layers);
     }
 }
 
-
-
 /**
  * Used as the class for micro-routing with "app.route"
- * 
+ *
  * only method acessors (.get(), .post(), .put(), ...)
  * and .all() and .use()
- * 
+ *
  * .static() is not allowed
  */
 class SlowerMicroRouter {
-    constructor (path, layerPool) {
+    constructor(path, layerPool) {
         this.path = path;
         this.layers = layerPool;
 
@@ -410,21 +438,26 @@ class SlowerMicroRouter {
         // get(), post(), put(), delete()
         for (let verb of HTTP_VERBS) {
             this[verb] = function (...callbacks) {
-                for (let callback of callbacks)
-                    this.#setRoute(verb, callback);
-		return this;
+                for (let callback of callbacks) this.#setRoute(verb, callback);
+                return this;
             };
         }
     }
 
-    #setRoute (method, handler) {
+    #setRoute(method, handler) {
         const path = this.path;
-        if (typeof method !== 'string') 
-            throw new Error('<SlowerMicroRouter>.route :: "method" parameter must be of type String');
+        if (typeof method !== 'string')
+            throw new Error(
+                '<SlowerMicroRouter>.route :: "method" parameter must be of type String'
+            );
         if (typeof path !== 'string' && path?.constructor?.name !== 'RegExp')
-            throw new Error('<SlowerMicroRouter>.route :: "path" parameter must be of type Function, String or RegExp');
+            throw new Error(
+                '<SlowerMicroRouter>.route :: "path" parameter must be of type Function, String or RegExp'
+            );
         if (typeof handler !== 'function')
-            throw new Error('<SlowerMicroRouter>.route :: "handler" parameter must be of type Function');
+            throw new Error(
+                '<SlowerMicroRouter>.route :: "handler" parameter must be of type Function'
+            );
         this.layers.push({ method, path, handler });
         return this;
     }
@@ -433,8 +466,8 @@ class SlowerMicroRouter {
     /**
      * Create a middleware for all HTTP methods, for a specific path
      * @overload
-     * @param {String} path 
-     * @param {...Function} handlers 
+     * @param {String} path
+     * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all methods, for a specific path
      *   app.all('/img/:id', (req, res, next) => {console.log(...); next()})
@@ -442,63 +475,63 @@ class SlowerMicroRouter {
     /**
      * Create a global middleware for a specific verb (all paths for that method)
      * @info This is the same as using "app[method]({callback})", without a path. Like: app.get(() => {});
-     * @overload 
+     * @overload
      * @param {string} verb (one of the HTTP verbs)
-     * @param {...Function} handlers 
+     * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all GET requests
      *   app.all('get', (req, res, next) => {console.log(...); next()})
      */
     /**
      * Create a global middleware (all paths and all HTTP methods)
-     * @overload 
-     * @param {...Function} handlers 
+     * @overload
+     * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all HTTP requests (of any method)
      *   app.all((req, res, next) => {console.log(...); next()})
      */
-    all (path, ...handlers) {
-        
+    all(path, ...handlers) {
         // function signature:      app.all({METHOD}, ...{HANDLERS})
         // example:     app.all('post', () => {});
         if (typeof path === 'string' && HTTP_VERBS.includes(path.toLowerCase()))
             for (let handler of handlers)
                 this.#setRoute(path, MATCH_ANY, handler);
-    
-
         // function signature:      app.all({PATH}, ...{HANDLERS})
         // example:     app.all('/api', () => {});
         else if (typeof path === 'string')
             for (let handler of handlers)
-                for (let verb of HTTP_VERBS) 
+                for (let verb of HTTP_VERBS)
                     this.#setRoute(verb, path, handler);
-
         // function signature:      app.all(...{HANDLERS})
-        // example:     app.all(() => {}); 
+        // example:     app.all(() => {});
         else if (typeof path === 'function')
             for (let verb of HTTP_VERBS) {
                 this.#setRoute(verb, MATCH_ANY, path);
                 for (let handler of handlers)
                     this.#setRoute(verb, MATCH_ANY, handler);
             }
+        else
+            throw new Error(
+                '<SlowerMicroRouter>.use :: "handler" parameter must be of type Function'
+            );
 
-        
-        else throw new Error('<SlowerMicroRouter>.use :: "handler" parameter must be of type Function');
-        
         return this;
     }
     // Just a more comprehensive call to app.all for defining middlewares
-    use (...b) { this.all(...b); return this; };
+    use(...b) {
+        this.all(...b);
+        return this;
+    }
 }
 
-
 // Create basic main routing creation
-function slower (options) {
+function slower(options) {
     return new SlowerRouter(options);
 }
+
 // Add the subrouter class
 slower.Router = function () {
     return new SlowerSubRouter();
-}
+};
 
 module.exports = slower;