@ndiinginc/router 4.1.3 → 4.3.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@ndiinginc/router",
-  "version": "4.1.3",
+  "version": "4.3.0",
   "description": "",
-  "main": "./src/app.js",
+  "main": "./src/index.js",
   "scripts": {
     "test": "nodemon --exec \"node -e \\\"require('@ndiinginc/test')(require('path').resolve('tests'),{verbose:true})\\\"\"",
-    "dev": "nodemon src/app.js",
+    "dev": "nodemon src/index.js",
     "prettier": "npx prettier . --write",
     "commit": "node -e \"require('@ndiinginc/commit')()\"",
     "npm:dry-run": "npm publish --dry-run",

package/src/app.js

@@ -1,67 +1,76 @@
 const http = require("node:http");
-const { Response } = require("./response.js");
+const { Router } = require("./router.js");
 const { Request } = require("./request.js");
-const { Router } = require("./Router.js");
+const { Response } = require("./response.js");
+const { ErrorResponse } = require("./error.js");
+
+/**@type {import('http').ServerOptions}*/
+const SERVER_OPTIONS = {
+    IncomingMessage: Request,
+    ServerResponse: Response,
+};
 
 class App extends Router {
+    async withTimeout(handlerPromise, delay) {
+        let timeout;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeout = setTimeout(() => reject(ErrorResponse.status(504)), delay);
+        });
+
+        await Promise.race([handlerPromise, timeoutPromise]).finally(() => clearTimeout(timeout));
+    }
+
     /**
      * @param {import('http').IncomingMessage} req
      * @param {import('http').ServerResponse} res
      */
