slower 2.1.3 → 2.1.6

package/package.json

@@ -3,7 +3,7 @@
 		"path-to-regexp": "^6.2.2"
 	},
 	"name": "slower",
-	"version": "2.1.3",
+	"version": "2.1.6",
 	"main": "index.js",
 	"devDependencies": {},
 	"scripts": {

package/src/slower.js

@@ -2,6 +2,7 @@
 const http = require('node:http');
 const https = require('node:https');
 const path = require('node:path');
+const fs = require('node:fs');
 const { createReadStream } = require('node:fs');
 const { pipeline } = require('node:stream/promises');
 
@@ -33,20 +34,24 @@ class SlowerRouter {
         this.layers = new Map();
 
         // Create basic route shortcuts
-        // get(), post(), put(), delete()
-        // They can be used with either 1 or 2 params
+        // get(), post(), put(), delete(), ...
+        // They can be used with either 1 or more params
         /**
-         *  app.get({path}, {handler})  ->  apply handler for a specific route
+         *  app.get({path}, {handler})                  ->  apply handlers for a specific route
+         *  app.get({path}, {handler}, {handler}, ...)  ->  apply handlers for a specific route
          * or
-         *  app.get({handler})          ->  apply handler for any route for a specific method
+         *  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());
-            this[verb] = function (path, callback) {
+            this[verb] = function (path, ...callbacks) {
                 if (typeof path === 'function')
-                    return this.#setRoute(verb, MATCH_ANY, path);
-                return this.#setRoute(verb, path, callback);
+                    this.#setRoute(verb, MATCH_ANY, path);
+                for (let callback of callbacks)
+                    this.#setRoute(verb, path, callback);
+                return this;
             };
         }
 
@@ -67,8 +72,9 @@ class SlowerRouter {
             // Get all routes that match the URL and join with middlewares to cycle
             let foundRoutes = utils.getMatchingRoute(req.url, req.method, self.layers);
             let layers = foundRoutes;
-            // If there are no layers, add an Error:404 special layer (not found)
-            if (layers.length === 0) layers.push(utils.noLayersFoundFallback);
+            // Add an Error:404 special layer to the end of the layers list
+            // This prevents accidental requests hanging
+            layers.push(utils.noLayersFoundFallback);
 
             // Set properties on request and response objects
             req = await setupRequest(req);
@@ -109,7 +115,7 @@ class SlowerRouter {
      * Create a middleware for all HTTP methods, for a specific path
      * @overload
      * @param {String} path 
-     * @param {Function} handler 
+     * @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()})
@@ -119,7 +125,7 @@ class SlowerRouter {
      * @info This is the same as using "app[method]({callback})", without a path. Like: app.get(() => {});
      * @overload 
      * @param {string} verb (one of the HTTP verbs)
-     * @param {Function} handler 
+     * @param {...Function} handlers
      * @returns {SlowerRouter}
      * @example Applies a middleware for all GET requests
      *   app.all('get', (req, res, next) => {console.log(...); next()})
@@ -127,28 +133,39 @@ class SlowerRouter {
     /**
      * Create a global middleware (all paths and all HTTP methods)
      * @overload 
-     * @param {Function} handler 
+     * @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, handler) {
-        // function signature:      app.all({METHOD}, {HANDLER})
+    all (path, ...handlers) {
+
+        // function signature:      app.all({METHOD}, ...{HANDLERS})
         // example:     app.all('post', () => {});
         if (typeof path === 'string' && HTTP_VERBS.includes(path.toLowerCase()))
-            this.#setRoute(path, MATCH_ANY, handler);
+            for (let handler of handlers)
+                this.#setRoute(path, MATCH_ANY, handler);
+    
 
-        // function signature:      app.all({PATH}, {HANDLER})
+        // function signature:      app.all({PATH}, ...{HANDLERS})
         // example:     app.all('/api', () => {});
         else if (typeof path === 'string')
-            for (let verb of HTTP_VERBS) this.#setRoute(verb, path, handler);
-        
-        // function signature:      app.all({HANDLER})
+            for (let handler of handlers)
+                for (let verb of HTTP_VERBS) 
+                    this.#setRoute(verb, path, handler);
+
+        // function signature:      app.all(...{HANDLERS})
         // example:     app.all(() => {}); 
         else if (typeof path === 'function')
-            for (let verb of HTTP_VERBS) this.#setRoute(verb, MATCH_ANY, path);
+            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');
+
         return this;
     }
     // Just a more comprehensive call to app.all for defining middlewares
@@ -171,6 +188,9 @@ class SlowerRouter {
      */
     static (directoryPath, mountPath = '') {
         const absoluteDir = path.resolve(directoryPath);
+        if (!fs.existsSync(absoluteDir))
+            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];
@@ -238,21 +258,47 @@ class SlowerRouter {
 
 
 /**
- * Used as the class for micro-routing with "app.route"
- * 
- * only method acessors (.get(), .post(), .put(), ...)
- * and .all() and .use()
- * 
- * .static() is not allowed
+ * Used as the class for modular routers
+ * used in "slower.Router()"
  */
-class SlowerMicroRouter {
-    constructor (path, layerPool) {
-        this.path = path;
-        this.layers = layerPool;
+class SlowerSubRouter {
+    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(), ...
+        // They can be used with either 1 or more params
+        /**
+         *  app.get({path}, {handler})                  ->  apply handlers for a specific route
+         *  app.get({path}, {handler}, {handler}, ...)  ->  apply handlers for a specific route
+         * 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) {
+                if (typeof path === 'function')
+                    this.#setRoute(verb, MATCH_ANY, path);
+                for (let callback of callbacks)
+                    this.#setRoute(verb, path, callback);
+                return this;
+            };
+        }
     }
 
-    #setRoute (method, handler) {
-        const path = this.path;
+    #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')
@@ -263,66 +309,188 @@ class SlowerMicroRouter {
         return this;
     }
 
-    all (handler) {
-        const path = this.path;
-        if (typeof path === 'string')
-            for (let verb of HTTP_VERBS) this.#setRoute(verb, path, handler);
-        else if (typeof path !== 'function')
-            throw new Error('<SlowerSubRouter>.use :: "handler" parameter must be of type Function');
-        else for (let verb of HTTP_VERBS) this.#setRoute(verb, '/(.{0,})', path);
+    // Add middleware
+    /**
+     * Create a middleware for all HTTP methods, for a specific path
+     * @overload
+     * @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()})
+     */
+    /**
+     * 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 
+     * @param {string} verb (one of the HTTP verbs)
+     * @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
+     * @returns {SlowerRouter}
+     * @example Applies a middleware for all HTTP requests (of any method)
+     *   app.all((req, res, next) => {console.log(...); next()})
+     */
+    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) 
+                    this.#setRoute(verb, path, handler);
+
+        // function signature:      app.all(...{HANDLERS})
+        // 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');
+
         return this;
     }
     // Just a more comprehensive call to app.all for defining middlewares
     use (...b) { this.all(...b); return this; };
+
+    static (directoryPath, mountPath = '') {
+        this.layers.push({ static: true, directoryPath, mountPath });
+        return this;
+    }
+
+    /**
+     * Creates a temporary synced mini-router for a specific path
+     * Allows to declare multiple handlers for methods of a specific path
+     * @param {string} path 
+     * @returns {SlowerMicroRouter}
+     * @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) {
+        return new SlowerMicroRouter(path, this.layers);
+    }
 }
 
 
+
 /**
- * Used as the class for modular routers
- * used in "slower.Router()"
+ * 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 SlowerSubRouter {
-    constructor () {
-        this.METHODS = HTTP_VERBS;
-        this.layers = new Array();
+class SlowerMicroRouter {
+    constructor (path, layerPool) {
+        this.path = path;
+        this.layers = layerPool;
 
         // 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);
+            this[verb] = function (...callbacks) {
+                for (let callback of callbacks)
+                    this.#setRoute(verb, callback);
             };
         }
     }
 
-    #setRoute (method, path, handler) {
+    #setRoute (method, handler) {
+        const path = this.path;
         if (typeof method !== 'string') 
-            throw new Error('<SlowerSubRouter>.route :: "method" parameter must be of type String');
+            throw new Error('<SlowerMicroRouter>.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('<SlowerMicroRouter>.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('<SlowerMicroRouter>.route :: "handler" parameter must be of type Function');
         this.layers.push({ method, path, handler });
         return this;
     }
 
-    all (path, handler) {
-        if (typeof path === 'string')
-            for (let verb of HTTP_VERBS) this.#setRoute(verb, path, handler);
-        else if (typeof path !== 'function')
-            throw new Error('<SlowerSubRouter>.use :: "handler" parameter must be of type Function');
-        else for (let verb of HTTP_VERBS) this.#setRoute(verb, '/(.{0,})', path);
+    // Add middleware
+    /**
+     * Create a middleware for all HTTP methods, for a specific path
+     * @overload
+     * @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()})
+     */
+    /**
+     * 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 
+     * @param {string} verb (one of the HTTP verbs)
+     * @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 
+     * @returns {SlowerRouter}
+     * @example Applies a middleware for all HTTP requests (of any method)
+     *   app.all((req, res, next) => {console.log(...); next()})
+     */
+    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) 
+                    this.#setRoute(verb, path, handler);
+
+        // function signature:      app.all(...{HANDLERS})
+        // 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');
+        
         return this;
     }
     // Just a more comprehensive call to app.all for defining middlewares
     use (...b) { this.all(...b); return this; };
-
-    static (directoryPath, mountPath = '') {
-        this.layers.push({ static: true, directoryPath, mountPath });
-        return this;
-    }
 }
 
+
 // Create basic main routing creation
 function slower (options) {
     return new SlowerRouter(options);