hono 1.1.1 → 1.2.2

package/dist/router/trie-router/index.d.ts

@@ -1 +1 @@
-export { TrieRouter } from '../../router/trie-router/router';
+export { TrieRouter } from './router';

package/dist/router/trie-router/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrieRouter = void 0;
-var router_1 = require("../../router/trie-router/router");
+var router_1 = require("./router");
 Object.defineProperty(exports, "TrieRouter", { enumerable: true, get: function () { return router_1.TrieRouter; } });

package/dist/router/trie-router/node.d.ts

@@ -1,12 +1,13 @@
 import { Result } from '../../router';
 import type { Pattern } from '../../utils/url';
 export declare class Node<T> {
-    method: Record<string, T>;
-    handler: T;
+    methods: Record<string, T>[];
+    handlers: T[];
     children: Record<string, Node<T>>;
-    middlewares: [];
     patterns: Pattern[];
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
+    private getHandlers;
+    private next;
     search(method: string, path: string): Result<T>;
 }

package/dist/router/trie-router/node.js

@@ -3,96 +3,164 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = void 0;
 const router_1 = require("../../router");
 const url_1 = require("../../utils/url");
-const noRoute = () => {
-    return null;
-};
+function findParam(node, name) {
+    for (let i = 0, len = node.patterns.length; i < len; i++) {
+        if (typeof node.patterns[i] === 'object' && node.patterns[i][1] === name) {
+            return true;
+        }
+    }
+    const nodes = Object.values(node.children);
+    for (let i = 0, len = nodes.length; i < len; i++) {
+        if (findParam(nodes[i], name)) {
+            return true;
+        }
+    }
+    return false;
+}
 class Node {
     constructor(method, handler, children) {
         this.children = children || {};
-        this.method = {};
+        this.methods = [];
         if (method && handler) {
-            this.method[method] = handler;
+            const m = {};
+            m[method] = handler;
+            this.methods = [m];
         }
-        this.middlewares = [];
         this.patterns = [];
     }
     insert(method, path, handler) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         let curNode = this;
         const parts = (0, url_1.splitPath)(path);
+        const parentPatterns = [];
+        const errorMessage = (name) => {
+            return `Duplicate param name, use another name instead of '${name}' - ${method} ${path} <--- '${name}'`;
+        };
         for (let i = 0, len = parts.length; i < len; i++) {
             const p = parts[i];
             if (Object.keys(curNode.children).includes(p)) {
+                parentPatterns.push(...curNode.patterns);
                 curNode = curNode.children[p];
                 continue;
             }
             curNode.children[p] = new Node();
             const pattern = (0, url_1.getPattern)(p);
             if (pattern) {
+                if (typeof pattern === 'object') {
+                    for (let j = 0, len = parentPatterns.length; j < len; j++) {
+                        if (typeof parentPatterns[j] === 'object' && parentPatterns[j][1] === pattern[1]) {
+                            throw new Error(errorMessage(pattern[1]));
+                        }
+                    }
+                    if (Object.values(curNode.children).some((n) => findParam(n, pattern[1]))) {
+                        throw new Error(errorMessage(pattern[1]));
+                    }
+                }
                 curNode.patterns.push(pattern);
+                parentPatterns.push(...curNode.patterns);
             }
+            parentPatterns.push(...curNode.patterns);
             curNode = curNode.children[p];
         }
-        curNode.method[method] = handler;
+        if (!curNode.methods.length) {
+            curNode.methods = [];
+        }
+        const m = {};
+        m[method] = handler;
+        curNode.methods.push(m);
         return curNode;
     }
