@ndiinginc/router 4.14.0 → 4.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ndiinginc/router",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "",
   "main": "./src/index.js",
   "scripts": {

package/src/app.js

@@ -2,12 +2,9 @@ const http = require("http");
 const { Router } = require("./router");
 const { Request } = require("./request");
 const { Response } = require("./response");
-
-/**@type {import('http').ServerOptions}*/
-const SERVER_OPTIONS = {
-    IncomingMessage: Request,
-    ServerResponse: Response,
-};
+const { json } = require("./middleware/json");
+const { cors } = require("./middleware/cors");
+const { urlencoded } = require("./middleware/urlencoded");
 
 class App extends Router {
     /**
@@ -28,7 +25,6 @@ class App extends Router {
         const promise = handlerPromise().catch((error) => {
             if (!req.controller.signal.aborted) {
                 req.controller.abort(error);
-            } else {
             }
         });
         try {
@@ -40,10 +36,10 @@ class App extends Router {
     }
 
     /**
-     * @param {Response} res
      * @param {Error} err
+     * @param {Response} res
      */
-    fallback(res, err) {
+    fallback(err, res) {
         if (!res.writableEnded) {
             if (!err) {
                 res.statusCode = 404;
@@ -65,12 +61,12 @@ class App extends Router {
      * @param {Response} res
      */
     async handle(req, res) {
-        const { params, paramsLength, handlers, errorHandlers } = this.find(req.method, req.path);
-        req.params = paramsLength ? Object.assign(Object.create(null), params) : Object.create(null);
+        const { params, handlers, errorHandlers } = this.find(req.method, req.path);
+        req.params = this.decodeParams(params);
         let err;
         try {
             const handlerPromise = async () => {
-                for (const handler of handlers) {
+                for (const handler of Object.values(handlers)) {
                     if (res.writableEnded) break;
                     await handler(req, res);
                 }
@@ -83,7 +79,7 @@ class App extends Router {
         } catch (error) {
             err = error;
             try {
-                for (const handler of errorHandlers) {
+                for (const handler of Object.values(errorHandlers)) {
                     if (res.writableEnded) break;
                     await handler(err, req, res);
                 }
@@ -91,7 +87,7 @@ class App extends Router {
                 err = new Error(error.message, { cause: err });
             }
         }
-        this.fallback(res, err);
+        this.fallback(err, res);
     }
 
     /**
@@ -99,13 +95,21 @@ class App extends Router {
      * @returns {import('http').Server}
      */
     listen(...args) {
-        const requestListener = (req, res) => this.handle(req, res);
-        const server = http.createServer(SERVER_OPTIONS, requestListener);
+        const server = http.createServer(
+            {
+                IncomingMessage: Request,
+                ServerResponse: Response,
+            },
+            (req, res) => this.handle(req, res),
+        );
         server.listen(...args);
         return server;
     }
 }
 
-App.SERVER_OPTIONS = SERVER_OPTIONS;
+App.Router = Router;
+App.json = json;
+App.cors = cors;
+App.urlencoded = urlencoded;
 
 exports.App = App;

package/src/index.js

@@ -1,13 +1,4 @@
 require("./polyfill");
 const { App } = require("./app");
-const { Router } = require("./router");
-const { json } = require("./middleware/json");
-const { cors } = require("./middleware/cors");
-const { urlencoded } = require("./middleware/urlencoded");
-
-App.Router = Router;
-App.json = json;
-App.cors = cors;
-App.urlencoded = urlencoded;
 
 module.exports = App;

package/src/middleware/cors.js

@@ -21,6 +21,7 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
     if (Array.isArray(headers)) {
         headers = headers.map((h) => h.toLowerCase());
     }
+
     if (Array.isArray(methods)) {
         methods = methods.map((m) => m.toUpperCase());
     }

package/src/node.js

@@ -8,13 +8,10 @@ class Node {
             /**@type {String}*/
             this.name = segment.slice(1);
         }
-
         /**@type {Map<string,Node>}*/
         this.children = new Map();
-
         /**@type {Map<string,Node>}*/
         this.params = new Map();
-
         /**@type {Node}*/
         this.wildcard = null;
         /**@type {Map<string,Function[]>}*/
@@ -31,13 +28,9 @@ class Node {
             return this.wildcard;
         }
         if (segment.startsWith(":")) {
-            return this.params.getOrInsertComputed(segment, (segment) => {
-                return new Node(segment);
-            });
+            return this.params.getOrInsertComputed(segment, (segment) => new Node(segment));
         }
-        return this.children.getOrInsertComputed(segment, (segment) => {
-            return new Node(segment);
-        });
+        return this.children.getOrInsertComputed(segment, (segment) => new Node(segment));
     }
 
     /**

package/src/router.js

@@ -1,6 +1,12 @@
 const { decodeParam } = require("./util");
 const { Node } = require("./node");
 
+/**
+ * @callback Callback
+ * @param {import('./request').Request} req
+ * @param {import('./response').Response} res
+ */
+
 /**
  * @typedef {Object} Options
  * @property {Number} [requestTimeout=0]
@@ -12,7 +18,6 @@ class Router {
      */
     constructor(options = {}) {
         this.requestTimeout = options.requestTimeout ?? 0;
-
         this.root = new Node();
         this.seq = 0;
     }
@@ -55,17 +60,15 @@ class Router {
 
     /**
      * @param {String} method
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      */
     add(method, path, ...handlers) {
         if (typeof path === "function") {
             handlers = [path, ...handlers];
             path = null;
         }
-
         let node = this.root;
-        let params = [];
         if (path) {
             let i = 0;
             while (i < path.length) {
@@ -74,7 +77,6 @@ class Router {
                     while (j < path.length && path[j] !== "/") j++;
                     let segment = path.slice(i, j);
                     node = node.add(segment);
-                    params.push(segment.slice(1));
                     i = j;
                 } else if (path[i] === "*") {
                     let j = i + 1;
@@ -101,8 +103,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     use(path, ...handlers) {
@@ -111,8 +113,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     get(path, ...handlers) {
@@ -121,8 +123,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     query(path, ...handlers) {
@@ -131,8 +133,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     head(path, ...handlers) {
@@ -141,8 +143,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     options(path, ...handlers) {
@@ -151,8 +153,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     trace(path, ...handlers) {
@@ -161,8 +163,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     put(path, ...handlers) {
@@ -171,8 +173,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     delete(path, ...handlers) {
@@ -181,8 +183,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     post(path, ...handlers) {
@@ -191,8 +193,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     patch(path, ...handlers) {
@@ -201,8 +203,8 @@ class Router {
     }
 
     /**
-     * @param {String|Function} path
-     * @param  {Function[]} handlers
+     * @param {String|Callback} path
+     * @param  {Callback[]} handlers
      * @returns {this}
      */
     connect(path, ...handlers) {
@@ -219,14 +221,15 @@ class Router {
      * @param {Object} state
      * @returns {{path:Array,params:Object,matched:Boolean}}
      */
-    search(method, path, node, nodes = [], params = {}, state = { nodes: [], params: {} }) {
+    search(method, path, node = this.root, nodes = [], params = {}, state = { nodes: [], params: {} }) {
         nodes.push(node);
         if (0 === path.length) {
             if (node.handlers.has(method) || node.handlers.has("ALL")) {
                 return { nodes, params, matched: true };
             }
             if (nodes.length > state.nodes.length) {
-                state = { nodes: nodes.slice(), params: { ...params } };
+                state.nodes = nodes.slice();
+                params = { ...params };
             }
             nodes.pop();
             return { nodes: state.nodes, params: state.params, matched: false };
@@ -237,81 +240,79 @@ class Router {
                 if (res.matched) return res;
             }
         }
-        for (const [segment, child] of node.params) {
+        for (const [, child] of node.params) {
             const slashIdx = path.indexOf("/");
             const value = slashIdx === -1 ? path : path.slice(0, slashIdx);
             const rest = slashIdx === -1 ? "" : path.slice(slashIdx);
             if (value.length > 0) {
-                const next = { ...params, [child.name]: decodeParam(value) };
+                const next = { ...params, [child.name]: value };
                 const result = this.search(method, rest, child, nodes, next, state);
                 if (result.matched) return result;
             }
         }
         if (node.wildcard && (node.wildcard.handlers.get(method) || node.wildcard.handlers.get("ALL"))) {
             nodes.push(node.wildcard);
-            return {
-                nodes,
-                params: { ...params, wildcard: path },
-                matched: true,
-            };
+            return { nodes, params: { ...params, wildcard: path }, matched: true };
         }
         if (nodes.length > state.nodes.length) {
-            state = { nodes: nodes.slice(), params: { ...params } };
+            state.nodes = nodes.slice();
+            params = { ...params };
         }
         nodes.pop();
         return { nodes: state.nodes, params: state.params, matched: false };
     }
 
     /**
-     * @param {Node} r
+     * @param {Node} node
      * @param {String} method
      * @param {Object} handlers
      */
-    collectHandler(r, method, handlers) {
-        if (r.handlers.has(method)) {
-            for (const entry of r.handlers.get(method)) {
-                handlers[entry.seq] = entry.handler;
+    collectHandler(node, method, handlers) {
+        if (node.handlers.has(method)) {
+            for (const { seq, handler } of node.handlers.get(method)) {
+                handlers[seq] = handler;
             }
         }
     }
 
     /**
-     * @param {Node} r
+     * @param {Node} node
      * @param {Object} handlers
      * @param {Object} errorHandlers
      */
-    collectMiddleware(r, handlers, errorHandlers) {
-        this.collectHandler(r, "ALL", handlers);
-        this.collectHandler(r, "CATCH", errorHandlers);
+    collectMiddleware(node, handlers, errorHandlers) {
+        this.collectHandler(node, "ALL", handlers);
+        this.collectHandler(node, "CATCH", errorHandlers);
+    }
+
+    decodeParams(obj) {
+        const params = Object.create(null);
+        for (const key of Object.keys(obj)) {
+            params[key] = decodeParam(obj[key]);
+        }
+        return params;
     }
 
     /**
      * @param {String} method
      * @param {String} path
-     * @returns {{matched: boolean;params: Object;paramsLength: number;handlers: any[];errorHandlers: any[];}}
+     * @returns {{params: Object;handlers: any[];errorHandlers: any[];}}
      */
     find(method, path) {
-        let res = this.search(method, path, this.root);
-
+        let res = this.search(method, path);
         if (!res.matched && path.length > 1) {
             const alt = path.endsWith("/") ? path.slice(0, -1) : path + "/";
-            res = this.search(method, alt, this.root);
+            res = this.search(method, alt);
         }
         const handlers = {};
         const errorHandlers = {};
-        for (const r of res.nodes) {
-            this.collectMiddleware(r, handlers, errorHandlers);
+        for (const node of res.nodes) {
+            this.collectMiddleware(node, handlers, errorHandlers);
         }
         if (res.matched) {
-            this.collectHandler(res.nodes.at(-1), method, handlers);
+            this.collectHandler(res.nodes[res.nodes.length - 1], method, handlers);
         }
-        return {
-            matched: res.matched,
-            params: res.params,
-            paramsLength: Object.keys(res.params).length,
-            handlers: Object.values(handlers),
-            errorHandlers: Object.values(errorHandlers),
-        };
+        return { params: res.params, handlers, errorHandlers };
     }
 }
 exports.Router = Router;