@hono/zod-openapi 0.5.1 → 0.7.0

package/README.md

@@ -174,6 +174,57 @@ app.openapi(
 )
 ```
 
+### A DRY approach to handling validation errors
+
+In the case that you have a common error formatter, you can initialize the `OpenAPIHono` instance with a `defaultHook`.
+
+```ts
+const app = new OpenAPIHono({
+  defaultHook: (result, c) => {
+    if (!result.success) {
+      return c.jsonT(
+        {
+          ok: false,
+          errors: formatZodErrors(result),
+          source: 'custom_error_handler',
+        },
+        422
+      )
+    }
+  },
+})
+```
+
+You can still override the `defaultHook` by providing the hook at the call site when appropriate.
+
+```ts
+// uses the defaultHook
+app.openapi(createPostRoute, (c) => {
+  const { title } = c.req.valid('json')
+  return c.jsonT({ title })
+})
+
+// override the defaultHook by passing in a hook
+app.openapi(
+  createBookRoute,
+  (c) => {
+    const { title } = c.req.valid('json')
+    return c.jsonT({ title })
+  },
+  (result, c) => {
+    if (!result.success) {
+      return c.jsonT(
+        {
+          ok: false,
+          source: 'routeHook' as const,
+        },
+        400
+      )
+    }
+  }
+)
+```
+
 ### OpenAPI v3.1
 
 You can generate OpenAPI v3.1 spec using the following methods:
@@ -211,7 +262,7 @@ You can configure middleware for each endpoint from a route created by `createRo
 import { prettyJSON } from 'hono/pretty-json'
 import { cache } from 'honoc/cache'
 
