@orval/hono 7.14.0 → 7.16.0

package/dist/zValidator.ts

@@ -1,139 +1,137 @@
 // based on https://github.com/honojs/middleware/blob/main/packages/zod-validator/src/index.ts
-import type { z, ZodSchema, ZodError } from 'zod';
-import type {
-  Context,
-  Env,
-  Input,
-  MiddlewareHandler,
-  TypedResponse,
-  ValidationTargets,
-} from 'hono';
+import type { ZodSafeParseResult as ZodSafeParseResult$1 } from 'zod/v4'
+import type { Context, Env, Input, MiddlewareHandler, TypedResponse, ValidationTargets } from 'hono'
+import { zValidator as zValidatorBase } from '@hono/zod-validator'
+import * as v3 from 'zod/v3'
+import * as v4 from 'zod/v4/core'
 
-type HasUndefined<T> = undefined extends T ? true : false;
+type Awaitable<T> = T | Promise<T>
+type HasUndefined<T> = undefined extends T ? true : false
 
-type Hook<T, E extends Env, P extends string, O = {}> = (
-  result:
-    | { success: true; data: T }
-    | { success: false; error: ZodError; data: T },
-  c: Context<E, P>,
-) =>
-  | Response
-  | Promise<Response>
-  | void
-  | Promise<Response | void>
-  | TypedResponse<O>;
-import { zValidator as zValidatorBase } from '@hono/zod-validator';
+type ZodSchema = v3.ZodType | v4.$ZodType
+type ZodError<T extends ZodSchema> = T extends v4.$ZodType ? v4.$ZodError<v4.output<T>> : v3.ZodError
+type ZodSafeParseResult<T, T2, T3 extends ZodSchema> = T3 extends v4.$ZodType ? ZodSafeParseResult$1<T> : v3.SafeParseReturnType<T, T2>
+type zInput<T> = T extends v3.ZodType ? v3.input<T> : T extends v4.$ZodType ? v4.input<T> : never
+type zOutput<T> = T extends v3.ZodType ? v3.output<T> : T extends v4.$ZodType ? v4.output<T> : never
+type zInfer<T> = T extends v3.ZodType ? v3.infer<T> : T extends v4.$ZodType ? v4.infer<T> : never
+type Hook<T, E extends Env, P extends string, Target extends keyof ValidationTargetsWithResponse = keyof ValidationTargetsWithResponse, O = {}, Schema extends ZodSchema = any> = (result: ({
+  success: true
+  data: T
+} | {
+  success: false
+  error: ZodError<Schema>
+  data: T
+}) & {
+  target: Target
+}, c: Context<E, P>) => Awaitable<Response | void | TypedResponse<O>>
 
-type ValidationTargetsWithResponse = ValidationTargets & { response: any };
+type ValidationTargetsWithResponse = ValidationTargets & { response: any }
 
+/**
+ * zValidator wraps `zValidator` from `@hono/zod-validator` and extends it to support response validation. It forwards
+ * query parameter, path parameter, and request body validation to `@hono/zod-validator`.
+ */
 export const zValidator =
   <
     T extends ZodSchema,
     Target extends keyof ValidationTargetsWithResponse,
     E extends Env,
     P extends string,
-    In = z.input<T>,
-    Out = z.output<T>,
+    In = zInput<T>,
+    Out = zOutput<T>,
     I extends Input = {
       in: HasUndefined<In> extends true
         ? {
-            [K in Target]?: K extends 'json'
-              ? In
-              : HasUndefined<
-                    keyof ValidationTargetsWithResponse[K]
-                  > extends true
-                ? { [K2 in keyof In]?: ValidationTargetsWithResponse[K][K2] }
-                : { [K2 in keyof In]: ValidationTargetsWithResponse[K][K2] };
-          }
+          [K in Target]?: In extends ValidationTargetsWithResponse[K]
+            ? In
+            : {
+              [K2 in keyof In]?: In[K2] extends ValidationTargetsWithResponse[K][K2]
+                ? In[K2]
+                : ValidationTargetsWithResponse[K][K2]
+            }
+        }
         : {
-            [K in Target]: K extends 'json'
-              ? In
-              : HasUndefined<
-                    keyof ValidationTargetsWithResponse[K]
-                  > extends true
-                ? { [K2 in keyof In]?: ValidationTargetsWithResponse[K][K2] }
-                : { [K2 in keyof In]: ValidationTargetsWithResponse[K][K2] };
-          };
-      out: { [K in Target]: Out };
+          [K in Target]: In extends ValidationTargetsWithResponse[K]
+            ? In
+            : {
+              [K2 in keyof In]: In[K2] extends ValidationTargetsWithResponse[K][K2]
+                ? In[K2]
+                : ValidationTargetsWithResponse[K][K2]
+            }
+        }
+      out: { [K in Target]: Out }
     },
     V extends I = I,
