@kubb/plugin-zod 5.0.0-alpha.8 → 5.0.0-beta.3

package/src/generators/zodGenerator.tsx

@@ -1,201 +1,215 @@
-import path from 'node:path'
-import { useMode, usePluginDriver } from '@kubb/core/hooks'
-import { type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter, getImports } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { File } from '@kubb/react-fabric'
-import { Zod } from '../components'
+import type { Adapter } from '@kubb/core'
+import { ast, defineGenerator } from '@kubb/core'
+import type { AdapterOas } from '@kubb/adapter-oas'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { Operations } from '../components/Operations.tsx'
+import { Zod } from '../components/Zod.tsx'
+import { ZOD_NAMESPACE_IMPORTS } from '../constants.ts'
+import { printerZod } from '../printers/printerZod.ts'
+import { printerZodMini } from '../printers/printerZodMini.ts'
 import type { PluginZod } from '../types'
+import { buildSchemaNames } from '../utils.ts'
 
-export const zodGenerator = createReactGenerator<PluginZod>({
+export const zodGenerator = defineGenerator<PluginZod>({
   name: 'zod',
-  Operation({ config, operation, generator, plugin }) {
-    const {
-      options,
-      options: { coercion: globalCoercion, inferred, typed, mapper, wrapOutput, version, guidType, mini },
-    } = plugin
-
-    const mode = useMode()
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getFile, getGroup } = useOperationManager(generator)
-    const schemaManager = useSchemaManager()
-
-    const file = getFile(operation)
-    const schemas = getSchemas(operation)
-    const schemaGenerator = new SchemaGenerator(options, {
-      fabric: generator.context.fabric,
-      oas,
-      plugin,
-      driver,
-      events: generator.context.events,
-      mode,
-      override: options.override,
-    })
+  renderer: jsxRenderer,
+  schema(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options
+    const dateType = (adapter as Adapter<AdapterOas>).options.dateType
+
+    if (!node.name) {
+      return
+    }
 
-    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
-      .flat()
-      .filter(Boolean)
-    const toZodPath = path.resolve(config.root, config.output.path, '.kubb/ToZod.ts')
+    const mode = ctx.getMode(output)
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-    const mapOperationSchema = ({ name, schema: schemaOriginal, description, keysToOmit: keysToOmitOriginal, ...options }: OperationSchemaType) => {
-      let schemaObject = schemaOriginal
-      let keysToOmit = keysToOmitOriginal
+    const imports = adapter.getImports(node, (schemaName) => ({
+      name: resolver.resolveSchemaName(schemaName),
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+    }))
 
-      if ((schemaOriginal.anyOf || schemaOriginal.oneOf) && keysToOmitOriginal && keysToOmitOriginal.length > 0) {
-        schemaObject = structuredClone(schemaOriginal)
+    const meta = {
+      name: resolver.resolveSchemaName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
+    } as const
 
-        // Remove $ref so the schema parser generates inline schema instead of a reference
-        delete schemaObject.$ref
+    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : undefined
 
-        for (const key of keysToOmitOriginal) {
-          delete schemaObject.properties?.[key]
-        }
+    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
 
-        if (Array.isArray(schemaObject.required)) {
-          schemaObject.required = schemaObject.required.filter((key) => !keysToOmitOriginal.includes(key))
-        }
+    const schemaPrinter = mini
+      ? printerZodMini({ guidType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
+      : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
 
-        keysToOmit = undefined
-      }
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+      >
+        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
+        {mode === 'split' && imports.map((imp) => <File.Import key={[node.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
 
-      const hasProperties = Object.keys(schemaObject || {}).length > 0
-      const hasDefaults = Object.values(schemaObject.properties || {}).some((prop) => prop && Object.hasOwn(prop, 'default'))
+        <Zod name={meta.name} node={node} printer={schemaPrinter} inferTypeName={inferTypeName} />
+      </File>
+    )
+  },
+  operation(node, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options
+    const dateType = (adapter as Adapter<AdapterOas>).options.dateType
 
-      const required = Array.isArray(schemaObject?.required) ? schemaObject.required.length > 0 : !!schemaObject?.required
-      const optional = !required && !hasDefaults && hasProperties && name.includes('Params')
+    const mode = ctx.getMode(output)
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-      if (!optional && Array.isArray(schemaObject.required) && !schemaObject.required.length) {
-        schemaObject.required = Object.entries(schemaObject.properties || {})
-          .filter(([_key, value]) => value && Object.hasOwn(value, 'default'))
-          .map(([key]) => key)
-      }
+    const params = ast.caseParams(node.parameters, paramsCasing)
 
-      const tree = [
-        ...schemaGenerator.parse({ schema: schemaObject, name, parentName: null }),
-        optional ? { keyword: schemaKeywords.optional } : undefined,
-      ].filter(Boolean)
-      const imports = getImports(tree)
-      const group = options.operation ? getGroup(options.operation) : undefined
+    const meta = {
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+    } as const
 
-      const coercion = name.includes('Params') ? { numbers: true, strings: false, dates: true } : globalCoercion
+    const cyclicSchemas = adapter.inputNode ? ast.findCircularSchemas(adapter.inputNode.schemas) : undefined
 
-      const zod = {
-        name: schemaManager.getName(name, { type: 'function' }),
-        inferTypeName: schemaManager.getName(name, { type: 'type' }),
-        file: schemaManager.getFile(name),
-      }
+    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+      if (!schema) return null
 
-      const type = {
-        name: schemaManager.getName(name, {
-          type: 'type',
-          pluginName: pluginTsName,
-        }),
-        file: schemaManager.getFile(options.operationName || name, {
-          pluginName: pluginTsName,
-          group,
-        }),
-      }
+      const inferTypeName = inferred ? resolver.resolveTypeName(name) : undefined
+
+      const imports = adapter.getImports(schema, (schemaName) => ({
+        name: resolver.resolveSchemaName(schemaName),
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+      }))
+
+      const schemaPrinter = mini
+        ? printerZodMini({ guidType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
+        : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
 
       return (
         <>
-          {typed && <File.Import isTypeOnly root={file.path} path={type.file.path} name={[type.name]} />}
-          {imports.map((imp) => (
-            <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} />
-          ))}
-          <Zod
-            name={zod.name}
-            typeName={typed ? type.name : undefined}
-            inferTypeName={inferred ? zod.inferTypeName : undefined}
-            description={description}
-            tree={tree}
-            schema={schemaObject}
-            mapper={mapper}
-            coercion={coercion}
-            keysToOmit={keysToOmit}
-            wrapOutput={wrapOutput}
-            version={plugin.options.version}
-            guidType={guidType}
-            emptySchemaType={plugin.options.emptySchemaType}
-            mini={mini}
-          />
+          {mode === 'split' &&
+            imports.map((imp) => <File.Import key={[name, imp.path, imp.name].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+          <Zod name={name} node={schema} printer={schemaPrinter} inferTypeName={inferTypeName} />
         </>
       )
     }
 
-    const isZodImport = plugin.options.importPath === 'zod' || plugin.options.importPath === 'zod/mini'
+    const paramSchemas = params.map((param) => renderSchemaEntry({ schema: param.schema, name: resolver.resolveParamName(node, param) }))
+
+    const responseSchemas = node.responses.map((res) =>
+      renderSchemaEntry({
+        schema: res.schema,
+        name: resolver.resolveResponseStatusName(node, res.statusCode),
+        keysToOmit: res.keysToOmit,
+      }),
+    )
+
+    const responsesWithSchema = node.responses.filter((res) => res.schema)
+    const responseUnionSchema =
+      responsesWithSchema.length > 0
+        ? (() => {
+            const responseUnionName = resolver.resolveResponseName(node)
+
+            // Collect all import names from response schemas to detect naming collisions.
+            // When a response is a $ref to a component schema whose resolved name matches
+            // the response union name, skip generation to avoid redeclaration errors.
+            const importedNames = new Set(
+              responsesWithSchema.flatMap((res) =>
+                res.schema
+                  ? adapter
+                      .getImports(res.schema, (schemaName) => ({
+                        name: resolver.resolveSchemaName(schemaName),
+                        path: '',
+                      }))
+                      .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
+                  : [],
+              ),
+            )
+
+            if (importedNames.has(responseUnionName)) {
+              return null
+            }
+
+            const members = responsesWithSchema.map((res) => ast.createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) }))
+            const unionNode = members.length === 1 ? members[0]! : ast.createSchema({ type: 'union', members })
+
+            return renderSchemaEntry({
+              schema: unionNode,
+              name: responseUnionName,
+            })
+          })()
+        : null
+
+    const requestSchema = node.requestBody?.content?.[0]?.schema
+      ? renderSchemaEntry({
+          schema: {
+            ...node.requestBody.content![0]!.schema!,
+            description: node.requestBody.description ?? node.requestBody.content![0]!.schema!.description,
+          },
+          name: resolver.resolveDataName(node),
+          keysToOmit: node.requestBody.content![0]!.keysToOmit,
+        })
+      : null
 
     return (
       <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-        banner={getBanner({ oas, output: plugin.options.output, config: driver.config })}
-        footer={getFooter({ oas, output: plugin.options.output })}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
-        <File.Import name={isZodImport ? 'z' : ['z']} path={plugin.options.importPath} isNameSpace={isZodImport} />
-        {typed && version === '3' && <File.Import name={['ToZod']} isTypeOnly root={file.path} path={toZodPath} />}
-        {operationSchemas.map(mapOperationSchema)}
+        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
+        {paramSchemas}
+        {responseSchemas}
+        {responseUnionSchema}
+        {requestSchema}
       </File>
     )
   },
-  Schema({ config, schema, plugin }) {
-    const { getName, getFile } = useSchemaManager()
-    const {
-      options: { output, emptySchemaType, coercion, inferred, typed, mapper, importPath, wrapOutput, version, guidType, mini },
-    } = plugin
-    const driver = usePluginDriver()
-    const oas = useOas()
-
-    const imports = getImports(schema.tree)
-
-    const zod = {
-      name: getName(schema.name, { type: 'function' }),
-      inferTypeName: getName(schema.name, { type: 'type' }),
-      file: getFile(schema.name),
-    }
+  operations(nodes, ctx) {
+    const { adapter, config, resolver, root } = ctx
+    const { output, importPath, group, operations, paramsCasing } = ctx.options
 
-    const type = {
-      name: getName(schema.name, { type: 'type', pluginName: pluginTsName }),
-      file: getFile(schema.name, { pluginName: pluginTsName }),
+    if (!operations) {
+      return
     }
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
+
+    const meta = {
+      file: resolver.resolveFile({ name: 'operations', extname: '.ts' }, { root, output, group }),
+    } as const
 
-    const isZodImport = importPath === 'zod' || importPath === 'zod/mini'
-    const toZodPath = path.resolve(config.root, config.output.path, '.kubb/ToZod.ts')
+    const transformedOperations = nodes.map((node) => {
+      const params = ast.caseParams(node.parameters, paramsCasing)
+
+      return {
+        node,
+        data: buildSchemaNames(node, { params, resolver }),
+      }
+    })
+
+    const imports = transformedOperations.flatMap(({ node, data }) => {
+      const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean) as string[]
+      const opFile = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
+
+      return names.map((name) => <File.Import key={[name, opFile.path].join('-')} name={[name]} root={meta.file.path} path={opFile.path} />)
+    })
 
     return (
       <File
-        baseName={zod.file.baseName}
-        path={zod.file.path}
-        meta={zod.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
-        <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {typed && <File.Import isTypeOnly root={zod.file.path} path={type.file.path} name={[type.name]} />}
-        {typed && version === '3' && <File.Import name={['ToZod']} isTypeOnly root={zod.file.path} path={toZodPath} />}
-        {imports.map((imp) => (
-          <File.Import key={[imp.path, imp.name, imp.isTypeOnly].join('-')} root={zod.file.path} path={imp.path} name={imp.name} />
-        ))}
-
-        <Zod
-          name={zod.name}
-          typeName={typed ? type.name : undefined}
-          inferTypeName={inferred ? zod.inferTypeName : undefined}
-          description={schema.value.description}
-          tree={schema.tree}
-          schema={schema.value}
-          mapper={mapper}
-          coercion={coercion}
-          wrapOutput={wrapOutput}
-          version={version}
-          guidType={guidType}
-          emptySchemaType={emptySchemaType}
-          mini={mini}
-        />
+        <File.Import isTypeOnly name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
+        {imports}
+        <Operations name="operations" operations={transformedOperations} />
       </File>
     )
   },

package/src/index.ts

@@ -1,2 +1,11 @@
-export { pluginZod, pluginZodName } from './plugin.ts'
-export type { PluginZod } from './types.ts'
+export { zodGenerator } from './generators/zodGenerator.tsx'
+
+export { default, pluginZod, pluginZodName } from './plugin.ts'
+export type { PrinterZodFactory, PrinterZodNodes, PrinterZodOptions } from './printers/printerZod.ts'
+export { printerZod } from './printers/printerZod.ts'
+export type { PrinterZodMiniFactory, PrinterZodMiniNodes, PrinterZodMiniOptions } from './printers/printerZodMini.ts'
+export { printerZodMini } from './printers/printerZodMini.ts'
+
+export { resolverZod } from './resolvers/resolverZod.ts'
+
+export type { PluginZod, ResolverZod } from './types.ts'

package/src/plugin.ts

@@ -1,183 +1,94 @@
-import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode, PackageManager } from '@kubb/core'
-import { OperationGenerator, pluginOasName, SchemaGenerator } from '@kubb/plugin-oas'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { operationsGenerator } from './generators'
+import { camelCase } from '@internals/utils'
+import { definePlugin, type Group } from '@kubb/core'
 import { zodGenerator } from './generators/zodGenerator.tsx'
-import { source as toZodSource } from './templates/ToZod.source.ts'
+import { resolverZod } from './resolvers/resolverZod.ts'
 import type { PluginZod } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-zod`, used in driver lookups and warnings.
+ */
 export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
 
-export const pluginZod = createPlugin<PluginZod>((options) => {
+/**
+ * Generates Zod validation schemas from an OpenAPI specification.
+ * Walks schemas and operations, delegates to generators, and writes barrel files
+ * based on the configured `barrelType`.
+ *
+ * @example Zod schema generator
+ * ```ts
+ * import pluginZod from '@kubb/plugin-zod'
+ * export default defineConfig({
+ *   plugins: [pluginZod({ output: { path: 'zod' } })]
+ * })
+ * ```
+ */
+export const pluginZod = definePlugin<PluginZod>((options) => {
   const {
     output = { path: 'zod', barrelType: 'named' },
     group,
     exclude = [],
     include,
     override = [],
-    transformers = {},
-    dateType = 'string',
-    unknownType = 'any',
-    emptySchemaType = unknownType,
-    integerType = 'number',
     typed = false,
-    mapper = {},
     operations = false,
     mini = false,
-    version = mini ? '4' : new PackageManager().isValidSync('zod', '>=4') ? '4' : '3',
     guidType = 'uuid',
-    importPath = mini ? 'zod/mini' : version === '4' ? 'zod/v4' : 'zod',
+    importPath = mini ? 'zod/mini' : 'zod',
     coercion = false,
     inferred = false,
-    generators = [zodGenerator, operations ? operationsGenerator : undefined].filter(Boolean),
     wrapOutput = undefined,
-    contentType,
+    paramsCasing,
+    printer,
+    resolver: userResolver,
+    transformer: userTransformer,
+    generators: userGenerators = [],
   } = options
 
-  // @deprecated Will be removed in v5 when collisionDetection defaults to true
-  const usedEnumNames = {}
+  const groupConfig = group
+    ? ({
+        ...group,
+        name: (ctx) => {
+          if (group.type === 'path') {
+            return `${ctx.group.split('/')[1]}`
+          }
+          return `${camelCase(ctx.group)}Controller`
+        },
+      } satisfies Group)
+    : undefined
 
   return {
     name: pluginZodName,
-    options: {
-      output,
-      transformers,
-      include,
-      exclude,
-      override,
-      typed,
-      dateType,
-      unknownType,
-      emptySchemaType,
-      integerType,
-      mapper,
-      importPath,
-      coercion,
-      operations,
-      inferred,
-      group,
-      wrapOutput,
-      version,
-      guidType,
-      mini,
-      usedEnumNames,
-    },
-    pre: [pluginOasName, typed ? pluginTsName : undefined].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      if (mode === 'single') {
-        /**
-         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
-         */
-        return path.resolve(root, output.path)
-      }
-
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
-          ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Controller`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
-      }
-
-      return path.resolve(root, output.path, baseName)
-    },
-    resolveName(name, type) {
-      let resolvedName = camelCase(name, {
-        suffix: type ? 'schema' : undefined,
-        isFile: type === 'file',
-      })
-
-      if (type === 'type') {
-        resolvedName = pascalCase(resolvedName)
-      }
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
-
-      return resolvedName
-    },
-    async install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-
-      if (this.plugin.options.typed && this.plugin.options.version === '3') {
-        // pre add bundled
-        await this.addFile({
-          baseName: 'ToZod.ts',
-          path: path.resolve(root, '.kubb/ToZod.ts'),
-          sources: [
-            {
-              name: 'ToZod',
-              value: toZodSource,
-            },
-          ],
-          imports: [],
-          exports: [],
+    options,
+    hooks: {
+      'kubb:plugin:setup'(ctx) {
+        ctx.setOptions({
+          output,
+          exclude,
+          include,
+          override,
+          group: groupConfig,
+          typed,
+          importPath,
+          coercion,
+          operations,
+          inferred,
+          guidType,
+          mini,
+          wrapOutput,
+          paramsCasing,
+          printer,
         })
-      }
-
-      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        include: undefined,
-        override,
-        mode,
-        output: output.path,
-      })
-
-      const schemaFiles = await schemaGenerator.build(...generators)
-      await this.upsertFile(...schemaFiles)
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-      })
-
-      const operationFiles = await operationGenerator.build(...generators)
-      await this.upsertFile(...operationFiles)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+        ctx.setResolver(userResolver ? { ...resolverZod, ...userResolver } : resolverZod)
+        if (userTransformer) {
+          ctx.setTransformer(userTransformer)
+        }
+        ctx.addGenerator(zodGenerator)
+        for (const gen of userGenerators) {
+          ctx.addGenerator(gen)
+        }
+      },
     },
   }
 })
+
+export default pluginZod