hono 2.3.1 → 2.4.0

package/dist/compose.js

@@ -1,66 +1,63 @@
-import { HonoContext } from './context';
-// Based on the code in the MIT licensed `koa-compose` package.
-export const compose = (middleware, onNotFound, onError) => {
-    const middlewareLength = middleware.length;
-    return (context, next) => {
-        let index = -1;
-        return dispatch(0);
-        function dispatch(i) {
-            if (i <= index) {
-                throw new Error('next() called multiple times');
-            }
-            let handler = middleware[i];
-            index = i;
-            if (i === middlewareLength && next)
-                handler = next;
-            let res;
-            let isError = false;
-            if (!handler) {
-                if (context instanceof HonoContext && context.finalized === false && onNotFound) {
-                    res = onNotFound(context);
-                }
-            }
-            else {
-                try {
-                    res = handler(context, () => {
-                        const dispatchRes = dispatch(i + 1);
-                        return dispatchRes instanceof Promise ? dispatchRes : Promise.resolve(dispatchRes);
-                    });
-                }
-                catch (err) {
-                    if (err instanceof Error && context instanceof HonoContext && onError) {
-                        context.error = err;
-                        res = onError(err, context);
-                        isError = true;
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-            }
-            if (!(res instanceof Promise)) {
-                if (res && (context.finalized === false || isError)) {
-                    context.res = res;
-                }
-                return context;
-            }
-            else {
-                return res
-                    .then((res) => {
-                    if (res && context.finalized === false) {
-                        context.res = res;
-                    }
-                    return context;
-                })
-                    .catch((err) => {
-                    if (err instanceof Error && context instanceof HonoContext && onError) {
-                        context.error = err;
-                        context.res = onError(err, context);
-                        return context;
-                    }
-                    throw err;
-                });
-            }
+// src/compose.ts
+import { HonoContext } from "./context.js";
+var compose = (middleware, onNotFound, onError) => {
+  const middlewareLength = middleware.length;
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      let handler = middleware[i];
+      index = i;
+      if (i === middlewareLength && next)
+        handler = next;
+      let res;
+      let isError = false;
+      if (!handler) {
+        if (context instanceof HonoContext && context.finalized === false && onNotFound) {
+          res = onNotFound(context);
         }
-    };
+      } else {
+        try {
+          res = handler(context, () => {
+            const dispatchRes = dispatch(i + 1);
+            return dispatchRes instanceof Promise ? dispatchRes : Promise.resolve(dispatchRes);
+          });
+        } catch (err) {
+          if (err instanceof Error && context instanceof HonoContext && onError) {
+            context.error = err;
+            res = onError(err, context);
+            isError = true;
+          } else {
+            throw err;
+          }
+        }
+      }
+      if (!(res instanceof Promise)) {
+        if (res && (context.finalized === false || isError)) {
+          context.res = res;
+        }
+        return context;
+      } else {
+        return res.then((res2) => {
+          if (res2 && context.finalized === false) {
+            context.res = res2;
+          }
+          return context;
+        }).catch((err) => {
+          if (err instanceof Error && context instanceof HonoContext && onError) {
+            context.error = err;
+            context.res = onError(err, context);
+            return context;
+          }
+          throw err;
+        });
+      }
+    }
+  };
+};
+export {
+  compose
 };

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 './types';
 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> | unknown = Schema> {
+    req: Request<P, S extends Schema ? SchemaToProp<S> : any>;
     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, S extends Schema ? SchemaToProp<S> : any>;
     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,144 +1,140 @@
-import { serialize } from './utils/cookie';
-export class HonoContext {
-    constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
-        this.error = undefined;
-        this._status = 200;
-        this._pretty = false;
-        this._prettySpace = 2;
-        this._executionCtx = executionCtx;
-        this.req = req;
-        this.env = env || {};
-        this.notFoundHandler = notFoundHandler;
-        this.finalized = false;
-    }
-    get event() {
-        if (this._executionCtx instanceof FetchEvent) {
-            return this._executionCtx;
-        }
-        else {
-            throw Error('This context has no FetchEvent');
-        }
-    }
-    get executionCtx() {
-        if (this._executionCtx) {
-            return this._executionCtx;
-        }
-        else {
-            throw Error('This context has no ExecutionContext');
-        }
-    }
-    get res() {
-        return (this._res || (this._res = new Response('404 Not Found', { status: 404 })));
-    }
-    set res(_res) {
-        this._res = _res;
-        this.finalized = true;
-    }
-    header(name, value, options) {
-        this._headers || (this._headers = {});
-        const key = name.toLowerCase();
-        let shouldAppend = false;
-        if (options && options.append) {
-            const vAlreadySet = this._headers[key];
-            if (vAlreadySet && vAlreadySet.length) {
-                shouldAppend = true;
-            }
-        }
-        if (shouldAppend) {
-            this._headers[key].push(value);
-        }
-        else {
-            this._headers[key] = [value];
-        }
-        if (this.finalized) {
-            if (shouldAppend) {
-                this.res.headers.append(name, value);
-            }
-            else {
-                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, status, headers = {}) {
-        return new Response(data, {
-            status: status || this._status || 200,
-            headers: this._finalizeHeaders(headers),
-        });
-    }
-    _finalizeHeaders(incomingHeaders) {
-        const finalizedHeaders = [];
-        const headersKv = this._headers || {};
-        // If Response is already set
-        if (this._res) {
-            this._res.headers.forEach((v, k) => {
-                headersKv[k] = [v];
-            });
-        }
-        for (const key of Object.keys(incomingHeaders)) {
-            const value = incomingHeaders[key];
-            if (typeof value === 'string') {
-                finalizedHeaders.push([key, value]);
-            }
-            else {
-                for (const v of value) {
-                    finalizedHeaders.push([key, v]);
-                }
-            }
-            delete headersKv[key];
+// src/context.ts
+import { serialize } from "./utils/cookie.js";
+var HonoContext = class {
+  constructor(req, env = {}, executionCtx = void 0, notFoundHandler = () => new Response()) {
+    this.error = void 0;
+    this._status = 200;
+    this._pretty = false;
+    this._prettySpace = 2;
+    this._executionCtx = executionCtx;
+    this.req = req;
+    this.env = env || {};
+    this.notFoundHandler = notFoundHandler;
+    this.finalized = false;
+  }
+  get event() {
+    if (this._executionCtx instanceof FetchEvent) {
+      return this._executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  get executionCtx() {
+    if (this._executionCtx) {
+      return this._executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  get res() {
+    return this._res || (this._res = new Response("404 Not Found", { status: 404 }));
+  }
+  set res(_res) {
+    this._res = _res;
+    this.finalized = true;
+  }
+  header(name, value, options) {
+    this._headers || (this._headers = {});
+    const key = name.toLowerCase();
+    let shouldAppend = false;
+    if (options && options.append) {
+      const vAlreadySet = this._headers[key];
+      if (vAlreadySet && vAlreadySet.length) {
+        shouldAppend = true;
+      }
+    }
+    if (shouldAppend) {
+      this._headers[key].push(value);
+    } else {
+      this._headers[key] = [value];
+    }
+    if (this.finalized) {
+      if (shouldAppend) {
+        this.res.headers.append(name, value);
+      } else {
+        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 void 0;
+    }
+    return this._map[key];
+  }
+  pretty(prettyJSON, space = 2) {
+    this._pretty = prettyJSON;
+    this._prettySpace = space;
+  }
+  newResponse(data, status, headers = {}) {
+    return new Response(data, {
+      status: status || this._status || 200,
+      headers: this._finalizeHeaders(headers)
+    });
+  }
+  _finalizeHeaders(incomingHeaders) {
+    const finalizedHeaders = [];
+    const headersKv = this._headers || {};
+    if (this._res) {
+      this._res.headers.forEach((v, k) => {
+        headersKv[k] = [v];
+      });
+    }
+    for (const key of Object.keys(incomingHeaders)) {
+      const value = incomingHeaders[key];
+      if (typeof value === "string") {
+        finalizedHeaders.push([key, value]);
+      } else {
+        for (const v of value) {
+          finalizedHeaders.push([key, v]);
         }
-        for (const key of Object.keys(headersKv)) {
-            for (const value of headersKv[key]) {
-                const kv = [key, value];
-                finalizedHeaders.push(kv);
-            }
-        }
-        return finalizedHeaders;
-    }
-    body(data, status = this._status, headers = {}) {
-        return this.newResponse(data, status, headers);
-    }
-    text(text, status = this._status, headers = {}) {
-        headers['content-type'] = 'text/plain; charset=UTF-8';
-        return this.body(text, status, headers);
-    }
-    json(object, status = this._status, headers = {}) {
-        const body = this._pretty
-            ? JSON.stringify(object, null, this._prettySpace)
-            : JSON.stringify(object);
-        headers['content-type'] = 'application/json; charset=UTF-8';
-        return this.body(body, status, headers);
-    }
-    html(html, status = this._status, headers = {}) {
-        headers['content-type'] = 'text/html; charset=UTF-8';
-        return this.body(html, status, headers);
-    }
-    redirect(location, status = 302) {
-        return this.newResponse(null, status, {
-            Location: location,
-        });
-    }
-    cookie(name, value, opt) {
-        const cookie = serialize(name, value, opt);
-        this.header('set-cookie', cookie, { append: true });
-    }
-    notFound() {
-        return this.notFoundHandler(this);
-    }
-}
+      }
+      delete headersKv[key];
+    }
+    for (const key of Object.keys(headersKv)) {
+      for (const value of headersKv[key]) {
+        const kv = [key, value];
+        finalizedHeaders.push(kv);
+      }
+    }
+    return finalizedHeaders;
+  }
+  body(data, status = this._status, headers = {}) {
+    return this.newResponse(data, status, headers);
+  }
+  text(text, status = this._status, headers = {}) {
+    headers["content-type"] = "text/plain; charset=UTF-8";
+    return this.body(text, status, headers);
+  }
+  json(object, status = this._status, headers = {}) {
+    const body = this._pretty ? JSON.stringify(object, null, this._prettySpace) : JSON.stringify(object);
+    headers["content-type"] = "application/json; charset=UTF-8";
+    return this.body(body, status, headers);
+  }
+  html(html, status = this._status, headers = {}) {
+    headers["content-type"] = "text/html; charset=UTF-8";
+    return this.body(html, status, headers);
+  }
+  redirect(location, status = 302) {
+    return this.newResponse(null, status, {
+      Location: location
+    });
+  }
+  cookie(name, value, opt) {
+    const cookie = serialize(name, value, opt);
+    this.header("set-cookie", cookie, { append: true });
+  }
+  notFound() {
+    return this.notFoundHandler(this);
+  }
+};
+export {
+  HonoContext
+};

package/dist/hono.d.ts

@@ -1,58 +1,43 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Context } from './context';
 import type { Router } from './router';
-export interface ContextVariableMap {
+import type { Handler, Environment, ParamKeys, ErrorHandler, NotFoundHandler } from './types';
+import type { Schema } from './validator/schema';
+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;
 }
-export declare type Bindings = Record<string, any>;
-export declare type Variables = Record<string, any>;
-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 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 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;