-    async handleRequest(req, res) {
-        let err;
-
+    async handle(req, res) {
         const { params, handlers, errorHandlers } = this.find(req.method, req.path);
         req.params = params;
 
+        let err;
         try {
-            for (const handler of handlers) {
-                if (res.done) break;
-                await handler(req, res);
-            }
+            const handlerPromise = (async () => {
+                for (const handler of handlers) {
+                    if (res.writableEnded) break;
+                    await handler(req, res);
+                }
+            })();
+
+            if (req.timeout) await this.withTimeout(handlerPromise, req.timeout);
+            else await handlerPromise;
         } catch (error) {
             err = error;
 
             try {
                 for (const handler of errorHandlers) {
-                    if (res.done) break;
+                    if (res.writableEnded) break;
                     await handler(err, req, res);
                 }
             } catch (error) {
-                err = error;
+                err = new Error(error.message, { cause: err });
             }
         }
 
-        if (!res.done) {
-            if (!err) {
-                res.statusCode = 404;
-                err = new Error(http.STATUS_CODES[res.statusCode]);
+        if (!res.writableEnded) {
+            if (!err) err = ErrorResponse.status(404);
+
+            if (!res.statusCode || res.statusCode < 400) {
+                res.statusCode = err.statusCode || 500;
             }
 
-            res.statusCode = res.statusCode >= 200 && res.statusCode < 300 ? 500 : res.statusCode;
-            const error = { message: err.message };
-            if (process.env.NODE_ENV === "development") error.stack = err.stack;
-            res.json({ error });
+            res.json({ error: { message: err.message, stack: err.stack } });
         }
     }
 
-    /**
-     * @param {import('net').ListenOptions} options
-     * @returns {import('http').Server}
-     */
-    listen(...args) {
-        const serverOptions = {
-            IncomingMessage: Request,
-            ServerResponse: Response,
-        };
-        const requestListener = (req, res) => this.handleRequest(req, res);
-
-        const server = http.createServer(serverOptions, requestListener);
-
-        server.listen(...args);
-
+    listen(...params) {
+        const requestListener = (req, res) => this.handle(req, res);
+        const server = http.createServer(SERVER_OPTIONS, requestListener);
+        server.listen(...params);
         return server;
     }
 }
 
-module.exports = App;
+App.SERVER_OPTIONS = SERVER_OPTIONS;
+
+exports.App = App;

package/src/cache.js

@@ -1,18 +1,14 @@
 class Cache {
     constructor(size) {
         this.size = size;
-
         this.map = new Map();
     }
 
     get(key) {
         if (!this.map.has(key)) return undefined;
-
         const value = this.map.get(key);
-
         this.map.delete(key);
         this.map.set(key, value);
-
         return value;
     }
 
@@ -21,8 +17,8 @@ class Cache {
         else if (this.map.size >= this.size) {
             this.map.delete(this.map.keys().next().value);
         }
-
         this.map.set(key, value);
     }
 }
+
 exports.Cache = Cache;

package/src/error.js

@@ -0,0 +1,26 @@
+const http = require("node:http");
+
+// Client error responses (400 – 499)
+// Server error responses (500 – 599)
+class ErrorResponse extends Error {
+    constructor({ statusCode, message } = {}, options) {
+        super(message, options);
+
+        this.name = this.constructor.name;
+
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+
+        this.statusCode = statusCode;
+    }
+
+    static status(statusCode) {
+        return new ErrorResponse({
+            statusCode,
+            message: http.STATUS_CODES[statusCode],
+        });
+    }
+}
+
+exports.ErrorResponse = ErrorResponse;

package/src/index.js

@@ -0,0 +1,11 @@
+const { inspect } = require("node:util");
+const { json } = require("./middleware/json.js");
+const { cors } = require("./middleware/cors.js");
+const { App } = require("./app.js");
+const { Router } = require("./router.js");
+
+App.Router = Router;
+App.json = json;
+App.cors = cors;
+
+module.exports = App;

package/src/middleware/cors.js

@@ -0,0 +1,139 @@
+function pattern(string) {
+    return new RegExp(
+        `(${String(string)
+            .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+            .replace(/ /g, "")
+            .replace(/,/g, "|")
+            .replace(/\\\*/g, ".*")})`,
+        "i",
+    );
+}
+
+/**
+ * @typedef CORSOptions
+ * @property {String} [origin="*"]
+ * @property {Boolean} [credentials=false]
+ * @property {String|Array} headers
+ * @property {Number} [maxAge=0]
+ * @property {String|Array} methods
+ */
+
+/**
+ * @param {CORSOptions} options
+ */
+function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods } = {}) {
+    const HEADERS_PATTERN = headers && pattern(headers);
+    const METHODS_PATTERN = methods && pattern(methods);
+    const ORIGIN_PATTERN = pattern(origin);
+
+    /**
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowCredentials(res) {
+        if (credentials) {
+            res.setHeader("Access-Control-Allow-Credentials", "true");
+        }
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowHeaders(req, res) {
+        const reqHeaders = req.headers["access-control-request-headers"];
+        if (!reqHeaders) return;
+
+        let value;
+        if (headers === "*" && !credentials) {
+            value = "*";
+        } else if (Array.isArray(headers) && HEADERS_PATTERN && HEADERS_PATTERN.test(reqHeaders)) {
+            value = headers;
+        }
+        if (value) res.setHeader("Access-Control-Allow-Headers", value);
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowMethods(req, res) {
+        const reqMethod = req.headers["access-control-request-method"];
+        if (!reqMethod) return;
+
+        let value;
+        if (methods === "*" && !credentials) {
+            value = "*";
+        } else if (Array.isArray(methods) && METHODS_PATTERN && METHODS_PATTERN.test(reqMethod)) {
+            value = methods;
+        }
+        if (value) res.setHeader("Access-Control-Allow-Methods", value);
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    function setAllowOrigin(req, res) {
+        const reqOrigin = req.headers["origin"];
+
+        let value;
+        let explicit;
+        if (origin === "*") {
+            if (!credentials) value = "*";
+            else {
+                value = reqOrigin;
+                explicit = true;
+            }
+        } else if (origin === null) {
+            value = "null";
+        } else if (typeof origin === "string" && ORIGIN_PATTERN.test(reqOrigin)) {
+            value = origin;
+            explicit = true;
+        }
+        if (value) res.setHeader("Access-Control-Allow-Origin", value);
+        if (explicit) res.appendHeader("Vary", "Origin");
+    }
+
+    /**
+     * @param {import('http').ServerResponse} res
+     */
+    function setExposeHeaders(res) {
+        let value;
+        if (headers === "*" && !credentials) {
+            value = "*";
+        } else if (Array.isArray(headers)) {
+            value = headers;
+        }
+        if (value) res.setHeader("Access-Control-Expose-Headers", value);
+    }
+
+    /**
+     * @param {import('http').ServerResponse} res
+     */
+    function setMaxAge(res) {
+        if (maxAge > 0) {
+            res.setHeader("Access-Control-Max-Age", maxAge);
+        }
+    }
+
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    return (req, res) => {
+        setAllowCredentials(res);
+        setAllowOrigin(req, res);
+        if (req.method === "OPTIONS") {
+            setAllowHeaders(req, res);
+            setAllowMethods(req, res);
+            setMaxAge(res);
+
+            res.statusCode = 204;
+            res.setHeader("Content-Length", "0");
+            res.end();
+        } else {
+            setExposeHeaders(res);
+        }
+    };
+}
+exports.cors = cors;

package/src/{middleware.js → middleware/json.js}

@@ -1,5 +1,6 @@
 const http = require("node:http");
 
+// middleware
 function json({ limit = 100 * 1024 } = {}) {
     const reviver = (key, value) => {
         if (key === "__proto__" || key === "constructor" || key === "prototype") {
@@ -25,14 +26,15 @@ function json({ limit = 100 * 1024 } = {}) {
         }
 
         let chunkLength = 0;
+
         const chunks = [];
+
         for await (const chunk of req) {
             chunkLength += chunk.length;
             if (chunkLength > limit) {
                 res.statusCode = 413;
                 throw new Error(http.STATUS_CODES[res.statusCode]);
             }
-
             chunks.push(chunk);
         }
 
@@ -49,4 +51,5 @@ function json({ limit = 100 * 1024 } = {}) {
         }
     };
 }
-module.exports.json = json;
+
+exports.json = json;

package/src/node.js

@@ -1,12 +1,11 @@
 const { Pattern } = require("./pattern.js");
 
 class Node {
-    constructor(segment) {
+    constructor(segment = "") {
         this.segment = segment;
         this.pattern = new Pattern(segment);
-        /**@type {Map<string, Node>}*/
+        /**@type {Map<string,Node>}*/
         this.children = new Map();
-        /**@type {Map<string, FunctionHandler[]>}*/
         this.handlers = new Map([
             ["ALL", []],
             ["GET", []],
@@ -26,13 +25,11 @@ class Node {
         if (!this.children.has(segment)) {
             this.children.set(segment, new Node(segment));
         }
-
         return this.children.get(segment);
     }
 
     /**
      * @param {Node} node
-     * @param {Number} offset
      */
     merge(node, offset) {
         for (const [method, handlers] of node.handlers) {
@@ -52,9 +49,6 @@ class Node {
         }
     }
 
-    /**
-     * @param {Number} offset
-     */
     setSeqOffset(offset) {
         for (const [, handlers] of this.handlers) {
             for (const handler of handlers) {
@@ -83,4 +77,5 @@ class Node {
         return max;
     }
 }
+
 exports.Node = Node;

package/src/pattern.js

@@ -1,34 +1,34 @@
 /**
- * @typedef {Object} PatternExec
- * @property {number} index - The zero-based index of the match in the input string.
- * @property {string} input - The original input string.
- * @property {Object.<string, string>} [groups] - Named capture groups, or undefined.
+ * @typedef PatternExecResult
+ * @property {number} index
+ * @property {string} input
+ * @property {Record<string, string>} [groups]
+ * @property {number} length
  */
 class Pattern {
     constructor(input) {
-        const pattern = input
-            .replace(/[.+*?^${}()|[\]\\]/g, "\\$&")
+        const pattern = `^${input
+            .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
             .replace(/:(\w+)/g, "(?<$1>[^/]+)")
-            .replace(/\\\*/g, ".*");
-
-        Object.defineProperty(this, "re", {
-            value: new RegExp(`^${pattern}$`),
-            writable: true,
-            enumerable: false,
+            .replace(/\\\*/g, ".*")}$`;
+        Object.defineProperty(this, "regex", {
+            value: new RegExp(pattern),
             configurable: true,
+            enumerable: false,
         });
     }
 
-    test(input) {
-        return this.re.test(input);
-    }
-
     /**
-     * @param {String} input
-     * @returns {PatternExec | null}
+     * @param {string} input
+     * @returns {PatternExecResult | null}
      */
     exec(input) {
-        return this.re.exec(input);
+        return this.regex.exec(input);
+    }
+
+    test(input) {
+        return this.regex.test(input);
     }
 }
+
 exports.Pattern = Pattern;

package/src/request.js

@@ -1,43 +1,37 @@
 const http = require("node:http");
+const { parseUrl, parseQueryString } = require("./util.js");
 
 class Request extends http.IncomingMessage {
-    static base = "http://127.0.0";
+    _path;
+    _parsed;
+    _query;
+    params = {};
+    timeout = 0;
 
     get path() {
         if (this._path) return this._path;
 
-        if (this.url.indexOf('?')===-1) {
+        if (this.url.indexOf("?") === -1) {
             this._path = this.url;
             return this._path;
         }
 
-        this.parsed = URL.parse(this.url, Request.base);
-        this._path = this.parsed.pathname;
+        this._parsed = parseUrl(this.url);
+        this._path = this._parsed.path;
         return this._path;
     }
 
     get query() {
         if (this._query) return this._query;
 
-        if (!this.parsed) {
+        if (!this._parsed) {
             this._query = {};
             return this._query;
         }
 
-        const query = {};
-        for (const [name, value] of this.parsed.searchParams) {
-            if (query[name]) {
-                if (Array.isArray(query[name])) {
-                    query[name].push(value);
-                } else {
-                    query[name] = [query[name], value];
-                }
-            } else {
-                query[name] = value;
-            }
-        }
-        this._query = query;
+        this._query = parseQueryString(this._parsed.queryString);
         return this._query;
     }
 }
+
 exports.Request = Request;

package/src/response.js

@@ -1,14 +1,13 @@
 const http = require("node:http");
 
 class Response extends http.ServerResponse {
-    send(string) {
-        this.end(string);
-        this.done = true;
+    send(chunk) {
+        this.end(chunk);
     }
 
-    json(object) {
-        this.setHeader("content-type", "application/json");
-        this.send(JSON.stringify(object));
+    json(value) {
+        this.setHeader("Content-Type", "application/json");
+        this.end(JSON.stringify(value));
     }
 }
 exports.Response = Response;

package/src/router.js

@@ -1,45 +1,19 @@
-const { Node } = require("./node");
-const { Cache } = require("./cache");
-
-/**
- * @callback Handler
- * @param {*} req
- * @param {*} res
- */
-/**
- * @callback Middleware
- * @param {*} req
- */
-/**
- * @callback ErrorHandler
- * @param {*} err
- * @param {*} req
- * @param {*} res
- */
-/**
- * @typedef {Handler|Middleware|ErrorHandler} FunctionHandler
- */
+const { Node } = require("./node.js");
+const { Cache } = require("./cache.js");
 
 class Router {
     constructor(options = {}) {
-        this.cacheSize = options.cacheSize ?? 30_000;
+        this.cacheSize = options.size ?? 1000;
 
-        this.root = new Node("/");
+        this.root = new Node();
         this.seq = 0;
         this.cache = new Cache(this.cacheSize);
     }
 
     split(path) {
-        if (path === "/") return [];
-
         return path.split("/").filter(Boolean);
     }
 
-    /**
-     * @param {*} method
-     * @param {*} path
-     * @param {FunctionHandler[]} handler
-     */
     add(method, path, ...handlers) {
         if (typeof path === "function") {
             handlers = [path, ...handlers];
@@ -120,6 +94,11 @@ class Router {
         return this;
     }
 
+    /**
+     * @param {'GET'|'QUERY'|'HEAD'|'OPTIONS'|'TRACE'|'PUT'|'DELETE'|'POST'|'PATCH'|'CONNECT'} method
+     * @param {String} path
+     * @returns {{params: {};handlers: any[];errorHandlers: any[];}}
+     */
     find(method, path) {
         const key = `${method} ${path}`;
 
@@ -171,9 +150,15 @@ class Router {
             }
         }
 
-        const value = { params, handlers: Object.values(handlers), errorHandlers: Object.values(errorHandlers) };
-        this.cache.set(key, value);
-        return value;
+        const result = {
+            params,
+            handlers: Object.values(handlers),
+            errorHandlers: Object.values(errorHandlers),
+        };
+
+        this.cache.set(key, result);
+
+        return result;
     }
 }
-module.exports.Router = Router;
+exports.Router = Router;

package/src/util.js

@@ -0,0 +1,27 @@
+const URL_REGEX = /^([^?#]*)(\?([^#]*))?(#.*)?$/;
+const QUERY_STRING_REGEX = /([^=&]*)?=([^&]*)?/g;
+
+function parseQueryString(queryString) {
+    const result = {};
+
+    let match;
+    while ((match = QUERY_STRING_REGEX.exec(queryString)) !== null) {
+        const [, name = "", raw = ""] = match;
+
+        const value = decodeURIComponent(raw);
+
+        if (result[name]) {
+            if (Array.isArray(result[name])) result[name].push(value);
+            else result[name] = [result[name], value];
+        } else result[name] = value;
+    }
+
+    return result;
+}
+exports.parseQueryString = parseQueryString;
+
+function parseUrl(url) {
+    const [, path = "/", , queryString = ""] = URL_REGEX.exec(url);
+    return { path, queryString };
+}
+exports.parseUrl = parseUrl;