@ndiinginc/router 4.0.0 → 4.1.0

package/README.md

@@ -46,11 +46,7 @@ app.listen(3000);
 Semua method mengembalikan `this`, jadi bisa di-chain.
 
 ```js
-app.get("/users", handler)
-   .post("/users", handler)
-   .put("/users/:id", handler)
-   .patch("/users/:id", handler)
-   .delete("/users/:id", handler);
+app.get("/users", handler).post("/users", handler).put("/users/:id", handler).patch("/users/:id", handler).delete("/users/:id", handler);
 ```
 
 Method yang tersedia: `get`, `post`, `put`, `patch`, `delete`, `head`, `options`, `trace`, `connect`, `query`, dan `use` (semua method).
@@ -149,12 +145,12 @@ Jika tidak ada handler yang mengirim response, router mengirim JSON otomatis:
 
 ## Request
 
-| Properti | Keterangan |
-| --- | --- |
-| `req.path` | Pathname tanpa query string |
-| `req.query` | Object query string. Key yang berulang menjadi array |
-| `req.params` | Parameter dari route dinamis |
-| `req.body` | Hasil parse body (butuh middleware `json()`) |
+| Properti     | Keterangan                                           |
+| ------------ | ---------------------------------------------------- |
+| `req.path`   | Pathname tanpa query string                          |
+| `req.query`  | Object query string. Key yang berulang menjadi array |
+| `req.params` | Parameter dari route dinamis                         |
+| `req.body`   | Hasil parse body (butuh middleware `json()`)         |
 
 ```js
 // GET /search?tag=a&tag=b&page=2
@@ -165,9 +161,9 @@ app.get("/search", (req, res) => {
 
 ## Response
 
-| Method | Keterangan |
-| --- | --- |
-| `res.send(string)` | Kirim response dan akhiri chain |
+| Method             | Keterangan                                                  |
+| ------------------ | ----------------------------------------------------------- |
+| `res.send(string)` | Kirim response dan akhiri chain                             |
 | `res.json(object)` | Set `content-type: application/json`, serialize, lalu kirim |
 
 Keduanya juga turunan dari `http.ServerResponse`, jadi `res.statusCode`, `res.setHeader()`, dan lainnya tetap tersedia.

package/package.json

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

package/rest/router.http

@@ -13,6 +13,6 @@ GET http://localhost:4000
 ###
 GET http://localhost:5000
 
-autocannon -c 100 -d 10 -p 10 localhost:3000
-autocannon -c 100 -d 10 -p 10 localhost:4000
-autocannon -c 100 -d 10 -p 10 localhost:5000
+autocannon -c 100 -d 40 -p 10 localhost:3000
+autocannon -c 100 -d 40 -p 10 localhost:4000
+autocannon -c 100 -d 40 -p 10 localhost:5000

package/src/app.js

@@ -0,0 +1,67 @@
+const http = require("node:http");
+const { Response } = require("./response.js");
+const { Request } = require("./request.js");
+const { Router } = require("./Router.js");
+
+class App extends Router {
+    /**
+     * @param {import('http').IncomingMessage} req
+     * @param {import('http').ServerResponse} res
+     */
+    async handleRequest(req, res) {
+        let err;
+
+        const { params, handlers, errorHandlers } = this.find(req.method, req.path);
+        req.params = params;
+
+        try {
+            for (const handler of handlers) {
+                if (res.done) break;
+                await handler(req, res);
+            }
+        } catch (error) {
+            err = error;
+
+            try {
+                for (const handler of errorHandlers) {
+                    if (res.done) break;
+                    await handler(err, req, res);
+                }
+            } catch (error) {
+                err = error;
+            }
+        }
+
+        if (!res.done) {
+            if (!err) {
+                res.statusCode = 404;
+                err = new Error(http.STATUS_CODES[res.statusCode]);
+            }
+
+            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 });
+        }
+    }
+
+    /**
+     * @param {import('net').ListenOptions} options
+     * @returns {import('http').Server}
+     */
+    listen(options = {}, callback) {
+        const serverOptions = {
+            IncomingMessage: Request,
+            ServerResponse: Response,
+        };
+        const requestListener = (req, res) => this.handleRequest(req, res);
+
+        const server = http.createServer(serverOptions, requestListener);
+
+        server.listen(options, callback);
+
+        return server;
+    }
+}
+
+module.exports = App;

package/src/cache.js

@@ -0,0 +1,28 @@
+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;
+    }
+
+    set(key, value) {
+        if (this.map.has(key)) this.map.delete(key);
+        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/middleware.js

@@ -24,14 +24,15 @@ function json({ limit = 100 * 1024 } = {}) {
             throw new Error(http.STATUS_CODES[res.statusCode]);
         }
 
-        let bodySize = 0;
+        let chunkLength = 0;
         const chunks = [];
         for await (const chunk of req) {
-            bodySize += chunk.length;
-            if (bodySize > limit) {
+            chunkLength += chunk.length;
+            if (chunkLength > limit) {
                 res.statusCode = 413;
                 throw new Error(http.STATUS_CODES[res.statusCode]);
             }
+
             chunks.push(chunk);
         }
 
@@ -40,9 +41,8 @@ function json({ limit = 100 * 1024 } = {}) {
             return;
         }
 
-        const rawBody = Buffer.concat(chunks).toString("utf8");
         try {
-            req.body = JSON.parse(rawBody, reviver);
+            req.body = JSON.parse(Buffer.concat(chunks), reviver);
         } catch (error) {
             res.statusCode = 400;
             throw new Error("Invalid JSON body");

package/src/node.js

@@ -6,14 +6,27 @@ class Node {
         this.pattern = new Pattern(segment);
         /**@type {Map<string, Node>}*/
         this.children = new Map();
-        /**@type {Map<string, Function[]>}*/
-        this.handlers = new Map();
+        /**@type {Map<string, FunctionHandler[]>}*/
+        this.handlers = new Map([
+            ["ALL", []],
+            ["GET", []],
+            ["QUERY", []],
+            ["HEAD", []],
+            ["OPTIONS", []],
+            ["TRACE", []],
+            ["PUT", []],
+            ["DELETE", []],
+            ["POST", []],
+            ["PATCH", []],
+            ["CONNECT", []],
+        ]);
     }
 
     add(segment) {
         if (!this.children.has(segment)) {
             this.children.set(segment, new Node(segment));
         }
+
         return this.children.get(segment);
     }
 
@@ -25,7 +38,7 @@ class Node {
         for (const [method, handlers] of node.handlers) {
             for (const handler of handlers) {
                 handler.seq += offset;
-                this.handlers.getOrInsert(method, []).push(handler);
+                this.handlers.get(method).push(handler);
             }
         }
 
@@ -39,6 +52,9 @@ class Node {
         }
     }
 
+    /**
+     * @param {Number} offset
+     */
     setSeqOffset(offset) {
         for (const [, handlers] of this.handlers) {
             for (const handler of handlers) {

package/src/pattern.js

@@ -1,24 +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.
+ */
 class Pattern {
-    static baseURL = "http://localhost";
-
     constructor(input) {
-        const regexStr = input
+        const pattern = input
             .replace(/[.+*?^${}()|[\]\\]/g, "\\$&")
             .replace(/:(\w+)/g, "(?<$1>[^/]+)")
             .replace(/\\\*/g, ".*");
-        this.regex = new RegExp(`^${regexStr}$`);
-    }
 
-    exec(input) {
-        const match = this.regex.exec(input);
-        if (!match) return null;
-        return {
-            pathname: { groups: match.groups || {} },
-        };
+        Object.defineProperty(this, "re", {
+            value: new RegExp(`^${pattern}$`),
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
     }
 
     test(input) {
-        return this.regex.test(input);
+        return this.re.test(input);
+    }
+
+    /**
+     * @param {String} input
+     * @returns {PatternExec | null}
+     */
+    exec(input) {
+        return this.re.exec(input);
     }
 }
 exports.Pattern = Pattern;

package/src/request.js

@@ -1,17 +1,30 @@
-const { IncomingMessage } = require("node:http");
+const http = require("node:http");
+
+class Request extends http.IncomingMessage {
+    static base = "http://127.0.0";
 
-class Request extends IncomingMessage {
     get path() {
-        if (this.url.indexOf("?") !== -1) {
-            this.parsed = URL.parse(this.url, "http://localhost");
-            return this.parsed.pathname;
+        if (this._path) return this._path;
+
+        if (this.url === "/") {
+            this._path = this.url;
+            return this._path;
         }
-        return this.url;
+
+        this.parsed = URL.parse(this.url, Request.base);
+        this._path = this.parsed.pathname;
+        return this._path;
     }
 
     get query() {
+        if (this._query) return this._query;
+
+        if (!this.parsed) {
+            this._query = {};
+            return this._query;
+        }
+
         const query = {};
-        if (!this.parsed) return query;
         for (const [name, value] of this.parsed.searchParams) {
             if (query[name]) {
                 if (Array.isArray(query[name])) {
@@ -23,7 +36,8 @@ class Request extends IncomingMessage {
                 query[name] = value;
             }
         }
-        return query;
+        this._query = query;
+        return this._query;
     }
 }
 exports.Request = Request;

package/src/response.js

@@ -1,9 +1,9 @@
-const { ServerResponse } = require("node:http");
+const http = require("node:http");
 
-class Response extends ServerResponse {
+class Response extends http.ServerResponse {
     send(string) {
-        this.done = true;
         this.end(string);
+        this.done = true;
     }
 
     json(object) {

package/src/router.js

@@ -1,25 +1,48 @@
-require("./polyfill.js");
-const http = require("node:http");
-const { Response } = require("./response.js");
-const { Request } = require("./request.js");
-const { Node } = require("./node.js");
+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
+ */
 
 class Router {
-    /**@type {Node}*/
-    root;
+    constructor(options = {}) {
+        this.cacheSize = options.cacheSize ?? 30_000;
 
-    constructor() {
-        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);
     }
 
-    add(method, path, handler) {
+    /**
+     * @param {*} method
+     * @param {*} path
+     * @param {FunctionHandler[]} handler
+     */
+    add(method, path, ...handlers) {
         if (typeof path === "function") {
-            handler = path;
+            handlers = [path, ...handlers];
             path = null;
         }
 
@@ -31,182 +54,126 @@ class Router {
             }
         }
 
-        if (handler.root) {
-            node.merge(handler.root, this.seq);
-            this.seq = node.getMaxSeq() + 1;
-        } else {
-            handler.seq = this.seq++;
-            node.handlers.getOrInsert(method, []).push(handler);
+        for (const handler of handlers) {
+            if (handler.root) {
+                node.merge(handler.root, this.seq);
+                this.seq = node.getMaxSeq() + 1;
+            } else {
+                handler.seq = this.seq++;
+                node.handlers.get(method).push(handler);
+            }
         }
     }
 
-    use(path, handler) {
-        this.add("ALL", path, handler);
+    use(path, ...handlers) {
+        this.add("ALL", path, ...handlers);
         return this;
     }
 
-    get(path, handler) {
-        this.add("GET", path, handler);
+    get(path, ...handlers) {
+        this.add("GET", path, ...handlers);
         return this;
     }
-    query(path, handler) {
-        this.add("QUERY", path, handler);
+
+    query(path, ...handlers) {
+        this.add("QUERY", path, ...handlers);
         return this;
     }
-    head(path, handler) {
-        this.add("HEAD", path, handler);
+
+    head(path, ...handlers) {
+        this.add("HEAD", path, ...handlers);
         return this;
     }
-    options(path, handler) {
-        this.add("OPTIONS", path, handler);
+
+    options(path, ...handlers) {
+        this.add("OPTIONS", path, ...handlers);
         return this;
     }
-    trace(path, handler) {
-        this.add("TRACE", path, handler);
+
+    trace(path, ...handlers) {
+        this.add("TRACE", path, ...handlers);
         return this;
     }
-    put(path, handler) {
-        this.add("PUT", path, handler);
+
+    put(path, ...handlers) {
+        this.add("PUT", path, ...handlers);
         return this;
     }
-    delete(path, handler) {
-        this.add("DELETE", path, handler);
+
+    delete(path, ...handlers) {
+        this.add("DELETE", path, ...handlers);
         return this;
     }
-    post(path, handler) {
-        this.add("POST", path, handler);
+
+    post(path, ...handlers) {
+        this.add("POST", path, ...handlers);
         return this;
     }
-    patch(path, handler) {
-        this.add("PATCH", path, handler);
+
+    patch(path, ...handlers) {
+        this.add("PATCH", path, ...handlers);
         return this;
     }
-    connect(path, handler) {
-        this.add("CONNECT", path, handler);
+
+    connect(path, ...handlers) {
+        this.add("CONNECT", path, ...handlers);
         return this;
     }
 
     find(method, path) {
-        let params = {};
-        let handlers = {};
-        let errorHandlers = {};
+        const key = `${method} ${path}`;
 
-        let node = this.root;
+        const cached = this.cache.get(key);
+        if (cached) return cached;
 
-        const inputs = this.split(path);
-        if (inputs.length) {
-            for (const input of inputs) {
-                let matched = node.children.get(input);
-
-                if (!matched) {
-                    for (const [, child] of node.children) {
-                        const match = child.pattern.exec(input);
-                        if (match) {
-                            matched = child;
-                            Object.assign(params, match.pathname.groups);
-                            break;
-                        }
-                    }
-                }
-
-                if (!matched) {
-                    node = null;
-                    params = {};
-                    break;
-                }
-
-                node = matched;
+        let node = this.root;
 
-                if (node.handlers.has("ALL")) {
-                    for (const handler of node.handlers.get("ALL")) {
-                        if (handler.length === 3) errorHandlers[handler.seq] = handler;
-                        else handlers[handler.seq] = handler;
+        let params = {};
+        const handlers = {};
+        const errorHandlers = {};
+
+        for (const input of this.split(path)) {
+            let matched = node.children.get(input);
+
+            if (!matched) {
+                for (const [, child] of node.children) {
+                    const match = child.pattern.exec(input);
+                    if (match) {
+                        matched = child;
+                        Object.assign(params, match.groups);
+                        break;
                     }
                 }
             }
-        }
 
-        if (this.root.handlers.has("ALL")) {
-            for (const handler of this.root.handlers.get("ALL")) {
-                if (handler.length === 3) errorHandlers[handler.seq] = handler;
-                else handlers[handler.seq] = handler;
+            if (!matched) {
+                node = null;
+                params = {};
+                break;
             }
-        }
 
-        if (node && node.handlers.has(method)) {
-            for (const handler of node.handlers.get(method)) {
+            node = matched;
+
+            for (const handler of node.handlers.get("ALL")) {
                 if (handler.length === 3) errorHandlers[handler.seq] = handler;
                 else handlers[handler.seq] = handler;
             }
         }
 
-        return {
-            params,
-            handlers: Object.values(handlers),
-            errorHandlers: Object.values(errorHandlers),
-        };
-    }
-
-    /**
-     * @param {import('http').RequestOptions} req
-     * @param {import('http').ServerResponse} res
-     */
-    async handleRequest(req, res) {
-        const result = this.find(req.method, req.path);
-        req.params = result.params;
-
-        try {
-            for (const handler of result.handlers) {
-                if (res.done) break;
-                await handler(req, res);
-            }
-        } catch (error) {
-            res.error = error;
-
-            try {
-                for (const handler of result.errorHandlers) {
-                    if (res.done) break;
-                    await handler(res.error, req, res);
-                }
-            } catch (error) {
-                res.error = error;
-            }
+        for (const handler of this.root.handlers.get("ALL")) {
+            if (handler.length === 3) errorHandlers[handler.seq] = handler;
+            else handlers[handler.seq] = handler;
         }
 
-        if (!res.done) {
-            if (!res.error) {
-                res.statusCode = 404;
-                res.error = new Error(http.STATUS_CODES[res.statusCode]);
+        if (node) {
+            for (const handler of node.handlers.get(method)) {
+                handlers[handler.seq] = handler;
             }
-
-            res.statusCode = res.statusCode >= 200 && res.statusCode < 300 ? 500 : res.statusCode;
-
-            const error = {
-                code: res.error.code,
-                message: res.error.message,
-            };
-            if (process.env.NODE_ENV === "development") error.stack = res.error.stack;
-
-            res.json({ error });
         }
-    }
 
-    /**
-     * @returns {import('http').Server}
-     */
-    listen(...params) {
-        const server = http.createServer(
-            {
-                IncomingMessage: Request,
-                ServerResponse: Response,
-            },
-            (req, res) => this.handleRequest(req, res),
-        );
-
-        server.listen(...params);
-
-        return server;
+        const value = { params, handlers: Object.values(handlers), errorHandlers: Object.values(errorHandlers) };
+        this.cache.set(key, value);
+        return value;
     }
 }
-
-module.exports = Router;
+module.exports.Router = Router;

package/src/polyfill.js

@@ -1,9 +0,0 @@
-// Polyfill for Map.prototype.getOrInsert
-if (!Map.prototype.getOrInsert) {
-    Map.prototype.getOrInsert = function (key, defaultValue) {
-        if (!this.has(key)) {
-            this.set(key, defaultValue);
-        }
-        return this.get(key);
-    };
-}