hono 1.4.0 → 1.4.3

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 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.
+hono - trie-router(default) x 389,510 ops/sec ±3.16% (85 runs sampled)
+hono - regexp-router x 452,290 ops/sec ±2.64% (84 runs sampled)
+itty-router x 206,013 ops/sec ±3.39% (90 runs sampled)
+sunder x 323,131 ops/sec ±0.75% (97 runs sampled)
+worktop x 191,218 ops/sec ±2.70% (91 runs sampled)
+Fastest is hono - regexp-router
+✨  Done in 43.56s.
 ```
 
 ## Why so fast?
@@ -98,7 +98,7 @@ import { basicAuth } from 'hono/basic-auth'
 
 const v1 = new Hono()
 v1.get('/posts', (c) => {
-  return c.text('list pots')
+  return c.text('list posts')
 })
   .post(basicAuth({ username, password }), (c) => {
     return c.text('created!', 201)
@@ -644,7 +644,7 @@ npx wrangler publish ./src/index.ts
 
 You can start making your Cloudflare Workers application with [the starter template](https://github.com/honojs/hono-minimal). It is really minimal using TypeScript, esbuild, Miniflare, and Jest.
 
-To generate a project skelton, run this command.
+To generate a project skeleton, run this command.
 
 ```
 npx create-cloudflare my-app https://github.com/honojs/hono-minimal

package/dist/compose.d.ts

@@ -1,2 +1,2 @@
 import type { ErrorHandler, NotFoundHandler } from './hono';
-export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler, onNotFound?: NotFoundHandler) => (context: C, next?: Function) => Promise<C>;
+export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler<import("./context").Env> | undefined, onNotFound?: NotFoundHandler<import("./context").Env> | undefined) => (context: C, next?: Function | undefined) => Promise<C>;

package/dist/compose.js

@@ -13,29 +13,26 @@ const compose = (middleware, onError, onNotFound) => {
             }
             let handler = middleware[i];
             index = i;
-            if (i === middleware.length)
+            if (i === middleware.length && next)
                 handler = next;