-app.use(route.getRoutingPath(), prettyJSON(), cache({ cacheName: "my-cache" }))
+app.use(route.getRoutingPath(), prettyJSON(), cache({ cacheName: 'my-cache' }))
 app.openapi(route, handler)
 ```
 

package/dist/index.cjs

@@ -32,11 +32,13 @@ var import_hono = require("hono");
 var import_zod = require("zod");
 var OpenAPIHono = class _OpenAPIHono extends import_hono.Hono {
   openAPIRegistry;
+  defaultHook;
   constructor(init) {
     super(init);
     this.openAPIRegistry = new import_zod_to_openapi.OpenAPIRegistry();
+    this.defaultHook = init?.defaultHook;
   }
-  openapi = (route, handler, hook) => {
+  openapi = (route, handler, hook = this.defaultHook) => {
     this.openAPIRegistry.registerPath(route);
     const validators = [];
     if (route.request?.query) {
@@ -133,6 +135,9 @@ var OpenAPIHono = class _OpenAPIHono extends import_hono.Hono {
     });
     return this;
   }
+  basePath(path) {
+    return new _OpenAPIHono(super.basePath(path));
+  }
 };
 var createRoute = (routeConfig) => {
   return {

package/dist/index.d.cts

@@ -1,8 +1,8 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
 import * as openapi3_ts_oas30 from 'openapi3-ts/oas30';
-import { OpenAPIRegistry, RouteConfig, ZodRequestBody, ZodContentObject, ResponseConfig } from '@asteasolutions/zod-to-openapi';
+import { RouteConfig, OpenAPIRegistry, ZodRequestBody, ZodContentObject, ResponseConfig } from '@asteasolutions/zod-to-openapi';
 import { OpenAPIObjectConfig } from '@asteasolutions/zod-to-openapi/dist/v3.0/openapi-generator';
-import { Env, Schema, Hono, Input, Handler, ToSchema, Context, TypedResponse } from 'hono';
+import { Env, Input, Handler, Schema, Hono, ToSchema, Context, TypedResponse } from 'hono';
 import { MergeSchemaPath, MergePath } from 'hono/dist/types/types';
 import { RemoveBlankRecord } from 'hono/utils/types';
 import { AnyZodObject, z, ZodSchema, ZodError, ZodType } from 'zod';
@@ -42,6 +42,10 @@ type InputTypeForm<R extends RouteConfig> = R['request'] extends RequestTypes ?
         form: z.output<R['request']['body']['content'][keyof R['request']['body']['content']]['schema']>;
     };
 } : {} : {} : {} : {};
+type InputTypeParam<R extends RouteConfig> = InputTypeBase<R, 'params', 'param'>;
+type InputTypeQuery<R extends RouteConfig> = InputTypeBase<R, 'query', 'query'>;
+type InputTypeHeader<R extends RouteConfig> = InputTypeBase<R, 'headers', 'header'>;
+type InputTypeCookie<R extends RouteConfig> = InputTypeBase<R, 'cookies', 'cookie'>;
 type OutputType<R extends RouteConfig> = R['responses'] extends Record<infer _, infer C> ? C extends ResponseConfig ? C['content'] extends ZodContentObject ? IsJson<keyof C['content']> extends never ? {} : C['content'][keyof C['content']]['schema'] extends ZodSchema ? z.infer<C['content'][keyof C['content']]['schema']> : {} : {} : {} : {};
 type Hook<T, E extends Env, P extends string, O> = (result: {
     success: true;
@@ -52,17 +56,24 @@ type Hook<T, E extends Env, P extends string, O> = (result: {
 }, c: Context<E, P>) => TypedResponse<O> | Promise<TypedResponse<T>> | void;
 type ConvertPathType<T extends string> = T extends `${infer _}/{${infer Param}}${infer _}` ? `/:${Param}` : T;
 type HandlerResponse<O> = TypedResponse<O> | Promise<TypedResponse<O>>;
-type HonoInit = ConstructorParameters<typeof Hono>[0];
+type OpenAPIHonoOptions<E extends Env> = {
+    defaultHook?: Hook<any, E, any, any>;
+};
+type HonoInit<E extends Env> = ConstructorParameters<typeof Hono>[0] & OpenAPIHonoOptions<E>;
+type RouteHandler<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Handler<E, P, I, HandlerResponse<OutputType<R>>>;
+type RouteHook<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Hook<I, E, P, OutputType<R>>;
 declare class OpenAPIHono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends Hono<E, S, BasePath> {
     openAPIRegistry: OpenAPIRegistry;
-    constructor(init?: HonoInit);
-    openapi: <R extends RouteConfig, I extends Input = InputTypeBase<R, "params", "param"> & InputTypeBase<R, "query", "query"> & InputTypeBase<R, "headers", "header"> & InputTypeBase<R, "cookies", "cookie"> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R["path"]>>(route: R, handler: Handler<E, P, I, HandlerResponse<OutputType<R>>>, hook?: Hook<I, E, P, OutputType<R>> | undefined) => OpenAPIHono<E, ToSchema<R["method"], P, I["in"], OutputType<R>>, BasePath>;
+    defaultHook?: OpenAPIHonoOptions<E>['defaultHook'];
+    constructor(init?: HonoInit<E>);
+    openapi: <R extends RouteConfig, I extends Input = InputTypeBase<R, "params", "param"> & InputTypeBase<R, "query", "query"> & InputTypeBase<R, "headers", "header"> & InputTypeBase<R, "cookies", "cookie"> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R["path"]>>(route: R, handler: Handler<E, P, I, HandlerResponse<OutputType<R>>>, hook?: Hook<I, E, P, OutputType<R>> | undefined) => OpenAPIHono<E, S & ToSchema<R["method"], P, I["in"], OutputType<R>>, BasePath>;
     getOpenAPIDocument: (config: OpenAPIObjectConfig) => openapi3_ts_oas30.OpenAPIObject;
     getOpenAPI31Document: (config: OpenAPIObjectConfig) => openapi3_ts_oas31.OpenAPIObject;
     doc: (path: string, config: OpenAPIObjectConfig) => void;
     doc31: (path: string, config: OpenAPIObjectConfig) => void;
     route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath>): OpenAPIHono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> & S, BasePath>;
     route<SubPath extends string>(path: SubPath): Hono<E, RemoveBlankRecord<S>, BasePath>;
+    basePath<SubPath extends string>(path: SubPath): OpenAPIHono<E, S, MergePath<BasePath, SubPath>>;
 }
 type RoutingPath<P extends string> = P extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${RoutingPath<Tail>}` : P;
 declare const createRoute: <P extends string, R extends Omit<RouteConfig, "path"> & {
@@ -71,4 +82,4 @@ declare const createRoute: <P extends string, R extends Omit<RouteConfig, "path"
     getRoutingPath(): RoutingPath<R["path"]>;
 };
 
