feat: add Zod 4 compatibility for query param type detection

The internal Zod schema structure changed between Zod 3 and Zod 4:
- `_def.typeName` -> `_def.type`
- `ZodFirstPartyTypeKind` enum values -> lowercase string literals
- `ZodEffects._def.schema` -> pipe `_def.in`

This update adds helper functions to detect Zod types in a way that
works with both Zod 3 and Zod 4:
- `getZodTypeIdentifier()` - returns type from either `_def.type` or `_def.typeName`
- `isZodType()` - checks against both Zod 3 enum and Zod 4 string

Type mappings:
- ZodOptional -> "optional"
- ZodDefault -> "default"
- ZodEffects -> "pipe"
- ZodObject -> "object"
- ZodArray -> "array"
- ZodBoolean -> "boolean"

Files updated:
- src/middleware/with-input-validation.ts - query param type detection
- src/cli/commands/codegen/openapi.ts - commonParams type check

This ensures boolean query params are correctly coerced from strings
(e.g., "true" -> true) in both Zod versions.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: chmaltsp

package-lock.json

@@ -164,7 +164,7 @@
     "ts-morph": "^21.0.1",
     "watcher": "^2.3.0",
     "yargs": "^17.7.2",
-    "zod": "^3.22.4"
+    "zod": "^3.22.4 || ^4.0.0"
   },
   "peerDependencies": {
     "@ava/get-port": ">=2.0.0",

package.json

@@ -108,7 +108,10 @@ export class CodeGenOpenAPI extends BaseCommand {
         const areCommonParamsRequiredInQuery =
           HTTP_METHODS_WITHOUT_BODY.includes(method.toLowerCase())
         if (!areCommonParamsRequiredInQuery) {
-          if (commonParams?._def.typeName === "ZodObject") {
+          // Support both Zod 3 (_def.typeName) and Zod 4 (_def.type)
+          const commonParamsType =
+            commonParams?._def.type ?? commonParams?._def.typeName
+          if (commonParamsType === "ZodObject" || commonParamsType === "object") {
             commonParams = (commonParams as ZodObject<any>).partial()
           } else {
             commonParams = commonParams?.optional()

src/cli/commands/codegen/openapi.ts

@@ -10,6 +10,28 @@ import {
   InvalidQueryParamsError,
 } from "./http-exceptions.js"
 
+/**
+ * Get the type identifier from a Zod schema definition.
+ * Supports both Zod 3 (_def.typeName) and Zod 4 (_def.type).
+ */
+const getZodTypeIdentifier = (def: any): string | undefined => {
+  // Zod 4 uses _def.type (lowercase string like "string", "boolean", "optional")
+  // Zod 3 uses _def.typeName (ZodFirstPartyTypeKind enum values)
+  return def.type ?? def.typeName
+}
+
+/**
+ * Check if a type identifier matches a specific Zod type.
+ * Supports both Zod 3 (ZodFirstPartyTypeKind) and Zod 4 (lowercase strings).
+ */
+const isZodType = (
+  typeIdentifier: string | undefined,
+  zod3Kind: (typeof ZodFirstPartyTypeKind)[keyof typeof ZodFirstPartyTypeKind],
+  zod4Type: string
+): boolean => {
+  return typeIdentifier === zod3Kind || typeIdentifier === zod4Type
+}
+
 const getZodObjectSchemaFromZodEffectSchema = (
   isZodEffect: boolean,
   schema: z.ZodTypeAny
@@ -18,50 +40,75 @@ const getZodObjectSchemaFromZodEffectSchema = (
     return schema as z.ZodObject<any>
   }
 
-  let currentSchema = schema
-
-  while (currentSchema instanceof z.ZodEffects) {
-    currentSchema = currentSchema._def.schema
+  let currentSchema = schema as any
+
+  // Handle both Zod 3 (ZodEffects with _def.schema) and Zod 4 (pipe with _def.in)
+  while (
+    currentSchema instanceof z.ZodEffects ||
+    getZodTypeIdentifier(currentSchema._def) === "pipe"
+  ) {
+    if (currentSchema instanceof z.ZodEffects) {
+      currentSchema = currentSchema._def.schema
+    } else if (currentSchema._def.in) {
+      // Zod 4 pipe structure
+      currentSchema = currentSchema._def.in
+    } else {
+      break
+    }
   }
 
   return currentSchema as z.ZodObject<any>
 }
 
 /**
  * This function is used to get the correct schema from a ZodEffect | ZodDefault | ZodOptional schema.
- * TODO: this function should handle all special cases of ZodSchema and not just ZodEffect | ZodDefault | ZodOptional
+ * Supports both Zod 3 and Zod 4 internal structures.
  */
 const getZodDefFromZodSchemaHelpers = (schema: z.ZodTypeAny) => {
-  const special_zod_types = [
-    ZodFirstPartyTypeKind.ZodOptional,
-    ZodFirstPartyTypeKind.ZodDefault,
-    ZodFirstPartyTypeKind.ZodEffects,
-  ]
-
-  while (special_zod_types.includes(schema._def.typeName)) {
+  let currentSchema = schema as any
+  let typeId = getZodTypeIdentifier(currentSchema._def)
+
+  // Keep unwrapping optional, default, effects/pipe until we get to the base type
+  while (
+    isZodType(typeId, ZodFirstPartyTypeKind.ZodOptional, "optional") ||
+    isZodType(typeId, ZodFirstPartyTypeKind.ZodDefault, "default") ||
+    isZodType(typeId, ZodFirstPartyTypeKind.ZodEffects, "pipe")
+  ) {
     if (
-      schema._def.typeName === ZodFirstPartyTypeKind.ZodOptional ||
-      schema._def.typeName === ZodFirstPartyTypeKind.ZodDefault
+      isZodType(typeId, ZodFirstPartyTypeKind.ZodOptional, "optional") ||
+      isZodType(typeId, ZodFirstPartyTypeKind.ZodDefault, "default")
     ) {
-      schema = schema._def.innerType
-      continue
+      currentSchema = currentSchema._def.innerType
+    } else if (isZodType(typeId, ZodFirstPartyTypeKind.ZodEffects, "pipe")) {
+      // Zod 3 uses _def.schema, Zod 4 uses _def.in
+      currentSchema = currentSchema._def.schema ?? currentSchema._def.in
     }
 
-    if (schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects) {
-      schema = schema._def.schema
-      continue
+    if (!currentSchema?._def) {
+      break
     }
+    typeId = getZodTypeIdentifier(currentSchema._def)
   }
-  return schema._def
+
+  return currentSchema._def
 }
 
 const tryGetZodSchemaAsObject = (
   schema: z.ZodTypeAny
 ): z.ZodObject<any> | undefined => {
-  const isZodEffect = schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects
+  const typeId = getZodTypeIdentifier(schema._def)
+  const isZodEffect = isZodType(
+    typeId,
+    ZodFirstPartyTypeKind.ZodEffects,
+    "pipe"
+  )
   const safe_schema = getZodObjectSchemaFromZodEffectSchema(isZodEffect, schema)
-  const isZodObject =
-    safe_schema._def.typeName === ZodFirstPartyTypeKind.ZodObject
+  const safeTypeId = getZodTypeIdentifier(safe_schema._def)
+  const isZodObject = isZodType(
+    safeTypeId,
+    ZodFirstPartyTypeKind.ZodObject,
+    "object"
+  )
 
   if (!isZodObject) {
     return undefined
@@ -72,12 +119,14 @@ const tryGetZodSchemaAsObject = (
 
 const isZodSchemaArray = (schema: z.ZodTypeAny) => {
   const def = getZodDefFromZodSchemaHelpers(schema)
-  return def.typeName === ZodFirstPartyTypeKind.ZodArray
+  const typeId = getZodTypeIdentifier(def)
+  return isZodType(typeId, ZodFirstPartyTypeKind.ZodArray, "array")
 }
 
 const isZodSchemaBoolean = (schema: z.ZodTypeAny) => {
   const def = getZodDefFromZodSchemaHelpers(schema)
-  return def.typeName === ZodFirstPartyTypeKind.ZodBoolean
+  const typeId = getZodTypeIdentifier(def)
+  return isZodType(typeId, ZodFirstPartyTypeKind.ZodBoolean, "boolean")
 }
 
 const parseQueryParams = (