hono 2.2.0 → 2.2.2

package/dist/cjs/context.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HonoContext = void 0;
-const hono_1 = require("./hono");
 const cookie_1 = require("./utils/cookie");
 class HonoContext {
     constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
@@ -31,7 +30,7 @@ class HonoContext {
         }
     }
     get res() {
-        return (this._res || (this._res = new Response(hono_1.defaultNotFoundMessage, { status: 404 })));
+        return (this._res || (this._res = new Response('404 Not Found', { status: 404 })));
     }
     set res(_res) {
         this._res = _res;

package/dist/cjs/hono.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = exports.defaultNotFoundMessage = void 0;
+exports.Hono = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
 const request_1 = require("./request");
@@ -11,7 +11,6 @@ const smart_router_1 = require("./router/smart-router");
 const static_router_1 = require("./router/static-router");
 const trie_router_1 = require("./router/trie-router");
 const url_1 = require("./utils/url");
-exports.defaultNotFoundMessage = '404 Not Found';
 function defineDynamicClass() {
     return class {
     };
@@ -27,17 +26,23 @@ class Hono extends defineDynamicClass() {
         this.path = '/';
         this.routes = [];
         this.notFoundHandler = (c) => {
-            const message = exports.defaultNotFoundMessage;
-            return c.text(message, 404);
+            return c.text('404 Not Found', 404);
         };
         this.errorHandler = (err, c) => {
-            console.error(`${err.stack || err.message}`);
+            console.trace(err.message);
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
+        this.handleEvent = (event) => {
+            return this.fetch(event.request, event);
+        };
         this.fetch = (request, Environment, executionCtx) => {
             return this.dispatch(request, executionCtx, Environment);
         };
+        this.request = async (input, requestInit) => {
+            const req = input instanceof Request ? input : new Request(input, requestInit);
+            return await this.fetch(req);
+        };
         (0, request_1.extendRequestPrototype)();
         const allMethods = [...router_1.METHODS, router_2.METHOD_NAME_ALL_LOWERCASE];
         allMethods.map((method) => {
@@ -100,7 +105,13 @@ class Hono extends defineDynamicClass() {
     matchRoute(method, path) {
         return this.router.match(method, path);
     }
-    async dispatch(request, eventOrExecutionCtx, env) {
+    handleError(err, c) {
+        if (err instanceof Error) {
+            return this.errorHandler(err, c);
+        }
+        throw err;
+    }
+    dispatch(request, eventOrExecutionCtx, env) {
         const path = (0, url_1.getPathFromURL)(request.url, this.strict);
         const method = request.method;
         const result = this.matchRoute(method, path);
@@ -109,46 +120,46 @@ class Hono extends defineDynamicClass() {
         // Do not `compose` if it has only one handler
         if (result && result.handlers.length === 1) {
             const handler = result.handlers[0];
+            let res;
             try {
-                const res = handler(c, async () => { });
-                if (res) {
-                    const awaited = res instanceof Promise ? await res : res;
-                    if (awaited)
-                        return awaited;
-                }
-                return this.notFoundHandler(c);
+                res = handler(c, async () => { });
+                if (!res)
+                    return this.notFoundHandler(c);
             }
             catch (err) {
-                if (err instanceof Error) {
-                    return this.errorHandler(err, c);
-                }
-                throw err;
+                return this.handleError(err, c);
             }
+            if (res instanceof Response)
+                return res;
+            return (async () => {
+                let awaited;
+                try {
+                    awaited = await res;
+                }
+                catch (err) {
+                    return this.handleError(err, c);
+                }
+                if (!awaited) {
+                    return this.notFoundHandler(c);
+                }
+                return awaited;
+            })();
         }
         const handlers = result ? result.handlers : [this.notFoundHandler];
         const composed = (0, compose_1.compose)(handlers, this.notFoundHandler);
-        let context;
-        try {
-            const tmp = composed(c);
-            context = tmp instanceof Promise ? await tmp : tmp;
-            if (!context.finalized) {
-                throw new Error('Context is not finalized. You may forget returning Response object or `await next()`');
+        return (async () => {
+            try {
+                const tmp = composed(c);
+                const context = tmp instanceof Promise ? await tmp : tmp;
+                if (!context.finalized) {
+                    throw new Error('Context is not finalized. You may forget returning Response object or `await next()`');
+                }
+                return context.res;
             }
-        }
-        catch (err) {
-            if (err instanceof Error) {
-                return this.errorHandler(err, c);
+            catch (err) {
+                return this.handleError(err, c);
             }
-            throw err;
-        }
-        return context.res;
-    }
-    handleEvent(event) {
-        return this.dispatch(event.request, event);
-    }
-    request(input, requestInit) {
-        const req = input instanceof Request ? input : new Request(input, requestInit);
-        return this.dispatch(req);
+        })();
     }
 }
 exports.Hono = Hono;

package/dist/cjs/middleware/validator/middleware.js

@@ -2,21 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatorMiddleware = void 0;
 const validator_1 = require("./validator");
-function getValidatorList(schema) {
-    const map = [];
-    for (const [key, value] of Object.entries(schema)) {
-        if (value instanceof validator_1.VBase) {
-            map.push([[key], value]);
-        }
-        else {
-            const children = getValidatorList(value);
-            for (const [keys, validator] of children) {
-                map.push([[key, ...keys], validator]);
-            }
-        }
-    }
-    return map;
-}
 const validatorMiddleware = (validationFunction, options) => {
     const v = new validator_1.Validator();
     const handler = async (c, next) => {
@@ -54,3 +39,18 @@ const validatorMiddleware = (validationFunction, options) => {
     return handler;
 };
 exports.validatorMiddleware = validatorMiddleware;
+function getValidatorList(schema) {
+    const map = [];
+    for (const [key, value] of Object.entries(schema)) {
+        if (value instanceof validator_1.VBase) {
+            map.push([[key], value]);
+        }
+        else {
+            const children = getValidatorList(value);
+            for (const [keys, validator] of children) {
+                map.push([[key, ...keys], validator]);
+            }
+        }
+    }
+    return map;
+}

package/dist/cjs/middleware/validator/validator.js

@@ -31,6 +31,7 @@ class VBase {
             });
         };
         this.isOptional = () => {
+            this._optional = true;
             return this.addRule(() => true);
         };
         this.isEqual = (comparison) => {
@@ -101,7 +102,13 @@ class VBase {
         this.validateValue = (value) => {
             // Check type
             if (typeof value !== this.type) {
-                return false;
+                if (this._optional && typeof value === 'undefined') {
+                    // Do nothing.
+                    // The value is allowed to be `undefined` if it is `optional`
+                }
+                else {
+                    return false;
+                }
             }
             // Sanitize
             for (const sanitizer of this.sanitizers) {
@@ -119,6 +126,7 @@ class VBase {
         this.type = options.type || 'string';
         this.rules = [];
         this.sanitizers = [];
+        this._optional = false;
     }
     message(value) {
         this._message = value;

package/dist/context.js

@@ -1,4 +1,3 @@
-import { defaultNotFoundMessage } from './hono';
 import { serialize } from './utils/cookie';
 export class HonoContext {
     constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
@@ -28,7 +27,7 @@ export class HonoContext {
         }
     }
     get res() {
-        return (this._res || (this._res = new Response(defaultNotFoundMessage, { status: 404 })));
+        return (this._res || (this._res = new Response('404 Not Found', { status: 404 })));
     }
     set res(_res) {
         this._res = _res;

package/dist/hono.d.ts

@@ -15,32 +15,31 @@ export declare type MiddlewareHandler = <E extends Partial<Environment> = Enviro
 export declare type NotFoundHandler<E extends Partial<Environment> = Environment> = (c: Context<string, E>) => Response | Promise<Response>;
 export declare type ErrorHandler<E extends Partial<Environment> = Environment> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
-export declare const defaultNotFoundMessage = "404 Not Found";
 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 extends Partial<Environment>, D extends ValidatedData, U = Hono<E, T, D>> {
-    <Path extends string, Env extends Partial<Environment>, Data extends ValidatedData = D>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, Env, Data>[]): U;
-    (...handlers: Handler<string, E, D>[]): U;
-    <Path extends string, Env extends Partial<Environment> = E, Data extends ValidatedData = D>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, Env, Data>[]): U;
-    (path: string, ...handlers: Handler<string, E, D>[]): U;
+interface HandlerInterface<T extends string, E extends Partial<Environment>, U = Hono<E, T>> {
+    <Path extends string, Data extends ValidatedData>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): U;
+    (...handlers: Handler<string, E>[]): U;
+    <Path extends string, Data extends ValidatedData>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): U;
+    (path: string, ...handlers: Handler<string, E>[]): U;
 }
 interface Route<E extends Partial<Environment> = Environment, D extends ValidatedData = ValidatedData> {
     path: string;
     method: string;
     handler: Handler<string, E, D>;
 }
-declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, T extends string = string, D_1 extends ValidatedData = ValidatedData, U = Hono<E_1, T, D_1>>() => {
-    all: HandlerInterface<T, E_1, D_1, U>;
-    get: HandlerInterface<T, E_1, D_1, U>;
-    post: HandlerInterface<T, E_1, D_1, U>;
-    put: HandlerInterface<T, E_1, D_1, U>;
-    delete: HandlerInterface<T, E_1, D_1, U>;
-    head: HandlerInterface<T, E_1, D_1, U>;
-    options: HandlerInterface<T, E_1, D_1, U>;
-    patch: HandlerInterface<T, E_1, D_1, U>;
+declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, T extends string = string, U = Hono<E_1, T, ValidatedData>>() => {
+    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 extends Partial<Environment> = Environment, P extends string = '/', D extends ValidatedData = ValidatedData> extends Hono_base<E, P, D, Hono<E, P, D>> {
+export declare class Hono<E extends Partial<Environment> = Environment, P extends string = '/', D extends ValidatedData = ValidatedData> extends Hono_base<E, P, Hono<E, P, D>> {
     readonly router: Router<Handler<string, E, D>>;
     readonly strict: boolean;
     private _tempPath;
@@ -50,15 +49,16 @@ export declare class Hono<E extends Partial<Environment> = Environment, P extend
     private notFoundHandler;
     private errorHandler;
     route(path: string, app?: Hono<any>): Hono<E, P, D>;
-    use<Path extends string = string, Env extends Partial<Environment> = E, Data extends ValidatedData = D>(...middleware: Handler<Path, Env, Data>[]): Hono<Env, Path, Data>;
-    use<Path extends string = string, Env extends Partial<Environment> = E, Data extends ValidatedData = D>(arg1: string, ...middleware: Handler<Path, Env, Data>[]): Hono<Env, Path, D>;
+    use<Path extends string = string, Data extends ValidatedData = D>(...middleware: Handler<Path, E, Data>[]): Hono<E, Path, Data>;
+    use<Path extends string = string, Data extends ValidatedData = D>(arg1: string, ...middleware: Handler<Path, E, Data>[]): Hono<E, Path, D>;
     onError(handler: ErrorHandler<E>): Hono<E, P, D>;
     notFound(handler: NotFoundHandler<E>): Hono<E, P, D>;
     private addRoute;
     private matchRoute;
+    private handleError;
     private dispatch;
-    handleEvent(event: FetchEvent): Promise<Response>;
-    fetch: (request: Request, Environment?: E['Bindings'], executionCtx?: ExecutionContext) => Promise<Response>;
-    request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
+    handleEvent: (event: FetchEvent) => Response | Promise<Response>;
+    fetch: (request: Request, Environment?: E['Bindings'], executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    request: (input: RequestInfo, requestInit?: RequestInit) => Promise<Response>;
 }
 export {};

package/dist/hono.js

@@ -8,7 +8,6 @@ import { SmartRouter } from './router/smart-router';
 import { StaticRouter } from './router/static-router';
 import { TrieRouter } from './router/trie-router';
 import { getPathFromURL, mergePath } from './utils/url';
-export const defaultNotFoundMessage = '404 Not Found';
 function defineDynamicClass() {
     return class {
     };
@@ -24,17 +23,23 @@ export class Hono extends defineDynamicClass() {
         this.path = '/';
         this.routes = [];
         this.notFoundHandler = (c) => {
-            const message = defaultNotFoundMessage;
-            return c.text(message, 404);
+            return c.text('404 Not Found', 404);
         };
         this.errorHandler = (err, c) => {
-            console.error(`${err.stack || err.message}`);
+            console.trace(err.message);
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
+        this.handleEvent = (event) => {
+            return this.fetch(event.request, event);
+        };
         this.fetch = (request, Environment, executionCtx) => {
             return this.dispatch(request, executionCtx, Environment);
         };
+        this.request = async (input, requestInit) => {
+            const req = input instanceof Request ? input : new Request(input, requestInit);
+            return await this.fetch(req);
+        };
         extendRequestPrototype();
         const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
         allMethods.map((method) => {
@@ -97,7 +102,13 @@ export class Hono extends defineDynamicClass() {
     matchRoute(method, path) {
         return this.router.match(method, path);
     }
-    async dispatch(request, eventOrExecutionCtx, env) {
+    handleError(err, c) {
+        if (err instanceof Error) {
+            return this.errorHandler(err, c);
+        }
+        throw err;
+    }
+    dispatch(request, eventOrExecutionCtx, env) {
         const path = getPathFromURL(request.url, this.strict);
         const method = request.method;
         const result = this.matchRoute(method, path);
@@ -106,45 +117,45 @@ export class Hono extends defineDynamicClass() {
         // Do not `compose` if it has only one handler
         if (result && result.handlers.length === 1) {
             const handler = result.handlers[0];
+            let res;
             try {
-                const res = handler(c, async () => { });
-                if (res) {
-                    const awaited = res instanceof Promise ? await res : res;
-                    if (awaited)
-                        return awaited;
-                }
-                return this.notFoundHandler(c);
+                res = handler(c, async () => { });
+                if (!res)
+                    return this.notFoundHandler(c);
             }
             catch (err) {
-                if (err instanceof Error) {
-                    return this.errorHandler(err, c);
-                }
-                throw err;
+                return this.handleError(err, c);
             }
+            if (res instanceof Response)
+                return res;
+            return (async () => {
+                let awaited;
+                try {
+                    awaited = await res;
+                }
+                catch (err) {
+                    return this.handleError(err, c);
+                }
+                if (!awaited) {
+                    return this.notFoundHandler(c);
+                }
+                return awaited;
+            })();
         }
         const handlers = result ? result.handlers : [this.notFoundHandler];
         const composed = compose(handlers, this.notFoundHandler);
-        let context;
-        try {
-            const tmp = composed(c);
-            context = tmp instanceof Promise ? await tmp : tmp;
-            if (!context.finalized) {
-                throw new Error('Context is not finalized. You may forget returning Response object or `await next()`');
+        return (async () => {
+            try {
+                const tmp = composed(c);
+                const context = tmp instanceof Promise ? await tmp : tmp;
+                if (!context.finalized) {
+                    throw new Error('Context is not finalized. You may forget returning Response object or `await next()`');
+                }
+                return context.res;
             }
-        }
-        catch (err) {
-            if (err instanceof Error) {
-                return this.errorHandler(err, c);
+            catch (err) {
+                return this.handleError(err, c);
             }
-            throw err;
-        }
-        return context.res;
-    }
-    handleEvent(event) {
-        return this.dispatch(event.request, event);
-    }
-    request(input, requestInit) {
-        const req = input instanceof Request ? input : new Request(input, requestInit);
-        return this.dispatch(req);
+        })();
     }
 }

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

@@ -1,6 +1,7 @@
-import type { MiddlewareHandler } from '../../hono';
+import type { Context } from '../../context';
+import type { Next } from '../../hono';
 export declare type ServeStaticOptions = {
     root?: string;
     path?: string;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => MiddlewareHandler;
+export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;

package/dist/middleware/serve-static/module.d.mts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../../hono").MiddlewareHandler;
+declare const module: (options?: ServeStaticOptions) => (c: import("../..").Context<string, any, import("../../hono").ValidatedData>, next: import("../..").Next) => Promise<Response | undefined>;
 export { module as serveStatic };

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

@@ -1,9 +1,10 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { MiddlewareHandler } from '../../hono';
+import type { Context } from '../../context';
+import type { Next } from '../../hono';
 export declare type ServeStaticOptions = {
     root?: string;
     path?: string;
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const serveStatic: (options?: ServeStaticOptions) => MiddlewareHandler;
+export declare const serveStatic: (options?: ServeStaticOptions) => (c: Context, next: Next) => Promise<Response | undefined>;

package/dist/middleware/validator/middleware.d.ts

@@ -1,8 +1,7 @@
 import type { Context } from '../../context';
-import type { Environment, Handler } from '../../hono';
+import type { Environment, Next, ValidatedData } from '../../hono';
 import { Validator } from './validator';
 import type { VString, VNumber, VBoolean, VObject, ValidateResult } from './validator';
-declare type ValidationFunction<T> = (v: Validator, c: Context) => T;
 declare type Schema = {
     [key: string]: VString | VNumber | VBoolean | VObject | Schema;
 };
@@ -14,8 +13,10 @@ declare type ResultSet = {
     messages: string[];
     results: ValidateResult[];
 };
-declare type Done = (resultSet: ResultSet, context: Context) => Response | void;
-export declare const validatorMiddleware: <T extends Schema>(validationFunction: ValidationFunction<T>, options?: {
-    done?: Done;
-}) => Handler<string, Environment, SchemaToProp<T>>;
+declare type Done<Env extends Partial<Environment>> = (resultSet: ResultSet, context: Context<string, Env>) => Response | void;
+declare type ValidationFunction<T, Env extends Partial<Environment>> = (v: Validator, c: Context<string, Env>) => T;
+declare type MiddlewareHandler<Data extends ValidatedData = ValidatedData, Env extends Partial<Environment> = Environment> = (c: Context<string, Env, Data>, next: Next) => Promise<void> | Promise<Response | undefined>;
+export declare const validatorMiddleware: <T extends Schema, Env extends Partial<Environment>>(validationFunction: ValidationFunction<T, Env>, options?: {
+    done?: Done<Env> | undefined;
+} | undefined) => MiddlewareHandler<SchemaToProp<T>, Env>;
 export {};

package/dist/middleware/validator/middleware.js

@@ -1,19 +1,4 @@
 import { VBase, Validator } from './validator';
-function getValidatorList(schema) {
-    const map = [];
-    for (const [key, value] of Object.entries(schema)) {
-        if (value instanceof VBase) {
-            map.push([[key], value]);
-        }
-        else {
-            const children = getValidatorList(value);
-            for (const [keys, validator] of children) {
-                map.push([[key, ...keys], validator]);
-            }
-        }
-    }
-    return map;
-}
 export const validatorMiddleware = (validationFunction, options) => {
     const v = new Validator();
     const handler = async (c, next) => {
@@ -50,3 +35,18 @@ export const validatorMiddleware = (validationFunction, options) => {
     };
     return handler;
 };
+function getValidatorList(schema) {
+    const map = [];
+    for (const [key, value] of Object.entries(schema)) {
+        if (value instanceof VBase) {
+            map.push([[key], value]);
+        }
+        else {
+            const children = getValidatorList(value);
+            for (const [keys, validator] of children) {
+                map.push([[key, ...keys], validator]);
+            }
+        }
+    }
+    return map;
+}

package/dist/middleware/validator/validator.d.ts

@@ -27,6 +27,7 @@ export declare abstract class VBase {
     rules: Rule[];
     sanitizers: Sanitizer[];
     private _message;
+    private _optional;
     constructor(options: VOptions);
     addRule: (rule: Rule) => this;
     addSanitizer: (sanitizer: Sanitizer) => this;

package/dist/middleware/validator/validator.js

@@ -27,6 +27,7 @@ export class VBase {
             });
         };
         this.isOptional = () => {
+            this._optional = true;
             return this.addRule(() => true);
         };
         this.isEqual = (comparison) => {
@@ -97,7 +98,13 @@ export class VBase {
         this.validateValue = (value) => {
             // Check type
             if (typeof value !== this.type) {
-                return false;
+                if (this._optional && typeof value === 'undefined') {
+                    // Do nothing.
+                    // The value is allowed to be `undefined` if it is `optional`
+                }
+                else {
+                    return false;
+                }
             }
             // Sanitize
             for (const sanitizer of this.sanitizers) {
@@ -115,6 +122,7 @@ export class VBase {
         this.type = options.type || 'string';
         this.rules = [];
         this.sanitizers = [];
+        this._optional = false;
     }
     message(value) {
         this._message = value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "module": "dist/index.js",