hono 3.5.1 → 3.5.2

package/dist/types/adapter/aws-lambda/handler.d.ts

@@ -1,5 +1,5 @@
 import type { Hono } from '../../hono';
-import type { Env } from '../../types';
+import type { Env, Schema } from '../../types';
 import type { ApiGatewayRequestContext, LambdaFunctionUrlRequestContext } from './custom-context';
 interface APIGatewayProxyEventV2 {
     httpMethod: string;
@@ -36,7 +36,7 @@ interface APIGatewayProxyResult {
 /**
  * Accepts events from API Gateway/ELB(`APIGatewayProxyEvent`) and directly through Function Url(`APIGatewayProxyEventV2`)
  */
-export declare const handle: <E extends Env = Env, S = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => (event: APIGatewayProxyEvent | APIGatewayProxyEventV2 | LambdaFunctionUrlEvent) => Promise<APIGatewayProxyResult>;
+export declare const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => (event: APIGatewayProxyEvent | APIGatewayProxyEventV2 | LambdaFunctionUrlEvent) => Promise<APIGatewayProxyResult>;
 export declare const isContentTypeBinary: (contentType: string) => boolean;
 export declare const isContentEncodingBinary: (contentEncoding: string | null) => boolean;
 export {};

package/dist/types/client/types.d.ts

@@ -1,19 +1,11 @@
 import type { Hono } from '../hono';
-import type { ValidationTargets } from '../types';
+import type { Schema } from '../types';
 import type { RemoveBlankRecord } from '../utils/types';
-declare type MethodName = `$${string}`;
-declare type Endpoint = Record<MethodName, Data>;
-declare type Data = {
-    input: Partial<ValidationTargets> & {
-        param?: Record<string, string>;
-    };
-    output: {};
-};
 export declare type ClientRequestOptions = {
     headers?: Record<string, string>;
     fetch?: typeof fetch;
 };
-declare type ClientRequest<S extends Data> = {
+declare type ClientRequest<S extends Schema> = {
     [M in keyof S]: S[M] extends {
         input: infer R;
         output: infer O;
@@ -38,12 +30,12 @@ export interface Response extends ClientResponse<unknown> {
 export declare type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponse<InferResponseType<T>>>;
 export declare type InferResponseType<T> = T extends (args: any | undefined) => Promise<ClientResponse<infer O>> ? O : never;
 export declare type InferRequestType<T> = T extends (args: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
-declare type PathToChain<Path extends string, E extends Endpoint, Original extends string = ''> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
+declare type PathToChain<Path extends string, E extends Schema, Original extends string = ''> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
     [K in P]: PathToChain<R, E, Original>;
 } : {
     [K in Path extends '' ? 'index' : Path]: ClientRequest<E extends Record<string, unknown> ? E[Original] : never>;
 };
-export declare type Client<T> = T extends Hono<any, infer S, any> ? S extends Record<infer K, Endpoint> ? K extends string ? PathToChain<K, S> : never : never : never;
+export declare type Client<T> = T extends Hono<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<K, S> : never : never : never;
 export declare type Callback = (opts: CallbackOptions) => unknown;
 interface CallbackOptions {
     path: string[];

package/dist/types/hono-base.d.ts

@@ -1,14 +1,14 @@
 import { Context } from './context';
 import type { ExecutionContext } from './context';
 import type { Router } from './router';
-import type { Env, ErrorHandler, H, HandlerInterface, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, MergePath, MergeSchemaPath, FetchEventLike } from './types';
+import type { Env, ErrorHandler, H, HandlerInterface, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, MergePath, MergeSchemaPath, FetchEventLike, Schema } from './types';
 import type { RemoveBlankRecord } from './utils/types';
 interface RouterRoute {
     path: string;
     method: string;
     handler: H;
 }
-declare const Hono_base: new <E_1 extends Env = Env, S_1 = {}, BasePath_1 extends string = "/">() => {
+declare const Hono_base: new <E_1 extends Env = Env, S_1 extends Schema = {}, BasePath_1 extends string = "/">() => {
     all: HandlerInterface<E_1, "all", S_1, BasePath_1>;
     options: HandlerInterface<E_1, "options", S_1, BasePath_1>;
     get: HandlerInterface<E_1, "get", S_1, BasePath_1>;
@@ -21,7 +21,7 @@ declare const Hono_base: new <E_1 extends Env = Env, S_1 = {}, BasePath_1 extend
 } & {
     use: MiddlewareHandlerInterface<E_1, S_1, BasePath_1>;
 };
-declare class Hono<E extends Env = Env, S = {}, BasePath extends string = '/'> extends Hono_base<E, S, BasePath> {
+declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends Hono_base<E, S, BasePath> {
     router: Router<H>;
     readonly getPath: (request: Request, options?: {
         env?: E['Bindings'];
@@ -35,7 +35,7 @@ declare class Hono<E extends Env = Env, S = {}, BasePath extends string = '/'> e
     private clone;
     private notFoundHandler;
     private errorHandler;
-    route<SubPath extends string, SubEnv extends Env, SubSchema, SubBasePath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath>): Hono<E, RemoveBlankRecord<MergeSchemaPath<SubSchema, SubPath> | S>, BasePath>;
+    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath>): Hono<E, MergeSchemaPath<SubSchema, SubPath> & S, BasePath>;
     /** @description
      * Use `basePath` instead of `route` when passing **one** argument, such as `app.route('/api')`.
      * The use of `route` with **one** argument has been removed in v4.

package/dist/types/hono.d.ts

@@ -1,6 +1,6 @@
 import { HonoBase } from './hono-base';
-import type { Env } from './types';
-export declare class Hono<E extends Env = Env, S = {}, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+import type { Env, Schema } from './types';
+export declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
     constructor(init?: Partial<Pick<Hono, 'router' | 'getPath'> & {
         strict: boolean;
     }>);

package/dist/types/preset/quick.d.ts

@@ -1,6 +1,6 @@
 import { HonoBase } from '../hono-base';
-import type { Env } from '../types';
-export declare class Hono<E extends Env = Env, S = {}, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+import type { Env, Schema } from '../types';
+export declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
     constructor(init?: Partial<Pick<Hono, 'getPath'> & {
         strict: boolean;
     }>);

package/dist/types/preset/tiny.d.ts

@@ -1,6 +1,6 @@
 import { HonoBase } from '../hono-base';
-import type { Env } from '../types';
-export declare class Hono<E extends Env = Env, S = {}, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+import type { Env, Schema } from '../types';
+export declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
     constructor(init?: Partial<Pick<Hono, 'getPath'> & {
         strict: boolean;
     }>);

package/dist/types/types.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from './context';
 import type { Hono } from './hono';
-import type { UnionToIntersection, RemoveBlankRecord } from './utils/types';
+import type { UnionToIntersection } from './utils/types';
 export declare type Bindings = Record<string, unknown>;
 export declare type Variables = Record<string, unknown>;
 export declare type Env = {
@@ -19,77 +19,87 @@ export declare type MiddlewareHandler<E extends Env = any, P extends string = an
 export declare type H<E extends Env = any, P extends string = any, I extends Input = {}, O = {}> = Handler<E, P, I, O> | MiddlewareHandler<E, P, I>;
 export declare type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
 export declare type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response | Promise<Response>;
-export interface HandlerInterface<E extends Env = Env, M extends string = any, S = {}, BasePath extends string = '/'> {
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, O = {}>(...handlers: [H<E, P, I, O>, H<E, P, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I['in'], O>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2>(...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I3['in'], O>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3>(...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I4['in'], O>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4>(...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>, H<E, P, I5, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I5['in'], O>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, O = {}>(...handlers: Handler<E, P, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I['in'], O>>, BasePath>;
-    <P extends string, O = {}, I extends Input = {}>(path: P, handler: H<E, MergePath<BasePath, P>, I, O>): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I['in'], O>>, BasePath>;
-    <P extends string, O = {}, I extends Input = {}>(path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, O>, H<E, MergePath<BasePath, P>, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I['in'], O>>, BasePath>;
+export interface HandlerInterface<E extends Env = Env, M extends string = any, S extends Schema = {}, BasePath extends string = '/'> {
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, O = {}>(...handlers: [H<E, P, I, O>, H<E, P, I, O>]): Hono<E, S & ToSchema<M, P, I['in'], O>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2>(...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>]): Hono<E, S & ToSchema<M, P, I3['in'], O>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3>(...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>]): Hono<E, S & ToSchema<M, P, I4['in'], O>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4>(...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>, H<E, P, I5, O>]): Hono<E, S & ToSchema<M, P, I5['in'], O>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, O = {}>(...handlers: Handler<E, P, I, O>[]): Hono<E, S & ToSchema<M, P, I['in'], O>, BasePath>;
+    <P extends string, O = {}, I extends Input = {}>(path: P, handler: H<E, MergePath<BasePath, P>, I, O>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], O>, BasePath>;
+    <P extends string, O = {}, I extends Input = {}>(path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, O>, H<E, MergePath<BasePath, P>, I, O>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], O>, BasePath>;
     <P extends string, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2>(path: P, ...handlers: [
         H<E, MergePath<BasePath, P>, I, O>,
         H<E, MergePath<BasePath, P>, I2, O>,
         H<E, MergePath<BasePath, P>, I3, O>
-    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I3['in'], O>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], O>, BasePath>;
     <P extends string, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3>(path: P, ...handlers: [
         H<E, MergePath<BasePath, P>, I, O>,
         H<E, MergePath<BasePath, P>, I2, O>,
         H<E, MergePath<BasePath, P>, I3, O>,
         H<E, MergePath<BasePath, P>, I4, O>
-    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I4['in'], O>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], O>, BasePath>;
     <P extends string, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I & I2 & I3 & I4>(path: P, ...handlers: [
         H<E, MergePath<BasePath, P>, I, O>,
         H<E, MergePath<BasePath, P>, I2, O>,
         H<E, MergePath<BasePath, P>, I3, O>,
         H<E, MergePath<BasePath, P>, I4, O>,
         H<E, MergePath<BasePath, P>, I5, O>
-    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I5['in'], O>>, BasePath>;
-    <P extends string, I extends Input = {}, O = {}>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I['in'], O>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], O>, BasePath>;
+    <P extends string, I extends Input = {}, O = {}>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], O>, BasePath>;
 }
-export interface MiddlewareHandlerInterface<E extends Env = Env, S = {}, BasePath extends string = '/'> {
+export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
     (...handlers: MiddlewareHandler<E, MergePath<BasePath, ExtractKey<S>>>[]): Hono<E, S, BasePath>;
     <P extends string>(path: P, ...handlers: MiddlewareHandler<E, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
 }
-export interface OnHandlerInterface<E extends Env = Env, S = {}, BasePath extends string = '/'> {
-    <M extends string, P extends string, O = {}, I extends Input = {}>(method: M, path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, O>, H<E, MergePath<BasePath, P>, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I['in'], O>>, BasePath>;
+export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+    <M extends string, P extends string, O = {}, I extends Input = {}>(method: M, path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, O>, H<E, MergePath<BasePath, P>, I, O>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], O>, BasePath>;
     <M extends string, P extends string, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2>(method: M, path: P, ...handlers: [
         H<E, MergePath<BasePath, P>, I, O>,
         H<E, MergePath<BasePath, P>, I2, O>,
         H<E, MergePath<BasePath, P>, I3, O>
-    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I3['in'], O>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], O>, BasePath>;
     <M extends string, P extends string, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3>(method: M, path: P, ...handlers: [
         H<E, MergePath<BasePath, P>, I, O>,
         H<E, MergePath<BasePath, P>, I2, O>,
         H<E, MergePath<BasePath, P>, I3, O>,
         H<E, MergePath<BasePath, P>, I4, O>
-    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I4['in'], O>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], O>, BasePath>;
     <M extends string, P extends string, O = {}, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I2 & I3, I5 extends Input = I3 & I4>(method: M, path: P, ...handlers: [
         H<E, MergePath<BasePath, P>, I, O>,
         H<E, MergePath<BasePath, P>, I2, O>,
         H<E, MergePath<BasePath, P>, I3, O>,
         H<E, MergePath<BasePath, P>, I4, O>,
         H<E, MergePath<BasePath, P>, I5, O>
-    ]): Hono<E, S | Schema<M, MergePath<BasePath, P>, I5['in'], O>, BasePath>;
-    <M extends string, P extends string, O extends {} = {}, I extends Input = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I['in'], O>>, BasePath>;
-    <P extends string, O extends {} = {}, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<string, MergePath<BasePath, P>, I['in'], O>>, BasePath>;
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], O>, BasePath>;
+    <M extends string, P extends string, O extends {} = {}, I extends Input = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], O>, BasePath>;
+    <P extends string, O extends {} = {}, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I['in'], O>, BasePath>;
 }
 declare type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;
-export declare type Schema<M extends string, P extends string, I extends Input['in'], O> = {
-    [K in P]: AddDollar<{
-        [K2 in M]: {
+export declare type ToSchema<M extends string, P extends string, I extends Input['in'], O> = {
+    [K in P]: {
+        [K2 in M as AddDollar<string & K2>]: {
             input: unknown extends I ? AddParam<{}, P> : AddParam<I, P>;
             output: unknown extends O ? {} : O;
         };
-    }>;
+    };
+};
+export declare type Schema = {
+    [Path: string]: {
+        [Method: `$${Lowercase<string>}`]: {
+            input: Partial<ValidationTargets> & {
+                param?: Record<string, string>;
+            };
+            output: {};
+        };
+    };
+};
+export declare type MergeSchemaPath<OrigSchema, SubPath extends string> = {
+    [K in keyof OrigSchema as `${SubPath}${K & string}`]: OrigSchema[K];
 };
 export declare type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I & {
     param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
 };
-export declare type AddDollar<T> = T extends Record<infer K, infer R> ? K extends string ? {
-    [MethodName in `$${Lowercase<K>}`]: R;
-} : never : never;
-export declare type MergeSchemaPath<S, P extends string> = S extends Record<infer Key, infer T> ? Key extends string ? Record<MergePath<P, Key>, T> : never : never;
+declare type AddDollar<T extends string> = `$${Lowercase<T>}`;
 export declare type MergePath<A extends string, B extends string> = A extends '' ? B : A extends '/' ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? Q extends '' ? A : `${A}/${Q}` : `${A}/${B}`;
 export declare type TypedResponse<T = unknown> = {
     response: Response | Promise<Response>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "3.5.1",
+  "version": "3.5.2",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",