-  >(
+    InferredValue = zInfer<T>
+  > (
     target: Target,
     schema: T,
-    hook?: Hook<z.infer<T>, E, P>,
+    hook?: Hook<InferredValue, E, P, Target, {}, T>
   ): MiddlewareHandler<E, P, V> =>
-  async (c, next) => {
-    if (target !== 'response') {
-      const value = await zValidatorBase<
-        T,
-        keyof ValidationTargets,
-        E,
-        P,
-        In,
-        Out,
-        I,
-        V
-      >(
-        target,
-        schema,
-        hook,
-      )(c, next);
-
-      if (value instanceof Response) {
-        return value;
+    async (c, next) => {
+      if (target !== 'response'){
+        return zValidatorBase<
+          T,
+          keyof ValidationTargets,
+          E,
+          P,
+          In,
+          Out,
+          I,
+          V,
+          InferredValue
+        >(
+          target,
+          schema,
+          hook as Hook<InferredValue, E, P, keyof ValidationTargets, {}, T>
+        )(c, next)
       }
-    } else {
-      await next();
+
+      await next()
 
       if (
         c.res.status !== 200 ||
         !c.res.headers.get('Content-Type')?.includes('application/json')
       ) {
-        return;
+        return
       }
 
-      let value: unknown;
+      let value: unknown
       try {
-        value = await c.res.json();
+        value = await c.res.json()
       } catch {
-        const message = 'Malformed JSON in response';
-        c.res = new Response(message, { status: 400 });
+        const message = 'Malformed JSON in response'
+        c.res = new Response(message, { status: 400 })
 
-        return;
+        return
       }
 
-      const result = await schema.safeParseAsync(value);
+      const { success, data, error } = await (schema as v3.ZodType).safeParseAsync(value) as ZodSafeParseResult<InferredValue, Out, T>
 
       if (hook) {
-        const hookResult = hook({ data: value, ...result }, c);
-        if (hookResult) {
-          if (hookResult instanceof Response || hookResult instanceof Promise) {
-            const hookResponse = await hookResult;
+        const hookResult = await hook({
+          target, success,
+          data: data as InferredValue,
+          error: error as ZodError<T>
+        }, c)
 
-            if (hookResponse instanceof Response) {
-              c.res = new Response(hookResponse.body, hookResponse);
-            }
-          }
-          if (
-            'response' in hookResult &&
-            hookResult.response instanceof Response
-          ) {
-            c.res = new Response(hookResult.response.body, hookResult.response);
+        if (typeof hookResult === 'object' && hookResult != null) {
+          if (hookResult instanceof Response) {
+            c.res = new Response(hookResult.body, hookResult)
+          } else if ('response' in hookResult && hookResult.response instanceof Response) {
+            c.res = new Response(hookResult.response.body, hookResult.response)
           }
         }
       }
 
-      if (!result.success) {
-        c.res = new Response(JSON.stringify(result), {
+      if (!success) {
+        c.res = new Response(JSON.stringify({ success, data, error }), {
           status: 400,
           headers: {
-            'Content-Type': 'application/json',
-          },
-        });
+            'Content-Type': 'application/json'
+          }
+        })
       } else {
-        c.res = new Response(JSON.stringify(result.data), c.res);
+        c.res = new Response(JSON.stringify(data), c.res)
       }
     }
-
-    return;
-  };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orval/hono",
-  "version": "7.14.0",
+  "version": "7.16.0",
   "license": "MIT",
   "exports": {
     ".": {
@@ -15,23 +15,24 @@
   "scripts": {
     "build": "tsdown --config-loader unconfig",
     "dev": "tsdown --config-loader unconfig --watch src",
-    "lint": "eslint .",
+    "lint": "tsc --noEmit src/zValidator.ts && eslint .",
     "clean": "rimraf .turbo dist",
     "nuke": "rimraf .turbo dist node_modules"
   },
   "dependencies": {
-    "@orval/core": "7.14.0",
-    "@orval/zod": "7.14.0",
-    "fs-extra": "^11.3.1",
+    "@orval/core": "7.16.0",
+    "@orval/zod": "7.16.0",
+    "fs-extra": "^11.3.2",
     "lodash.uniq": "^4.5.0",
     "openapi3-ts": "4.5.0"
   },
   "devDependencies": {
+    "@hono/zod-validator": "^0.7.4",
     "@types/fs-extra": "^11.0.4",
     "@types/lodash.uniq": "^4.5.9",
-    "eslint": "^9.35.0",
+    "eslint": "^9.38.0",
     "rimraf": "^6.0.1",
-    "tsdown": "^0.15.2",
-    "typescript": "^5.9.2"
+    "tsdown": "^0.15.8",
+    "typescript": "^5.9.3"
   }
 }