hono 2.3.1 → 2.3.2

package/dist/cjs/context.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HonoContext = void 0;
 const cookie_1 = require("./utils/cookie");
 class HonoContext {
-    constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
+    constructor(req, env = {}, executionCtx = undefined, notFoundHandler = () => new Response()) {
         this.error = undefined;
         this._status = 200;
         this._pretty = false;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatorMiddleware = void 0;
 const http_status_1 = require("../../utils/http-status");
 const object_1 = require("../../utils/object");
-const validator_1 = require("./validator");
+const validator_1 = require("../../validator/validator");
 const validatorMiddleware = (validationFunction, options) => {
     const v = new validator_1.Validator();
     const handler = async (c, next) => {

package/dist/cjs/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/validator/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/{middleware/validator → validator}/validator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VBooleanArray = exports.VStringArray = exports.VNumberArray = exports.VBoolean = exports.VNumber = exports.VString = exports.VBase = exports.Validator = exports.VArray = exports.VObject = exports.VObjectBase = void 0;
-const json_1 = require("../../utils/json");
+const json_1 = require("./../utils/json");
 const rule_1 = require("./rule");
 const sanitizer_1 = require("./sanitizer");
 class VObjectBase {
@@ -179,6 +179,7 @@ class VBase {
                 const typeResult = this.validateRule(typeRule, value);
                 typeResult.jsonData || (typeResult.jsonData = jsonData);
                 results.unshift(typeResult);
+                this.rules.unshift(typeRule);
             }
             return results;
         };
@@ -215,6 +216,8 @@ class VBase {
             return true;
         };
         this.validateValue = (func, value) => {
+            if (this._optional && typeof value === 'undefined')
+                return true;
             if (Array.isArray(value)) {
                 // Sanitize
                 for (const sanitizer of this.sanitizers) {

package/dist/compose.d.ts

@@ -1,7 +1,8 @@
 import type { Environment, NotFoundHandler, ErrorHandler } from './hono';
+import type { Schema } from './validator/schema';
 interface ComposeContext {
     finalized: boolean;
-    res: any;
+    res: unknown;
 }
-export declare const compose: <C extends ComposeContext, E extends Partial<Environment> = Environment>(middleware: Function[], onNotFound?: NotFoundHandler<E> | undefined, onError?: ErrorHandler<E> | undefined) => (context: C, next?: Function) => C | Promise<C>;
+export declare const compose: <C extends ComposeContext, P extends string = string, E extends Partial<Environment> = Environment, D extends Partial<Schema> = Schema>(middleware: Function[], onNotFound?: NotFoundHandler<P, E, D> | undefined, onError?: ErrorHandler<P, E, D> | undefined) => (context: C, next?: Function) => C | Promise<C>;
 export {};

package/dist/context.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Environment, NotFoundHandler, ContextVariableMap, ValidatedData } from './hono';
+import type { Environment, NotFoundHandler, ContextVariableMap } from './hono';
 import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
+import type { Schema, SchemaToProp } from './validator/schema';
 declare type Headers = Record<string, string | string[]>;
 export declare type Data = string | ArrayBuffer | ReadableStream;
-export interface Context<RequestParamKeyType extends string = string, E extends Partial<Environment> = any, D extends ValidatedData = ValidatedData> {
-    req: Request<RequestParamKeyType, D>;
+export interface Context<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> {
+    req: Request<P, SchemaToProp<S>>;
     env: E['Bindings'];
     event: FetchEvent;
     executionCtx: ExecutionContext;
@@ -20,7 +21,7 @@ export interface Context<RequestParamKeyType extends string = string, E extends
     set: {
         <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
         <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
-        (key: string, value: any): void;
+        (key: string, value: unknown): void;
     };
     get: {
         <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
@@ -37,8 +38,8 @@ export interface Context<RequestParamKeyType extends string = string, E extends
     cookie: (name: string, value: string, options?: CookieOptions) => void;
     notFound: () => Response | Promise<Response>;
 }
-export declare class HonoContext<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment, D extends ValidatedData = ValidatedData> implements Context<RequestParamKeyType, E, D> {
-    req: Request<RequestParamKeyType, D>;
+export declare class HonoContext<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> implements Context<P, E, S> {
+    req: Request<P, SchemaToProp<S>>;
     env: E['Bindings'];
     finalized: boolean;
     error: Error | undefined;
@@ -50,7 +51,7 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     private _headers;
     private _res;
     private notFoundHandler;
-    constructor(req: Request<RequestParamKeyType>, env?: E['Bindings'] | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler<E>);
+    constructor(req: Request<P>, env?: E['Bindings'], executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler<P, E, S>);
     get event(): FetchEvent;
     get executionCtx(): ExecutionContext;
     get res(): Response;
@@ -61,10 +62,10 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     status(status: StatusCode): void;
     set<Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
     set<Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
-    set(key: string, value: any): void;
+    set(key: string, value: unknown): void;
     get<Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
     get<Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
-    get<T = any>(key: string): T;
+    get<T>(key: string): T;
     pretty(prettyJSON: boolean, space?: number): void;
     newResponse(data: Data | null, status: StatusCode, headers?: Headers): Response;
     private _finalizeHeaders;

package/dist/context.js

@@ -1,6 +1,6 @@
 import { serialize } from './utils/cookie';
 export class HonoContext {
-    constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
+    constructor(req, env = {}, executionCtx = undefined, notFoundHandler = () => new Response()) {
         this.error = undefined;
         this._status = 200;
         this._pretty = false;

package/dist/hono.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="@cloudflare/workers-types" />
 import type { Context } from './context';
 import type { Router } from './router';
+import type { Schema } from './validator/schema';
 export interface ContextVariableMap {
 }
 export declare type Bindings = Record<string, any>;
@@ -9,50 +10,50 @@ export declare type Environment = {
     Bindings: Bindings;
     Variables: Variables;
 };
-export declare type ValidatedData = Record<string, any>;
-export declare type Handler<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment, D extends ValidatedData = ValidatedData> = (c: Context<RequestParamKeyType, E, D>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined | void>;
-export declare type MiddlewareHandler = <E extends Partial<Environment> = Environment>(c: Context<string, E>, next: Next) => Promise<void> | Promise<Response | undefined>;
-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 Handler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (c: Context<P, E, S>, next: Next) => Response | Promise<Response | undefined | void>;
+export declare type MiddlewareHandler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (c: Context<P, E, S>, next: Next) => Promise<Response | undefined | void>;
+export declare type NotFoundHandler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (c: Context<P, E, S>) => Response | Promise<Response>;
+export declare type ErrorHandler<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> = (err: Error, c: Context<P, E, S>) => 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 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 HandlerInterface<P extends string, E extends Partial<Environment>, S extends Partial<Schema>, U = Hono<E, P, S>> {
+    <Path extends string, Data extends Schema>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): U;
+    (...handlers: Handler<string, E, S>[]): U;
+    <Path extends string, Data extends Partial<Schema> = Schema>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): U;
+    <Path extends string, Data extends Schema>(path: Path, ...handlers: Handler<string, E, Data>[]): U;
+    (path: string, ...handlers: Handler<string, E, S>[]): U;
 }
-interface Route<E extends Partial<Environment> = Environment, D extends ValidatedData = ValidatedData> {
+interface Route<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> {
     path: string;
     method: string;
-    handler: Handler<string, E, D>;
+    handler: Handler<P, E, S>;
 }
-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>;
+declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, P_1 extends string = string, S_1 extends Partial<Schema> = Schema, U = Hono<E_1, P_1, S_1>>() => {
+    all: HandlerInterface<P_1, E_1, S_1, U>;
+    get: HandlerInterface<P_1, E_1, S_1, U>;
+    post: HandlerInterface<P_1, E_1, S_1, U>;
+    put: HandlerInterface<P_1, E_1, S_1, U>;
+    delete: HandlerInterface<P_1, E_1, S_1, U>;
+    head: HandlerInterface<P_1, E_1, S_1, U>;
+    options: HandlerInterface<P_1, E_1, S_1, U>;
+    patch: HandlerInterface<P_1, E_1, S_1, U>;
 };
-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>>;
+export declare class Hono<E extends Partial<Environment> = Environment, P extends string = '/', S extends Partial<Schema> = Schema> extends Hono_base<E, P, S, Hono<E, P, S>> {
+    readonly router: Router<Handler<P, E, S>>;
     readonly strict: boolean;
     private _tempPath;
     private path;
-    routes: Route<E, D>[];
+    routes: Route<P, E, S>[];
     constructor(init?: Partial<Pick<Hono, 'router' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
-    route(path: string, app?: Hono<any>): Hono<E, P, 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>;
+    route(path: string, app?: Hono<E, P, S>): this;
+    use<Path extends string = string, Data extends Partial<Schema> = Schema>(...middleware: Handler<Path, E, Data>[]): Hono<E, Path, S>;
+    use<Path extends string = string, Data extends Partial<Schema> = Schema>(arg1: string, ...middleware: Handler<Path, E, Data>[]): Hono<E, Path, S>;
+    onError(handler: ErrorHandler<P, E, S>): this;
+    notFound(handler: NotFoundHandler<P, E, S>): this;
     private addRoute;
     private matchRoute;
     private handleError;

package/dist/index.d.ts

@@ -2,6 +2,7 @@
 import { Hono } from './hono';
 export type { Handler, Next, ContextVariableMap } from './hono';
 export type { Context } from './context';
+export type { Validator } from './validator/validator';
 declare module './hono' {
     interface Hono {
         fire(): void;

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

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

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

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

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

@@ -1,22 +1,16 @@
 import type { Context } from '../../context';
-import type { Environment, Next, ValidatedData } from '../../hono';
-import { Validator, VObjectBase } from './validator';
-import type { VString, VNumber, VBoolean, VObject, VNumberArray, VStringArray, VBooleanArray, ValidateResult, VArray } from './validator';
-export declare type Schema = {
-    [key: string]: VString | VNumber | VBoolean | VStringArray | VNumberArray | VBooleanArray | Schema | VObject<Schema> | VArray<Schema>;
-};
-declare type SchemaToProp<T> = {
-    [K in keyof T]: T[K] extends VNumberArray ? number[] : T[K] extends VBooleanArray ? boolean[] : T[K] extends VStringArray ? string[] : T[K] extends VNumber ? number : T[K] extends VBoolean ? boolean : T[K] extends VString ? string : T[K] extends VObjectBase<Schema> ? T[K]['container'] extends VNumber ? number : T[K]['container'] extends VString ? string : T[K]['container'] extends VBoolean ? boolean : T[K] extends VArray<Schema> ? SchemaToProp<ReadonlyArray<T[K]['container']>> : T[K] extends VObject<Schema> ? SchemaToProp<T[K]['container']> : T[K] extends Schema ? SchemaToProp<T[K]> : never : SchemaToProp<T[K]>;
-};
+import type { Environment, MiddlewareHandler } from '../../hono';
+import type { Schema } from '../../validator/schema';
+import type { ValidateResult } from '../../validator/validator';
+import { Validator } from '../../validator/validator';
 declare type ResultSet = {
     hasError: boolean;
     messages: string[];
     results: ValidateResult[];
 };
-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>;
+declare type Done<P extends string, E extends Partial<Environment> = Environment> = (resultSet: ResultSet, c: Context<P, E>) => Response | void;
+declare type ValidationFunction<P extends string, E extends Partial<Environment> = Environment, S extends Schema = Schema> = (v: Validator, c: Context<P, E>) => S;
+export declare const validatorMiddleware: <P extends string, E extends Partial<Environment> = Environment, S extends Schema = Schema>(validationFunction: ValidationFunction<P, E, S>, options?: {
+    done?: Done<P, E> | undefined;
+} | undefined) => MiddlewareHandler<string, E, S>;
 export {};

package/dist/middleware/validator/middleware.js

@@ -1,6 +1,6 @@
 import { getStatusText } from '../../utils/http-status';
 import { mergeObjects } from '../../utils/object';
-import { VBase, Validator, VObjectBase } from './validator';
+import { Validator, VBase, VObjectBase } from '../../validator/validator';
 export const validatorMiddleware = (validationFunction, options) => {
     const v = new Validator();
     const handler = async (c, next) => {

package/dist/request.d.ts

@@ -29,10 +29,10 @@ declare global {
         bodyData?: BodyData;
         parseBody<BodyType extends BodyData>(): Promise<BodyType>;
         jsonData?: any;
-        json<JSONData = any>(): Promise<JSONData>;
+        json<JSONData = unknown>(): Promise<Partial<JSONData>>;
         data: Data;
         valid: {
-            (key: string | string[], value: any): Data;
+            (key: string | string[], value: unknown): Data;
             (): Data;
         };
     }

package/dist/utils/types.d.ts

@@ -0,0 +1,3 @@
+export declare type Expect<T extends true> = T;
+export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export declare type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;

package/dist/utils/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validator/schema.d.ts

@@ -0,0 +1,7 @@
+import type { VString, VNumber, VBoolean, VObject, VNumberArray, VStringArray, VBooleanArray, VArray, VObjectBase } from './validator';
+export declare type Schema = {
+    [key: string]: VString | VNumber | VBoolean | VStringArray | VNumberArray | VBooleanArray | Schema | VObject<Schema> | VArray<Schema>;
+};
+export declare type SchemaToProp<T> = {
+    [K in keyof T]: T[K] extends VNumberArray ? number[] : T[K] extends VBooleanArray ? boolean[] : T[K] extends VStringArray ? string[] : T[K] extends VNumber ? number : T[K] extends VBoolean ? boolean : T[K] extends VString ? string : T[K] extends VObjectBase<Schema> ? T[K]['container'] extends VNumber ? number : T[K]['container'] extends VString ? string : T[K]['container'] extends VBoolean ? boolean : T[K] extends VArray<Schema> ? SchemaToProp<ReadonlyArray<T[K]['container']>> : T[K] extends VObject<Schema> ? SchemaToProp<T[K]['container']> : T[K] extends Schema ? SchemaToProp<T[K]> : never : SchemaToProp<T[K]>;
+};

package/dist/validator/schema.js

@@ -0,0 +1 @@
+export {};

package/dist/{middleware/validator → validator}/validator.d.ts

@@ -1,5 +1,5 @@
-import type { JSONObject, JSONPrimitive, JSONArray } from '../../utils/json';
-import type { Schema } from './middleware';
+import type { JSONObject, JSONPrimitive, JSONArray } from './../utils/json';
+import type { Schema } from './schema';
 declare type Target = 'query' | 'header' | 'body' | 'json';
 declare type Type = JSONPrimitive | JSONObject | JSONArray | File;
 declare type RuleFunc = (value: Type) => boolean;
@@ -71,7 +71,9 @@ export declare abstract class VBase {
     asNumber: () => VNumber | VNumberArray;
     asBoolean: () => VBoolean | VBooleanArray;
     get(value: string): this;
-    validate: (req: Request) => Promise<ValidateResult[]>;
+    validate: <R extends Request<string, {
+        [x: string]: any;
+    }>>(req: R) => Promise<ValidateResult[]>;
     protected getTypeRuleName(): string;
     private validateRule;
     private validateType;

package/dist/{middleware/validator → validator}/validator.js

@@ -1,4 +1,4 @@
-import { JSONPathCopy } from '../../utils/json';
+import { JSONPathCopy } from './../utils/json';
 import { rule } from './rule';
 import { sanitizer } from './sanitizer';
 export class VObjectBase {
@@ -172,6 +172,7 @@ export class VBase {
                 const typeResult = this.validateRule(typeRule, value);
                 typeResult.jsonData || (typeResult.jsonData = jsonData);
                 results.unshift(typeResult);
+                this.rules.unshift(typeRule);
             }
             return results;
         };
@@ -208,6 +209,8 @@ export class VBase {
             return true;
         };
         this.validateValue = (func, value) => {
+            if (this._optional && typeof value === 'undefined')
+                return true;
             if (Array.isArray(value)) {
                 // Sanitize
                 for (const sanitizer of this.sanitizers) {

package/package.json

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