slower 2.1.0 → 2.1.2

package/package.json

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

package/src/slower.js

@@ -12,6 +12,7 @@ const utils = require('./utils');
 
 const MIME_TABLE = require('./mimetable.json');
 const HTTP_VERBS = http.METHODS.map(v => v.toLowerCase());
+const MATCH_ANY = '/(.{0,})';
 
 class SlowerRouter {
     #server;
@@ -33,9 +34,18 @@ class SlowerRouter {
 
         // Create basic route shortcuts
         // get(), post(), put(), delete()
+        // They can be used with either 1 or 2 params
+        /**
+         *  app.get({path}, {handler})  ->  apply handler for a specific route
+         * or
+         *  app.get({handler})          ->  apply handler for any route for a specific method
+         * 
+         */
         for (let verb of HTTP_VERBS) {
             this.layers.set(verb, new Map());
             this[verb] = function (path, callback) {
+                if (typeof path === 'function')
+                    return this.#setRoute(verb, MATCH_ANY, path);
                 return this.#setRoute(verb, path, callback);
             };
         }
@@ -57,6 +67,8 @@ 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);
 
             // Set properties on request and response objects
             req = await setupRequest(req);
@@ -99,20 +111,44 @@ class SlowerRouter {
      * @param {String} path 
      * @param {Function} handler 
      * @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} handler 
+     * @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} handler 
      * @returns {SlowerRouter}
+     * @example Applies a middleware for all HTTP requests (of any method)
+     *   app.all((req, res, next) => {console.log(...); next()})
      */
     all (path, handler) {
-        if (typeof path === 'string')
+        // function signature:      app.all({METHOD}, {HANDLER})
+        // example:     app.all('post', () => {});
+        if (typeof path === 'string' && HTTP_VERBS.includes(path.toLowerCase()))
+            this.#setRoute(path, MATCH_ANY, handler);
+
+        // function signature:      app.all({PATH}, {HANDLER})
+        // example:     app.all('/api', () => {});
+        else if (typeof path === 'string')
             for (let verb of HTTP_VERBS) this.#setRoute(verb, path, handler);
-        else if (typeof path !== 'function')
-            throw new Error('<SlowerRouter>.use :: "handler" parameter must be of type Function');
-        else for (let verb of HTTP_VERBS) this.#setRoute(verb, '/(.{0,})', path);
-        // this.middlewares.add(handlerA);
+        
+        // function signature:      app.all({HANDLER})
+        // example:     app.all(() => {}); 
+        else if (typeof path === 'function')
+            for (let verb of HTTP_VERBS) this.#setRoute(verb, MATCH_ANY, path);
+
+        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
@@ -179,13 +215,72 @@ class SlowerRouter {
                 this.static(layer.directoryPath, mount(layer.mountPath));
                 continue;
             }
-            console.log(layer)
             this.#setRoute(layer.method, mount(layer.path), layer.handler);
         }
         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 micro-routing with "app.route"
+ * 
+ * only method acessors (.get(), .post(), .put(), ...)
+ * and .all() and .use()
+ * 
+ * .static() is not allowed
+ */
+class SlowerMicroRouter {
+    constructor (path, layerPool) {
+        this.path = path;
+        this.layers = layerPool;
+    }
+
+    #setRoute (method, handler) {
+        const path = this.path;
+        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');
+        if (typeof handler !== 'function')
+            throw new Error('<SlowerSubRouter>.route :: "handler" parameter must be of type Function');
+        this.layers.push({ method, path, handler });
+        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);
+        return this;
+    }
+    // Just a more comprehensive call to app.all for defining middlewares
+    use (...b) { this.all(...b); return this; };
+}
+
+
+/**
+ * Used as the class for modular routers
+ * used in "slower.Router()"
+ */
 class SlowerSubRouter {
     constructor () {
         this.METHODS = HTTP_VERBS;
@@ -229,12 +324,12 @@ class SlowerSubRouter {
 }
 
 // Create basic main routing creation
-function Slower (options) {
+function slower (options) {
     return new SlowerRouter(options);
 }
 // Add the subrouter class
-Slower.Router = function () {
+slower.Router = function () {
     return new SlowerSubRouter();
 }
 
-module.exports = Slower;
+module.exports = slower;

package/src/utils.js

@@ -1,16 +1,4 @@
 
-
-// https://dev.to/thiagomr/como-funciona-o-express-js-criando-um-http-server-express-like-do-zero-sem-frameworks-125p
-
-// https://dev.to/wesleymreng7/creating-your-own-expressjs-from-scratch-part-1-basics-methods-and-routing-a8
-// https://dev.to/wesleymreng7/creating-your-own-expressjs-from-scratch-part-2-middlewares-and-controllers-2fbc
-// https://dev.to/wesleymreng7/creating-your-own-expressjs-from-scratch-part-3-treating-request-and-response-objects-4ecf
-// https://dev.to/wesleymreng7/creating-your-own-expressjs-from-scratch-part-4-modular-router-and-global-middlewares-560m
-// https://dev.to/wesleymreng7/creating-your-own-expressjs-from-scratch-part-5-serving-static-files-3e11
-// https://dev.to/wesleymreng7/creating-your-own-expressjs-from-scratch-part-6-creating-a-body-parser-middleware-15e7
-
-// https://thecodebarbarian.com/write-your-own-express-from-scratch
-
 const { statSync, readdirSync } = require('node:fs')
 const { join } = require('node:path');
 const { parse } = require('node:querystring');
@@ -58,4 +46,20 @@ const getURLPathBody = (urlPath = '') => urlPath.split('?')[0] || '';
 // /page?foo=bar&abc=123    ->  { foo: 'bar', abc: '123' }
 const getURLQueryString = (urlPath = '') => parse((urlPath.split('?')[1] || '').split('#')[0]);
 
-module.exports = { getMatchingRoute, getFiles, normalizeAddress, getFileExtension, getURLPathBody, getURLQueryString };
+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
+};