-export { OpenAPIHono, createRoute };
+export { OpenAPIHono, OpenAPIHonoOptions, RouteHandler, RouteHook, createRoute };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
 import * as openapi3_ts_oas30 from 'openapi3-ts/oas30';
-import { OpenAPIRegistry, RouteConfig, ZodRequestBody, ZodContentObject, ResponseConfig } from '@asteasolutions/zod-to-openapi';
+import { RouteConfig, OpenAPIRegistry, ZodRequestBody, ZodContentObject, ResponseConfig } from '@asteasolutions/zod-to-openapi';
 import { OpenAPIObjectConfig } from '@asteasolutions/zod-to-openapi/dist/v3.0/openapi-generator';
-import { Env, Schema, Hono, Input, Handler, ToSchema, Context, TypedResponse } from 'hono';
+import { Env, Input, Handler, Schema, Hono, ToSchema, Context, TypedResponse } from 'hono';
 import { MergeSchemaPath, MergePath } from 'hono/dist/types/types';
 import { RemoveBlankRecord } from 'hono/utils/types';
 import { AnyZodObject, z, ZodSchema, ZodError, ZodType } from 'zod';
@@ -42,6 +42,10 @@ type InputTypeForm<R extends RouteConfig> = R['request'] extends RequestTypes ?
         form: z.output<R['request']['body']['content'][keyof R['request']['body']['content']]['schema']>;
     };
 } : {} : {} : {} : {};
