hono 2.5.10 → 2.6.1

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

@@ -27,6 +27,7 @@ var import_validator = require("../../validator/validator");
 const validatorMiddleware = (validationFunction, options) => {
   const v = new import_validator.Validator();
   const handler = async (c, next) => {
+    var _a;
     const resultSet = {
       hasError: false,
       messages: [],
@@ -75,14 +76,16 @@ const validatorMiddleware = (validationFunction, options) => {
           const dst = data;
           data = (0, import_object.mergeObjects)(dst, jsonData);
         } else {
-          c.req.valid(keys, value);
+          let tmp = data;
+          for (let i = 0; i < keys.length - 1; i++) {
+            tmp = tmp[_a = keys[i]] || (tmp[_a] = {});
+          }
+          tmp[keys[keys.length - 1]] = value;
         }
       }
     }
     if (!resultSet.hasError) {
-      Object.keys(data).map((key) => {
-        c.req.valid(key, data[key]);
-      });
+      c.req.valid(data);
     }
     if (options && options.done) {
       const res = options.done(resultSet, c);

package/dist/cjs/request.js

@@ -113,20 +113,12 @@ function extendRequestPrototype() {
     }
     return jsonData;
   };
-  Request.prototype.valid = function(keys, value) {
-    var _a;
+  Request.prototype.valid = function(data) {
     if (!this.data) {
       this.data = {};
     }
-    if (keys !== void 0) {
-      if (typeof keys === "string") {
-        keys = [keys];
-      }
-      let data = this.data;
-      for (let i = 0; i < keys.length - 1; i++) {
-        data = data[_a = keys[i]] || (data[_a] = {});
-      }
-      data[keys[keys.length - 1]] = value;
+    if (data) {
+      this.data = data;
     }
     return this.data;
   };

package/dist/context.d.ts

@@ -6,7 +6,7 @@ import type { Schema, SchemaToProp } from './validator/schema';
 declare type Headers = Record<string, string | string[]>;
 declare type Runtime = 'node' | 'deno' | 'bun' | 'cloudflare' | 'fastly' | 'vercel' | 'other';
 export declare type Data = string | ArrayBuffer | ReadableStream;
-export declare class Context<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> {
+export declare class Context<P extends string = string, E extends Partial<Environment> = Environment, S = any> {
     req: Request<unknown, P, S extends Schema ? SchemaToProp<S> : S>;
     env: E['Bindings'];
     finalized: boolean;

package/dist/hono.d.ts

@@ -1,22 +1,21 @@
 import type { Router } from './router';
 import type { ExecutionContext } from './types';
 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;
+interface HandlerInterface<P extends string, E extends Partial<Environment> = Environment, S = unknown, U = Hono<E, P, S>> {
+    <Path extends string, Data = S>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): Hono<E, Path, Data & S>;
+    (...handlers: Handler<P, E, S>[]): U;
+    <Path extends string, Data = S>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E, Data>[]): Hono<E, Path, Data & S>;
+    <Path extends string, Data = S>(path: Path, ...handlers: Handler<string, E, Data>[]): Hono<E, string, Data & S>;
+    (path: string, ...handlers: Handler<P, E, S>[]): U;
 }
-interface Route<P extends string = string, E extends Partial<Environment> = Environment, S extends Partial<Schema> = Schema> {
+interface Route<P extends string = string, E extends Partial<Environment> = Environment, S = unknown> {
     path: string;
     method: string;
     handler: Handler<P, E, S>;
 }
-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>>() => {
-    get: HandlerInterface<P_1, E_1, S_1, U>;
+declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, P_1 extends string = string, S_1 = unknown, 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>;
@@ -24,7 +23,7 @@ declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, P_
     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 = '/', S extends Partial<Schema> = Schema> extends Hono_base<E, P, S, Hono<E, P, S>> {
+export declare class Hono<E extends Partial<Environment> = Environment, P extends string = string, S = unknown> extends Hono_base<E, P, S, Hono<E, P, S>> {
     readonly router: Router<Handler<P, E, S>>;
     readonly strict: boolean;
     private _tempPath;
@@ -34,8 +33,8 @@ export declare class Hono<E extends Partial<Environment> = Environment, P extend
     private notFoundHandler;
     private errorHandler;
     route(path: string, app?: Hono<any>): this;
-    use<Path extends string = string, Data extends Partial<Schema> = Schema>(...middleware: Handler<Path, E, Data>[]): Hono<E, P, S>;
-    use<Path extends string = string, Data extends Partial<Schema> = Schema>(arg1: string, ...middleware: Handler<Path, E, Data>[]): Hono<E, P, S>;
+    use<Path extends string = string, Data = unknown>(...middleware: Handler<Path, E, Data>[]): Hono<E, P, S>;
+    use<Path extends string = string, Data = unknown>(arg1: string, ...middleware: Handler<Path, E, Data>[]): Hono<E, P, S>;
     on(method: string, path: string, ...handlers: Handler<P, E, S>[]): this;
     onError(handler: ErrorHandler<E>): this;
     notFound(handler: NotFoundHandler<E>): this;

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

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler<string, import("../../types").Environment, import("../../validator/schema").Schema>;
+declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler<string, import("../../types").Environment, any>;
 export { module as serveStatic };

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

@@ -1,6 +1,5 @@
 import type { Context } from '../../context';
 import type { Environment, MiddlewareHandler } from '../../types';
-import type { Schema } from '../../validator/schema';
 import type { ValidateResult } from '../../validator/validator';
 import { Validator } from '../../validator/validator';
 declare type ResultSet = {
@@ -9,8 +8,8 @@ declare type ResultSet = {
     results: ValidateResult[];
 };
 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?: {
+declare type ValidationFunction<P extends string, E extends Partial<Environment> = Environment, S = unknown> = (v: Validator, c: Context<P, E>) => S;
+export declare const validatorMiddleware: <P extends string, E extends Partial<Environment> = Environment, S = unknown>(validationFunction: ValidationFunction<P, E, S>, options?: {
     done?: Done<P, E> | undefined;
 } | undefined) => MiddlewareHandler<string, E, S>;
 export {};

package/dist/middleware/validator/middleware.js

@@ -5,6 +5,7 @@ import { Validator, VBase, VObjectBase } from "../../validator/validator.js";
 var validatorMiddleware = (validationFunction, options) => {
   const v = new Validator();
   const handler = async (c, next) => {
+    var _a;
     const resultSet = {
       hasError: false,
       messages: [],
@@ -53,14 +54,16 @@ var validatorMiddleware = (validationFunction, options) => {
           const dst = data;
           data = mergeObjects(dst, jsonData);
         } else {
-          c.req.valid(keys, value);
+          let tmp = data;
+          for (let i = 0; i < keys.length - 1; i++) {
+            tmp = tmp[_a = keys[i]] || (tmp[_a] = {});
+          }
+          tmp[keys[keys.length - 1]] = value;
         }
       }
     }
     if (!resultSet.hasError) {
-      Object.keys(data).map((key) => {
-        c.req.valid(key, data[key]);
-      });
+      c.req.valid(data);
     }
     if (options && options.done) {
       const res = options.done(resultSet, c);

package/dist/request.d.ts

@@ -1,8 +1,7 @@
 import type { BodyData } from './utils/body';
 import type { Cookie } from './utils/cookie';
-declare type ValidatedData = Record<string, unknown>;
 declare global {
-    interface Request<CfHostMetadata = unknown, ParamKeyType extends string = string, Data extends ValidatedData = ValidatedData> {
+    interface Request<CfHostMetadata = unknown, ParamKeyType extends string = string, Data = any> {
         paramData?: Record<ParamKeyType, string>;
         param: {
             (key: ParamKeyType): string;
@@ -23,7 +22,7 @@ declare global {
             (): Record<string, string>;
         };
         cookie: {
-            (name: string): string;
+            (name: string): string | undefined;
             (): Cookie;
         };
         bodyData?: BodyData;
@@ -32,10 +31,9 @@ declare global {
         json<T>(): Promise<T>;
         data: Data;
         valid: {
-            (key: string | string[], value: unknown): Data;
+            (data: Data): Data;
             (): Data;
         };
     }
 }
 export declare function extendRequestPrototype(): void;
-export {};

package/dist/request.js

@@ -91,20 +91,12 @@ function extendRequestPrototype() {
     }
     return jsonData;
   };
-  Request.prototype.valid = function(keys, value) {
-    var _a;
+  Request.prototype.valid = function(data) {
     if (!this.data) {
       this.data = {};
     }
-    if (keys !== void 0) {
-      if (typeof keys === "string") {
-        keys = [keys];
-      }
-      let data = this.data;
-      for (let i = 0; i < keys.length - 1; i++) {
-        data = data[_a = keys[i]] || (data[_a] = {});
-      }
-      data[keys[keys.length - 1]] = value;
+    if (data) {
+      this.data = data;
     }
     return this.data;
   };

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 import type { Context } from './context';
-import type { Schema } from './validator/schema';
 export interface ContextVariableMap {
 }
 export declare type Bindings = Record<string, any>;
@@ -8,16 +7,16 @@ export declare type Environment = {
     Bindings: Bindings;
     Variables: Variables;
 };
-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 Handler<P extends string = string, E extends Partial<Environment> = Environment, S = any> = (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 = any> = (c: Context<P, E, S>, next: Next) => Promise<Response | undefined | void>;
 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;
 export declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-export interface CustomHandler<P extends string | Partial<Environment> | Schema = string, E = Partial<Environment> | Partial<Schema>, S = Partial<Schema>> {
-    (c: Context<P extends string ? P : P extends Partial<Environment> ? string : P extends Partial<Schema> ? string : never, P extends Partial<Environment> ? P : P extends Partial<Schema> ? Partial<Environment> : E extends Partial<Environment> ? E extends Partial<Schema> ? Environment : E : E extends Partial<Schema> ? Partial<Environment> : Environment, S extends Schema ? S : P extends Schema ? P : E extends Schema ? E : any>, next: Next): Response | Promise<Response | undefined | void>;
+export interface CustomHandler<P = string, E = Partial<Environment>, S = any> {
+    (c: Context<P extends string ? P : string, P extends Partial<Environment> ? P : E extends Partial<Environment> ? E : never, P extends string ? E extends Partial<Environment> ? S : P extends Partial<Environment> ? E : never : P extends Partial<Environment> ? E extends Partial<Environment> ? S : E : P>, next: Next): Response | Promise<Response | undefined | void>;
 }
 export interface ExecutionContext {
     waitUntil(promise: Promise<void>): void;

package/dist/validator/schema.d.ts

@@ -2,6 +2,6 @@ import type { VString, VNumber, VBoolean, VObject, VNumberArray, VStringArray, V
 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]>;
+export declare type SchemaToProp<T> = T extends VArray<infer R> ? SchemaToProp<R>[] : T extends VObject<infer R> ? SchemaToProp<R> : {
+    [K in keyof T]: T[K] extends VNumberArray ? number[] : T[K] extends VBooleanArray ? boolean[] : T[K] extends VStringArray ? string[] : T[K] extends VString ? string : T[K] extends VNumber ? number : T[K] extends VBoolean ? boolean : 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<infer R> ? SchemaToProp<R>[] : T[K] extends VObject<infer R> ? SchemaToProp<R> : T[K] extends Schema ? SchemaToProp<T[K]> : never : SchemaToProp<T[K]>;
 };

package/dist/validator/validator.d.ts

@@ -73,9 +73,7 @@ export declare abstract class VBase {
     asNumber: () => VNumber | VNumberArray;
     asBoolean: () => VBoolean | VBooleanArray;
     get(value: string): this;
-    validate: <R extends Request<unknown, string, {
-        [x: string]: unknown;
-    }>>(req: R) => Promise<ValidateResult[]>;
+    validate: <R extends Request<unknown, string, any>>(req: R) => Promise<ValidateResult[]>;
     protected getTypeRuleName(): string;
     private sanitizeValue;
     private validateRule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.5.10",
+  "version": "2.6.1",
   "description": "Ultrafast web framework for Cloudflare Workers, Deno, and Bun.",
   "main": "dist/cjs/index.js",
   "type": "module",