hono 2.2.3 → 2.2.5

package/dist/cjs/compose.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compose = void 0;
 const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
-const compose = (middleware, onNotFound) => {
+const compose = (middleware, onNotFound, onError) => {
     const middlewareLength = middleware.length;
     return (context, next) => {
         let index = -1;
@@ -17,29 +17,51 @@ const compose = (middleware, onNotFound) => {
             if (i === middlewareLength && next)
                 handler = next;
             let res;
+            let isError = false;
             if (!handler) {
                 if (context instanceof context_1.HonoContext && context.finalized === false && onNotFound) {
                     res = onNotFound(context);
                 }
             }
             else {
-                res = handler(context, () => {
-                    const dispatchRes = dispatch(i + 1);
-                    return dispatchRes instanceof Promise ? dispatchRes : Promise.resolve(dispatchRes);
-                });
+                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 context_1.HonoContext && onError) {
+                        context.error = err;
+                        res = onError(err, context);
+                        isError = true;
+                    }
+                    else {
+                        throw err;
+                    }
+                }
             }
             if (!(res instanceof Promise)) {
-                if (res && context.finalized === false) {
+                if (res && (context.finalized === false || isError)) {
                     context.res = res;
                 }
                 return context;
             }
             else {
-                return res.then((res) => {
+                return res
+                    .then((res) => {
                     if (res && context.finalized === false) {
                         context.res = res;
                     }
                     return context;
+                })
+                    .catch((err) => {
+                    if (err instanceof Error && context instanceof context_1.HonoContext && onError) {
+                        context.error = err;
+                        context.res = onError(err, context);
+                        return context;
+                    }
+                    throw err;
                 });
             }
         }

package/dist/cjs/context.js

@@ -4,6 +4,7 @@ exports.HonoContext = void 0;
 const cookie_1 = require("./utils/cookie");
 class HonoContext {
     constructor(req, env = undefined, executionCtx = undefined, notFoundHandler = () => new Response()) {
+        this.error = undefined;
         this._status = 200;
         this._pretty = false;
         this._prettySpace = 2;

package/dist/cjs/hono.js

@@ -146,7 +146,7 @@ class Hono extends defineDynamicClass() {
             })();
         }
         const handlers = result ? result.handlers : [this.notFoundHandler];
-        const composed = (0, compose_1.compose)(handlers, this.notFoundHandler);
+        const composed = (0, compose_1.compose)(handlers, this.notFoundHandler, this.errorHandler);
         return (async () => {
             try {
                 const tmp = composed(c);

package/dist/cjs/middleware/serve-static/bun.js

@@ -12,7 +12,7 @@ const DEFAULT_DOCUMENT = 'index.html';
 const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
-        if (c.res && c.finalized) {
+        if (c.finalized) {
             await next();
         }
         const url = new URL(c.req.url);

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validatorMiddleware = void 0;
+const http_status_1 = require("../../utils/http-status");
 const validator_1 = require("./validator");
 const validatorMiddleware = (validationFunction, options) => {
     const v = new validator_1.Validator();
@@ -12,7 +13,14 @@ const validatorMiddleware = (validationFunction, options) => {
         };
         const validatorList = getValidatorList(validationFunction(v, c));
         for (const [keys, validator] of validatorList) {
-            const result = await validator.validate(c.req);
+            let result;
+            try {
+                result = await validator.validate(c.req);
+            }
+            catch (e) {
+                // Invalid JSON request
+                return c.text((0, http_status_1.getStatusText)(400), 400);
+            }
             if (result.isValid) {
                 // Set data on request object
                 c.req.valid(keys, result.value);

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VObject = exports.VBoolean = exports.VNumber = exports.VString = exports.VBase = exports.Validator = void 0;
+exports.VBooleanArray = exports.VStringArray = exports.VNumberArray = exports.VObject = exports.VBoolean = exports.VNumber = exports.VString = exports.VBase = exports.Validator = void 0;
 const json_1 = require("../../utils/json");
 const rule_1 = require("./rule");
 const sanitizer_1 = require("./sanitizer");
@@ -25,7 +25,7 @@ class VBase {
         };
         this.isRequired = () => {
             return this.addRule((value) => {
-                if (value)
+                if (value !== undefined && value !== null && value !== '')
                     return true;
                 return false;
             });
@@ -71,28 +71,38 @@ class VBase {
                 value = body[this.key];
             }
             if (this.target === 'json') {
-                const obj = await req.json();
-                value = (0, json_1.JSONPath)(obj, this.key);
+                try {
+                    const obj = (await req.json());
+                    value = (0, json_1.JSONPath)(obj, this.key);
+                }
+                catch (e) {
+                    throw new Error('Malformed JSON in request body');
+                }
             }
             result.value = value;
             result.isValid = this.validateValue(value);
-            if (result.isValid == false) {
+            if (result.isValid === false) {
                 if (this._message) {
                     result.message = this._message;
                 }
                 else {
+                    const valToStr = Array.isArray(value)
+                        ? `[${value
+                            .map((val) => val === undefined ? 'undefined' : typeof val === 'string' ? `"${val}"` : val)
+                            .join(', ')}]`
+                        : value;
                     switch (this.target) {
                         case 'query':
-                            result.message = `Invalid Value: the query parameter "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the query parameter "${this.key}" is invalid - ${valToStr}`;
                             break;
                         case 'header':
-                            result.message = `Invalid Value: the request header "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the request header "${this.key}" is invalid - ${valToStr}`;
                             break;
                         case 'body':
-                            result.message = `Invalid Value: the request body "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the request body "${this.key}" is invalid - ${valToStr}`;
                             break;
                         case 'json':
-                            result.message = `Invalid Value: the JSON body "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the JSON body "${this.key}" is invalid - ${valToStr}`;
                             break;
                     }
                 }
@@ -101,31 +111,59 @@ class VBase {
         };
         this.validateValue = (value) => {
             // Check type
-            if (typeof value !== this.type) {
-                if (this._optional && typeof value === 'undefined') {
-                    // Do nothing.
-                    // The value is allowed to be `undefined` if it is `optional`
-                }
-                else {
+            if (this.isArray) {
+                if (!Array.isArray(value)) {
                     return false;
                 }
+                for (const val of value) {
+                    if (typeof val !== this.type) {
+                        // Value is of wrong type here
+                        // If not optional, or optional and not undefined, return false
+                        if (!this._optional || typeof val !== 'undefined')
+                            return false;
+                    }
+                }
+                // Sanitize
+                for (const sanitizer of this.sanitizers) {
+                    value = value.map((innerVal) => sanitizer(innerVal));
+                }
+                for (const rule of this.rules) {
+                    for (const val of value) {
+                        if (!rule(val)) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
             }
-            // Sanitize
-            for (const sanitizer of this.sanitizers) {
-                value = sanitizer(value);
-            }
-            for (const rule of this.rules) {
-                if (!rule(value)) {
-                    return false;
+            else {
+                if (typeof value !== this.type) {
+                    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) {
+                    value = sanitizer(value);
+                }
+                for (const rule of this.rules) {
+                    if (!rule(value)) {
+                        return false;
+                    }
                 }
+                return true;
             }
-            return true;
         };
         this.target = options.target;
         this.key = options.key;
         this.type = options.type || 'string';
         this.rules = [];
         this.sanitizers = [];
+        this.isArray = options.isArray || false;
         this._optional = false;
     }
     message(value) {
@@ -137,6 +175,9 @@ exports.VBase = VBase;
 class VString extends VBase {
     constructor(options) {
         super(options);
+        this.asArray = () => {
+            return new VStringArray(this);
+        };
         this.isEmpty = (options = { ignore_whitespace: false }) => {
             return this.addRule((value) => rule_1.rule.isEmpty(value, options));
         };
@@ -171,6 +212,9 @@ exports.VString = VString;
 class VNumber extends VBase {
     constructor(options) {
         super(options);
+        this.asArray = () => {
+            return new VNumberArray(this);
+        };
         this.isGte = (min) => {
             return this.addRule((value) => rule_1.rule.isGte(value, min));
         };
@@ -184,6 +228,9 @@ exports.VNumber = VNumber;
 class VBoolean extends VBase {
     constructor(options) {
         super(options);
+        this.asArray = () => {
+            return new VBooleanArray(this);
+        };
         this.isTrue = () => {
             return this.addRule((value) => rule_1.rule.isTrue(value));
         };
@@ -201,3 +248,24 @@ class VObject extends VBase {
     }
 }
 exports.VObject = VObject;
+class VNumberArray extends VNumber {
+    constructor(options) {
+        super(options);
+        this.isArray = true;
+    }
+}
+exports.VNumberArray = VNumberArray;
+class VStringArray extends VString {
+    constructor(options) {
+        super(options);
+        this.isArray = true;
+    }
+}
+exports.VStringArray = VStringArray;
+class VBooleanArray extends VBoolean {
+    constructor(options) {
+        super(options);
+        this.isArray = true;
+    }
+}
+exports.VBooleanArray = VBooleanArray;

package/dist/cjs/router/reg-exp-router/router.js

@@ -60,7 +60,7 @@ class RegExpRouter {
         this.routes = { [router_1.METHOD_NAME_ALL]: {} };
     }
     add(method, path, handler) {
-        var _a, _b;
+        var _a;
         const { middleware, routes } = this;
         if (!middleware || !routes) {
             throw new Error('Can not add a route since the matcher is already built.');
@@ -91,17 +91,17 @@ class RegExpRouter {
         for (let i = 0, len = paths.length; i < len; i++) {
             const path = paths[i];
             routes[method] || (routes[method] = {});
-            (_b = routes[method])[path] || (_b[path] = [
-                ...(routes[router_1.METHOD_NAME_ALL][path] ||
-                    findMiddleware(middleware[method], path) ||
-                    findMiddleware(middleware[router_1.METHOD_NAME_ALL], path) ||
-                    []),
-            ]);
             Object.keys(routes).forEach((m) => {
-                ;
-                (method === router_1.METHOD_NAME_ALL || method === m) &&
-                    routes[m][path] &&
+                var _a;
+                if (method === router_1.METHOD_NAME_ALL || method === m) {
+                    (_a = routes[m])[path] || (_a[path] = [
+                        ...(routes[router_1.METHOD_NAME_ALL][path] ||
+                            findMiddleware(middleware[method], path) ||
+                            findMiddleware(middleware[router_1.METHOD_NAME_ALL], path) ||
+                            []),
+                    ]);
                     routes[m][path].push(handler);
+                }
             });
         }
     }

package/dist/cjs/router/trie-router/node.js

@@ -151,7 +151,6 @@ class Node {
                         if (typeof name === 'string' && !matched) {
                             params[name] = part;
                         }
-                        break;
                     }
                 }
             }

package/dist/cjs/utils/json.js

@@ -1,22 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONPath = void 0;
-const JSONPath = (data, path) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let val = data;
-    const parts = path.split('.');
+const JSONPathInternal = (data, parts) => {
     const length = parts.length;
-    for (let i = 0; i < length && val !== undefined; i++) {
+    for (let i = 0; i < length && data !== undefined; i++) {
         const p = parts[i];
-        if (p !== '') {
-            if (typeof val === 'object') {
-                val = val[p];
-            }
-            else {
-                val = undefined;
-            }
+        if (p === '') {
+            continue;
+        }
+        if (typeof data !== 'object' || data === null) {
+            return undefined;
+        }
+        if (p === '*') {
+            const restParts = parts.slice(i + 1);
+            const values = Object.values(data).map((v) => JSONPathInternal(v, restParts));
+            return restParts.indexOf('*') === -1 ? values : values.flat();
+        }
+        else {
+            data = data[p]; // `data` may be an array, but accessing it as an object yields the same result.
         }
     }
-    return val;
+    return data;
+};
+const JSONPath = (data, path) => {
+    try {
+        return JSONPathInternal(data, path.replace(/\[(.*?)\]/g, '.$1').split(/\./));
+    }
+    catch (e) {
+        return undefined;
+    }
 };
 exports.JSONPath = JSONPath;

package/dist/compose.d.ts

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

package/dist/compose.js

@@ -1,6 +1,6 @@
 import { HonoContext } from './context';
 // Based on the code in the MIT licensed `koa-compose` package.
-export const compose = (middleware, onNotFound) => {
+export const compose = (middleware, onNotFound, onError) => {
     const middlewareLength = middleware.length;
     return (context, next) => {
         let index = -1;
@@ -14,29 +14,51 @@ export const compose = (middleware, onNotFound) => {
             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 {
-                res = handler(context, () => {
-                    const dispatchRes = dispatch(i + 1);
-                    return dispatchRes instanceof Promise ? dispatchRes : Promise.resolve(dispatchRes);
-                });
+                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) {
+                if (res && (context.finalized === false || isError)) {
                     context.res = res;
                 }
                 return context;
             }
             else {
-                return res.then((res) => {
+                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;
                 });
             }
         }

package/dist/context.d.ts

@@ -10,6 +10,7 @@ export interface Context<RequestParamKeyType extends string = string, E extends
     event: FetchEvent;
     executionCtx: ExecutionContext;
     finalized: boolean;
+    error: Error | undefined;
     get res(): Response;
     set res(_res: Response);
     header: (name: string, value: string, options?: {
@@ -40,6 +41,7 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     req: Request<RequestParamKeyType, D>;
     env: E['Bindings'];
     finalized: boolean;
+    error: Error | undefined;
     _status: StatusCode;
     private _executionCtx;
     private _pretty;

package/dist/context.js

@@ -1,6 +1,7 @@
 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;

package/dist/hono.js

@@ -143,7 +143,7 @@ export class Hono extends defineDynamicClass() {
             })();
         }
         const handlers = result ? result.handlers : [this.notFoundHandler];
-        const composed = compose(handlers, this.notFoundHandler);
+        const composed = compose(handlers, this.notFoundHandler, this.errorHandler);
         return (async () => {
             try {
                 const tmp = composed(c);

package/dist/middleware/serve-static/bun.js

@@ -9,7 +9,7 @@ const DEFAULT_DOCUMENT = 'index.html';
 export const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
-        if (c.res && c.finalized) {
+        if (c.finalized) {
             await next();
         }
         const url = new URL(c.req.url);

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

@@ -1,12 +1,12 @@
 import type { Context } from '../../context';
 import type { Environment, Next, ValidatedData } from '../../hono';
 import { Validator } from './validator';
-import type { VString, VNumber, VBoolean, VObject, ValidateResult } from './validator';
+import type { VString, VNumber, VBoolean, VObject, VNumberArray, VStringArray, VBooleanArray, ValidateResult } from './validator';
 declare type Schema = {
-    [key: string]: VString | VNumber | VBoolean | VObject | Schema;
+    [key: string]: VString | VNumber | VBoolean | VObject | VStringArray | VNumberArray | VBooleanArray | Schema;
 };
 declare type SchemaToProp<T> = {
-    [K in keyof T]: T[K] extends VNumber ? number : T[K] extends VBoolean ? boolean : T[K] extends VString ? string : T[K] extends VObject ? object : T[K] extends Schema ? SchemaToProp<T[K]> : never;
+    [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 VObject ? object : T[K] extends Schema ? SchemaToProp<T[K]> : never;
 };
 declare type ResultSet = {
     hasError: boolean;

package/dist/middleware/validator/middleware.js

@@ -1,3 +1,4 @@
+import { getStatusText } from '../../utils/http-status';
 import { VBase, Validator } from './validator';
 export const validatorMiddleware = (validationFunction, options) => {
     const v = new Validator();
@@ -9,7 +10,14 @@ export const validatorMiddleware = (validationFunction, options) => {
         };
         const validatorList = getValidatorList(validationFunction(v, c));
         for (const [keys, validator] of validatorList) {
-            const result = await validator.validate(c.req);
+            let result;
+            try {
+                result = await validator.validate(c.req);
+            }
+            catch (e) {
+                // Invalid JSON request
+                return c.text(getStatusText(400), 400);
+            }
             if (result.isValid) {
                 // Set data on request object
                 c.req.valid(keys, result.value);

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

@@ -1,5 +1,6 @@
+import type { JSONObject, JSONPrimitive, JSONArray } from '../../utils/json';
 declare type Target = 'query' | 'header' | 'body' | 'json';
-declare type Type = string | number | boolean | object | undefined;
+declare type Type = JSONPrimitive | JSONObject | JSONArray | File;
 declare type Rule = (value: Type) => boolean;
 declare type Sanitizer = (value: Type) => Type;
 export declare class Validator {
@@ -19,6 +20,7 @@ declare type VOptions = {
     target: Target;
     key: string;
     type?: 'string' | 'number' | 'boolean' | 'object';
+    isArray?: boolean;
 };
 export declare abstract class VBase {
     type: 'string' | 'number' | 'boolean' | 'object';
@@ -26,6 +28,7 @@ export declare abstract class VBase {
     key: string;
     rules: Rule[];
     sanitizers: Sanitizer[];
+    isArray: boolean;
     private _message;
     private _optional;
     constructor(options: VOptions);
@@ -43,6 +46,7 @@ export declare abstract class VBase {
 }
 export declare class VString extends VBase {
     constructor(options: VOptions);
+    asArray: () => VStringArray;
     isEmpty: (options?: {
         ignore_whitespace: boolean;
     }) => this;
@@ -62,15 +66,29 @@ export declare class VString extends VBase {
 }
 export declare class VNumber extends VBase {
     constructor(options: VOptions);
+    asArray: () => VNumberArray;
     isGte: (min: number) => this;
     isLte: (min: number) => this;
 }
 export declare class VBoolean extends VBase {
     constructor(options: VOptions);
+    asArray: () => VBooleanArray;
     isTrue: () => this;
     isFalse: () => this;
 }
 export declare class VObject extends VBase {
     constructor(options: VOptions);
 }
+export declare class VNumberArray extends VNumber {
+    isArray: true;
+    constructor(options: VOptions);
+}
+export declare class VStringArray extends VString {
+    isArray: true;
+    constructor(options: VOptions);
+}
+export declare class VBooleanArray extends VBoolean {
+    isArray: true;
+    constructor(options: VOptions);
+}
 export {};

package/dist/middleware/validator/validator.js

@@ -21,7 +21,7 @@ export class VBase {
         };
         this.isRequired = () => {
             return this.addRule((value) => {
-                if (value)
+                if (value !== undefined && value !== null && value !== '')
                     return true;
                 return false;
             });
@@ -67,28 +67,38 @@ export class VBase {
                 value = body[this.key];
             }
             if (this.target === 'json') {
-                const obj = await req.json();
-                value = JSONPath(obj, this.key);
+                try {
+                    const obj = (await req.json());
+                    value = JSONPath(obj, this.key);
+                }
+                catch (e) {
+                    throw new Error('Malformed JSON in request body');
+                }
             }
             result.value = value;
             result.isValid = this.validateValue(value);
-            if (result.isValid == false) {
+            if (result.isValid === false) {
                 if (this._message) {
                     result.message = this._message;
                 }
                 else {
+                    const valToStr = Array.isArray(value)
+                        ? `[${value
+                            .map((val) => val === undefined ? 'undefined' : typeof val === 'string' ? `"${val}"` : val)
+                            .join(', ')}]`
+                        : value;
                     switch (this.target) {
                         case 'query':
-                            result.message = `Invalid Value: the query parameter "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the query parameter "${this.key}" is invalid - ${valToStr}`;
                             break;
                         case 'header':
-                            result.message = `Invalid Value: the request header "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the request header "${this.key}" is invalid - ${valToStr}`;
                             break;
                         case 'body':
-                            result.message = `Invalid Value: the request body "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the request body "${this.key}" is invalid - ${valToStr}`;
                             break;
                         case 'json':
-                            result.message = `Invalid Value: the JSON body "${this.key}" is invalid - ${value}`;
+                            result.message = `Invalid Value: the JSON body "${this.key}" is invalid - ${valToStr}`;
                             break;
                     }
                 }
@@ -97,31 +107,59 @@ export class VBase {
         };
         this.validateValue = (value) => {
             // Check type
-            if (typeof value !== this.type) {
-                if (this._optional && typeof value === 'undefined') {
-                    // Do nothing.
-                    // The value is allowed to be `undefined` if it is `optional`
-                }
-                else {
+            if (this.isArray) {
+                if (!Array.isArray(value)) {
                     return false;
                 }
+                for (const val of value) {
+                    if (typeof val !== this.type) {
+                        // Value is of wrong type here
+                        // If not optional, or optional and not undefined, return false
+                        if (!this._optional || typeof val !== 'undefined')
+                            return false;
+                    }
+                }
+                // Sanitize
+                for (const sanitizer of this.sanitizers) {
+                    value = value.map((innerVal) => sanitizer(innerVal));
+                }
+                for (const rule of this.rules) {
+                    for (const val of value) {
+                        if (!rule(val)) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
             }
-            // Sanitize
-            for (const sanitizer of this.sanitizers) {
-                value = sanitizer(value);
-            }
-            for (const rule of this.rules) {
-                if (!rule(value)) {
-                    return false;
+            else {
+                if (typeof value !== this.type) {
+                    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) {
+                    value = sanitizer(value);
+                }
+                for (const rule of this.rules) {
+                    if (!rule(value)) {
+                        return false;
+                    }
                 }
+                return true;
             }
-            return true;
         };
         this.target = options.target;
         this.key = options.key;
         this.type = options.type || 'string';
         this.rules = [];
         this.sanitizers = [];
+        this.isArray = options.isArray || false;
         this._optional = false;
     }
     message(value) {
@@ -132,6 +170,9 @@ export class VBase {
 export class VString extends VBase {
     constructor(options) {
         super(options);
+        this.asArray = () => {
+            return new VStringArray(this);
+        };
         this.isEmpty = (options = { ignore_whitespace: false }) => {
             return this.addRule((value) => rule.isEmpty(value, options));
         };
@@ -165,6 +206,9 @@ export class VString extends VBase {
 export class VNumber extends VBase {
     constructor(options) {
         super(options);
+        this.asArray = () => {
+            return new VNumberArray(this);
+        };
         this.isGte = (min) => {
             return this.addRule((value) => rule.isGte(value, min));
         };
@@ -177,6 +221,9 @@ export class VNumber extends VBase {
 export class VBoolean extends VBase {
     constructor(options) {
         super(options);
+        this.asArray = () => {
+            return new VBooleanArray(this);
+        };
         this.isTrue = () => {
             return this.addRule((value) => rule.isTrue(value));
         };
@@ -192,3 +239,21 @@ export class VObject extends VBase {
         this.type = 'object';
     }
 }
+export class VNumberArray extends VNumber {
+    constructor(options) {
+        super(options);
+        this.isArray = true;
+    }
+}
+export class VStringArray extends VString {
+    constructor(options) {
+        super(options);
+        this.isArray = true;
+    }
+}
+export class VBooleanArray extends VBoolean {
+    constructor(options) {
+        super(options);
+        this.isArray = true;
+    }
+}

package/dist/router/reg-exp-router/router.js

@@ -57,7 +57,7 @@ export class RegExpRouter {
         this.routes = { [METHOD_NAME_ALL]: {} };
     }
     add(method, path, handler) {
-        var _a, _b;
+        var _a;
         const { middleware, routes } = this;
         if (!middleware || !routes) {
             throw new Error('Can not add a route since the matcher is already built.');
@@ -88,17 +88,17 @@ export class RegExpRouter {
         for (let i = 0, len = paths.length; i < len; i++) {
             const path = paths[i];
             routes[method] || (routes[method] = {});
-            (_b = routes[method])[path] || (_b[path] = [
-                ...(routes[METHOD_NAME_ALL][path] ||
-                    findMiddleware(middleware[method], path) ||
-                    findMiddleware(middleware[METHOD_NAME_ALL], path) ||
-                    []),
-            ]);
             Object.keys(routes).forEach((m) => {
-                ;
-                (method === METHOD_NAME_ALL || method === m) &&
-                    routes[m][path] &&
+                var _a;
+                if (method === METHOD_NAME_ALL || method === m) {
+                    (_a = routes[m])[path] || (_a[path] = [
+                        ...(routes[METHOD_NAME_ALL][path] ||
+                            findMiddleware(middleware[method], path) ||
+                            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                            []),
+                    ]);
                     routes[m][path].push(handler);
+                }
             });
         }
     }

package/dist/router/trie-router/node.js

@@ -148,7 +148,6 @@ export class Node {
                         if (typeof name === 'string' && !matched) {
                             params[name] = part;
                         }
-                        break;
                     }
                 }
             }

package/dist/utils/json.d.ts

@@ -1 +1,7 @@
-export declare const JSONPath: (data: object, path: string) => any;
+export declare type JSONPrimitive = string | boolean | number | null | undefined;
+export declare type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
+export declare type JSONObject = {
+    [key: string]: JSONPrimitive | JSONArray | JSONObject;
+};
+export declare type JSONValue = JSONObject | JSONArray | JSONPrimitive;
+export declare const JSONPath: (data: JSONObject, path: string) => JSONValue;

package/dist/utils/json.js

@@ -1,18 +1,29 @@
-export const JSONPath = (data, path) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let val = data;
-    const parts = path.split('.');
+const JSONPathInternal = (data, parts) => {
     const length = parts.length;
-    for (let i = 0; i < length && val !== undefined; i++) {
+    for (let i = 0; i < length && data !== undefined; i++) {
         const p = parts[i];
-        if (p !== '') {
-            if (typeof val === 'object') {
-                val = val[p];
-            }
-            else {
-                val = undefined;
-            }
+        if (p === '') {
+            continue;
+        }
+        if (typeof data !== 'object' || data === null) {
+            return undefined;
+        }
+        if (p === '*') {
+            const restParts = parts.slice(i + 1);
+            const values = Object.values(data).map((v) => JSONPathInternal(v, restParts));
+            return restParts.indexOf('*') === -1 ? values : values.flat();
+        }
+        else {
+            data = data[p]; // `data` may be an array, but accessing it as an object yields the same result.
         }
     }
-    return val;
+    return data;
+};
+export const JSONPath = (data, path) => {
+    try {
+        return JSONPathInternal(data, path.replace(/\[(.*?)\]/g, '.$1').split(/\./));
+    }
+    catch (e) {
+        return undefined;
+    }
 };

package/package.json

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