hono 0.0.10 → 0.0.11

package/README.md

@@ -16,19 +16,21 @@ app.fire()
 ## Feature
 
 - Fast - the router is implemented with Trie-Tree structure.
-- Tiny - use only standard API.
 - Portable - zero dependencies.
 - Flexible - you can make your own middlewares.
-- Optimized - for Cloudflare Workers and Fastly Compute@Edge.
+- Easy - simple API, builtin middleware, and TypeScript support.
+- Optimized - for Cloudflare Workers or Fastly Compute@Edge.
 
 ## Benchmark
 
+Hono is fastest!!
+
 ```
-hono x 813,001 ops/sec ±2.96% (75 runs sampled)
-itty-router x 160,415 ops/sec ±3.31% (85 runs sampled)
-sunder x 307,438 ops/sec ±4.77% (73 runs sampled)
+hono x 758,264 ops/sec ±5.41% (75 runs sampled)
+itty-router x 158,359 ops/sec ±3.21% (89 runs sampled)
+sunder x 297,581 ops/sec ±4.74% (83 runs sampled)
 Fastest is hono
-✨  Done in 37.03s.
+✨  Done in 42.84s.
 ```
 
 ## Install
@@ -45,8 +47,8 @@ $ npm install hono
 
 ## Methods
 
-- app.**HTTP_METHOD**(path, callback)
-- app.**all**(path, callback)
+- app.**HTTP_METHOD**(path, handler)
+- app.**all**(path, handler)
 - app.**route**(path)
 - app.**use**(path, middleware)
 
@@ -120,25 +122,25 @@ const { Hono, Middleware } = require('hono')
 
 ...
 
-app.use('*', Middleware.poweredBy)
+app.use('*', Middleware.poweredBy())
+app.use('*', Middleware.logger())
 
 ```
 
 ### Custom Middleware
 
 ```js
-const logger = async (c, next) => {
+// Custom logger
+app.use('*', async (c, next) => {
   console.log(`[${c.req.method}] ${c.req.url}`)
   await next()
-}
+})
 
-const addHeader = async (c, next) => {
+// Add custom header
+app.use('/message/*', async (c, next) => {
   await next()
   await c.res.headers.add('x-message', 'This is middleware!')
-}
-
-app.use('*', logger)
-app.use('/message/*', addHeader)
+})
 
 app.get('/message/hello', () => 'Hello Middleware!')
 ```
@@ -146,20 +148,18 @@ app.get('/message/hello', () => 'Hello Middleware!')
 ### Custom 404 Response
 
 ```js
-const customNotFound = async (c, next) => {
+app.use('*', async (c, next) => {
   await next()
   if (c.res.status === 404) {
     c.res = new Response('Custom 404 Not Found', { status: 404 })
   }
-}
-
-app.use('*', customNotFound)
+})
 ```
 
 ### Complex Pattern
 
 ```js
