hono 1.3.4 → 1.4.0

package/README.md

@@ -38,13 +38,13 @@ app.fire()
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-hono - trie-router(default) x 737,602 ops/sec ±3.65% (67 runs sampled)
-hono - regexp-router x 1,188,203 ops/sec ±6.42% (60 runs sampled)
-itty-router x 163,970 ops/sec ±3.05% (91 runs sampled)
-sunder x 344,468 ops/sec ±0.87% (97 runs sampled)
-worktop x 222,044 ops/sec ±2.13% (85 runs sampled)
-Fastest is hono - regexp-router
-✨  Done in 84.04s.
+hono - trie-router(default) x 725,892 ops/sec ±4.02% (74 runs sampled)
+hono - regexp-router x 733,494 ops/sec ±3.00% (67 runs sampled)
+itty-router x 167,167 ops/sec ±1.25% (91 runs sampled)
+sunder x 327,697 ops/sec ±2.45% (92 runs sampled)
+worktop x 216,468 ops/sec ±3.01% (85 runs sampled)
+Fastest is hono - regexp-router,hono - trie-router(default)
+✨  Done in 69.57s.
 ```
 
 ## Why so fast?
@@ -137,10 +137,10 @@ npm install hono
 
 An instance of `Hono` has these methods.
 
-- app.**HTTP_METHOD**(\[path,\] handler|middleware...)
-- app.**all**(\[path,\] handler|middleware...)
+- app.**HTTP_METHOD**(\[path,\]handler|middleware...)
+- app.**all**(\[path,\]handler|middleware...)
 - app.**route**(path, \[app\])
-- app.**use**(\[path,\] middleware)
+- app.**use**(\[path,\]middleware)
 - app.**notFound**(handler)
 - app.**onError**(err, handler)
 - app.**fire**()
@@ -249,12 +249,37 @@ app.route('/book', book)
 
 ## Middleware
 
-Middleware operate after/before executing Handler. We can get `Response` before dispatching or manipulate `Response` after dispatching.
+Middleware works after/before Handler. We can get `Request` before dispatching or manipulate `Response` after dispatching.
 
 ### Definition of Middleware
 
-- Handler - should return `Response` object.
-- Middleware - should return nothing, do `await next()`
+- Handler - should return `Response` object. Only one handler will be called.
+- Middleware - should return nothing, will be proceeded to next middleware with `await next()`
+
+The user can register middleware using `c.use` or using `c.HTTP_METHOD` as well as the handlers. For this feature, it's easy to specify the path and the method.
+
+```ts
+// match any method, all routes
+app.use('*', logger())
+
+// specify path
+app.use('/posts/*', cors())
+
+// specify method and path
+app.post('/posts/*', basicAuth(), bodyParse())
+```
+
+If the handler returns `Response`, it will be used for the end-user, and stopping the processing.
+
+```ts
+app.post('/posts', (c) => c.text('Created!', 201))
+```
+
+In this case, four middleware are processed before dispatching like this:
+
+```ts
+logger() -> cors() -> basicAuth() -> bodyParse() -> *handler*
+```
 
 ### Built-in Middleware
 
@@ -354,6 +379,14 @@ app.get('/search', (c) => {
   ...
 })
 
+// Multiple query values
+app.get('/search', (c) => {
+  const queries = c.req.queries('q')
+  // ---> GET search?q=foo&q=bar
+  // queries[0] => foo, queries[1] => bar
+  ...
+})
+
 // Captured params
 app.get('/entry/:id', (c) => {
   const id = c.req.param('id')
@@ -382,7 +415,6 @@ The Response is the same as below.
 ```ts
 new Response('Thank you for comming', {
   status: 201,
-  statusText: 'Created',
   headers: {
     'X-Message': 'Hello',
     'Content-Type': 'text/plain',
@@ -510,6 +542,49 @@ test('GET /hello is ok', async () => {
 })
 ```
 
+## router
+
+The `router` option specify which router is used inside. The default router is `TrieRouter`. If you want to use `RexExpRouter`, write like this:
+
+```ts
+import { RegExpRouter } from 'hono/router/reg-exp-router'
+
+const app = new Hono({ router: new RegExpRouter() })
+```
+
+## Routing Ordering
+
+The routing priority is decided by the order of registration. Only one handler will be dispatched.
+
+```ts
+app.get('/book/a', (c) => c.text('a')) // a
+app.get('/book/:slug', (c) => c.text('common')) // common
+```
+
+```http
+GET /book/a ---> `a` // common will not be dispatched
+GET /book/b ---> `common` // a will not be dispatched
+```
+
+All scoring rules:
+
+```ts
+app.get('/api/*', 'c') // score 1.1 <--- `/*` is special wildcard
+app.get('/api/:type/:id', 'd') // score 3.2
+app.get('/api/posts/:id', 'e') // score 3.3
+app.get('/api/posts/123', 'f') // score 3.4
+app.get('/*/*/:id', 'g') // score 3.5
+app.get('/api/posts/*/comment', 'h') // score 4.6 - not match
+app.get('*', 'a') // score 0.7
+app.get('*', 'b') // score 0.8
+```
+
+```plain
+GET /api/posts/123
+---> will match => c, d, e, f, b, a, b
+---> sort by score => a, b, c, d, e, f, g
+```
+
 ## Cloudflare Workers with Hono
 
 Using [Wrangler](https://developers.cloudflare.com/workers/cli-wrangler/), you can develop the application locally and publish it with few commands.
@@ -584,7 +659,7 @@ import { Hono } from 'hono'
 import { cors } from 'hono/cors'
 import { basicAuth } from 'hono/basic-auth'
 import { prettyJSON } from 'hono/pretty-json'
-import { getPosts, getPosts, createPost } from './model'
+import { getPosts, getPost, createPost, Post } from './model'
 
 const app = new Hono()
 app.get('/', (c) => c.text('Pretty Blog API'))
@@ -597,6 +672,7 @@ export interface Bindings {
 }
 
 const api = new Hono<Bindings>()
+api.use('/posts/*', cors())
 
 api.get('/posts', (c) => {
   const { limit, offset } = c.req.query()
@@ -617,14 +693,12 @@ api.post(
     await auth(c, next)
   },
   async (c) => {
-    const post = await c.req.json<POST>()
+    const post = await c.req.json<Post>()
     const ok = createPost({ post })
     return c.json({ ok })
   }
 )
 
-app.use('/posts/*', cors())
-
 app.route('/api', api)
 
 export default app

package/dist/compose.js

@@ -1,6 +1,9 @@
-import { Context } from './context';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compose = void 0;
+const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
-export const compose = (middleware, onError, onNotFound) => {
+const compose = (middleware, onError, onNotFound) => {
     return async (context, next) => {
         let index = -1;
         return dispatch(0);
@@ -13,24 +16,26 @@ export const compose = (middleware, onError, onNotFound) => {
             if (i === middleware.length)
                 handler = next;
             if (handler === undefined) {
-                if (context instanceof Context && context.res === undefined) {
+                if (context instanceof context_1.Context && context.res.finalized === false) {
                     context.res = onNotFound(context);
+                    context.res.finalized = true;
                 }
                 return Promise.resolve(context);
             }
             return Promise.resolve(handler(context, dispatch.bind(null, i + 1)))
                 .then(async (res) => {
                 // If handler return Response like `return c.text('foo')`
-                if (res && context instanceof Context) {
+                if (res && context instanceof context_1.Context) {
                     context.res = res;
-                    dispatch(i + 1); // <--- Call next()
+                    context.res.finalized = true;
                 }
                 return context;
             })
                 .catch((err) => {
-                if (onError && context instanceof Context) {
+                if (onError && context instanceof context_1.Context) {
                     if (err instanceof Error) {
                         context.res = onError(err, context);
+                        context.res.finalized = true;
                     }
                     return context;
                 }
@@ -41,3 +46,4 @@ export const compose = (middleware, onError, onNotFound) => {
         }
     };
 };
+exports.compose = compose;

package/dist/context.d.ts

@@ -8,18 +8,16 @@ export declare class Context<RequestParamKeyType extends string = string, E = En
     res: Response;
     env: E;
     event: FetchEvent;
-    private _headers;
     private _status;
-    private _statusText;
     private _pretty;
     private _prettySpace;
     private _map;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
     notFound: () => Response | Promise<Response>;
     constructor(req: Request<RequestParamKeyType>, opts?: {
-        res: Response;
         env: E;
         event: FetchEvent;
+        res?: Response;
     });
     private initRequest;
     header(name: string, value: string): void;

package/dist/context.js

@@ -1,16 +1,20 @@
-import { getStatusText } from './utils/http-status';
-import { isAbsoluteURL } from './utils/url';
-export class Context {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const url_1 = require("./utils/url");
+class Context {
     constructor(req, opts) {
-        this.res = undefined;
-        this._headers = {};
         this._status = 200;
-        this._statusText = '';
         this._pretty = false;
         this._prettySpace = 2;
         this.req = this.initRequest(req);
         this._map = {};
         Object.assign(this, opts);
+        if (!this.res) {
+            const res = new Response(null, { status: 404 });
+            res.finalized = false;
+            this.res = res;
+        }
     }
     initRequest(req) {
         req.header = ((name) => {
@@ -32,8 +36,21 @@ export class Context {
             }
             else {
                 const result = {};
-                for (const [key, value] of url.searchParams) {
-                    result[key] = value;
+                for (const key of url.searchParams.keys()) {
+                    result[key] = url.searchParams.get(key);
+                }
+                return result;
+            }
+        });
+        req.queries = ((key) => {
+            const url = new URL(req.url);
+            if (key) {
+                return url.searchParams.getAll(key);
+            }
+            else {
+                const result = {};
+                for (const key of url.searchParams.keys()) {
+                    result[key] = url.searchParams.getAll(key);
                 }
                 return result;
             }
@@ -41,14 +58,10 @@ export class Context {
         return req;
     }
     header(name, value) {
-        if (this.res) {
-            this.res.headers.set(name, value);
-        }
-        this._headers[name] = value;
+        this.res.headers.set(name, value);
     }
     status(status) {
         this._status = status;
-        this._statusText = getStatusText(status);
     }
     set(key, value) {
         this._map[key] = value;
@@ -62,12 +75,15 @@ export class Context {
     }
     newResponse(data, init = {}) {
         init.status = init.status || this._status || 200;
-        init.statusText =
-            init.statusText || this._statusText || getStatusText(init.status);
-        init.headers = { ...this._headers, ...init.headers };
+        let headers = {};
+        this.res.headers.forEach((v, k) => {
+            headers[k] = v;
+        });
+        init.headers = Object.assign(headers, init.headers);
+        headers = {};
         return new Response(data, init);
     }
-    body(data, status = this._status, headers = this._headers) {
+    body(data, status = this._status, headers = {}) {
         return this.newResponse(data, {
             status: status,
             headers: headers,
@@ -101,7 +117,7 @@ export class Context {
         if (typeof location !== 'string') {
             throw new TypeError('location must be a string!');
         }
-        if (!isAbsoluteURL(location)) {
+        if (!(0, url_1.isAbsoluteURL)(location)) {
             const url = new URL(this.req.url);
             url.pathname = location;
             location = url.toString();
@@ -114,3 +130,4 @@ export class Context {
         });
     }
 }
+exports.Context = Context;

package/dist/hono.d.ts

@@ -12,11 +12,18 @@ declare global {
             (key: string): string;
             (): Record<string, string>;
         };
+        queries: {
+            (key: string): string[];
+            (): Record<string, string[]>;
+        };
         header: {
             (name: string): string;
             (): Record<string, string>;
         };
     }
+    interface Response {
+        finalized: boolean;
+    }
 }
 export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | void | Promise<void>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response;
@@ -47,15 +54,13 @@ declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     patch: HandlerInterface<T, E_1, U>;
 };
 export declare class Hono<E = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
-    readonly routerClass: {
-        new (): Router<any>;
-    };
+    readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
-    private _router;
     private _tempPath;
     private path;
+    private _cachedResponse;
     routes: Route<E>[];
-    constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
+    constructor(init?: Partial<Pick<Hono, 'router' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
     route(path: string, app?: Hono<any>): Hono<E, P>;

package/dist/hono.js

@@ -1,18 +1,21 @@
-import { compose } from './compose';
-import { Context } from './context';
-import { METHOD_NAME_ALL } from './router';
-import { METHOD_NAME_ALL_LOWERCASE } from './router';
-import { TrieRouter } from './router/trie-router'; // Default Router
-import { getPathFromURL, mergePath } from './utils/url';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hono = void 0;
+const compose_1 = require("./compose");
+const context_1 = require("./context");
+const router_1 = require("./router");
+const router_2 = require("./router");
+const trie_router_1 = require("./router/trie-router"); // Default Router
+const url_1 = require("./utils/url");
 const methods = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
 function defineDynamicClass() {
     return class {
     };
 }
-export class Hono extends defineDynamicClass() {
+class Hono extends defineDynamicClass() {
     constructor(init = {}) {
         super();
-        this.routerClass = TrieRouter;
+        this.router = new trie_router_1.TrieRouter();
         this.strict = true; // strict routing - default is true
         this.path = '/';
         this.routes = [];
@@ -25,7 +28,7 @@ export class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        const allMethods = [...methods, METHOD_NAME_ALL_LOWERCASE];
+        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
         allMethods.map((method) => {
             this[method] = (args1, ...args) => {
                 if (typeof args1 === 'string') {
@@ -43,8 +46,9 @@ export class Hono extends defineDynamicClass() {
             };
         });
         Object.assign(this, init);
-        this._router = new this.routerClass();
         this._tempPath = null;
+        this._cachedResponse = new Response(null, { status: 404 });
+        this._cachedResponse.finalized = false;
     }
     route(path, app) {
         this._tempPath = path;
@@ -64,7 +68,7 @@ export class Hono extends defineDynamicClass() {
             handlers.unshift(arg1);
         }
         handlers.map((handler) => {
-            this.addRoute(METHOD_NAME_ALL, this.path, handler);
+            this.addRoute(router_1.METHOD_NAME_ALL, this.path, handler);
         });
         return this;
     }
@@ -79,17 +83,17 @@ export class Hono extends defineDynamicClass() {
     addRoute(method, path, handler) {
         method = method.toUpperCase();
         if (this._tempPath) {
-            path = mergePath(this._tempPath, path);
+            path = (0, url_1.mergePath)(this._tempPath, path);
         }
-        this._router.add(method, path, handler);
+        this.router.add(method, path, handler);
         const r = { path: path, method: method, handler: handler };
         this.routes.push(r);
     }
     async matchRoute(method, path) {
-        return this._router.match(method, path);
+        return this.router.match(method, path);
     }
     async dispatch(request, event, env) {
-        const path = getPathFromURL(request.url, { strict: this.strict });
+        const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
         const method = request.method;
         const result = await this.matchRoute(method, path);
         request.param = ((key) => {
@@ -103,9 +107,13 @@ export class Hono extends defineDynamicClass() {
             }
         });
         const handlers = result ? result.handlers : [this.notFoundHandler];
-        const c = new Context(request, { env: env, event: event, res: undefined });
+        const c = new context_1.Context(request, {
+            env: env,
+            event: event,
+            res: this._cachedResponse,
+        });
         c.notFound = () => this.notFoundHandler(c);
-        const composed = compose(handlers, this.errorHandler, this.notFoundHandler);
+        const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
         let context;
         try {
             context = await composed(c);
@@ -135,3 +143,4 @@ export class Hono extends defineDynamicClass() {
         });
     }
 }
+exports.Hono = Hono;

package/dist/middleware/jwt/index.js

@@ -8,7 +8,6 @@ const jwt = (options) => {
     }
     return async (ctx, next) => {
         const credentials = ctx.req.headers.get('Authorization');
-        await next();
         if (!credentials) {
             ctx.res = new Response('Unauthorized', {
                 status: 401,
@@ -26,6 +25,7 @@ const jwt = (options) => {
                     'WWW-Authenticate': 'Basic ${options.secret}',
                 },
             });
+            return;
         }
         let authorized = false;
         let msg = '';
@@ -43,7 +43,9 @@ const jwt = (options) => {
                     'WWW-Authenticate': 'Bearer ${options.secret}',
                 },
             });
+            return;
         }
+        await next();
     };
 };
 exports.jwt = jwt;

package/dist/middleware/mustache/mustache.js

@@ -1,19 +1,19 @@
-import { bufferToString } from '../../utils/buffer';
-import { getContentFromKVAsset, getKVFilePath } from '../../utils/cloudflare';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mustache = void 0;
+const mustache_1 = __importDefault(require("mustache"));
+const buffer_1 = require("../../utils/buffer");
+const cloudflare_1 = require("../../utils/cloudflare");
 const EXTENSION = '.mustache';
 const DEFAULT_DOCUMENT = 'index.mustache';
-export const mustache = (init = { root: '' }) => {
+const mustache = (init = { root: '' }) => {
     const { root } = init;
     return async (c, next) => {
-        let Mustache;
-        try {
-            Mustache = require('mustache');
-        }
-        catch {
-            throw new Error('If you want to use Mustache Middleware, install "mustache" package first.');
-        }
         c.render = async (filename, params = {}, options) => {
-            const path = getKVFilePath({
+            const path = (0, cloudflare_1.getKVFilePath)({
                 filename: `${filename}${EXTENSION}`,
                 root: root,
                 defaultDocument: DEFAULT_DOCUMENT,
@@ -22,30 +22,31 @@ export const mustache = (init = { root: '' }) => {
                 manifest: init.manifest,
                 namespace: init.namespace ? init.namespace : c.env ? c.env.__STATIC_CONTENT : undefined,
             };
-            const buffer = await getContentFromKVAsset(path, kvAssetOptions);
+            const buffer = await (0, cloudflare_1.getContentFromKVAsset)(path, kvAssetOptions);
             if (!buffer) {
                 throw new Error(`Template "${path}" is not found or blank.`);
             }
-            const content = bufferToString(buffer);
+            const content = (0, buffer_1.bufferToString)(buffer);
             const partialArgs = {};
             if (options) {
                 const partials = options;
                 for (const key of Object.keys(partials)) {
-                    const partialPath = getKVFilePath({
+                    const partialPath = (0, cloudflare_1.getKVFilePath)({
                         filename: `${partials[key]}${EXTENSION}`,
                         root: root,
                         defaultDocument: DEFAULT_DOCUMENT,
                     });
-                    const partialBuffer = await getContentFromKVAsset(partialPath, kvAssetOptions);
+                    const partialBuffer = await (0, cloudflare_1.getContentFromKVAsset)(partialPath, kvAssetOptions);
                     if (!partialBuffer) {
                         throw new Error(`Partial Template "${partialPath}" is not found or blank.`);
                     }
-                    partialArgs[key] = bufferToString(partialBuffer);
+                    partialArgs[key] = (0, buffer_1.bufferToString)(partialBuffer);
                 }
             }
-            const output = Mustache.render(content, params, partialArgs);
+            const output = mustache_1.default.render(content, params, partialArgs);
             return c.html(output);
         };
         await next();
     };
 };
+exports.mustache = mustache;

package/dist/middleware/serve-static/serve-static.js

@@ -1,25 +1,28 @@
-import { getContentFromKVAsset, getKVFilePath } from '../../utils/cloudflare';
-import { getMimeType } from '../../utils/mime';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStatic = void 0;
+const cloudflare_1 = require("../../utils/cloudflare");
+const mime_1 = require("../../utils/mime");
 const DEFAULT_DOCUMENT = 'index.html';
 // This middleware is available only on Cloudflare Workers.
-export const serveStatic = (options = { root: '' }) => {
+const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
-        if (c.res) {
+        if (c.res && c.res.finalized) {
             await next();
         }
         const url = new URL(c.req.url);
-        const path = getKVFilePath({
+        const path = (0, cloudflare_1.getKVFilePath)({
             filename: url.pathname,
             root: options.root,
             defaultDocument: DEFAULT_DOCUMENT,
         });
-        const content = await getContentFromKVAsset(path, {
+        const content = await (0, cloudflare_1.getContentFromKVAsset)(path, {
             manifest: options.manifest,
             namespace: options.namespace ? options.namespace : c.env ? c.env.__STATIC_CONTENT : undefined,
         });
         if (content) {
-            const mimeType = getMimeType(path);
+            const mimeType = (0, mime_1.getMimeType)(path);
             if (mimeType) {
                 c.header('Content-Type', mimeType);
             }
@@ -32,3 +35,4 @@ export const serveStatic = (options = { root: '' }) => {
         }
     };
 };
+exports.serveStatic = serveStatic;

package/dist/router/reg-exp-router/router.d.ts

@@ -1,4 +1,4 @@
-import { Router, Result } from '../../router';
+import type { Router, Result } from '../../router';
 interface Hint {
     components: string[];
     regExpComponents: Array<true | string>;
@@ -8,16 +8,22 @@ interface Hint {
     maybeHandler: boolean;
     namedParams: [number, string, string][];
 }
+interface HandlerWithSortIndex<T> {
+    handler: T;
+    index: number;
+    componentsLength: number;
+}
 interface Route<T> {
     method: string;
     path: string;
     hint: Hint;
-    handlers: T[];
-    middleware: T[];
+    handlers: HandlerWithSortIndex<T>[];
+    middleware: HandlerWithSortIndex<T>[];
     paramAliasMap: Record<string, string[]>;
 }
-export declare class RegExpRouter<T> extends Router<T> {
+export declare class RegExpRouter<T> implements Router<T> {
     routeData?: {
+        index: number;
         routes: Route<T>[];
         methods: Set<string>;
     };