slower 2.1.8 → 2.1.9

package/package.json

@@ -1,16 +1,16 @@
 {
-	"dependencies": {
-		"path-to-regexp": "^6.2.2"
-	},
-	"name": "slower",
-	"version": "2.1.8",
-	"main": "index.js",
-	"devDependencies": {},
-	"scripts": {
-		"test": "echo \"Error: no test specified\" && exit 1"
-	},
-	"keywords": [],
-	"author": "Tomás Luchesi <no.mad.devtech@gmail.com>",
-	"license": "MIT",
-	"description": "A package for simple HTTP server routing."
-}
+    "name": "slower",
+    "version": "2.1.9",
+    "main": "index.js",
+    "devDependencies": {},
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "dependencies": {
+        "path-to-regexp": "^6.2.2"
+    },
+    "keywords": [],
+    "author": "Tomás Luchesi <no.mad.devtech@gmail.com>",
+    "license": "MIT",
+    "description": "A package for simple HTTP server routing."
+}

package/src/decorators.js

@@ -11,7 +11,7 @@ const utils = require('./utils');
  * @exposes .json()
  * @exposes .file()
  */
-function setupResponse(response) {
+function setupResponse(response, request) {
     /**
      * Sets the response status code
      * @chainable
@@ -67,11 +67,7 @@ function setupResponse(response) {
      * @info And if no type is specified, binary type is used (application/octet-stream)
      */
     response.type = function (mime) {
-        let mimetype =
-            MIME_TABLE[mime] ||
-            mime ||
-            MIME_TABLE[extension] ||
-            MIME_TABLE['default'];
+        let mimetype = MIME_TABLE[mime] || mime || MIME_TABLE['default'];
         response.setHeader('Content-type', mimetype);
         return response;
     };
@@ -193,7 +189,7 @@ function setupRequest(request) {
      * @property
      * Holds the request body data as a buffer
      */
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
         // Set classical socket locals
         request.session = {
             port: request.socket.localPort,

package/src/slower.js

@@ -1,4 +1,3 @@
-
 const http = require('node:http');
 const https = require('node:https');
 const path = require('node:path');
@@ -20,16 +19,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 +41,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 +54,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,33 +79,46 @@ 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') 
+            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
         this.layers.get(method).set(path, handler);
         return this;
@@ -114,7 +128,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 +137,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 +146,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 +193,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 +243,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 +252,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 +271,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 +311,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 +324,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 +345,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 +354,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 +363,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 +410,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 +440,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 +468,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 +477,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;

package/src/utils.js

@@ -1,17 +1,15 @@
-
-const { statSync, readdirSync } = require('node:fs')
+const { statSync, readdirSync } = require('node:fs');
 const { join } = require('node:path');
 const { parse } = require('node:querystring');
 
 function* getFiles(folder) {
     const files = readdirSync(folder);
     for (const file of files) {
-        const absolutePath = join(folder, file)
+        const absolutePath = join(folder, file);
         if (statSync(absolutePath).isDirectory()) {
-            yield* getFiles(absolutePath)
-        }
-        else {
-            yield absolutePath.replaceAll('..\\','')
+            yield* getFiles(absolutePath);
+        } else {
+            yield absolutePath.replaceAll('..\\', '');
         }
     }
 }
@@ -22,44 +20,48 @@ const getMatchingRoute = (url, method, layers) => {
     // Get only the layers from the proper HTTP verb
     let routes = layers.get(method) || new Map();
     // Iterate through all routes, and get the one that match
-    for (let [ pathFn, callback ] of routes) {
+    for (let [pathFn, callback] of routes) {
         let params = pathFn(getURLPathBody(url));
         // Return the matching route
-        if (!!params) {
+        if (params) {
             // add to list
-            let built = ({ callback });
+            let built = { callback };
             if (params.params && params.params['0'] === undefined)
                 built['params'] = params.params;
             list.push(built);
         }
     }
     return list;
-}
+};
 
-const normalizeAddress = addr => addr.startsWith('::') ? addr : addr.substring(addr.indexOf(':',2)+1);
+const normalizeAddress = addr =>
+    addr.startsWith('::') ? addr : addr.substring(addr.indexOf(':', 2) + 1);
 
-const getFileExtension = (fname) => fname.split('.').filter(Boolean).slice(-1)[0];
+const getFileExtension = fname => fname.split('.').filter(Boolean).slice(-1)[0];
 
 // /page?foo=bar&abc=123    ->  /page
 const getURLPathBody = (urlPath = '') => urlPath.split('?')[0] || '';
 
 // /page?foo=bar&abc=123    ->  { foo: 'bar', abc: '123' }
-const getURLQueryString = (urlPath = '') => parse((urlPath.split('?')[1] || '').split('#')[0]);
-
-const noLayersFoundFallback = (req, res) => 
-    res.status(404).send(
-        `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">` + 
-        `<title>Error</title></head><body>` + 
-        `<pre>Cannot ${req.method.toUpperCase()} ${req.url}</pre></body></html>`
-    )
-;
+const getURLQueryString = (urlPath = '') =>
+    parse((urlPath.split('?')[1] || '').split('#')[0]);
 
-module.exports = { 
-    getMatchingRoute, 
-    getFiles, 
-    normalizeAddress, 
-    getFileExtension, 
-    getURLPathBody, 
+const noLayersFoundFallback = (req, res) =>
+    res
+        .status(404)
+        .send(
+            `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">` +
+                `<title>Error</title></head><body>` +
+                `<pre>Cannot ${req.method.toUpperCase()} ${
+                    req.url
+                }</pre></body></html>`
+        );
+module.exports = {
+    getMatchingRoute,
+    getFiles,
+    normalizeAddress,
+    getFileExtension,
+    getURLPathBody,
     getURLQueryString,
-    noLayersFoundFallback
-};
+    noLayersFoundFallback,
+};