-// Log response time
+// Output response time
 app.use('*', async (c, next) => {
   await next()
   const responseTime = await c.res.headers.get('X-Response-Time')
@@ -180,38 +180,41 @@ app.use('*', async (c, next) => {
 ### req
 
 ```js
+
+// Get Request object
 app.get('/hello', (c) => {
   const userAgent = c.req.headers.get('User-Agent')
   ...
 })
+
+// Query params
+app.get('/search', (c) => {
+  const query = c.req.query('q')
+  ...
+})
+
+// Captured params
+app.get('/entry/:id', (c) => {
+  const id = c.req.params('id')
+  ...
+})
 ```
 
 ### res
 
 ```js
+// Response object
 app.use('/', (c, next) => {
   next()
   c.res.headers.append('X-Debug', 'Debug message')
 })
 ```
 
-## Request
-
-### query
+### text
 
 ```js
-app.get('/search', (c) => {
-  const query = c.req.query('q')
-  ...
-})
-```
-
-### params
-
-```js
-app.get('/entry/:id', (c) => {
-  const id = c.req.params('id')
-  ...
+app.get('/say', (c) => {
+  return c.text('Hello!')
 })
 ```
 
@@ -219,7 +222,7 @@ app.get('/entry/:id', (c) => {
 
 Create your first Cloudflare Workers with Hono from scratch.
 
-### Demo
+### How to setup
 
 ![Demo](https://user-images.githubusercontent.com/10682/147877447-ff5907cd-49be-4976-b3b4-5df2ac6dfda4.gif)
 

package/dist/compose.d.ts

@@ -0,0 +1 @@
+export declare const compose: (middleware: any) => (context: any, next?: Function) => any;

package/dist/compose.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+// Based on the code in the MIT licensed `koa-compose` package.
+const compose = (middleware) => {
+    return function (context, next) {
+        let index = -1;
+        return dispatch(0);
+        function dispatch(i) {
+            if (i <= index)
+                return Promise.reject(new Error('next() called multiple times'));
+            index = i;
+            let fn = middleware[i];
+            if (i === middleware.length)
+                fn = next;
+            if (!fn)
+                return Promise.resolve();
+            try {
+                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        }
+    };
+};
+exports.compose = compose;

package/dist/hono.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="@cloudflare/workers-types" />
+import { Node, Result } from './node';
+import { Middleware } from './middleware';
+export { Middleware };
+declare global {
+    interface Request {
+        params: (key: string) => any;
+        query: (key: string) => string | null;
+    }
+}
+export declare class Context {
+    req: Request;
+    res: Response;
+    constructor(req: Request, res: Response);
+    newResponse(body?: BodyInit | null | undefined, init?: ResponseInit | undefined): Response;
+    text(body: string): Response;
+}
+declare type Handler = (c: Context, next?: Function) => Response | Promise<Response>;
+declare type MiddlwareHandler = (c: Context, next: Function) => Promise<void>;
+export declare class Router<T> {
+    node: Node<T>;
+    constructor();
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
+}
+export declare class Hono {
+    router: Router<Handler[]>;
+    middlewareRouters: Router<MiddlwareHandler>[];
+    tempPath: string;
+    constructor();
+    get(arg: string | Handler, ...args: Handler[]): Hono;
+    post(arg: string | Handler, ...args: Handler[]): Hono;
+    put(arg: string | Handler, ...args: Handler[]): Hono;
+    head(arg: string | Handler, ...args: Handler[]): Hono;
+    delete(arg: string | Handler, ...args: Handler[]): Hono;
+    options(arg: string | Handler, ...args: Handler[]): Hono;
+    patch(arg: string | Handler, ...args: Handler[]): Hono;
+    all(arg: string | Handler, ...args: Handler[]): Hono;
+    route(path: string): Hono;
+    use(path: string, middleware: MiddlwareHandler): void;
+    addRoute(method: string, arg: string | Handler, ...args: Handler[]): Hono;
+    matchRoute(method: string, path: string): Promise<Result<Handler[]>>;
+    dispatch(request: Request, response?: Response): Promise<Response>;
+    handleEvent(event: FetchEvent): Promise<Response>;
+    fire(): void;
+    notFound(): Response;
+}

package/dist/hono.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hono = exports.Router = exports.Context = exports.Middleware = void 0;
+const node_1 = require("./node");
+const compose_1 = require("./compose");
+const util_1 = require("./util");
+const middleware_1 = require("./middleware");
+Object.defineProperty(exports, "Middleware", { enumerable: true, get: function () { return middleware_1.Middleware; } });
+const METHOD_NAME_OF_ALL = 'ALL';
+class Context {
+    constructor(req, res) {
+        this.req = req;
+        this.res = res;
+    }
+    newResponse(body, init) {
+        return new Response(body, init);
+    }
+    text(body) {
+        return this.newResponse(body, {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/plain',
+            },
+        });
+    }
+}
+exports.Context = Context;
+class Router {
+    constructor() {
+        this.node = new node_1.Node();
+    }
+    add(method, path, handler) {
+        this.node.insert(method, path, handler);
+    }
+    match(method, path) {
+        return this.node.search(method, path);
+    }
+}
+exports.Router = Router;
+class Hono {
+    constructor() {
+        this.router = new Router();
+        this.middlewareRouters = [];
+        this.tempPath = '/';
+    }
+    /* HTTP METHODS */
+    get(arg, ...args) {
+        return this.addRoute('get', arg, ...args);
+    }
+    post(arg, ...args) {
+        return this.addRoute('post', arg, ...args);
+    }
+    put(arg, ...args) {
+        return this.addRoute('put', arg, ...args);
+    }
+    head(arg, ...args) {
+        return this.addRoute('head', arg, ...args);
+    }
+    delete(arg, ...args) {
+        return this.addRoute('delete', arg, ...args);
+    }
+    options(arg, ...args) {
+        return this.addRoute('options', arg, ...args);
+    }
+    patch(arg, ...args) {
+        return this.addRoute('patch', arg, ...args);
+    }
+    /*
+    trace
+    copy
+    lock
+    purge
+    unlock
+    report
+    checkout
+    merge
+    notify
+    subscribe
+    unsubscribe
+    search
+    connect
+    */
+    all(arg, ...args) {
+        return this.addRoute('all', arg, ...args);
+    }
+    route(path) {
+        this.tempPath = path;
+        return this;
+    }
+    use(path, middleware) {
+        if (middleware.constructor.name !== 'AsyncFunction') {
+            throw new TypeError('middleware must be a async function!');
+        }
+        const router = new Router();
+        router.add(METHOD_NAME_OF_ALL, path, middleware);
+        this.middlewareRouters.push(router);
+    }
+    // addRoute('get', '/', handler)
+    addRoute(method, arg, ...args) {
+        method = method.toUpperCase();
+        if (typeof arg === 'string') {
+            this.router.add(method, arg, args);
+        }
+        else {
+            args.unshift(arg);
+            this.router.add(method, this.tempPath, args);
+        }
+        return this;
+    }
+    async matchRoute(method, path) {
+        return this.router.match(method, path);
+    }
+    async dispatch(request, response) {
+        const [method, path] = [request.method, (0, util_1.getPathFromURL)(request.url)];
+        const result = await this.matchRoute(method, path);
+        request.params = (key) => {
+            if (result) {
+                return result.params[key];
+            }
+            return '';
+        };
+        let handler = result ? result.handler[0] : this.notFound; // XXX
+        const middleware = [];
+        for (const mr of this.middlewareRouters) {
+            const mwResult = mr.match(METHOD_NAME_OF_ALL, path);
+            if (mwResult) {
+                middleware.push(mwResult.handler);
+            }
+        }
+        let wrappedHandler = async (context, next) => {
+            context.res = await handler(context);
+            await next();
+        };
+        middleware.push(middleware_1.Middleware.defaultFilter);
+        middleware.push(wrappedHandler);
+        const composed = (0, compose_1.compose)(middleware);
+        const c = new Context(request, response);
+        await composed(c);
+        return c.res;
+    }
+    async handleEvent(event) {
+        return this.dispatch(event.request);
+    }
+    fire() {
+        addEventListener('fetch', (event) => {
+            event.respondWith(this.handleEvent(event));
+        });
+    }
+    notFound() {
+        return new Response('Not Found', { status: 404 });
+    }
+}
+exports.Hono = Hono;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { Hono, Middleware, Context } from './hono';

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.Middleware = exports.Hono = void 0;
+var hono_1 = require("./hono");
+Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
+Object.defineProperty(exports, "Middleware", { enumerable: true, get: function () { return hono_1.Middleware; } });
+Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return hono_1.Context; } });

package/dist/methods.d.ts

@@ -0,0 +1 @@
+export declare const methods: string[];

package/dist/methods.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.methods = void 0;
+exports.methods = [
+    'get',
+    'post',
+    'put',
+    'head',
+    'delete',
+    'options',
+    'trace',
+    'copy',
+    'lock',
+    'mkcol',
+    'move',
+    'patch',
+    'purge',
+    'propfind',
+    'proppatch',
+    'unlock',
+    'report',
+    'mkactivity',
+    'checkout',
+    'merge',
+    'm-search',
+    'notify',
+    'subscribe',
+    'unsubscribe',
+    'search',
+    'connect',
+];

package/dist/middleware/defaultFilter.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '../hono';
+export declare const defaultFilter: (c: Context, next: Function) => Promise<void>;

package/dist/middleware/defaultFilter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFilter = void 0;
+const defaultFilter = async (c, next) => {
+    c.req.query = (key) => {
+        const url = new URL(c.req.url);
+        return url.searchParams.get(key);
+    };
+    await next();
+};
+exports.defaultFilter = defaultFilter;

package/dist/middleware/logger/logger.d.ts

@@ -0,0 +1,5 @@
+import { Context } from '../../hono';
+export declare const logger: (fn?: {
+    (...data: any[]): void;
+    (...data: any[]): void;
+}) => (c: Context, next: Function) => Promise<void>;

package/dist/middleware/logger/logger.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const util_1 = require("../../util");
+const humanize = (n, opts) => {
+    const options = opts || {};
+    const d = options.delimiter || ',';
+    const s = options.separator || '.';
+    n = n.toString().split('.');
+    n[0] = n[0].replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1' + d);
+    return n.join(s);
+};
+const time = (start) => {
+    const delta = Date.now() - start;
+    return humanize([delta < 10000 ? delta + 'ms' : Math.round(delta / 1000) + 's']);
+};
+const LogPrefix = {
+    Outgoing: '-->',
+    Incoming: '<--',
+    Error: 'xxx',
+};
+const colorStatus = (status = 0) => {
+    const out = {
+        7: `\x1b[35m${status}\x1b[0m`,
+        5: `\x1b[31m${status}\x1b[0m`,
+        4: `\x1b[33m${status}\x1b[0m`,
+        3: `\x1b[36m${status}\x1b[0m`,
+        2: `\x1b[32m${status}\x1b[0m`,
+        1: `\x1b[32m${status}\x1b[0m`,
+        0: `\x1b[33m${status}\x1b[0m`,
+    };
+    return out[(status / 100) | 0];
+};
+function log(fn, prefix, method, path, status, elasped) {
+    const out = prefix === LogPrefix.Incoming
+        ? `  ${prefix} ${method} ${path}`
+        : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elasped}`;
+    fn(out);
+}
+const logger = (fn = console.log) => {
+    return async (c, next) => {
+        const { method } = c.req;
+        const path = (0, util_1.getPathFromURL)(c.req.url);
+        log(fn, LogPrefix.Incoming, method, path);
+        const start = Date.now();
+        try {
+            await next();
+        }
+        catch (e) {
+            log(fn, LogPrefix.Error, method, path, c.res.status || 500, time(start));
+            throw e;
+        }
+        log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
+    };
+};
+exports.logger = logger;

package/dist/middleware/poweredBy/poweredBy.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '../../hono';
+export declare const poweredBy: () => (c: Context, next: Function) => Promise<void>;

package/dist/middleware/poweredBy/poweredBy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poweredBy = void 0;
+const poweredBy = () => {
+    return async (c, next) => {
+        await next();
+        // await c.res.headers.append('X-Powered-By', 'Hono')
+        c.res.headers.append('X-Powered-By', 'Hono');
+    };
+};
+exports.poweredBy = poweredBy;

package/dist/middleware.d.ts

@@ -0,0 +1,8 @@
+export declare class Middleware {
+    static defaultFilter: (c: import("./hono").Context, next: Function) => Promise<void>;
+    static poweredBy: () => (c: import("./hono").Context, next: Function) => Promise<void>;
+    static logger: (fn?: {
+        (...data: any[]): void;
+        (...data: any[]): void;
+    }) => (c: import("./hono").Context, next: Function) => Promise<void>;
+}

package/dist/middleware.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = void 0;
+const defaultFilter_1 = require("./middleware/defaultFilter");
+const poweredBy_1 = require("./middleware/poweredBy/poweredBy");
+const logger_1 = require("./middleware/logger/logger");
+class Middleware {
+}
+exports.Middleware = Middleware;
+Middleware.defaultFilter = defaultFilter_1.defaultFilter;
+Middleware.poweredBy = poweredBy_1.poweredBy;
+Middleware.logger = logger_1.logger;

package/dist/node.d.ts

@@ -0,0 +1,24 @@
+export declare class Result<T> {
+    handler: T;
+    params: {
+        [key: string]: string;
+    };
+    constructor(handler: T, params: {
+        [key: string]: string;
+    });
+}
+export declare class Node<T> {
+    method: {
+        [key: string]: T;
+    };
+    handler: T;
+    children: {
+        [key: string]: Node<T>;
+    };
+    middlewares: [];
+    constructor(method?: string, handler?: any, children?: {
+        [key: string]: Node<T>;
+    });
+    insert(method: string, path: string, handler: T): Node<T>;
+    search(method: string, path: string): Result<T>;
+}

package/dist/node.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = exports.Result = void 0;
+const util_1 = require("./util");
+const METHOD_NAME_OF_ALL = 'ALL';
+class Result {
+    constructor(handler, params) {
+        this.handler = handler;
+        this.params = params;
+    }
+}
+exports.Result = Result;
+const noRoute = () => {
+    return null;
+};
+class Node {
+    constructor(method, handler, children) {
+        this.children = children || {};
+        this.method = {};
+        if (method && handler) {
+            this.method[method] = handler;
+        }
+        this.middlewares = [];
+    }
+    insert(method, path, handler) {
+        let curNode = this;
+        const parts = (0, util_1.splitPath)(path);
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const p = parts[i];
+            if (Object.keys(curNode.children).includes(p)) {
+                curNode = curNode.children[p];
+                continue;
+            }
+            curNode.children[p] = new Node();
+            curNode = curNode.children[p];
+        }
+        curNode.method[method] = handler;
+        return curNode;
+    }
+    search(method, path) {
+        let curNode = this;
+        const params = {};
+        let parts = (0, util_1.splitPath)(path);
+        for (let i = 0, len = parts.length; i < len; i++) {
+            const p = parts[i];
+            // '*' => match any path
+            if (curNode.children['*']) {
+                const astNode = curNode.children['*'];
+                if (Object.keys(astNode.children).length === 0) {
+                    curNode = astNode;
+                    break;
+                }
+            }
+            const nextNode = curNode.children[p];
+            if (nextNode) {
+                curNode = nextNode;
+                // '/hello/*' => match '/hello'
+                if (!(i == len - 1 && nextNode.children['*'])) {
+                    continue;
+                }
+            }
+            let isWildcard = false;
+            let isParamMatch = false;
+            const keys = Object.keys(curNode.children);
+            for (let j = 0, len = keys.length; j < len; j++) {
+                const key = keys[j];
+                // Wildcard
+                // '/hello/*/foo' => match /hello/bar/foo
+                if (key === '*') {
+                    curNode = curNode.children['*'];
+                    isWildcard = true;
+                    break;
+                }
+                const pattern = (0, util_1.getPattern)(key);
+                // Named match
+                if (pattern) {
+                    const match = p.match(new RegExp(pattern[1]));
+                    if (match) {
+                        const k = pattern[0];
+                        params[k] = match[1];
+                        curNode = curNode.children[key];
+                        isParamMatch = true;
+                        break;
+                    }
+                    return noRoute();
+                }
+            }
+            if (isWildcard && i === len - 1) {
+                break;
+            }
+            if (isWildcard === false && isParamMatch === false) {
+                return noRoute();
+            }
+        }
+        const handler = curNode.method[METHOD_NAME_OF_ALL] || curNode.method[method];
+        if (!handler) {
+            return noRoute();
+        }
+        return new Result(handler, params);
+    }
+}
+exports.Node = Node;