@jderstd/hono 0.7.1 → 0.8.1

package/README.md

@@ -20,7 +20,9 @@ And the response will be shown as below:
 
 ```json
 {
-    "success": true
+    "success": true,
+    "data": null,
+    "errors": []
 }
 ```
 

package/dist/body-limit.d.ts

@@ -4,63 +4,63 @@ declare const BODY_LIMIT_MAX_DEFAULT: 10485760;
 /** Options for `bodyLimit` middleware. */
 type BodyLimitOptions = {
   /**
-   * Maximum body size in bytes.
-   *
-   * By default, it is `BODY_LIMIT_MAX_DEFAULT`.
-   */
+  * Maximum body size in bytes.
+  *
+  * By default, it is `BODY_LIMIT_MAX_DEFAULT`.
+  */
   max?: number;
 };
 /**
- * Body limit middleware.
- *
- * Following error will be returned if the body size is over the limit:
- *
- * ```jsonc
- * // Status: 413
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "too_large",
- *             "path": [
- *                 "request",
- *                 "body"
- *             ],
- *             "message": "Request body is too large"
- *         }
- *     ]
- * }
- * ```
- *
- * For more information, please refer to
- * [Body Limit](https://hono.dev/docs/middleware/builtin/body-limit).
- *
- * ### Examples
- *
- * A example of using `bodyLimit` middleware:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { bodyLimit } from "@jderstd/hono/body-limit";
- *
- * const app: Hono = new Hono();
- *
- * app.use(bodyLimit());
- * ```
- *
- * A example of using `bodyLimit` middleware with options:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { bodyLimit } from "@jderstd/hono/body-limit";
- *
- * const app: Hono = new Hono();
- *
- * app.use(bodyLimit({
- *     max: 20 * 1024 * 1024, // 20MiB
- * }));
- * ```
- */
+* Body limit middleware.
+*
+* Following error will be returned if the body size is over the limit:
+*
+* ```jsonc
+* // Status: 413
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "too_large",
+*             "path": [
+*                 "request",
+*                 "body"
+*             ],
+*             "message": "Request body is too large"
+*         }
+*     ]
+* }
+* ```
+*
+* For more information, please refer to
+* [Body Limit](https://hono.dev/docs/middleware/builtin/body-limit).
+*
+* ### Examples
+*
+* A example of using `bodyLimit` middleware:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { bodyLimit } from "@jderstd/hono/body-limit";
+*
+* const app: Hono = new Hono();
+*
+* app.use(bodyLimit());
+* ```
+*
+* A example of using `bodyLimit` middleware with options:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { bodyLimit } from "@jderstd/hono/body-limit";
+*
+* const app: Hono = new Hono();
+*
+* app.use(bodyLimit({
+*     max: 20 * 1024 * 1024, // 20MiB
+* }));
+* ```
+*/
 declare const bodyLimit: (options?: BodyLimitOptions) => MiddlewareHandler;
 export { BODY_LIMIT_MAX_DEFAULT, type BodyLimitOptions, bodyLimit };
 //# sourceMappingURL=body-limit.d.ts.map

package/dist/ip-limit.d.ts

@@ -10,9 +10,9 @@ type IpLimitBaseOptions = {
   /** Denied IP addresses. */
   denyList?: IPRestrictionRule[];
   /**
-   * Whether show more information.
-   * By default, it's `false`.
-   */
+  * Whether show more information.
+  * By default, it's `false`.
+  */
   verbose?: boolean;
 };
 /** Options for `ipLimit` middleware. */
@@ -21,79 +21,79 @@ type IpLimitOptions = Format<{
   getConnInfo: GetIPAddr;
 } & IpLimitBaseOptions>;
 /**
- * IP limit middleware.
- *
- * Following error will be returned if the IP address is not allowed:
- *
- * ```jsonc
- * // Status: 403
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "forbidden"
- *         }
- *     ]
- * }
- * ```
- *
- * When `verbose` is `true`, the error will be like:
- *
- * ```jsonc
- * // Status: 403
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "forbidden",
- *             "path": [
- *                 "request",
- *                 "ip"
- *             ],
- *             "message": "Forbidden IP address: x.x.x.x"
- *         }
- *     ]
- * }
- * ```
- *
- * For more information, please refer to
- * [IP Restriction](https://hono.dev/docs/middleware/builtin/ip-restriction).
- *
- * For `getConnInfo`, please refer to
- * [ConnInfo helper](https://hono.dev/docs/helpers/conninfo).
- *
- * ### Example
- *
- * ```ts
- * import { Hono } from "hono";
- * import { ipLimit } from "@jderstd/hono/ip-limit";
- *
- * // getConnInfo helper for Node.js
- * import { getConnInfo } from "@hono/node-server/conninfo";
- *
- * const app: Hono = new Hono();
- *
- * app.use(
- *     ipLimit({
- *         getConnInfo,
- *         allowList: [],
- *         denyList: [],
- *     })
- * );
- * ```
- */
+* IP limit middleware.
+*
+* Following error will be returned if the IP address is not allowed:
+*
+* ```jsonc
+* // Status: 403
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "forbidden"
+*         }
+*     ]
+* }
+* ```
+*
+* When `verbose` is `true`, the error will be like:
+*
+* ```jsonc
+* // Status: 403
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "forbidden",
+*             "path": [
+*                 "request",
+*                 "ip"
+*             ],
+*             "message": "Forbidden IP address: x.x.x.x"
+*         }
+*     ]
+* }
+* ```
+*
+* For more information, please refer to
+* [IP Restriction](https://hono.dev/docs/middleware/builtin/ip-restriction).
+*
+* For `getConnInfo`, please refer to
+* [ConnInfo helper](https://hono.dev/docs/helpers/conninfo).
+*
+* ### Example
+*
+* ```ts
+* import { Hono } from "hono";
+* import { ipLimit } from "@jderstd/hono/ip-limit";
+*
+* // getConnInfo helper for Node.js
+* import { getConnInfo } from "@hono/node-server/conninfo";
+*
+* const app: Hono = new Hono();
+*
+* app.use(
+*     ipLimit({
+*         getConnInfo,
+*         allowList: [],
+*         denyList: [],
+*     })
+* );
+* ```
+*/
 declare function ipLimit(options: IpLimitOptions): MiddlewareHandler;
 /**
- * IP limit middleware for compatibility with `hono/ip-restriction`.
- *
- * This is functionally equivalent to:
- *
- * ```ts
- * ipLimit({ getConnInfo, ...options });
- * ```
- *
- * And it behaves the same as the main `ipLimit` function.
- */
+* IP limit middleware for compatibility with `hono/ip-restriction`.
+*
+* This is functionally equivalent to:
+*
+* ```ts
+* ipLimit({ getConnInfo, ...options });
+* ```
+*
+* And it behaves the same as the main `ipLimit` function.
+*/
 declare function ipLimit(getConnInfo: GetIPAddr, options?: IpLimitBaseOptions): MiddlewareHandler;
 export { type AddressType, type ConnInfo, type GetConnInfo, type GetIPAddr, type IPRestrictionRule, type IpLimitBaseOptions, type IpLimitOptions, type NetAddrInfo, ipLimit };
 //# sourceMappingURL=ip-limit.d.ts.map

package/dist/not-found.d.ts

@@ -1,33 +1,33 @@
 import { Context } from "hono";
 /**
- * Not found handler.
- *
- * Following response will be returned on route not found:
- *
- * ```jsonc
- * // Status: 404
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "not_found",
- *             "message": "Content not found"
- *         }
- *     ]
- * }
- * ```
- *
- * ### Example
- *
- * ```ts
- * import { Hono } from "hono";
- * import { notFoundHandler } from "@jderstd/hono/not-found";
- *
- * const app: Hono = new Hono();
- *
- * app.notFound(notFoundHandler());
- * ```
- */
+* Not found handler.
+*
+* Following response will be returned on route not found:
+*
+* ```jsonc
+* // Status: 404
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "not_found",
+*             "message": "Content not found"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Example
+*
+* ```ts
+* import { Hono } from "hono";
+* import { notFoundHandler } from "@jderstd/hono/not-found";
+*
+* const app: Hono = new Hono();
+*
+* app.notFound(notFoundHandler());
+* ```
+*/
 declare const notFoundHandler: () => ((c: Context) => Response);
 export { notFoundHandler };
 //# sourceMappingURL=not-found.d.ts.map

package/dist/not-found.js.map

@@ -1 +1 @@
-{"version":3,"file":"not-found.js","names":["code: ResponseErrorCode","ResponseErrorCode","createJsonResponse","getResponseErrorMessage"],"sources":["../src/handlers/not-found.ts"],"sourcesContent":["import type { Context } from \"hono\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\n/**\n * Not found handler.\n *\n * Following response will be returned on route not found:\n *\n * ```jsonc\n * // Status: 404\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"not_found\",\n *             \"message\": \"Content not found\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { notFoundHandler } from \"@jderstd/hono/not-found\";\n *\n * const app: Hono = new Hono();\n *\n * app.notFound(notFoundHandler());\n * ```\n */\nconst notFoundHandler = (): ((c: Context) => Response) => {\n    const code: ResponseErrorCode = ResponseErrorCode.NotFound;\n\n    return (c: Context): Response => {\n        return createJsonResponse(c, {\n            status: 404,\n            errors: [\n                {\n                    code,\n                    message: getResponseErrorMessage(code),\n                },\n            ],\n        });\n    };\n};\n\nexport { notFoundHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAM,wBAAoD;CACtD,MAAMA,OAA0BC,+CAAkB;AAElD,SAAQ,MAAyB;AAC7B,SAAOC,iCAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,SAASC,qDAAwB,KAAK;IACzC,CACJ;GACJ,CAAC"}
+{"version":3,"file":"not-found.js","names":["code: ResponseErrorCode","ResponseErrorCode","createJsonResponse","getResponseErrorMessage"],"sources":["../src/handlers/not-found.ts"],"sourcesContent":["/**\n * Not found handler module\n * @module handlers/not-found\n */\n\nimport type { Context } from \"hono\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\n/**\n * Not found handler.\n *\n * Following response will be returned on route not found:\n *\n * ```jsonc\n * // Status: 404\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"not_found\",\n *             \"message\": \"Content not found\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { notFoundHandler } from \"@jderstd/hono/not-found\";\n *\n * const app: Hono = new Hono();\n *\n * app.notFound(notFoundHandler());\n * ```\n */\nconst notFoundHandler = (): ((c: Context) => Response) => {\n    const code: ResponseErrorCode = ResponseErrorCode.NotFound;\n\n    return (c: Context): Response => {\n        return createJsonResponse(c, {\n            status: 404,\n            errors: [\n                {\n                    code,\n                    message: getResponseErrorMessage(code),\n                },\n            ],\n        });\n    };\n};\n\nexport { notFoundHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAM,wBAAoD;CACtD,MAAMA,OAA0BC,+CAAkB;AAElD,SAAQ,MAAyB;AAC7B,SAAOC,iCAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,SAASC,qDAAwB,KAAK;IACzC,CACJ;GACJ,CAAC"}

package/dist/not-found.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"not-found.mjs","names":["code: ResponseErrorCode"],"sources":["../src/handlers/not-found.ts"],"sourcesContent":["import type { Context } from \"hono\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\n/**\n * Not found handler.\n *\n * Following response will be returned on route not found:\n *\n * ```jsonc\n * // Status: 404\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"not_found\",\n *             \"message\": \"Content not found\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { notFoundHandler } from \"@jderstd/hono/not-found\";\n *\n * const app: Hono = new Hono();\n *\n * app.notFound(notFoundHandler());\n * ```\n */\nconst notFoundHandler = (): ((c: Context) => Response) => {\n    const code: ResponseErrorCode = ResponseErrorCode.NotFound;\n\n    return (c: Context): Response => {\n        return createJsonResponse(c, {\n            status: 404,\n            errors: [\n                {\n                    code,\n                    message: getResponseErrorMessage(code),\n                },\n            ],\n        });\n    };\n};\n\nexport { notFoundHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAM,wBAAoD;CACtD,MAAMA,OAA0B,kBAAkB;AAElD,SAAQ,MAAyB;AAC7B,SAAO,mBAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,SAAS,wBAAwB,KAAK;IACzC,CACJ;GACJ,CAAC"}
+{"version":3,"file":"not-found.mjs","names":["code: ResponseErrorCode"],"sources":["../src/handlers/not-found.ts"],"sourcesContent":["/**\n * Not found handler module\n * @module handlers/not-found\n */\n\nimport type { Context } from \"hono\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { getResponseErrorMessage, ResponseErrorCode } from \"#/response/error\";\n\n/**\n * Not found handler.\n *\n * Following response will be returned on route not found:\n *\n * ```jsonc\n * // Status: 404\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"not_found\",\n *             \"message\": \"Content not found\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Example\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { notFoundHandler } from \"@jderstd/hono/not-found\";\n *\n * const app: Hono = new Hono();\n *\n * app.notFound(notFoundHandler());\n * ```\n */\nconst notFoundHandler = (): ((c: Context) => Response) => {\n    const code: ResponseErrorCode = ResponseErrorCode.NotFound;\n\n    return (c: Context): Response => {\n        return createJsonResponse(c, {\n            status: 404,\n            errors: [\n                {\n                    code,\n                    message: getResponseErrorMessage(code),\n                },\n            ],\n        });\n    };\n};\n\nexport { notFoundHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAM,wBAAoD;CACtD,MAAMA,OAA0B,kBAAkB;AAElD,SAAQ,MAAyB;AAC7B,SAAO,mBAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI;IACA,SAAS,wBAAwB,KAAK;IACzC,CACJ;GACJ,CAAC"}

package/dist/on-error.d.ts

@@ -3,64 +3,64 @@ import { HTTPResponseError } from "hono/types";
 /** Options for `onErrorHandler` function. */
 type OnErrorHandlerOptions = {
   /**
-   * Whether show more information.
-   * By default, it's `false`.
-   */
+  * Whether show more information.
+  * By default, it's `false`.
+  */
   verbose?: boolean;
 };
 /**
- * On error handler.
- *
- * Following responses could be returned on error:
- *
- * ```jsonc
- * // Status: 400
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "bad_request"
- *         }
- *     ]
- * }
- * ```
- *
- * ```jsonc
- * // Status: 500
- * {
- *     "success": false,
- *     "errors": [
- *         {
- *             "code": "server"
- *         }
- *     ]
- * }
- * ```
- *
- * ### Examples
- *
- * Basic example of using `onErrorHandler` handler:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { onErrorHandler } from "@jderstd/hono/on-error";
- *
- * const app: Hono = new Hono();
- *
- * app.onError(onErrorHandler());
- * ```
- *
- * Show more information with `verbose` option:
- *
- * ```ts
- * import { Hono } from "hono";
- * import { onErrorHandler } from "@jderstd/hono/on-error";
- *
- * const app: Hono = new Hono();
- *
- * app.onError(onErrorHandler({ verbose: true }));
- * ```
- */
+* On error handler.
+*
+* Following responses could be returned on error:
+*
+* ```jsonc
+* // Status: 400
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "bad_request"
+*         }
+*     ]
+* }
+* ```
+*
+* ```jsonc
+* // Status: 500
+* {
+*     "success": false,
+*     "errors": [
+*         {
+*             "code": "server"
+*         }
+*     ]
+* }
+* ```
+*
+* ### Examples
+*
+* Basic example of using `onErrorHandler` handler:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { onErrorHandler } from "@jderstd/hono/on-error";
+*
+* const app: Hono = new Hono();
+*
+* app.onError(onErrorHandler());
+* ```
+*
+* Show more information with `verbose` option:
+*
+* ```ts
+* import { Hono } from "hono";
+* import { onErrorHandler } from "@jderstd/hono/on-error";
+*
+* const app: Hono = new Hono();
+*
+* app.onError(onErrorHandler({ verbose: true }));
+* ```
+*/
 declare const onErrorHandler: (options?: OnErrorHandlerOptions) => ((err: Error | HTTPResponseError, c: Context) => Response);
-export { onErrorHandler };
+export { type OnErrorHandlerOptions, onErrorHandler };
 //# sourceMappingURL=on-error.d.ts.map

package/dist/on-error.js.map

@@ -1 +1 @@
-{"version":3,"file":"on-error.js","names":["JderHttpException","HTTPException","res: Response","code: ResponseErrorCode","ResponseErrorCode","createJsonResponse"],"sources":["../src/handlers/on-error.ts"],"sourcesContent":["import type { Context } from \"hono\";\nimport type { HTTPResponseError } from \"hono/types\";\nimport type { StatusCode } from \"hono/utils/http-status\";\n\nimport { HTTPException } from \"hono/http-exception\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { ResponseErrorCode } from \"#/response/error\";\nimport { JderHttpException } from \"#/response/error/http\";\n\n/** Options for `onErrorHandler` function. */\ntype OnErrorHandlerOptions = {\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/**\n * On error handler.\n *\n * Following responses could be returned on error:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"bad_request\"\n *         }\n *     ]\n * }\n * ```\n *\n * ```jsonc\n * // Status: 500\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"server\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Examples\n *\n * Basic example of using `onErrorHandler` handler:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler());\n * ```\n *\n * Show more information with `verbose` option:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler({ verbose: true }));\n * ```\n */\nconst onErrorHandler = (\n    options?: OnErrorHandlerOptions,\n): ((err: Error | HTTPResponseError, c: Context) => Response) => {\n    return (err: Error | HTTPResponseError, c: Context): Response => {\n        // HTTP Exception for JDER format response\n        if (err instanceof JderHttpException) return err.getResponse();\n\n        // HTTP Exception\n        if (err instanceof HTTPException) {\n            const res: Response = err.getResponse();\n\n            const status: StatusCode = res.status as StatusCode;\n\n            const code: ResponseErrorCode =\n                status >= 500\n                    ? ResponseErrorCode.Server\n                    : ResponseErrorCode.BadRequest;\n\n            return createJsonResponse(c, {\n                status: res.status as StatusCode,\n                errors: [\n                    {\n                        code,\n                        ...(options?.verbose && {\n                            message: err.message,\n                        }),\n                    },\n                ],\n            });\n        }\n\n        // Internal server error\n        return createJsonResponse(c, {\n            status: 500,\n            errors: [\n                {\n                    code: ResponseErrorCode.Server,\n                    ...(options?.verbose && {\n                        message: err.message,\n                    }),\n                },\n            ],\n        });\n    };\n};\n\nexport { onErrorHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,MAAM,kBACF,YAC6D;AAC7D,SAAQ,KAAgC,MAAyB;AAE7D,MAAI,eAAeA,8CAAmB,QAAO,IAAI,aAAa;AAG9D,MAAI,eAAeC,mCAAe;GAC9B,MAAMC,MAAgB,IAAI,aAAa;GAIvC,MAAMC,OAFqB,IAAI,UAGjB,MACJC,+CAAkB,SAClBA,+CAAkB;AAE5B,UAAOC,iCAAmB,GAAG;IACzB,QAAQ,IAAI;IACZ,QAAQ,CACJ;KACI;KACA,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;KACJ,CACJ;IACJ,CAAC;;AAIN,SAAOA,iCAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI,MAAMD,+CAAkB;IACxB,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;IACJ,CACJ;GACJ,CAAC"}
+{"version":3,"file":"on-error.js","names":["JderHttpException","HTTPException","res: Response","code: ResponseErrorCode","ResponseErrorCode","createJsonResponse"],"sources":["../src/handlers/on-error.ts"],"sourcesContent":["/**\n * On error handler module\n * @module handlers/on-error\n */\n\nimport type { Context } from \"hono\";\nimport type { HTTPResponseError } from \"hono/types\";\nimport type { StatusCode } from \"hono/utils/http-status\";\n\nimport { HTTPException } from \"hono/http-exception\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { ResponseErrorCode } from \"#/response/error\";\nimport { JderHttpException } from \"#/response/error/http\";\n\n/** Options for `onErrorHandler` function. */\ntype OnErrorHandlerOptions = {\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/**\n * On error handler.\n *\n * Following responses could be returned on error:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"bad_request\"\n *         }\n *     ]\n * }\n * ```\n *\n * ```jsonc\n * // Status: 500\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"server\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Examples\n *\n * Basic example of using `onErrorHandler` handler:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler());\n * ```\n *\n * Show more information with `verbose` option:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler({ verbose: true }));\n * ```\n */\nconst onErrorHandler = (\n    options?: OnErrorHandlerOptions,\n): ((err: Error | HTTPResponseError, c: Context) => Response) => {\n    return (err: Error | HTTPResponseError, c: Context): Response => {\n        // HTTP Exception for JDER format response\n        if (err instanceof JderHttpException) return err.getResponse();\n\n        // HTTP Exception\n        if (err instanceof HTTPException) {\n            const res: Response = err.getResponse();\n\n            const status: StatusCode = res.status as StatusCode;\n\n            const code: ResponseErrorCode =\n                status >= 500\n                    ? ResponseErrorCode.Server\n                    : ResponseErrorCode.BadRequest;\n\n            return createJsonResponse(c, {\n                status: res.status as StatusCode,\n                errors: [\n                    {\n                        code,\n                        ...(options?.verbose && {\n                            message: err.message,\n                        }),\n                    },\n                ],\n            });\n        }\n\n        // Internal server error\n        return createJsonResponse(c, {\n            status: 500,\n            errors: [\n                {\n                    code: ResponseErrorCode.Server,\n                    ...(options?.verbose && {\n                        message: err.message,\n                    }),\n                },\n            ],\n        });\n    };\n};\n\nexport type { OnErrorHandlerOptions };\nexport { onErrorHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EA,MAAM,kBACF,YAC6D;AAC7D,SAAQ,KAAgC,MAAyB;AAE7D,MAAI,eAAeA,8CAAmB,QAAO,IAAI,aAAa;AAG9D,MAAI,eAAeC,mCAAe;GAC9B,MAAMC,MAAgB,IAAI,aAAa;GAIvC,MAAMC,OAFqB,IAAI,UAGjB,MACJC,+CAAkB,SAClBA,+CAAkB;AAE5B,UAAOC,iCAAmB,GAAG;IACzB,QAAQ,IAAI;IACZ,QAAQ,CACJ;KACI;KACA,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;KACJ,CACJ;IACJ,CAAC;;AAIN,SAAOA,iCAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI,MAAMD,+CAAkB;IACxB,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;IACJ,CACJ;GACJ,CAAC"}

package/dist/on-error.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"on-error.mjs","names":["res: Response","code: ResponseErrorCode"],"sources":["../src/handlers/on-error.ts"],"sourcesContent":["import type { Context } from \"hono\";\nimport type { HTTPResponseError } from \"hono/types\";\nimport type { StatusCode } from \"hono/utils/http-status\";\n\nimport { HTTPException } from \"hono/http-exception\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { ResponseErrorCode } from \"#/response/error\";\nimport { JderHttpException } from \"#/response/error/http\";\n\n/** Options for `onErrorHandler` function. */\ntype OnErrorHandlerOptions = {\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/**\n * On error handler.\n *\n * Following responses could be returned on error:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"bad_request\"\n *         }\n *     ]\n * }\n * ```\n *\n * ```jsonc\n * // Status: 500\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"server\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Examples\n *\n * Basic example of using `onErrorHandler` handler:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler());\n * ```\n *\n * Show more information with `verbose` option:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler({ verbose: true }));\n * ```\n */\nconst onErrorHandler = (\n    options?: OnErrorHandlerOptions,\n): ((err: Error | HTTPResponseError, c: Context) => Response) => {\n    return (err: Error | HTTPResponseError, c: Context): Response => {\n        // HTTP Exception for JDER format response\n        if (err instanceof JderHttpException) return err.getResponse();\n\n        // HTTP Exception\n        if (err instanceof HTTPException) {\n            const res: Response = err.getResponse();\n\n            const status: StatusCode = res.status as StatusCode;\n\n            const code: ResponseErrorCode =\n                status >= 500\n                    ? ResponseErrorCode.Server\n                    : ResponseErrorCode.BadRequest;\n\n            return createJsonResponse(c, {\n                status: res.status as StatusCode,\n                errors: [\n                    {\n                        code,\n                        ...(options?.verbose && {\n                            message: err.message,\n                        }),\n                    },\n                ],\n            });\n        }\n\n        // Internal server error\n        return createJsonResponse(c, {\n            status: 500,\n            errors: [\n                {\n                    code: ResponseErrorCode.Server,\n                    ...(options?.verbose && {\n                        message: err.message,\n                    }),\n                },\n            ],\n        });\n    };\n};\n\nexport { onErrorHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwEA,MAAM,kBACF,YAC6D;AAC7D,SAAQ,KAAgC,MAAyB;AAE7D,MAAI,eAAe,kBAAmB,QAAO,IAAI,aAAa;AAG9D,MAAI,eAAe,eAAe;GAC9B,MAAMA,MAAgB,IAAI,aAAa;GAIvC,MAAMC,OAFqB,IAAI,UAGjB,MACJ,kBAAkB,SAClB,kBAAkB;AAE5B,UAAO,mBAAmB,GAAG;IACzB,QAAQ,IAAI;IACZ,QAAQ,CACJ;KACI;KACA,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;KACJ,CACJ;IACJ,CAAC;;AAIN,SAAO,mBAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI,MAAM,kBAAkB;IACxB,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;IACJ,CACJ;GACJ,CAAC"}
+{"version":3,"file":"on-error.mjs","names":["res: Response","code: ResponseErrorCode"],"sources":["../src/handlers/on-error.ts"],"sourcesContent":["/**\n * On error handler module\n * @module handlers/on-error\n */\n\nimport type { Context } from \"hono\";\nimport type { HTTPResponseError } from \"hono/types\";\nimport type { StatusCode } from \"hono/utils/http-status\";\n\nimport { HTTPException } from \"hono/http-exception\";\n\nimport { createJsonResponse } from \"#/response\";\nimport { ResponseErrorCode } from \"#/response/error\";\nimport { JderHttpException } from \"#/response/error/http\";\n\n/** Options for `onErrorHandler` function. */\ntype OnErrorHandlerOptions = {\n    /**\n     * Whether show more information.\n     * By default, it's `false`.\n     */\n    verbose?: boolean;\n};\n\n/**\n * On error handler.\n *\n * Following responses could be returned on error:\n *\n * ```jsonc\n * // Status: 400\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"bad_request\"\n *         }\n *     ]\n * }\n * ```\n *\n * ```jsonc\n * // Status: 500\n * {\n *     \"success\": false,\n *     \"errors\": [\n *         {\n *             \"code\": \"server\"\n *         }\n *     ]\n * }\n * ```\n *\n * ### Examples\n *\n * Basic example of using `onErrorHandler` handler:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler());\n * ```\n *\n * Show more information with `verbose` option:\n *\n * ```ts\n * import { Hono } from \"hono\";\n * import { onErrorHandler } from \"@jderstd/hono/on-error\";\n *\n * const app: Hono = new Hono();\n *\n * app.onError(onErrorHandler({ verbose: true }));\n * ```\n */\nconst onErrorHandler = (\n    options?: OnErrorHandlerOptions,\n): ((err: Error | HTTPResponseError, c: Context) => Response) => {\n    return (err: Error | HTTPResponseError, c: Context): Response => {\n        // HTTP Exception for JDER format response\n        if (err instanceof JderHttpException) return err.getResponse();\n\n        // HTTP Exception\n        if (err instanceof HTTPException) {\n            const res: Response = err.getResponse();\n\n            const status: StatusCode = res.status as StatusCode;\n\n            const code: ResponseErrorCode =\n                status >= 500\n                    ? ResponseErrorCode.Server\n                    : ResponseErrorCode.BadRequest;\n\n            return createJsonResponse(c, {\n                status: res.status as StatusCode,\n                errors: [\n                    {\n                        code,\n                        ...(options?.verbose && {\n                            message: err.message,\n                        }),\n                    },\n                ],\n            });\n        }\n\n        // Internal server error\n        return createJsonResponse(c, {\n            status: 500,\n            errors: [\n                {\n                    code: ResponseErrorCode.Server,\n                    ...(options?.verbose && {\n                        message: err.message,\n                    }),\n                },\n            ],\n        });\n    };\n};\n\nexport type { OnErrorHandlerOptions };\nexport { onErrorHandler };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6EA,MAAM,kBACF,YAC6D;AAC7D,SAAQ,KAAgC,MAAyB;AAE7D,MAAI,eAAe,kBAAmB,QAAO,IAAI,aAAa;AAG9D,MAAI,eAAe,eAAe;GAC9B,MAAMA,MAAgB,IAAI,aAAa;GAIvC,MAAMC,OAFqB,IAAI,UAGjB,MACJ,kBAAkB,SAClB,kBAAkB;AAE5B,UAAO,mBAAmB,GAAG;IACzB,QAAQ,IAAI;IACZ,QAAQ,CACJ;KACI;KACA,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;KACJ,CACJ;IACJ,CAAC;;AAIN,SAAO,mBAAmB,GAAG;GACzB,QAAQ;GACR,QAAQ,CACJ;IACI,MAAM,kBAAkB;IACxB,GAAI,SAAS,WAAW,EACpB,SAAS,IAAI,SAChB;IACJ,CACJ;GACJ,CAAC"}