@kubb/plugin-zod 0.0.0-canary-20251103140549 → 0.0.0-canary-20251103161135

package/src/components/Zod.tsx

@@ -11,7 +11,7 @@ type Props = {
   typeName?: string
   inferTypeName?: string
   tree: Array<Schema>
-  rawSchema: SchemaObject
+  schema: SchemaObject
   description?: string
   coercion: PluginZod['resolvedOptions']['coercion']
   mapper: PluginZod['resolvedOptions']['mapper']
@@ -25,7 +25,7 @@ export function Zod({
   name,
   typeName,
   tree,
-  rawSchema,
+  schema,
   inferTypeName,
   mapper,
   coercion,
@@ -49,10 +49,7 @@ export function Zod({
     .map((schema, index) => {
       const siblings = schemas.filter((_, i) => i !== index)
 
-      return parserZod.parse(
-        { parent: undefined, current: schema, siblings },
-        { name, keysToOmit, typeName, description, mapper, coercion, wrapOutput, rawSchema, version },
-      )
+      return parserZod.parse({ schema, parent: undefined, current: schema, siblings, name }, { mapper, coercion, wrapOutput, version })
     })
     .filter(Boolean)
     .join('')
@@ -71,28 +68,25 @@ export function Zod({
     } else {
       suffix = '.unwrap()'
     }
-  } else {
-    if (firstSchema && isKeyword(firstSchema, schemaKeywords.ref) && version === '3') {
-      suffix = '.schema'
-    }
   }
 
   const emptyValue = parserZod.parse(
     {
+      schema,
       parent: undefined,
       current: {
         keyword: schemaKeywords[emptySchemaType],
       },
       siblings: [],
     },
-    { name, keysToOmit, typeName, description, mapper, coercion, wrapOutput, rawSchema, version },
+    { mapper, coercion, wrapOutput, version },
   )
 
   const baseSchemaOutput =
     [output, keysToOmit?.length ? `${suffix}.omit({ ${keysToOmit.map((key) => `'${key}': true`).join(',')} })` : undefined].filter(Boolean).join('') ||
     emptyValue ||
     ''
-  const wrappedSchemaOutput = wrapOutput ? wrapOutput({ output: baseSchemaOutput, schema: rawSchema }) || baseSchemaOutput : baseSchemaOutput
+  const wrappedSchemaOutput = wrapOutput ? wrapOutput({ output: baseSchemaOutput, schema }) || baseSchemaOutput : baseSchemaOutput
   const finalOutput = typeName ? `${wrappedSchemaOutput} as unknown as ${version === '4' ? 'z.ZodType' : 'ToZod'}<${typeName}>` : wrappedSchemaOutput
 
   return (

package/src/generators/__snapshots__/createPet.ts

@@ -12,11 +12,11 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = z.lazy(() => error)
+export const createPetsError = error
 
 export const createPetsMutationRequest = z.object({
   name: z.string(),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/createPetWithUnknownTypeUnknown.ts

@@ -12,11 +12,11 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = z.lazy(() => error)
+export const createPetsError = error
 
 export const createPetsMutationRequest = z.object({
   name: z.string(),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/createPetWithUnknownTypeUnknown_wrapOutput.ts

@@ -12,18 +12,16 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const createPetsError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
 export const createPetsMutationRequest = z.object({
   name: z.string().openapi({ example: 'Baxter' }),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/createPetWithUnknownTypeUnknown_wrapOutput_entire_.ts

@@ -12,19 +12,16 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = extendApi(
-  z.lazy(() => error),
-  {
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  },
-)
+export const createPetsError = extendApi(error, {
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
 export const createPetsMutationRequest = z.object({
   name: extendApi(z.string(), { example: 'Baxter' }),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/createPet_wrapOutput.ts

@@ -12,18 +12,16 @@ export const createPets201 = z.unknown()
 /**
  * @description unexpected error
  */
-export const createPetsError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const createPetsError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
 export const createPetsMutationRequest = z.object({
   name: z.string().openapi({ example: 'Baxter' }),
   tag: z.string(),
 })
 
-export const createPetsMutationResponse = z.lazy(() => createPets201)
+export const createPetsMutationResponse = createPets201

package/src/generators/__snapshots__/discriminator.ts

@@ -5,32 +5,24 @@
 import { z } from 'zod'
 
 export const advanced = z.union([
-  z
-    .lazy(() => enumerationValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('enum'),
-      }),
-    ),
-  z
-    .lazy(() => rangeValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('range'),
-      }),
-    ),
-  z
-    .lazy(() => regexValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('regex'),
-      }),
-    ),
-  z
-    .lazy(() => sliderValueSpecificationDto)
-    .and(
-      z.object({
-        type: z.literal('slider'),
-      }),
-    ),
+  enumerationValueSpecificationDto.and(
+    z.object({
+      type: z.literal('enum'),
+    }),
+  ),
+  rangeValueSpecificationDto.and(
+    z.object({
+      type: z.literal('range'),
+    }),
+  ),
+  regexValueSpecificationDto.and(
+    z.object({
+      type: z.literal('regex'),
+    }),
+  ),
+  sliderValueSpecificationDto.and(
+    z.object({
+      type: z.literal('slider'),
+    }),
+  ),
 ])

package/src/generators/__snapshots__/getPets.ts

@@ -12,11 +12,11 @@ export const listPetsQueryParams = z.object({
 /**
  * @description A paged array of pets
  */
-export const listPets200 = z.lazy(() => pets)
+export const listPets200 = pets
 
 /**
  * @description unexpected error
  */
-export const listPetsError = z.lazy(() => error)
+export const listPetsError = error
 
-export const listPetsQueryResponse = z.lazy(() => listPets200)
+export const listPetsQueryResponse = listPets200

package/src/generators/__snapshots__/getPets_wrapOutput.ts

@@ -12,18 +12,16 @@ export const listPetsQueryParams = z.object({
 /**
  * @description A paged array of pets
  */
-export const listPets200 = z.lazy(() => pets)
+export const listPets200 = pets
 
 /**
  * @description unexpected error
  */
-export const listPetsError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const listPetsError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
-export const listPetsQueryResponse = z.lazy(() => listPets200)
+export const listPetsQueryResponse = listPets200

package/src/generators/__snapshots__/petArray.ts

@@ -7,8 +7,4 @@ import { z } from 'zod'
 /**
  * @description List of Pet object
  */
-export const petArray = z
-  .array(z.lazy(() => pet))
-  .min(1)
-  .max(3)
-  .describe('List of Pet object')
+export const petArray = z.array(pet).min(1).max(3).describe('List of Pet object')

package/src/generators/__snapshots__/queryAllDefaulted.ts

@@ -16,4 +16,4 @@ export const getThings200 = z.object({
   items: z.array(z.lazy(() => thing)),
 })
 
-export const getThingsQueryResponse = z.lazy(() => getThings200)
+export const getThingsQueryResponse = getThings200

package/src/generators/__snapshots__/queryAllDefaulted_wrapOutput.ts

@@ -13,7 +13,7 @@ export const getThingsQueryParams = z.object({
  * @description A list of things
  */
 export const getThings200 = z.object({
-  items: z.array(z.lazy(() => thing)),
+  items: z.array(thing),
 })
 
-export const getThingsQueryResponse = z.lazy(() => getThings200)
+export const getThingsQueryResponse = getThings200

package/src/generators/__snapshots__/showPetById.ts

@@ -12,11 +12,11 @@ export const showPetByIdPathParams = z.object({
 /**
  * @description Expected response to a valid request
  */
-export const showPetById200 = z.lazy(() => pet)
+export const showPetById200 = pet
 
 /**
  * @description unexpected error
  */
-export const showPetByIdError = z.lazy(() => error)
+export const showPetByIdError = error
 
-export const showPetByIdQueryResponse = z.lazy(() => showPetById200)
+export const showPetByIdQueryResponse = showPetById200

package/src/generators/__snapshots__/showPetById_wrapOutput.ts

@@ -12,18 +12,16 @@ export const showPetByIdPathParams = z.object({
 /**
  * @description Expected response to a valid request
  */
-export const showPetById200 = z.lazy(() => pet)
+export const showPetById200 = pet
 
 /**
  * @description unexpected error
  */
-export const showPetByIdError = z
-  .lazy(() => error)
-  .openapi({
-    examples: [
-      { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
-      { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
-    ],
-  })
+export const showPetByIdError = error.openapi({
+  examples: [
+    { sample: { summary: 'A sample error', value: { code: 1, message: 'A sample error message' } } },
+    { other_example: { summary: 'Another sample error', value: { code: 2, message: 'A totally specific message' } } },
+  ],
+})
 
-export const showPetByIdQueryResponse = z.lazy(() => showPetById200)
+export const showPetByIdQueryResponse = showPetById200

package/src/generators/zodGenerator.tsx

@@ -81,7 +81,7 @@ export const zodGenerator = createReactGenerator<PluginZod>({
             inferTypeName={inferred ? zod.inferTypeName : undefined}
             description={description}
             tree={tree}
-            rawSchema={schemaObject}
+            schema={schemaObject}
             mapper={mapper}
             coercion={coercion}
             keysToOmit={keysToOmit}
@@ -150,7 +150,7 @@ export const zodGenerator = createReactGenerator<PluginZod>({
           inferTypeName={inferred ? zod.inferTypeName : undefined}
           description={schema.value.description}
           tree={schema.tree}
-          rawSchema={schema.value}
+          schema={schema.value}
           mapper={mapper}
           coercion={coercion}
           wrapOutput={wrapOutput}

package/src/parser.ts

@@ -1,5 +1,4 @@
 import transformers from '@kubb/core/transformers'
-import type { SchemaObject } from '@kubb/oas'
 
 import type { Schema, SchemaKeywordBase, SchemaMapper } from '@kubb/plugin-oas'
 import { isKeyword, SchemaGenerator, type SchemaKeywordMapper, type SchemaTree, schemaKeywords } from '@kubb/plugin-oas'
@@ -191,12 +190,12 @@ const zodKeywordMapper = {
   phone: undefined,
   readOnly: undefined,
   writeOnly: undefined,
-  ref: (value?: string, version: '3' | '4' = '3') => {
+  ref: (value?: string, lazy = true) => {
     if (!value) {
       return undefined
     }
 
-    return version === '4' ? value : `z.lazy(() => ${value})`
+    return lazy ? `z.lazy(() => ${value})` : value
   },
   blob: () => 'z.instanceof(File)',
   deprecated: undefined,
@@ -258,18 +257,14 @@ const shouldCoerce = (coercion: ParserOptions['coercion'] | undefined, type: 'da
 }
 
 type ParserOptions = {
-  name: string
-  typeName?: string
-  description?: string
-  keysToOmit?: string[]
+  lazy?: boolean
   mapper?: Record<string, string>
   coercion?: boolean | { dates?: boolean; strings?: boolean; numbers?: boolean }
   wrapOutput?: (opts: { output: string; schema: any }) => string | undefined
-  rawSchema: SchemaObject
   version: '3' | '4'
 }
 
-export function parse({ parent, current, name, siblings }: SchemaTree, options: ParserOptions): string | undefined {
+export function parse({ schema, parent, current, name, siblings }: SchemaTree, options: ParserOptions): string | undefined {
   const value = zodKeywordMapper[current.keyword as keyof typeof zodKeywordMapper]
 
   // Early exit: if siblings contain both matches and ref → skip matches entirely
@@ -287,7 +282,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
   if (isKeyword(current, schemaKeywords.union)) {
     // zod union type needs at least 2 items
     if (Array.isArray(current.args) && current.args.length === 1) {
-      return parse({ parent, name: name, current: current.args[0] as Schema, siblings }, options)
+      return parse({ schema, parent, name, current: current.args[0] as Schema, siblings }, options)
     }
     if (Array.isArray(current.args) && !current.args.length) {
       return ''
@@ -295,7 +290,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
 
     return zodKeywordMapper.union(
       sort(current.args)
-        .map((schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options))
+        .map((it, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options))
         .filter(Boolean),
     )
   }
@@ -305,7 +300,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
       .filter((schema: Schema) => {
         return ![schemaKeywords.optional, schemaKeywords.describe].includes(schema.keyword as typeof schemaKeywords.describe)
       })
-      .map((schema: Schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options))
+      .map((it: Schema, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options))
       .filter(Boolean)
 
     return `${items.slice(0, 1)}${zodKeywordMapper.and(items.slice(1))}`
@@ -314,7 +309,9 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
   if (isKeyword(current, schemaKeywords.array)) {
     return zodKeywordMapper.array(
       sort(current.args.items)
-        .map((schemas, _index, siblings) => parse({ parent: current, name: name, current: schemas, siblings }, options))
+        .map((it, _index, siblings) => {
+          return parse({ schema, parent: current, name, current: it, siblings }, options)
+        })
         .filter(Boolean),
       current.args.min,
       current.args.max,
@@ -329,7 +326,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
           keyword: schemaKeywords.const,
           args: current.args.items[0],
         }
-        return parse({ parent: current, name: name, current: child, siblings: [child] }, options)
+        return parse({ schema, parent: current, name, current: child, siblings: [child] }, options)
       }
 
       return zodKeywordMapper.union(
@@ -338,8 +335,8 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
             keyword: schemaKeywords.const,
             args: schema,
           }))
-          .map((schema, _index, siblings) => {
-            return parse({ parent: current, name: name, current: schema, siblings }, options)
+          .map((it, _index, siblings) => {
+            return parse({ schema, parent: current, name, current: it, siblings }, options)
           })
           .filter(Boolean),
       )
@@ -360,7 +357,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
   }
 
   if (isKeyword(current, schemaKeywords.ref)) {
-    return zodKeywordMapper.ref(current.args?.name, options.version)
+    return zodKeywordMapper.ref(current.args?.name, options.lazy ?? name === current.args.name)
   }
 
   if (isKeyword(current, schemaKeywords.object)) {
@@ -370,80 +367,84 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
     })
 
     const properties = propertyEntries
-      .map(([name, schemas]) => {
+      .map(([propertyName, schemas]) => {
         const nameSchema = schemas.find((it) => it.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
         const isNullable = schemas.some((it) => isKeyword(it, schemaKeywords.nullable))
         const isNullish = schemas.some((it) => isKeyword(it, schemaKeywords.nullish))
         const isOptional = schemas.some((it) => isKeyword(it, schemaKeywords.optional))
+        const hasRef = !!SchemaGenerator.find(schemas, schemaKeywords.ref)
 
-        const mappedName = nameSchema?.args || name
+        const mappedName = nameSchema?.args || propertyName
 
         // custom mapper(pluginOptions)
         if (options.mapper?.[mappedName]) {
-          return `"${name}": ${options.mapper?.[mappedName]}`
+          return `"${propertyName}": ${options.mapper?.[mappedName]}`
         }
 
         const baseSchemaOutput = sort(schemas)
           .filter((schema) => {
             return !isKeyword(schema, schemaKeywords.optional) && !isKeyword(schema, schemaKeywords.nullable) && !isKeyword(schema, schemaKeywords.nullish)
           })
-          .map((schema) => parse({ parent: current, name, current: schema, siblings: schemas }, options))
+          .map((it) => {
+            const lazy = !(options.version === '4' && hasRef)
+            return parse({ schema, parent: current, name, current: it, siblings: schemas }, { ...options, lazy })
+          })
           .filter(Boolean)
           .join('')
 
         const objectValue = options.wrapOutput
-          ? options.wrapOutput({ output: baseSchemaOutput, schema: options.rawSchema?.properties?.[name] }) || baseSchemaOutput
+          ? options.wrapOutput({ output: baseSchemaOutput, schema: schema?.properties?.[propertyName] }) || baseSchemaOutput
           : baseSchemaOutput
 
-        if (options.version === '4' && SchemaGenerator.find(schemas, schemaKeywords.ref)) {
+        if (options.version === '4' && hasRef) {
           // both optional and nullable
           if (isNullish) {
-            return `get "${name}"(){
-                return ${zodKeywordMapper.nullish(objectValue)}
+            return `get "${propertyName}"(){
+                return ${objectValue}${zodKeywordMapper.nullish()}
               }`
           }
 
           // undefined
           if (isOptional) {
-            return `get "${name}"(){
-                return ${zodKeywordMapper.optional(objectValue)}
+            return `get "${propertyName}"(){
+                return ${objectValue}${zodKeywordMapper.optional()}
               }`
           }
 
           // null
           if (isNullable) {
-            return `get "${name}"(){
-                return ${zodKeywordMapper.nullable(objectValue)}
+            return `get "${propertyName}"(){
+               return ${objectValue}${zodKeywordMapper.nullable()}
               }`
           }
 
-          return `get "${name}"(){
+          return `get "${propertyName}"(){
                 return ${objectValue}
               }`
         }
 
         // both optional and nullable
         if (isNullish) {
-          return `"${name}": ${objectValue}${zodKeywordMapper.nullish()}`
+          return `"${propertyName}": ${objectValue}${zodKeywordMapper.nullish()}`
         }
 
         // undefined
         if (isOptional) {
-          return `"${name}": ${zodKeywordMapper.optional(objectValue)}`
+          return `"${propertyName}": ${zodKeywordMapper.optional(objectValue)}`
         }
 
         // null
         if (isNullable) {
-          return `"${name}": ${zodKeywordMapper.nullable(objectValue)}`
+          return `"${propertyName}": ${zodKeywordMapper.nullable(objectValue)}`
         }
 
-        return `"${name}": ${objectValue}`
+        return `"${propertyName}": ${objectValue}`
       })
       .join(',\n')
 
     const additionalProperties = current.args?.additionalProperties?.length
       ? current.args.additionalProperties
-          .map((schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options))
+          .map((it, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options))
           .filter(Boolean)
           .join('')
       : undefined
@@ -458,7 +459,7 @@ export function parse({ parent, current, name, siblings }: SchemaTree, options:
 
   if (isKeyword(current, schemaKeywords.tuple)) {
     return zodKeywordMapper.tuple(
-      current.args.items.map((schema, _index, siblings) => parse({ parent: current, name: name, current: schema, siblings }, options)).filter(Boolean),
+      current.args.items.map((it, _index, siblings) => parse({ schema, parent: current, name, current: it, siblings }, options)).filter(Boolean),
     )
   }