-            if (handler === undefined) {
-                if (context instanceof context_1.Context && context.res.finalized === false) {
+            if (!handler) {
+                if (context instanceof context_1.Context && context.finalized === false && onNotFound) {
                     context.res = onNotFound(context);
-                    context.res.finalized = true;
                 }
                 return Promise.resolve(context);
             }
-            return Promise.resolve(handler(context, dispatch.bind(null, i + 1)))
+            return Promise.resolve(handler(context, () => dispatch(i + 1)))
                 .then(async (res) => {
                 // If handler return Response like `return c.text('foo')`
                 if (res && context instanceof context_1.Context) {
                     context.res = res;
-                    context.res.finalized = true;
                 }
                 return context;
             })
                 .catch((err) => {
-                if (onError && context instanceof context_1.Context) {
+                if (context instanceof context_1.Context && onError) {
                     if (err instanceof Error) {
                         context.res = onError(err, context);
-                        context.res.finalized = true;
                     }
                     return context;
                 }

package/dist/context.d.ts

@@ -1,35 +1,35 @@
 /// <reference types="@cloudflare/workers-types" />
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
-declare type Data = string | ArrayBuffer | ReadableStream;
+export declare type Data = string | ArrayBuffer | ReadableStream;
 export declare type Env = Record<string, any>;
 export declare class Context<RequestParamKeyType extends string = string, E = Env> {
     req: Request<RequestParamKeyType>;
-    res: Response;
     env: E;
-    event: FetchEvent;
+    event: FetchEvent | undefined;
+    finalized: boolean;
     private _status;
     private _pretty;
     private _prettySpace;
     private _map;
+    private _headers;
+    private _res;
+    private notFoundHandler;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
-    notFound: () => Response | Promise<Response>;
-    constructor(req: Request<RequestParamKeyType>, opts?: {
-        env: E;
-        event: FetchEvent;
-        res?: Response;
-    });
-    private initRequest;
+    constructor(req: Request<RequestParamKeyType>, env?: E | undefined, event?: FetchEvent | undefined, notFoundHandler?: (c: Context<string, E>) => Response);
+    get res(): Response;
+    set res(_res: Response);
     header(name: string, value: string): void;
     status(status: StatusCode): void;
     set(key: string, value: any): void;
     get(key: string): any;
     pretty(prettyJSON: boolean, space?: number): void;
-    newResponse(data: Data, init?: ResponseInit): Response;
+    newResponse(data: Data | null, status: StatusCode, headers?: Headers): Response;
     body(data: Data | null, status?: StatusCode, headers?: Headers): Response;
     text(text: string, status?: StatusCode, headers?: Headers): Response;
     json(object: object, status?: StatusCode, headers?: Headers): Response;
     html(html: string, status?: StatusCode, headers?: Headers): Response;
     redirect(location: string, status?: StatusCode): Response;
+    notFound(): Response | Promise<Response>;
 }
 export {};

package/dist/context.js

@@ -3,103 +3,69 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 const url_1 = require("./utils/url");
 class Context {
-    constructor(req, opts) {
+    constructor(req, env = undefined, event = undefined, notFoundHandler = () => new Response()) {
         this._status = 200;
         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;
+        this.req = req;
+        if (env) {
+            this.env = env;
         }
+        this.event = event;
+        this.notFoundHandler = notFoundHandler;
+        this.finalized = false;
     }
-    initRequest(req) {
-        req.header = ((name) => {
-            if (name) {
-                return req.headers.get(name);
-            }
-            else {
-                const result = {};
-                for (const [key, value] of req.headers) {
-                    result[key] = value;
-                }
-                return result;
-            }
-        });
-        req.query = ((key) => {
-            const url = new URL(req.url);
-            if (key) {
-                return url.searchParams.get(key);
-            }
-            else {
-                const result = {};
-                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;
-            }
-        });
-        return req;
+    get res() {
+        return (this._res || (this._res = new Response()));
+    }
+    set res(_res) {
+        this._res = _res;
+        this.finalized = true;
     }
     header(name, value) {
-        this.res.headers.set(name, value);
+        this._headers || (this._headers = {});
+        this._headers[name] = value;
+        if (this.finalized) {
+            this.res.headers.set(name, value);
+        }
     }
     status(status) {
         this._status = status;
     }
     set(key, value) {
+        this._map || (this._map = {});
         this._map[key] = value;
     }
     get(key) {
+        if (!this._map) {
+            return undefined;
+        }
         return this._map[key];
     }
     pretty(prettyJSON, space = 2) {
         this._pretty = prettyJSON;
         this._prettySpace = space;
     }
-    newResponse(data, init = {}) {
-        init.status = init.status || this._status || 200;
-        let headers = {};
-        this.res.headers.forEach((v, k) => {
-            headers[k] = v;
+    newResponse(data, status, headers = {}) {
+        const _headers = { ...this._headers, ...headers };
+        if (this._res) {
+            this._res.headers.forEach((v, k) => {
+                _headers[k] = v;
+            });
+        }
+        return new Response(data, {
+            status: status || this._status || 200,
+            headers: _headers,
         });
-        init.headers = Object.assign(headers, init.headers);
-        headers = {};
-        return new Response(data, init);
     }
     body(data, status = this._status, headers = {}) {
-        return this.newResponse(data, {
-            status: status,
-            headers: headers,
-        });
+        return this.newResponse(data, status, headers);
     }
     text(text, status = this._status, headers = {}) {
-        if (typeof text !== 'string') {
-            throw new TypeError('text method arg must be a string!');
-        }
         headers['Content-Type'] || (headers['Content-Type'] = 'text/plain; charset=UTF-8');
         return this.body(text, status, headers);
     }
     json(object, status = this._status, headers = {}) {
-        if (typeof object !== 'object') {
-            throw new TypeError('json method arg must be an object!');
-        }
         const body = this._pretty
             ? JSON.stringify(object, null, this._prettySpace)
             : JSON.stringify(object);
@@ -107,27 +73,21 @@ class Context {
         return this.body(body, status, headers);
     }
     html(html, status = this._status, headers = {}) {
-        if (typeof html !== 'string') {
-            throw new TypeError('html method arg must be a string!');
-        }
         headers['Content-Type'] || (headers['Content-Type'] = 'text/html; charset=UTF-8');
         return this.body(html, status, headers);
     }
     redirect(location, status = 302) {
-        if (typeof location !== 'string') {
-            throw new TypeError('location must be a string!');
-        }
         if (!(0, url_1.isAbsoluteURL)(location)) {
             const url = new URL(this.req.url);
             url.pathname = location;
             location = url.toString();
         }
-        return this.newResponse(null, {
-            status: status,
-            headers: {
-                Location: location,
-            },
+        return this.newResponse(null, status, {
+            Location: location,
         });
     }
+    notFound() {
+        return this.notFoundHandler(this);
+    }
 }
 exports.Context = Context;

package/dist/hono.d.ts

@@ -2,37 +2,14 @@
 import { Context } from './context';
 import type { Env } from './context';
 import type { Router } from './router';
-declare global {
-    interface Request<ParamKeyType extends string = string> {
-        param: {
-            (key: ParamKeyType): string;
-            (): Record<ParamKeyType, string>;
-        };
-        query: {
-            (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 Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response;
 export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
 declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
 declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
 declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-interface HandlerInterface<T extends string, E = Env, U = Hono<E, T>> {
+interface HandlerInterface<T extends string, E extends Env = Env, U = Hono<E, T>> {
     <Path extends string>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
     (path: string, ...handlers: Handler<string, E>[]): U;
     <Path extends string>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
@@ -44,21 +21,20 @@ interface Route<E extends Env> {
     handler: Handler<string, E>;
 }
 declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
-    delete: HandlerInterface<T, E_1, U>;
-    get: HandlerInterface<T, E_1, U>;
     all: HandlerInterface<T, E_1, U>;
+    get: HandlerInterface<T, E_1, U>;
     post: HandlerInterface<T, E_1, U>;
     put: HandlerInterface<T, E_1, U>;
+    delete: HandlerInterface<T, E_1, U>;
     head: HandlerInterface<T, E_1, U>;
     options: HandlerInterface<T, E_1, U>;
     patch: HandlerInterface<T, E_1, U>;
 };
-export declare class Hono<E = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
+export declare class Hono<E extends Env = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
     readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
     private _tempPath;
     private path;
-    private _cachedResponse;
     routes: Route<E>[];
     constructor(init?: Partial<Pick<Hono, 'router' | 'strict'>>);
     private notFoundHandler;

package/dist/hono.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hono = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
+const request_1 = require("./request");
 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'];
@@ -17,6 +17,7 @@ class Hono extends defineDynamicClass() {
         super();
         this.router = new trie_router_1.TrieRouter();
         this.strict = true; // strict routing - default is true
+        this._tempPath = '';
         this.path = '/';
         this.routes = [];
         this.notFoundHandler = (c) => {
@@ -28,7 +29,8 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
+        (0, request_1.extendRequestPrototype)(); // FIXME: should be executed at a better timing
+        const allMethods = [...methods, router_1.METHOD_NAME_ALL_LOWERCASE];
         allMethods.map((method) => {
             this[method] = (args1, ...args) => {
                 if (typeof args1 === 'string') {
@@ -46,9 +48,6 @@ class Hono extends defineDynamicClass() {
             };
         });
         Object.assign(this, init);
-        this._tempPath = null;
-        this._cachedResponse = new Response(null, { status: 404 });
-        this._cachedResponse.finalized = false;
     }
     route(path, app) {
         this._tempPath = path;
@@ -56,7 +55,7 @@ class Hono extends defineDynamicClass() {
             app.routes.map((r) => {
                 this.addRoute(r.method, r.path, r.handler);
             });
-            this._tempPath = null;
+            this._tempPath = '';
         }
         return this;
     }
@@ -89,30 +88,16 @@ class Hono extends defineDynamicClass() {
         const r = { path: path, method: method, handler: handler };
         this.routes.push(r);
     }
-    async matchRoute(method, path) {
+    matchRoute(method, path) {
         return this.router.match(method, path);
     }
     async dispatch(request, event, env) {
-        const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
+        const path = (0, url_1.getPathFromURL)(request.url, this.strict);
         const method = request.method;
-        const result = await this.matchRoute(method, path);
-        request.param = ((key) => {
-            if (result) {
-                if (key) {
-                    return result.params[key];
-                }
-                else {
-                    return result.params;
-                }
-            }
-        });
+        const result = this.matchRoute(method, path);
+        request.paramData = result?.params;
         const handlers = result ? result.handlers : [this.notFoundHandler];
-        const c = new context_1.Context(request, {
-            env: env,
-            event: event,
-            res: this._cachedResponse,
-        });
-        c.notFound = () => this.notFoundHandler(c);
+        const c = new context_1.Context(request, env, event, this.notFoundHandler);
         const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
         let context;
         try {
@@ -122,9 +107,8 @@ class Hono extends defineDynamicClass() {
             if (err instanceof Error) {
                 return this.errorHandler(err, c);
             }
+            throw err;
         }
-        if (!context.res)
-            return context.notFound();
         return context.res;
     }
     async handleEvent(event) {

package/dist/middleware/basic-auth/index.js

@@ -15,7 +15,7 @@ const auth = (req) => {
     if (!req.headers || typeof req.headers !== 'object') {
         throw new TypeError('argument req is required to have headers property');
     }
-    const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization'));
+    const match = CREDENTIALS_REGEXP.exec(req.headers.get('Authorization') || '');
     if (!match) {
         return undefined;
     }
@@ -49,7 +49,7 @@ const basicAuth = (options, ...users) => {
         ctx.res = new Response('Unauthorized', {
             status: 401,
             headers: {
-                'WWW-Authenticate': 'Basic realm="' + options.realm.replace(/"/g, '\\"') + '"',
+                'WWW-Authenticate': 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"',
             },
         });
     };

package/dist/middleware/cookie/index.js

@@ -4,7 +4,7 @@ exports.cookie = void 0;
 const cookie = () => {
     return async (c, next) => {
         c.req.cookie = ((name) => {
-            const cookie = c.req.headers.get('Cookie');
+            const cookie = c.req.headers.get('Cookie') || '';
             const obj = parse(cookie);
             if (name) {
                 const value = obj[name];

package/dist/middleware/cors/index.d.ts

@@ -8,5 +8,5 @@ declare type CORSOptions = {
     credentials?: boolean;
     exposeHeaders?: string[];
 };
-export declare const cors: (options?: CORSOptions) => (c: Context, next: Next) => Promise<void>;
+export declare const cors: (options?: CORSOptions | undefined) => (c: Context, next: Next) => Promise<void>;
 export {};

package/dist/middleware/cors/index.js

@@ -8,7 +8,10 @@ const cors = (options) => {
         allowHeaders: [],
         exposeHeaders: [],
     };
-    const opts = Object.assign(Object.assign({}, defaults), options);
+    const opts = {
+        ...defaults,
+        ...options,
+    };
     return async (c, next) => {
         await next();
         function set(key, value) {
@@ -23,7 +26,7 @@ const cors = (options) => {
         if (opts.credentials) {
             set('Access-Control-Allow-Credentials', 'true');
         }
-        if (opts.exposeHeaders.length) {
+        if (opts.exposeHeaders?.length) {
             set('Access-Control-Expose-Headers', opts.exposeHeaders.join(','));
         }
         if (c.req.method === 'OPTIONS') {
@@ -31,17 +34,17 @@ const cors = (options) => {
             if (opts.maxAge != null) {
                 set('Access-Control-Max-Age', opts.maxAge.toString());
             }
-            if (opts.allowMethods.length) {
+            if (opts.allowMethods?.length) {
                 set('Access-Control-Allow-Methods', opts.allowMethods.join(','));
             }
             let headers = opts.allowHeaders;
-            if (!headers.length) {
+            if (!headers?.length) {
                 const requestHeaders = c.req.headers.get('Access-Control-Request-Headers');
                 if (requestHeaders) {
                     headers = requestHeaders.split(/\s*,\s*/);
                 }
             }
-            if (headers.length) {
+            if (headers?.length) {
                 set('Access-Control-Allow-Headers', headers.join(','));
                 set('Vary', 'Access-Control-Request-Headers');
             }

package/dist/middleware/etag/index.js

@@ -7,8 +7,9 @@ const etag = (options = { weak: false }) => {
     return async (c, next) => {
         const ifNoneMatch = c.req.header('If-None-Match') || c.req.header('if-none-match');
         await next();
-        const clone = c.res.clone();
-        const body = await (0, body_1.parseBody)(c.res);
+        const res = c.res;
+        const clone = res.clone();
+        const body = await (0, body_1.parseBody)(res);
         const hash = await (0, crypto_1.sha1)(body);
         const etag = options.weak ? `W/"${hash}"` : `"${hash}"`;
         if (ifNoneMatch && ifNoneMatch === etag) {

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: {
@@ -18,7 +18,7 @@ export interface GraphQLParams {
     raw: boolean;
 }
 export declare const getGraphQLParams: (request: Request) => Promise<GraphQLParams>;
-export declare const errorMessages: (messages: string[], graphqlErrors?: readonly GraphQLError[] | readonly GraphQLFormattedError[]) => {
+export declare const errorMessages: (messages: string[], graphqlErrors?: readonly GraphQLError[] | readonly GraphQLFormattedError[] | undefined) => {
     errors: readonly GraphQLError[] | readonly GraphQLFormattedError[];
 } | {
     errors: {

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

@@ -6,20 +6,17 @@ exports.errorMessages = exports.getGraphQLParams = exports.graphqlServer = void
 const graphql_1 = require("graphql");
 const parse_body_1 = require("./parse-body");
 const graphqlServer = (options) => {
-    var _a, _b;
     const schema = options.schema;
     const rootValue = options.rootValue;
-    const pretty = (_a = options.pretty) !== null && _a !== void 0 ? _a : false;
-    const validationRules = (_b = options.validationRules) !== null && _b !== void 0 ? _b : [];
+    const pretty = options.pretty ?? false;
+    const validationRules = options.validationRules ?? [];
     // 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 +25,18 @@ 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;
+            throw e;
         }
         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,15 @@ 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;
+            throw syntaxError;
         }
         // 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 +70,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 +93,14 @@ 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;
+            throw contextError;
         }
-        if (result.data == null) {
-            c.res = c.json((0, exports.errorMessages)([result.errors.toString()], result.errors), 500);
-            return;
+        if (!result.data) {
+            if (result.errors) {
+                return c.json((0, exports.errorMessages)([result.errors.toString()], result.errors), 500);
+            }
         }
         /*
         Now, does not support GraphiQL
@@ -115,33 +109,32 @@ 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;
 const getGraphQLParams = async (request) => {
-    var _a, _b, _c;
     const urlData = new URLSearchParams(request.url.split('?')[1]);
     const bodyData = await (0, parse_body_1.parseBody)(request);
     // GraphQL Query string.
-    let query = (_a = urlData.get('query')) !== null && _a !== void 0 ? _a : bodyData.query;
+    let query = urlData.get('query') ?? bodyData.query;
     if (typeof query !== 'string') {
         query = null;
     }
     // Parse the variables if needed.
-    let variables = ((_b = urlData.get('variables')) !== null && _b !== void 0 ? _b : bodyData.variables);
+    let variables = (urlData.get('variables') ?? bodyData.variables);
     if (typeof variables === 'string') {
         try {
             variables = JSON.parse(variables);
         }
-        catch (_d) {
+        catch {
             throw Error('Variables are invalid JSON.');
         }
     }
@@ -149,7 +142,7 @@ const getGraphQLParams = async (request) => {
         variables = null;
     }
     // Name of GraphQL operation to execute.
-    let operationName = (_c = urlData.get('operationName')) !== null && _c !== void 0 ? _c : bodyData.operationName;
+    let operationName = urlData.get('operationName') ?? bodyData.operationName;
     if (typeof operationName !== 'string') {
         operationName = null;
     }

package/dist/middleware/jwt/index.js

@@ -10,9 +10,9 @@ const jwt = (options) => {
         const credentials = ctx.req.headers.get('Authorization');
         if (!credentials) {
             ctx.res = new Response('Unauthorized', {
-                status: 401,
+                status: 400,
                 headers: {
-                    'WWW-Authenticate': 'Basic ${options.secret}',
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="no authorization included in request"`,
                 },
             });
             return;
@@ -20,9 +20,9 @@ const jwt = (options) => {
         const parts = credentials.split(/\s+/);
         if (parts.length !== 2) {
             ctx.res = new Response('Unauthorized', {
-                status: 401,
+                status: 400,
                 headers: {
-                    'WWW-Authenticate': 'Basic ${options.secret}',
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="no authorization included in request"`,
                 },
             });
             return;
@@ -40,7 +40,7 @@ const jwt = (options) => {
                 status: 401,
                 statusText: msg,
                 headers: {
-                    'WWW-Authenticate': 'Bearer ${options.secret}',
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_token",error_description="token verification failure"`,
                 },
             });
             return;

package/dist/middleware/serve-static/serve-static.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="@cloudflare/workers-types" />
+import type { Env } from '../../context';
 import type { Handler } from '../../hono';
 export declare type ServeStaticOptions = {
     root: string;
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => Handler;
+export declare const serveStatic: (options?: ServeStaticOptions) => Handler<string, Env>;

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

@@ -8,7 +8,7 @@ const DEFAULT_DOCUMENT = 'index.html';
 const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
-        if (c.res && c.res.finalized) {
+        if (c.res && c.finalized) {
             await next();
         }
         const url = new URL(c.req.url);
@@ -33,6 +33,7 @@ const serveStatic = (options = { root: '' }) => {
             console.warn(`Static file: ${path} is not found`);
             await next();
         }
+        return;
     };
 };
 exports.serveStatic = serveStatic;

package/dist/request.d.ts

@@ -0,0 +1,22 @@
+declare global {
+    interface Request<ParamKeyType extends string = string> {
+        param: {
+            (key: ParamKeyType): string;
+            (): Record<ParamKeyType, string>;
+        };
+        paramData?: Record<ParamKeyType, string>;
+        query: {
+            (key: string): string;
+            (): Record<string, string>;
+        };
+        queries: {
+            (key: string): string[];
+            (): Record<string, string[]>;
+        };
+        header: {
+            (name: string): string;
+            (): Record<string, string>;
+        };
+    }
+}
+export declare function extendRequestPrototype(): void;

package/dist/request.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendRequestPrototype = void 0;
+function extendRequestPrototype() {
+    if (!!Request.prototype.param) {
+        // already extended
+        return;
+    }
+    Request.prototype.param = function (key) {
+        if (this.paramData) {
+            if (key) {
+                return this.paramData[key];
+            }
+            else {
+                return this.paramData;
+            }
+        }
+        return null;
+    };
+    Request.prototype.header = function (name) {
+        if (name) {
+            return this.headers.get(name);
+        }
+        else {
+            const result = {};
+            for (const [key, value] of this.headers) {
+                result[key] = value;
+            }
+            return result;
+        }
+    };
+    Request.prototype.query = function (key) {
+        const url = new URL(this.url);
+        if (key) {
+            return url.searchParams.get(key);
+        }
+        else {
+            const result = {};
+            for (const key of url.searchParams.keys()) {
+                result[key] = url.searchParams.get(key) || '';
+            }
+            return result;
+        }
+    };
+    Request.prototype.queries = function (key) {
+        const url = new URL(this.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;
+        }
+    };
+}
+exports.extendRequestPrototype = extendRequestPrototype;

package/dist/router/reg-exp-router/router.js

@@ -158,7 +158,7 @@ class RegExpRouter {
         const handlerWithSortIndex = {
             index,
             handler,
-            componentsLength: hint.components.length,
+            componentsLength: hint.components.length || 1,
         };
         for (let i = 0, len = routes.length; i < len; i++) {
             if (routes[i].method === method && routes[i].path === path) {
@@ -240,6 +240,7 @@ class RegExpRouter {
         return this.match(method, path);
     }
     buildAllMatchers() {
+        // @ts-ignore
         this.routeData.routes.sort(({ hint: a }, { hint: b }) => {
             if (a.componentsLength !== b.componentsLength) {
                 return a.componentsLength - b.componentsLength;
@@ -265,6 +266,7 @@ class RegExpRouter {
         const primaryMatchers = {};
         const secondaryMatchers = {};
         let hasAmbiguous = false;
+        // @ts-ignore
         this.routeData.methods.forEach((method) => {
             let _hasAmbiguous;
             [primaryMatchers[method], secondaryMatchers[method], _hasAmbiguous] =
@@ -280,6 +282,7 @@ class RegExpRouter {
         var _a, _b;
         let hasAmbiguous = false;
         const targetMethods = new Set([method, router_1.METHOD_NAME_ALL]);
+        // @ts-ignore
         const routes = this.routeData.routes.filter(({ method }) => targetMethods.has(method));
         // Reset temporary data per method
         for (let i = 0, len = routes.length; i < len; i++) {
@@ -315,7 +318,7 @@ class RegExpRouter {
                         }
                     }
                     if (routes[j].hint.components.length < routes[i].hint.components.length) {
-                        const componentsLength = routes[j].hint.components.length;
+                        const componentsLength = routes[j].hint.components.length || 1;
                         routes[j].middleware.push(...routes[i].handlers.map((h) => ({
                             componentsLength,
                             index: h.index,

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

@@ -15,6 +15,8 @@ class Trie {
          *  - character
          */
         const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
         this.root.insert(tokens, index, paramMap, this.context);
         return paramMap;
     }

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

@@ -11,10 +11,10 @@ export declare class Node<T> {
     patterns: Pattern[];
     order: number;
     name: string;
+    handlerSetCache: Record<string, HandlerSet<T>[]>;
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
     private getHandlerSets;
-    private next;
-    search(method: string, path: string): Result<T>;
+    search(method: string, path: string): Result<T> | null;
 }
 export {};

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

@@ -28,6 +28,7 @@ class Node {
             this.methods = [m];
         }
         this.patterns = [];
+        this.handlerSetCache = {};
     }
     insert(method, path, handler) {
         this.name = `${method} ${path}`;
@@ -70,7 +71,7 @@ class Node {
             score = score + this.order * 0.01;
         }
         else {
-            score = parts.length + 1 + this.order * 0.01;
+            score = parts.length + this.order * 0.01;
         }
         if (!curNode.methods.length) {
             curNode.methods = [];
@@ -82,93 +83,76 @@ class Node {
         return curNode;
     }
     getHandlerSets(node, method, wildcard) {
-        const handlerSets = [];
-        node.methods.map((m) => {
-            const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
-            if (handlerSet !== undefined) {
-                const hs = Object.assign({}, handlerSet);
-                if (wildcard) {
-                    hs.score = handlerSet.score - 1;
-                }
-                handlerSets.push(hs);
-                return;
-            }
-        });
-        return handlerSets;
-    }
-    next(node, part, method, isLast) {
-        const handlerSets = [];
-        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) {
-                    let wildcard = false;
-                    if (!Object.keys(astNode.children).length) {
-                        wildcard = true;
+        var _a, _b;
+        return ((_a = node.handlerSetCache)[_b = `${method}:${wildcard ? '1' : '0'}`] || (_a[_b] = (() => {
+            const handlerSets = [];
+            node.methods.map((m) => {
+                const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
+                if (handlerSet !== undefined) {
+                    const hs = { ...handlerSet };
+                    if (wildcard) {
+                        hs.score = handlerSet.score - 1;
                     }
-                    handlerSets.push(...this.getHandlerSets(astNode, method, wildcard));
-                    nextNodes.push(astNode);
-                }
-            }
-            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) {
-                        handlerSets.push(...this.getHandlerSets(node.children[key], method));
-                    }
-                    nextNodes.push(node.children[key]);
-                }
-                if (typeof name === 'string') {
-                    params[name] = part;
-                }
-            }
-        }
-        const nextNode = node.children[part];
-        if (nextNode) {
-            if (isLast === true) {
-                // '/hello/*' => match '/hello'
-                if (nextNode.children['*']) {
-                    handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
+                    handlerSets.push(hs);
+                    return;
                 }
-                handlerSets.push(...this.getHandlerSets(nextNode, method));
-            }
-            nextNodes.push(nextNode);
-        }
-        const next = {
-            nodes: nextNodes,
-            handlerSets: handlerSets,
-            params: params,
-        };
-        return next;
+            });
+            return handlerSets;
+        })()));
     }
     search(method, path) {
         const handlerSets = [];
-        let params = {};
+        const 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 part = 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;
+                const node = curNodes[j];
+                for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+                    const pattern = node.patterns[k];
+                    // Wildcard
+                    // '/hello/*/foo' => match /hello/bar/foo
+                    if (pattern === '*') {
+                        const astNode = node.children['*'];
+                        if (astNode) {
+                            handlerSets.push(...this.getHandlerSets(astNode, method));
+                            tempNodes.push(astNode);
+                        }
+                        continue;
+                    }
+                    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) {
+                                handlerSets.push(...this.getHandlerSets(node.children[key], method));
+                            }
+                            tempNodes.push(node.children[key]);
+                        }
+                        if (typeof name === 'string') {
+                            params[name] = part;
+                        }
+                    }
+                }
+                const nextNode = node.children[part];
+                if (nextNode) {
+                    if (isLast === true) {
+                        // '/hello/*' => match '/hello'
+                        if (nextNode.children['*']) {
+                            handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
+                        }
+                        handlerSets.push(...this.getHandlerSets(nextNode, method));
+                    }
+                    tempNodes.push(nextNode);
                 }
-                handlerSets.push(...res.handlerSets);
-                params = Object.assign(params, res.params);
-                tempNodes.push(...res.nodes);
             }
             curNodes = tempNodes;
         }

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

@@ -4,5 +4,5 @@ export declare class TrieRouter<T> implements Router<T> {
     node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;
-    match(method: string, path: string): Result<T>;
+    match(method: string, path: string): Result<T> | null;
 }

package/dist/utils/body.js

@@ -20,5 +20,6 @@ const parseBody = async (r) => {
         }, form);
         return data;
     }
+    return r.arrayBuffer();
 };
 exports.parseBody = parseBody;

package/dist/utils/buffer.d.ts

@@ -1,3 +1,3 @@
 export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
-export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function) => Promise<boolean>;
+export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function | undefined) => Promise<boolean>;
 export declare const bufferToString: (buffer: ArrayBuffer) => string;

package/dist/utils/cloudflare.d.ts

@@ -3,7 +3,7 @@ export declare type KVAssetOptions = {
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions) => Promise<ArrayBuffer>;
+export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions | undefined) => Promise<ArrayBuffer | null>;
 declare type FilePathOptions = {
     filename: string;
     root?: string;

package/dist/utils/cloudflare.js

@@ -28,7 +28,7 @@ const getContentFromKVAsset = async (path, options) => {
     }
     const key = ASSET_MANIFEST[path] || path;
     if (!key) {
-        return;
+        return null;
     }
     let content = await ASSET_NAMESPACE.get(key, { type: 'arrayBuffer' });
     if (content) {

package/dist/utils/crypto.d.ts

@@ -3,7 +3,7 @@ declare type Algorithm = {
     alias: string;
 };
 declare type Data = string | object | boolean;
-export declare const sha256: (data: Data) => Promise<string>;
-export declare const sha1: (data: Data) => Promise<string>;
-export declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string>;
+export declare const sha256: (data: Data) => Promise<string | null>;
+export declare const sha1: (data: Data) => Promise<string | null>;
+export declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string | null>;
 export {};

package/dist/utils/crypto.js

@@ -23,5 +23,6 @@ const createHash = async (data, algorithm) => {
             .join('');
         return hash;
     }
+    return null;
 };
 exports.createHash = createHash;

package/dist/utils/encode.js

@@ -10,7 +10,7 @@ const encodeBase64 = (str) => {
         const bytes = encoder.encode(str);
         return btoa(String.fromCharCode(...bytes));
     }
-    catch (_a) { }
+    catch { }
     try {
         return Buffer.from(str).toString('base64');
     }
@@ -30,7 +30,7 @@ const decodeBase64 = (str) => {
         const decoder = new TextDecoder();
         return decoder.decode(bytes);
     }
-    catch (_a) { }
+    catch { }
     try {
         return Buffer.from(str, 'base64').toString();
     }
@@ -71,6 +71,7 @@ const arrayBufferToBase64 = async (buf) => {
         return Buffer.from(String.fromCharCode(...new Uint8Array(buf))).toString('base64');
     }
     catch (e) { }
+    return '';
 };
 exports.arrayBufferToBase64 = arrayBufferToBase64;
 const arrayBufferToBase64URL = async (buf) => {

package/dist/utils/mime.d.ts

@@ -1 +1 @@
-export declare const getMimeType: (filename: string) => string;
+export declare const getMimeType: (filename: string) => string | undefined;

package/dist/utils/url.d.ts

@@ -1,10 +1,6 @@
 export declare type Pattern = readonly [string, string, RegExp | true] | '*';
 export declare const splitPath: (path: string) => string[];
 export declare const getPattern: (label: string) => Pattern | null;
-declare type Params = {
-    strict: boolean;
-};
-export declare const getPathFromURL: (url: string, params?: Params) => string;
+export declare const getPathFromURL: (url: string, strict?: boolean) => string;
 export declare const isAbsoluteURL: (url: string) => boolean;
 export declare const mergePath: (...paths: string[]) => string;
-export {};

package/dist/utils/url.js

@@ -34,17 +34,15 @@ const getPattern = (label) => {
     return null;
 };
 exports.getPattern = getPattern;
-const getPathFromURL = (url, params = { strict: true }) => {
+const getPathFromURL = (url, strict = true) => {
+    const queryIndex = url.indexOf('?');
+    const result = url.substring(url.indexOf('/', 8), queryIndex === -1 ? url.length : queryIndex);
     // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
     // default is true
-    if (params.strict === false && url.endsWith('/')) {
-        url = url.slice(0, -1);
+    if (strict === false && result.endsWith('/')) {
+        return result.slice(0, -1);
     }
-    const match = url.match(URL_REGEXP);
-    if (match) {
-        return match[1];
-    }
-    return '';
+    return result;
 };
 exports.getPathFromURL = getPathFromURL;
 const isAbsoluteURL = (url) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "1.4.0",
+  "version": "1.4.3",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -133,7 +133,7 @@
     "form-data": "^4.0.0",
     "graphql": "^16.4.0",
     "jest": "27.5.1",
-    "jest-environment-miniflare": "^2.4.0",
+    "jest-environment-miniflare": "^2.5.0",
     "mustache": "^4.2.0",
     "prettier": "^2.6.2",
     "prettier-plugin-md-nocjsp": "^1.2.0",