-    search(method, path) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let curNode = this;
-        const params = {};
-        const parts = (0, url_1.splitPath)(path);
-        for (let i = 0, len = parts.length; i < len; i++) {
-            const p = parts[i];
-            // '*' => match any path
-            // /api/* => default wildcard match
-            if (curNode.children['*'] && !curNode.children[p]) {
-                const astNode = curNode.children['*'];
-                if (Object.keys(astNode.children).length === 0) {
-                    curNode = astNode;
-                    break;
-                }
+    getHandlers(node, method) {
+        const handlers = [];
+        node.methods.map((m) => {
+            let handler = m[method];
+            if (handler !== undefined) {
+                handlers.push(handler);
+                return;
             }
-            const nextNode = curNode.children[p];
-            if (nextNode) {
-                curNode = nextNode;
-                // '/hello/*' => match '/hello'
-                if (!(i == len - 1 && nextNode.children['*'])) {
-                    continue;
+            handler = m[router_1.METHOD_NAME_ALL];
+            if (handler !== undefined) {
+                handlers.push(handler);
+                return;
+            }
+        });
+        return handlers;
+    }
+    next(node, part, method, isLast) {
+        const handlers = [];
+        const nextNodes = [];
+        const params = {};
+        for (let j = 0, len = node.patterns.length; j < len; j++) {
+            const pattern = node.patterns[j];
+            // Wildcard
+            // '/hello/*/foo' => match /hello/bar/foo
+            if (pattern === '*') {
+                const astNode = node.children['*'];
+                if (astNode) {
+                    handlers.push(...this.getHandlers(astNode, method));
+                    nextNodes.push(astNode);
                 }
             }
-            let isWildcard = false;
-            let isParamMatch = false;
-            for (let j = 0, len = curNode.patterns.length; j < len; j++) {
-                const pattern = curNode.patterns[j];
-                // Wildcard
-                // '/hello/*/foo' => match /hello/bar/foo
-                if (pattern === '*') {
-                    curNode = curNode.children['*'];
-                    isWildcard = true;
-                    break;
+            if (part === '')
+                continue;
+            // Named match
+            // `/posts/:id` => match /posts/123
+            const [key, name, matcher] = pattern;
+            if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
+                if (typeof key === 'string') {
+                    if (isLast === true) {
+                        handlers.push(...this.getHandlers(node.children[key], method));
+                    }
+                    nextNodes.push(node.children[key]);
                 }
-                // Named match
-                const [key, name, matcher] = pattern;
-                if (p !== '' && (matcher === true || matcher.test(p))) {
-                    params[name] = p;
-                    curNode = curNode.children[key];
-                    isParamMatch = true;
-                    break;
+                if (typeof name === 'string') {
+                    params[name] = part;
                 }
-                return noRoute();
-            }
-            if (isWildcard && i === len - 1) {
-                break;
             }
-            if (isWildcard === false && isParamMatch === false) {
-                return noRoute();
+        }
+        const nextNode = node.children[part];
+        if (nextNode) {
+            if (isLast === true) {
+                // '/hello/*' => match '/hello'
+                if (nextNode.children['*'] !== undefined) {
+                    handlers.push(...this.getHandlers(nextNode.children['*'], method));
+                }
+                handlers.push(...this.getHandlers(nextNode, method));
             }
+            nextNodes.push(nextNode);
         }
-        const handler = curNode.method[router_1.METHOD_NAME_OF_ALL] || curNode.method[method];
-        if (!handler) {
-            return noRoute();
+        const next = {
+            nodes: nextNodes,
+            handlers: handlers,
+            params: params,
+        };
+        return next;
+    }
+    search(method, path) {
+        const handlers = [];
+        let params = {};
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const curNode = this;
+        let curNodes = [curNode];
+        const parts = (0, url_1.splitPath)(path);
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const p = parts[i];
+            const isLast = i === len - 1;
+            const tempNodes = [];
+            for (let j = 0, len2 = curNodes.length; j < len2; j++) {
+                const res = this.next(curNodes[j], p, method, isLast);
+                if (res.nodes.length === 0) {
+                    continue;
+                }
+                handlers.push(...res.handlers);
+                params = Object.assign(params, res.params);
+                tempNodes.push(...res.nodes);
+            }
+            curNodes = tempNodes;
         }
-        return new router_1.Result(handler, params);
+        if (handlers.length <= 0)
+            return null;
+        return new router_1.Result(handlers, params);
     }
 }
 exports.Node = Node;

package/dist/router/trie-router/node.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/router/trie-router/node.test.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("./node");
+describe('Root Node', () => {
+    const node = new node_1.Node();
+    node.insert('get', '/', 'get root');
+    it('get /', () => {
+        const res = node.search('get', '/');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get root']);
+        expect(node.search('get', '/hello')).toBeNull();
+    });
+});
+describe('Root Node is not defined', () => {
+    const node = new node_1.Node();
+    node.insert('get', '/hello', 'get hello');
+    it('get /', () => {
+        expect(node.search('get', '/')).toBeNull();
+    });
+});
+describe('Get with *', () => {
+    const node = new node_1.Node();
+    node.insert('get', '*', 'get all');
+    it('get /', () => {
+        expect(node.search('get', '/')).not.toBeNull();
+        expect(node.search('get', '/hello')).not.toBeNull();
+    });
+});
+describe('Basic Usage', () => {
+    const node = new node_1.Node();
+    node.insert('get', '/hello', 'get hello');
+    node.insert('post', '/hello', 'post hello');
+    node.insert('get', '/hello/foo', 'get hello foo');
+    it('get, post /hello', () => {
+        expect(node.search('get', '/')).toBeNull();
+        expect(node.search('post', '/')).toBeNull();
+        expect(node.search('get', '/hello').handlers).toEqual(['get hello']);
+        expect(node.search('post', '/hello').handlers).toEqual(['post hello']);
+        expect(node.search('put', '/hello')).toBeNull();
+    });
+    it('get /nothing', () => {
+        expect(node.search('get', '/nothing')).toBeNull();
+    });
+    it('/hello/foo, /hello/bar', () => {
+        expect(node.search('get', '/hello/foo').handlers).toEqual(['get hello foo']);
+        expect(node.search('post', '/hello/foo')).toBeNull();
+        expect(node.search('get', '/hello/bar')).toBeNull();
+    });
+    it('/hello/foo/bar', () => {
+        expect(node.search('get', '/hello/foo/bar')).toBeNull();
+    });
+});
+describe('Name path', () => {
+    const node = new node_1.Node();
+    node.insert('get', '/entry/:id', 'get entry');
+    node.insert('get', '/entry/:id/comment/:comment_id', 'get comment');
+    node.insert('get', '/map/:location/events', 'get events');
+    it('get /entry/123', () => {
+        const res = node.search('get', '/entry/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get entry']);
+        expect(res.params).not.toBeNull();
+        expect(res.params['id']).toBe('123');
+        expect(res.params['id']).not.toBe('1234');
+    });
+    it('get /entry/456/comment', () => {
+        const res = node.search('get', '/entry/456/comment');
+        expect(res).toBeNull();
+    });
+    it('get /entry/789/comment/123', () => {
+        const res = node.search('get', '/entry/789/comment/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get comment']);
+        expect(res.params['id']).toBe('789');
+        expect(res.params['comment_id']).toBe('123');
+    });
+    it('get /map/:location/events', () => {
+        const res = node.search('get', '/map/yokohama/events');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get events']);
+        expect(res.params['location']).toBe('yokohama');
+    });
+});
+describe('Name path - Multiple route', () => {
+    const node = new node_1.Node();
+    node.insert('get', '/:type/:id', 'common');
+    node.insert('get', '/posts/:id', 'specialized');
+    it('get /posts/123', () => {
+        const res = node.search('get', '/posts/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['common', 'specialized']);
+        expect(res.params['id']).toBe('123');
+    });
+});
+describe('Wildcard', () => {
+    const node = new node_1.Node();
+    node.insert('get', '/wildcard-abc/*/wildcard-efg', 'wildcard');
+    it('/wildcard-abc/xxxxxx/wildcard-efg', () => {
+        const res = node.search('get', '/wildcard-abc/xxxxxx/wildcard-efg');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['wildcard']);
+    });
+    node.insert('get', '/wildcard-abc/*/wildcard-efg/hijk', 'wildcard');
+    it('/wildcard-abc/xxxxxx/wildcard-efg/hijk', () => {
+        const res = node.search('get', '/wildcard-abc/xxxxxx/wildcard-efg/hijk');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['wildcard']);
+    });
+});
+describe('Regexp', () => {
+    const node = new node_1.Node();
+    node.insert('get', '/regex-abc/:id{[0-9]+}/comment/:comment_id{[a-z]+}', 'regexp');
+    it('/regexp-abc/123/comment/abc', () => {
+        const res = node.search('get', '/regex-abc/123/comment/abc');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['regexp']);
+        expect(res.params['id']).toBe('123');
+        expect(res.params['comment_id']).toBe('abc');
+    });
+    it('/regexp-abc/abc', () => {
+        const res = node.search('get', '/regex-abc/abc');
+        expect(res).toBeNull();
+    });
+    it('/regexp-abc/123/comment/123', () => {
+        const res = node.search('get', '/regex-abc/123/comment/123');
+        expect(res).toBeNull();
+    });
+});
+describe('All', () => {
+    const node = new node_1.Node();
+    node.insert('ALL', '/all-methods', 'all methods'); // ALL
+    it('/all-methods', () => {
+        let res = node.search('get', '/all-methods');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['all methods']);
+        res = node.search('put', '/all-methods');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['all methods']);
+    });
+});
+describe('Special Wildcard', () => {
+    const node = new node_1.Node();
+    node.insert('ALL', '*', 'match all');
+    it('/foo', () => {
+        const res = node.search('get', '/foo');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['match all']);
+    });
+    it('/hello', () => {
+        const res = node.search('get', '/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['match all']);
+    });
+    it('/hello/foo', () => {
+        const res = node.search('get', '/hello/foo');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['match all']);
+    });
+});
+describe('Special Wildcard deeply', () => {
+    const node = new node_1.Node();
+    node.insert('ALL', '/hello/*', 'match hello');
+    it('/hello', () => {
+        const res = node.search('get', '/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['match hello']);
+    });
+    it('/hello/foo', () => {
+        const res = node.search('get', '/hello/foo');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['match hello']);
+    });
+});
+describe('Default with wildcard', () => {
+    const node = new node_1.Node();
+    node.insert('ALL', '/api/abc', 'match api');
+    node.insert('ALL', '/api/*', 'fallback');
+    it('/api/abc', () => {
+        const res = node.search('get', '/api/abc');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['fallback', 'match api']);
+    });
+    it('/api/def', () => {
+        const res = node.search('get', '/api/def');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['fallback']);
+    });
+});
+describe('Multi match', () => {
+    describe('Basic', () => {
+        const node = new node_1.Node();
+        node.insert('get', '*', 'GET *');
+        node.insert('get', '/abc/*', 'GET /abc/*');
+        node.insert('get', '/abc/*/edf', 'GET /abc/*/edf');
+        node.insert('get', '/abc/edf', 'GET /abc/edf');
+        node.insert('get', '/abc/*/ghi/jkl', 'GET /abc/*/ghi/jkl');
+        it('get /abc/edf', () => {
+            const res = node.search('get', '/abc/edf');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['GET *', 'GET /abc/*', 'GET /abc/edf']);
+        });
+        it('get /abc/xxx/edf', () => {
+            const res = node.search('get', '/abc/xxx/edf');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['GET *', 'GET /abc/*', 'GET /abc/*/edf']);
+        });
+        it('get /', () => {
+            const res = node.search('get', '/');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['GET *']);
+        });
+        it('post /', () => {
+            const res = node.search('post', '/');
+            expect(res).toBeNull();
+        });
+        it('get /abc/edf/ghi', () => {
+            const res = node.search('get', '/abc/edf/ghi');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['GET *', 'GET /abc/*']);
+        });
+    });
+    describe('Blog', () => {
+        const node = new node_1.Node();
+        node.insert('get', '*', 'middleware a');
+        node.insert('ALL', '*', 'middleware b');
+        node.insert('get', '/entry', 'get entries');
+        node.insert('post', '/entry/*', 'middleware c');
+        node.insert('post', '/entry', 'post entry');
+        node.insert('get', '/entry/:id', 'get entry');
+        node.insert('get', '/entry/:id/comment/:comment_id', 'get comment');
+        it('get /entry/123', async () => {
+            const res = node.search('get', '/entry/123');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b', 'get entry']);
+            expect(res.params['id']).toBe('123');
+        });
+        it('get /entry/123/comment/456', async () => {
+            const res = node.search('get', '/entry/123/comment/456');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b', 'get comment']);
+            expect(res.params['id']).toBe('123');
+            expect(res.params['comment_id']).toBe('456');
+        });
+        it('post /entry', async () => {
+            const res = node.search('post', '/entry');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware b', 'middleware c', 'post entry']);
+        });
+        it('delete /entry', async () => {
+            const res = node.search('delete', '/entry');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware b']);
+        });
+    });
+    describe('ALL', () => {
+        const node = new node_1.Node();
+        node.insert('ALL', '*', 'ALL *');
+        node.insert('ALL', '/abc/*', 'ALL /abc/*');
+        node.insert('ALL', '/abc/*/def', 'ALL /abc/*/def');
+        it('get /', () => {
+            const res = node.search('get', '/');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['ALL *']);
+        });
+        it('post /abc', () => {
+            const res = node.search('post', '/abc');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['ALL *', 'ALL /abc/*']);
+        });
+        it('delete /abc/xxx/def', () => {
+            const res = node.search('post', '/abc/xxx/def');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['ALL *', 'ALL /abc/*', 'ALL /abc/*/def']);
+        });
+    });
+    describe('Regexp', () => {
+        const node = new node_1.Node();
+        node.insert('get', '/regex-abc/:id{[0-9]+}/*', 'middleware a');
+        node.insert('get', '/regex-abc/:id{[0-9]+}/def', 'regexp');
+        it('/regexp-abc/123/def', () => {
+            const res = node.search('get', '/regex-abc/123/def');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'regexp']);
+            expect(res.params['id']).toBe('123');
+        });
+        it('/regexp-abc/123', () => {
+            const res = node.search('get', '/regex-abc/123/ghi');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a']);
+        });
+    });
+    describe('Trailing slash', () => {
+        const node = new node_1.Node();
+        node.insert('get', '/book', 'GET /book');
+        node.insert('get', '/book/:id', 'GET /book/:id');
+        it('get /book', () => {
+            const res = node.search('get', '/book');
+            expect(res).not.toBeNull();
+        });
+        it('get /book/', () => {
+            const res = node.search('get', '/book/');
+            expect(res).toBeNull();
+        });
+    });
+    describe('Same path', () => {
+        const node = new node_1.Node();
+        node.insert('get', '/hey', 'Middleware A');
+        node.insert('get', '/hey', 'Middleware B');
+        it('get /hey', () => {
+            const res = node.search('get', '/hey');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['Middleware A', 'Middleware B']);
+        });
+    });
+});
+describe('Duplicate param name', () => {
+    it('self', () => {
+        const node = new node_1.Node();
+        expect(() => {
+            node.insert('get', '/:id/:id', 'foo');
+        }).toThrowError(/Duplicate param name/);
+    });
+    it('parent', () => {
+        const node = new node_1.Node();
+        node.insert('get', '/:id/:action', 'foo');
+        expect(() => {
+            node.insert('get', '/posts/:id', 'bar');
+        }).toThrowError(/Duplicate param name/);
+    });
+    it('child', () => {
+        const node = new node_1.Node();
+        node.insert('get', '/posts/:id', 'foo');
+        expect(() => {
+            node.insert('get', '/:id/:action', 'bar');
+        }).toThrowError(/Duplicate param name/);
+    });
+    it('hierarchy', () => {
+        const node = new node_1.Node();
+        node.insert('get', '/posts/:id/comments/:comment_id', 'foo');
+        expect(() => {
+            node.insert('get', '/posts/:id', 'bar');
+        }).not.toThrowError();
+    });
+    it('regular expression', () => {
+        const node = new node_1.Node();
+        node.insert('get', '/:id/:action{create|update}', 'foo');
+        expect(() => {
+            node.insert('get', '/:id/:action{delete}', 'bar');
+        }).not.toThrowError();
+    });
+});

package/dist/router/trie-router/router.d.ts

@@ -1,9 +1,9 @@
 import { Router } from '../../router';
 import type { Result } from '../../router';
-import { Node } from '../../router/trie-router/node';
+import { Node } from './node';
 export declare class TrieRouter<T> extends Router<T> {
     node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;
-    match(method: string, path: string): Result<T> | null;
+    match(method: string, path: string): Result<T>;
 }

package/dist/router/trie-router/router.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrieRouter = void 0;
 const router_1 = require("../../router");
-const node_1 = require("../../router/trie-router/node");
+const node_1 = require("./node");
 class TrieRouter extends router_1.Router {
     constructor() {
         super();

package/dist/router/trie-router/router.test.d.ts

@@ -0,0 +1 @@
+export {};