hono 1.3.5 → 1.4.1

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,14 +542,47 @@ test('GET /hello is ok', async () => {
 })
 ```
 
-## routerClass
+## router
 
-The `routerClass` option specify which router is used inside. The default router is `TrieRouter`. If you want to use `RexExpRouter`, write like this:
+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({ routerClass: RegExpRouter })
+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
@@ -607,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()
@@ -633,8 +699,6 @@ api.post(
   }
 )
 
-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/graphql-server/index.d.ts

@@ -8,7 +8,7 @@ declare type Options = {
     pretty?: boolean;
     validationRules?: ReadonlyArray<ValidationRule>;
 };
-export declare const graphqlServer: (options: Options) => (c: Context, next: Next) => Promise<void>;
+export declare const graphqlServer: (options: Options) => (c: Context, next: Next) => Promise<Response>;
 export interface GraphQLParams {
     query: string | null;
     variables: {

package/dist/middleware/graphql-server/index.js

@@ -13,13 +13,11 @@ const graphqlServer = (options) => {
     const validationRules = (_b = options.validationRules) !== null && _b !== void 0 ? _b : [];
     // const showGraphiQL = options.graphiql ?? false
     return async (c, next) => {
-        await next();
         // GraphQL HTTP only supports GET and POST methods.
         if (c.req.method !== 'GET' && c.req.method !== 'POST') {
-            c.res = c.json((0, exports.errorMessages)(['GraphQL only supports GET and POST requests.']), 405, {
+            return c.json((0, exports.errorMessages)(['GraphQL only supports GET and POST requests.']), 405, {
                 Allow: 'GET, POST',
             });
-            return;
         }
         let params;
         try {
@@ -28,20 +26,17 @@ const graphqlServer = (options) => {
         catch (e) {
             if (e instanceof Error) {
                 console.error(`${e.stack || e.message}`);
-                c.res = c.json((0, exports.errorMessages)([e.message], [e]), 400);
+                return c.json((0, exports.errorMessages)([e.message], [e]), 400);
             }
-            return;
         }
         const { query, variables, operationName } = params;
         if (query == null) {
-            c.res = c.json((0, exports.errorMessages)(['Must provide query string.']), 400);
-            return;
+            return c.json((0, exports.errorMessages)(['Must provide query string.']), 400);
         }
         const schemaValidationErrors = (0, graphql_1.validateSchema)(schema);
         if (schemaValidationErrors.length > 0) {
             // Return 500: Internal Server Error if invalid schema.
-            c.res = c.json((0, exports.errorMessages)(['GraphQL schema validation error.'], schemaValidationErrors), 500);
-            return;
+            return c.json((0, exports.errorMessages)(['GraphQL schema validation error.'], schemaValidationErrors), 500);
         }
         let documentAST;
         try {
@@ -54,16 +49,14 @@ const graphqlServer = (options) => {
                 const e = new graphql_1.GraphQLError(syntaxError.message, {
                     originalError: syntaxError,
                 });
-                c.res = c.json((0, exports.errorMessages)(['GraphQL syntax error.'], [e]), 400);
+                return c.json((0, exports.errorMessages)(['GraphQL syntax error.'], [e]), 400);
             }
-            return;
         }
         // Validate AST, reporting any errors.
         const validationErrors = (0, graphql_1.validate)(schema, documentAST, [...graphql_1.specifiedRules, ...validationRules]);
         if (validationErrors.length > 0) {
             // Return 400: Bad Request if any validation errors exist.
-            c.res = c.json((0, exports.errorMessages)(['GraphQL validation error.'], validationErrors), 400);
-            return;
+            return c.json((0, exports.errorMessages)(['GraphQL validation error.'], validationErrors), 400);
         }
         if (c.req.method === 'GET') {
             // Determine if this GET request will perform a non-query.
@@ -76,10 +69,9 @@ const graphqlServer = (options) => {
                 }
                 */
                 // Otherwise, report a 405: Method Not Allowed error.
-                c.res = c.json((0, exports.errorMessages)([
+                return c.json((0, exports.errorMessages)([
                     `Can only perform a ${operationAST.operation} operation from a POST request.`,
                 ]), 405, { Allow: 'POST' });
-                return;
             }
         }
         let result;
@@ -100,13 +92,11 @@ const graphqlServer = (options) => {
                     nodes: documentAST,
                 });
                 // Return 400: Bad Request if any execution context errors exist.
-                c.res = c.json((0, exports.errorMessages)(['GraphQL execution context error.'], [e]), 400);
+                return c.json((0, exports.errorMessages)(['GraphQL execution context error.'], [e]), 400);
             }
-            return;
         }
         if (result.data == null) {
-            c.res = c.json((0, exports.errorMessages)([result.errors.toString()], result.errors), 500);
-            return;
+            return c.json((0, exports.errorMessages)([result.errors.toString()], result.errors), 500);
         }
         /*
         Now, does not support GraphiQL
@@ -115,14 +105,14 @@ const graphqlServer = (options) => {
         */
         if (pretty) {
             const payload = JSON.stringify(result, null, pretty ? 2 : 0);
-            c.res = c.text(payload, 200, {
+            return c.text(payload, 200, {
                 'Content-Type': 'application/json',
             });
         }
         else {
-            c.res = c.json(result);
+            return c.json(result);
         }
-        return;
+        await next(); // XXX
     };
 };
 exports.graphqlServer = graphqlServer;

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,13 +1,19 @@
-import Mustache from 'mustache';
-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) => {
         c.render = async (filename, params = {}, options) => {
-            const path = getKVFilePath({
+            const path = (0, cloudflare_1.getKVFilePath)({
                 filename: `${filename}${EXTENSION}`,
                 root: root,
                 defaultDocument: DEFAULT_DOCUMENT,
@@ -16,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;