+type InputTypeParam<R extends RouteConfig> = InputTypeBase<R, 'params', 'param'>;
+type InputTypeQuery<R extends RouteConfig> = InputTypeBase<R, 'query', 'query'>;
+type InputTypeHeader<R extends RouteConfig> = InputTypeBase<R, 'headers', 'header'>;
+type InputTypeCookie<R extends RouteConfig> = InputTypeBase<R, 'cookies', 'cookie'>;
 type OutputType<R extends RouteConfig> = R['responses'] extends Record<infer _, infer C> ? C extends ResponseConfig ? C['content'] extends ZodContentObject ? IsJson<keyof C['content']> extends never ? {} : C['content'][keyof C['content']]['schema'] extends ZodSchema ? z.infer<C['content'][keyof C['content']]['schema']> : {} : {} : {} : {};
 type Hook<T, E extends Env, P extends string, O> = (result: {
     success: true;
@@ -52,17 +56,24 @@ type Hook<T, E extends Env, P extends string, O> = (result: {
 }, c: Context<E, P>) => TypedResponse<O> | Promise<TypedResponse<T>> | void;
 type ConvertPathType<T extends string> = T extends `${infer _}/{${infer Param}}${infer _}` ? `/:${Param}` : T;
 type HandlerResponse<O> = TypedResponse<O> | Promise<TypedResponse<O>>;
-type HonoInit = ConstructorParameters<typeof Hono>[0];
+type OpenAPIHonoOptions<E extends Env> = {
+    defaultHook?: Hook<any, E, any, any>;
+};
+type HonoInit<E extends Env> = ConstructorParameters<typeof Hono>[0] & OpenAPIHonoOptions<E>;
+type RouteHandler<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Handler<E, P, I, HandlerResponse<OutputType<R>>>;
+type RouteHook<R extends RouteConfig, E extends Env = Env, I extends Input = InputTypeParam<R> & InputTypeQuery<R> & InputTypeHeader<R> & InputTypeCookie<R> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R['path']>> = Hook<I, E, P, OutputType<R>>;
 declare class OpenAPIHono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends Hono<E, S, BasePath> {
     openAPIRegistry: OpenAPIRegistry;
-    constructor(init?: HonoInit);
-    openapi: <R extends RouteConfig, I extends Input = InputTypeBase<R, "params", "param"> & InputTypeBase<R, "query", "query"> & InputTypeBase<R, "headers", "header"> & InputTypeBase<R, "cookies", "cookie"> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R["path"]>>(route: R, handler: Handler<E, P, I, HandlerResponse<OutputType<R>>>, hook?: Hook<I, E, P, OutputType<R>> | undefined) => OpenAPIHono<E, ToSchema<R["method"], P, I["in"], OutputType<R>>, BasePath>;
+    defaultHook?: OpenAPIHonoOptions<E>['defaultHook'];
+    constructor(init?: HonoInit<E>);
+    openapi: <R extends RouteConfig, I extends Input = InputTypeBase<R, "params", "param"> & InputTypeBase<R, "query", "query"> & InputTypeBase<R, "headers", "header"> & InputTypeBase<R, "cookies", "cookie"> & InputTypeForm<R> & InputTypeJson<R>, P extends string = ConvertPathType<R["path"]>>(route: R, handler: Handler<E, P, I, HandlerResponse<OutputType<R>>>, hook?: Hook<I, E, P, OutputType<R>> | undefined) => OpenAPIHono<E, S & ToSchema<R["method"], P, I["in"], OutputType<R>>, BasePath>;
     getOpenAPIDocument: (config: OpenAPIObjectConfig) => openapi3_ts_oas30.OpenAPIObject;
     getOpenAPI31Document: (config: OpenAPIObjectConfig) => openapi3_ts_oas31.OpenAPIObject;
     doc: (path: string, config: OpenAPIObjectConfig) => void;
     doc31: (path: string, config: OpenAPIObjectConfig) => void;
     route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string>(path: SubPath, app: Hono<SubEnv, SubSchema, SubBasePath>): OpenAPIHono<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> & S, BasePath>;
     route<SubPath extends string>(path: SubPath): Hono<E, RemoveBlankRecord<S>, BasePath>;
+    basePath<SubPath extends string>(path: SubPath): OpenAPIHono<E, S, MergePath<BasePath, SubPath>>;
 }
 type RoutingPath<P extends string> = P extends `${infer Head}/{${infer Param}}${infer Tail}` ? `${Head}/:${Param}${RoutingPath<Tail>}` : P;
 declare const createRoute: <P extends string, R extends Omit<RouteConfig, "path"> & {
@@ -71,4 +82,4 @@ declare const createRoute: <P extends string, R extends Omit<RouteConfig, "path"
     getRoutingPath(): RoutingPath<R["path"]>;
 };
 
-export { OpenAPIHono, createRoute };
+export { OpenAPIHono, OpenAPIHonoOptions, RouteHandler, RouteHook, createRoute };

package/dist/index.js

@@ -10,11 +10,13 @@ import { Hono } from "hono";
 import { z, ZodType } from "zod";
 var OpenAPIHono = class _OpenAPIHono extends Hono {
   openAPIRegistry;
+  defaultHook;
   constructor(init) {
     super(init);
     this.openAPIRegistry = new OpenAPIRegistry();
+    this.defaultHook = init?.defaultHook;
   }
-  openapi = (route, handler, hook) => {
+  openapi = (route, handler, hook = this.defaultHook) => {
     this.openAPIRegistry.registerPath(route);
     const validators = [];
     if (route.request?.query) {
@@ -111,6 +113,9 @@ var OpenAPIHono = class _OpenAPIHono extends Hono {
     });
     return this;
   }
+  basePath(path) {
+    return new _OpenAPIHono(super.basePath(path));
+  }
 };
 var createRoute = (routeConfig) => {
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/zod-openapi",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "A wrapper class of Hono which supports OpenAPI.",
   "type": "module",
   "main": "dist/index.js",
@@ -31,14 +31,15 @@
     "zod": "3.*"
   },
   "devDependencies": {
-    "hono": "^3.6.3",
+    "@hono/zod-validator": "^0.1.9",
+    "hono": "^3.7.2",
     "zod": "^3.22.1"
   },
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^5.5.0",
-    "@hono/zod-validator": "^0.1.8"
+    "@hono/zod-validator": "^0.1.9"
   },
   "engines": {
     "node": ">=16.0.0"
   }
-}
+}