@ndiinginc/router 4.14.1 → 4.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ndiinginc/router",
-  "version": "4.14.1",
+  "version": "4.16.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 result = this.find(req.method, req.path);
+        req.params = result.params;
         let err;
         try {
             const handlerPromise = async () => {
-                for (const handler of handlers) {
+                for (const handler of result.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 result.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

@@ -1,20 +1,17 @@
 class Node {
     /**
-     * @param {String} segment
+     * @param {String} prefix
      */
-    constructor(segment = "") {
-        this.segment = segment;
-        if (segment.startsWith(":")) {
+    constructor(prefix = "") {
+        this.prefix = prefix;
+        if (prefix.startsWith(":")) {
             /**@type {String}*/
-            this.name = segment.slice(1);
+            this.name = prefix.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[]>}*/
@@ -22,29 +19,25 @@ class Node {
     }
 
     /**
-     * @param {String} segment
+     * @param {String} prefix
      * @returns {Node}
      */
-    add(segment) {
-        if (segment === "*") {
+    add(prefix) {
+        if (prefix === "*") {
             if (!this.wildcard) this.wildcard = new Node("*");
             return this.wildcard;
         }
-        if (segment.startsWith(":")) {
-            return this.params.getOrInsertComputed(segment, (segment) => {
-                return new Node(segment);
-            });
+        if (prefix.startsWith(":")) {
+            return this.params.getOrInsertComputed(prefix, (prefix) => new Node(prefix));
         }
-        return this.children.getOrInsertComputed(segment, (segment) => {
-            return new Node(segment);
-        });
+        return this.children.getOrInsertComputed(prefix, (prefix) => new Node(prefix));
     }
 
     /**
-     * @param {String} segment
+     * @param {String} prefix
      */
-    remove(segment) {
-        this.children.delete(segment);
+    remove(prefix) {
+        this.children.delete(prefix);
     }
 
     /**
@@ -63,11 +56,11 @@ class Node {
         if (node.wildcard) {
             this.add("*").merge(node.wildcard, offset);
         }
-        for (const [segment, child] of node.params) {
-            this.add(segment).merge(child, offset);
+        for (const [prefix, child] of node.params) {
+            this.add(prefix).merge(child, offset);
         }
-        for (const [segment, child] of node.children) {
-            this.add(segment).merge(child, offset);
+        for (const [prefix, child] of node.children) {
+            this.add(prefix).merge(child, offset);
         }
     }
 

package/src/response.js

@@ -1,31 +1,41 @@
 const http = require("http");
+const fs = require("fs");
+const path = require("path");
 
 class Response extends http.ServerResponse {
-    /**
-     * @param {Number} code
-     * @returns {Response}
-     */
     status(code) {
         this.statusCode = code;
         return this;
     }
-
-    /**
-     * @param {String} chunk
-     */
     send(chunk) {
-        if (this.writableEnded) return;
-        this.end(chunk, null, null);
+        this.setHeader("Content-Type", "text/plain; charset=utf-8");
+        this.end(chunk);
     }
 
-    /**
-     * @param {Object} value
-     */
     json(value) {
-        if (!this.headersSent) {
-            this.setHeader("Content-Type", "application/json; charset=utf-8");
-        }
-        this.send(JSON.stringify(value));
+        this.setHeader("Content-Type", "application/json; charset=utf-8");
+        this.end(JSON.stringify(value));
+    }
+
+    download(filepath, filename) {
+        fs.stat(filepath, (err, stats) => {
+            if (err || !stats.isFile()) {
+                this.statusCode = 404;
+                return this.end();
+            }
+            filename=filename||path.basename(filepath)
+            this.setHeader("Content-Type", "application/octet-stream");
+            this.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+            this.setHeader("Content-Length", stats.size);
+            const stream = fs.createReadStream(filepath);
+            stream.on("error", (err) => {
+                if (!this.headersSent) {
+                    this.statusCode = 500;
+                    this.end();
+                }
+            });
+            stream.pipe(this);
+        });
     }
 }
 exports.Response = Response;

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;
     }
@@ -36,45 +41,42 @@ class Router {
      * @returns
      */
     walk(path, node) {
-        for (const [segment, child] of node.children) {
-            const lcp = this.lcp(segment, path);
+        for (const [prefix, child] of node.children) {
+            const lcp = this.lcp(prefix, path);
             if (lcp === 0) continue;
-            if (lcp === segment.length) {
+            if (lcp === prefix.length) {
                 if (lcp === path.length) return child;
                 return this.walk(path.slice(lcp), child);
             }
-            const newNode = new Node(segment.slice(0, lcp));
-            newNode.add(segment.slice(lcp)).merge(child);
+            const newNode = new Node(prefix.slice(0, lcp));
+            newNode.add(prefix.slice(lcp)).merge(child);
             const rest = path.slice(lcp);
             if (rest.length) newNode.add(rest);
-            node.add(newNode.segment).merge(newNode);
-            node.remove(segment);
+            node.add(newNode.prefix).merge(newNode);
+            node.remove(prefix);
         }
         return node.add(path);
     }
 
     /**
      * @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) {
                 if (path[i] === ":") {
                     let j = i + 1;
                     while (j < path.length && path[j] !== "/") j++;
-                    let segment = path.slice(i, j);
-                    node = node.add(segment);
-                    params.push(segment.slice(1));
+                    let prefix = path.slice(i, j);
+                    node = node.add(prefix);
                     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) {
@@ -226,95 +228,102 @@ class Router {
                 return { nodes, params, matched: true };
             }
             if (nodes.length > state.nodes.length) {
-                state.nodes=nodes.slice()
-                params={...params}
+                state.nodes = nodes.slice();
+                state.params = { ...params };
             }
             nodes.pop();
             return { nodes: state.nodes, params: state.params, matched: false };
         }
-        for (const [segment, child] of node.children) {
-            if (path.startsWith(segment)) {
-                const res = this.search(method, path.slice(segment.length), child, nodes, params, state);
-                if (res.matched) return res;
+        if (node.children.size) {
+            for (const [prefix, child] of node.children) {
+                if (path.startsWith(prefix)) {
+                    const res = this.search(method, path.slice(prefix.length), child, nodes, params, state);
+                    if (res.matched) return res;
+                }
             }
         }
-        for (const [segment, 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 result = this.search(method, rest, child, nodes, next, state);
-                if (result.matched) return result;
+        if (node.params.size) {
+            for (const [, child] of node.params) {
+                const index = path.indexOf("/");
+                const value = index === -1 ? path : path.slice(0, index);
+                if (value.length) {
+                    const rest = index === -1 ? "" : path.slice(index);
+                    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();
+            state.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)) {
+    collectHandler(node, method, handlers) {
+        if (node.handlers.has(method)) {
+            for (const entry of node.handlers.get(method)) {
                 handlers[entry.seq] = entry.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);
+        const keys = Object.keys(obj);
+        if (keys.length) {
+            for (const key of keys) {
+                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);
-
         if (!res.matched && path.length > 1) {
             const alt = path.endsWith("/") ? path.slice(0, -1) : path + "/";
             res = this.search(method, alt);
         }
         const handlers = {};
         const errorHandlers = {};
-        for (const r of res.nodes) {
-            this.collectMiddleware(r, handlers, errorHandlers);
-        }
         if (res.matched) {
             this.collectHandler(res.nodes.at(-1), method, handlers);
         }
+        for (const node of res.nodes) {
+            this.collectMiddleware(node, handlers, errorHandlers);
+        }
         return {
-            matched: res.matched,
-            params: res.params,
-            paramsLength: Object.keys(res.params).length,
+            params: this.decodeParams(res.params),
             handlers: Object.values(handlers),
             errorHandlers: Object.values(errorHandlers),
         };
     }
-
 }
 exports.Router = Router;