hono 1.4.7 → 1.5.2

package/README.md

@@ -483,10 +483,22 @@ app.use('/', async (c, next) => {
 })
 ```
 
+### c.executionCtx
+
+```ts
+// ExecutionContext object
+app.get('/foo', async (c) => {
+  c.executionCtx.waitUntil(
+    c.env.KV.put(key, data)
+  )
+  ...
+})
+```
+
 ### c.event
 
 ```ts
-// FetchEvent object
+// FetchEvent object (only set when using Service Worker syntax)
 app.get('/foo', async (c) => {
   c.event.waitUntil(
     c.env.KV.put(key, data)
@@ -523,8 +535,8 @@ addEventListener('fetch', (event) => {
 
 ```ts
 export default {
-  fetch(request: Request, env: Env, event: FetchEvent) {
-    return app.fetch(request, env, event)
+  fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    return app.fetch(request, env, ctx)
   },
 }
 ```
@@ -556,9 +568,9 @@ import { RegExpRouter } from 'hono/router/reg-exp-router'
 const app = new Hono({ router: new RegExpRouter() })
 ```
 
-## Routing Ordering
+## Routing priority
 
-The routing priority is decided by the order of registration. Only one handler will be dispatched.
+Handlers or middleware will be executed in registration order.
 
 ```ts
 app.get('/book/a', (c) => c.text('a')) // a
@@ -566,27 +578,37 @@ 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
+GET /book/a ---> `a`
+GET /book/b ---> `common`
 ```
 
-All scoring rules:
+When a handler is executed, the process will be stopped.
 
 ```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
+app.get('*', (c) => c.text('common')) // common
+app.get('/foo', (c) => c.text('foo')) // foo
 ```
 
-```plain
-GET /api/posts/123
----> will match => c, d, e, f, b, a, b
----> sort by score => a, b, c, d, e, f, g
+```http
+GET /foo ---> `common` // foo will not be dispatched
+```
+
+If you have the middleware that you want to execute, write the code above the handler.
+
+```ts
+app.use('*', logger())
+app.get('/foo', (c) => c.text('foo'))
+```
+
+If you want a "_fallback_" handler, write the code below the other handler.
+
+```ts
+app.get('/foo', (c) => c.text('foo')) // foo
+app.get('*', (c) => c.text('fallback')) // fallback
+```
+
+```http
+GET /bar ---> `fallback`
 ```
 
 ## Cloudflare Workers with Hono

package/dist/context.d.ts

@@ -1,13 +1,15 @@
 /// <reference types="@cloudflare/workers-types" />
 import type { NotFoundHandler } from './hono';
+import type { HonoRequest } from './request';
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
 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>;
+    req: HonoRequest<RequestParamKeyType>;
     env: E;
     event: FetchEvent | undefined;
+    executionCtx: ExecutionContext | undefined;
     finalized: boolean;
     private _status;
     private _pretty;
@@ -17,7 +19,7 @@ export declare class Context<RequestParamKeyType extends string = string, E = En
     private _res;
     private notFoundHandler;
     render: (content: string, params?: object, options?: object) => Response | Promise<Response>;
-    constructor(req: Request<RequestParamKeyType>, env?: E | undefined, event?: FetchEvent | undefined, notFoundHandler?: NotFoundHandler);
+    constructor(req: HonoRequest | Request, env?: E | undefined, eventOrExecutionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
     get res(): Response;
     set res(_res: Response);
     header(name: string, value: string): void;

package/dist/context.js

@@ -1,17 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
+const request_1 = require("./request");
 const url_1 = require("./utils/url");
 class Context {
-    constructor(req, env = undefined, event = undefined, notFoundHandler = () => new Response()) {
+    constructor(req, env = undefined, eventOrExecutionCtx = undefined, notFoundHandler = () => new Response()) {
         this._status = 200;
         this._pretty = false;
         this._prettySpace = 2;
-        this.req = req;
+        if (req instanceof Request) {
+            this.req = (0, request_1.extendHonoRequest)(req);
+        }
+        else {
+            this.req = req;
+        }
         if (env) {
             this.env = env;
         }
-        this.event = event;
+        this.executionCtx = eventOrExecutionCtx;
+        if (eventOrExecutionCtx && 'respondWith' in eventOrExecutionCtx) {
+            this.event = eventOrExecutionCtx;
+        }
         this.notFoundHandler = notFoundHandler;
         this.finalized = false;
     }

package/dist/hono.d.ts

@@ -48,7 +48,7 @@ export declare class Hono<E extends Env = Env, P extends string = '/'> extends H
     private matchRoute;
     private dispatch;
     handleEvent(event: FetchEvent): Promise<Response>;
-    fetch(request: Request, env?: E, event?: FetchEvent): Promise<Response>;
+    fetch(request: Request, env?: E, executionCtx?: ExecutionContext): Promise<Response>;
     request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
     fire(): void;
 }

package/dist/hono.js

@@ -29,7 +29,6 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        (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) => {
@@ -91,13 +90,14 @@ class Hono extends defineDynamicClass() {
     matchRoute(method, path) {
         return this.router.match(method, path);
     }
-    async dispatch(request, event, env) {
+    async dispatch(request, executionCtx, env) {
+        request = (0, request_1.extendHonoRequest)(request);
         const path = (0, url_1.getPathFromURL)(request.url, this.strict);
         const method = request.method;
         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, event, this.notFoundHandler);
+        const c = new context_1.Context(request, env, executionCtx, this.notFoundHandler);
         const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
         let context;
         try {
@@ -117,8 +117,8 @@ class Hono extends defineDynamicClass() {
     async handleEvent(event) {
         return this.dispatch(event.request, event);
     }
-    async fetch(request, env, event) {
-        return this.dispatch(request, event, env);
+    async fetch(request, env, executionCtx) {
+        return this.dispatch(request, executionCtx, env);
     }
     request(input, requestInit) {
         const req = input instanceof Request ? input : new Request(input, requestInit);

package/dist/middleware/body-parse/index.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from '../../context';
 import type { Next } from '../../hono';
-declare global {
-    interface Request {
+declare module '../../request' {
+    interface HonoRequest {
         parsedBody: any;
     }
 }

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

@@ -1,7 +1,7 @@
 import type { Context } from '../../context';
 import type { Next } from '../../hono';
-declare global {
-    interface Request {
+declare module '../../request' {
+    interface HonoRequest {
         cookie: {
             (name: string): string;
             (): Record<string, string>;

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

@@ -2,7 +2,8 @@
 import type { Env } from '../../context';
 import type { Handler } from '../../hono';
 export declare type ServeStaticOptions = {
-    root: string;
+    root?: string;
+    path?: string;
     manifest?: object | string;
     namespace?: KVNamespace;
 };

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

@@ -13,7 +13,7 @@ const serveStatic = (options = { root: '' }) => {
         }
         const url = new URL(c.req.url);
         const path = (0, cloudflare_1.getKVFilePath)({
-            filename: url.pathname,
+            filename: options.path ?? url.pathname,
             root: options.root,
             defaultDocument: DEFAULT_DOCUMENT,
         });

package/dist/request.d.ts

@@ -1,22 +1,20 @@
-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 class HonoRequest<ParamKeyType extends string = string> extends Request {
+    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;
+export declare function extendHonoRequest(request: HonoRequest): HonoRequest;

package/dist/request.js

@@ -1,12 +1,11 @@
 "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) {
+exports.extendHonoRequest = exports.HonoRequest = void 0;
+class HonoRequest extends Request {
+}
+exports.HonoRequest = HonoRequest;
+function extendHonoRequest(request) {
+    request.param = function (key) {
         if (this.paramData) {
             if (key) {
                 return this.paramData[key];
@@ -17,7 +16,7 @@ function extendRequestPrototype() {
         }
         return null;
     };
-    Request.prototype.header = function (name) {
+    request.header = function (name) {
         if (name) {
             return this.headers.get(name);
         }
@@ -29,7 +28,7 @@ function extendRequestPrototype() {
             return result;
         }
     };
-    Request.prototype.query = function (key) {
+    request.query = function (key) {
         const url = new URL(this.url);
         if (key) {
             return url.searchParams.get(key);
@@ -42,7 +41,7 @@ function extendRequestPrototype() {
             return result;
         }
     };
-    Request.prototype.queries = function (key) {
+    request.queries = function (key) {
         const url = new URL(this.url);
         if (key) {
             return url.searchParams.getAll(key);
@@ -55,5 +54,6 @@ function extendRequestPrototype() {
             return result;
         }
     };
+    return request;
 }
-exports.extendRequestPrototype = extendRequestPrototype;
+exports.extendHonoRequest = extendHonoRequest;

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

@@ -11,7 +11,6 @@ interface Hint {
 interface HandlerWithSortIndex<T> {
     handler: T;
     index: number;
-    componentsLength: number;
 }
 interface Route<T> {
     method: string;

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

@@ -65,9 +65,7 @@ function compareRoute(a, b) {
     return i === b.hint.regExpComponents.length || a.hint.endWithWildcard ? 1 : 0;
 }
 function compareHandler(a, b) {
-    return a.componentsLength !== b.componentsLength
-        ? a.componentsLength - b.componentsLength
-        : a.index - b.index;
+    return a.index - b.index;
 }
 function getSortedHandlers(handlers) {
     return [...handlers].sort(compareHandler).map((h) => h.handler);
@@ -158,7 +156,6 @@ class RegExpRouter {
         const handlerWithSortIndex = {
             index,
             handler,
-            componentsLength: hint.components.length || 1,
         };
         for (let i = 0, len = routes.length; i < len; i++) {
             if (routes[i].method === method && routes[i].path === path) {
@@ -318,9 +315,7 @@ class RegExpRouter {
                         }
                     }
                     if (routes[j].hint.components.length < routes[i].hint.components.length) {
-                        const componentsLength = routes[j].hint.components.length || 1;
                         routes[j].middleware.push(...routes[i].handlers.map((h) => ({
-                            componentsLength,
                             index: h.index,
                             handler: h.handler,
                         })));

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

@@ -66,18 +66,11 @@ class Node {
             parentPatterns.push(...curNode.patterns);
             curNode = curNode.children[p];
         }
-        let score = 1;
-        if (path === '*') {
-            score = score + this.order * 0.01;
-        }
-        else {
-            score = parts.length + this.order * 0.01;
-        }
         if (!curNode.methods.length) {
             curNode.methods = [];
         }
         const m = {};
-        const handlerSet = { handler: handler, name: this.name, score: score };
+        const handlerSet = { handler: handler, name: this.name, score: this.order };
         m[method] = handlerSet;
         curNode.methods.push(m);
         return curNode;
@@ -90,9 +83,6 @@ class Node {
                 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(hs);
                     return;
                 }

package/dist/utils/cloudflare.js

@@ -50,7 +50,7 @@ const getKVFilePath = (options) => {
         filename = filename.concat('/' + defaultDocument);
     }
     // /foo.html => foo.html
-    filename = filename.replace(/^\//, '');
+    filename = filename.replace(/^\.?\//, '');
     // assets/ => assets
     root = root.replace(/\/$/, '');
     // ./assets/foo.html => assets/foo.html

package/package.json

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