@kubb/plugin-zod 5.0.0-alpha.9 → 5.0.0-beta.15

package/src/components/Operations.tsx

@@ -1,35 +1,42 @@
 import { stringifyObject } from '@internals/utils'
-import type { HttpMethod, Operation } from '@kubb/oas'
-import type { SchemaNames } from '@kubb/plugin-oas/hooks'
-import { Const, File, Type } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { ast } from '@kubb/core'
+import { Const, File, Type } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+
+type SchemaNames = {
+  request: string | undefined
+  parameters: {
+    path: string | undefined
+    query: string | undefined
+    header: string | undefined
+  }
+  responses: { default?: string } & Record<number | string, string>
+  errors: Record<number | string, string>
+}
 
 type Props = {
   name: string
-  operations: Array<{ operation: Operation; data: SchemaNames }>
+  operations: Array<{ node: ast.OperationNode; data: SchemaNames }>
 }
 
-export function Operations({ name, operations }: Props): FabricReactNode {
-  const operationsJSON = operations.reduce(
+export function Operations({ name, operations }: Props): KubbReactNode {
+  const operationsJSON = operations.reduce<Record<string, unknown>>(
     (prev, acc) => {
-      prev[`"${acc.operation.getOperationId()}"`] = acc.data
+      prev[`"${acc.node.operationId}"`] = acc.data
 
       return prev
     },
     {} as Record<string, unknown>,
   )
 
-  const pathsJSON = operations.reduce(
-    (prev, acc) => {
-      prev[`"${acc.operation.path}"`] = {
-        ...(prev[`"${acc.operation.path}"`] || ({} as Record<HttpMethod, string>)),
-        [acc.operation.method]: `operations["${acc.operation.getOperationId()}"]`,
-      }
+  const pathsJSON = operations.reduce<Record<string, Record<string, string>>>((prev, acc) => {
+    prev[`"${acc.node.path}"`] = {
+      ...(prev[`"${acc.node.path}"`] ?? {}),
+      [acc.node.method]: `operations["${acc.node.operationId}"]`,
+    }
 
-      return prev
-    },
-    {} as Record<string, Record<HttpMethod, string>>,
-  )
+    return prev
+  }, {})
 
   return (
     <>

package/src/components/Zod.tsx

@@ -1,140 +1,40 @@
-import { jsStringEscape } from '@internals/utils'
-import type { SchemaObject } from '@kubb/oas'
-import { isKeyword, type Schema, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
-import { Const, File, Type } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import * as parserZod from '../parser.ts'
-import type { PluginZod } from '../types.ts'
+import type { ast } from '@kubb/core'
+import { Const, File, Type } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import type { PrinterZodFactory } from '../printers/printerZod.ts'
+import type { PrinterZodMiniFactory } from '../printers/printerZodMini.ts'
 
 type Props = {
   name: string
-  typeName?: string
+  node: ast.SchemaNode
+  /**
+   * Pre-configured printer instance created by the generator.
+   * The generator selects `printerZod` or `printerZodMini` based on the `mini` option,
+   * then merges in any user-supplied `printer.nodes` overrides.
+   */
+  printer: ast.Printer<PrinterZodFactory> | ast.Printer<PrinterZodMiniFactory>
   inferTypeName?: string
-  tree: Array<Schema>
-  schema: SchemaObject
-  description?: string
-  coercion: PluginZod['resolvedOptions']['coercion']
-  mapper: PluginZod['resolvedOptions']['mapper']
-  keysToOmit?: string[]
-  wrapOutput?: PluginZod['resolvedOptions']['wrapOutput']
-  version: '3' | '4'
-  guidType: PluginZod['resolvedOptions']['guidType']
-  emptySchemaType: PluginZod['resolvedOptions']['emptySchemaType']
-  mini?: boolean
 }
 
-export function Zod({
-  name,
-  typeName,
-  tree,
-  schema,
-  inferTypeName,
-  mapper,
-  coercion,
-  keysToOmit,
-  description,
-  wrapOutput,
-  version,
-  guidType,
-  emptySchemaType,
-  mini = false,
-}: Props): FabricReactNode {
-  const hasTuple = !!SchemaGenerator.find(tree, schemaKeywords.tuple)
+export function Zod({ name, node, printer, inferTypeName }: Props): KubbReactNode {
+  const output = printer.print(node)
 
-  const schemas = parserZod.sort(tree).filter((item) => {
-    if (hasTuple && (isKeyword(item, schemaKeywords.min) || isKeyword(item, schemaKeywords.max))) {
-      return false
-    }
-
-    return true
-  })
-
-  // In mini mode, filter out modifiers from the main schema parsing
-  const baseSchemas = mini ? parserZod.filterMiniModifiers(schemas) : schemas
-
-  const output = baseSchemas
-    .map((schemaKeyword, index) => {
-      const siblings = baseSchemas.filter((_, i) => i !== index)
-
-      return parserZod.parse({ schema, parent: undefined, current: schemaKeyword, siblings, name }, { mapper, coercion, wrapOutput, version, guidType, mini })
-    })
-    .filter(Boolean)
-    .join('')
-
-  let suffix = ''
-  const firstSchema = schemas.at(0)
-  const lastSchema = schemas.at(-1)
-
-  if (!mini && lastSchema && isKeyword(lastSchema, schemaKeywords.nullable)) {
-    if (firstSchema && isKeyword(firstSchema, schemaKeywords.ref)) {
-      if (version === '3') {
-        suffix = '.unwrap().schema.unwrap()'
-      } else {
-        suffix = '.unwrap().unwrap()'
-      }
-    } else {
-      suffix = '.unwrap()'
-    }
-  } else if (!mini) {
-    if (firstSchema && isKeyword(firstSchema, schemaKeywords.ref)) {
-      if (version === '3') {
-        suffix = '.schema'
-      } else {
-        suffix = '.unwrap()'
-      }
-    }
+  if (!output) {
+    return
   }
 
-  const emptyValue = parserZod.parse(
-    {
-      schema,
-      parent: undefined,
-      current: {
-        keyword: schemaKeywords[emptySchemaType],
-      },
-      siblings: [],
-    },
-    { mapper, coercion, wrapOutput, version, guidType, mini },
-  )
-
-  let baseSchemaOutput =
-    [output, keysToOmit?.length ? `${suffix}.omit({ ${keysToOmit.map((key) => `'${key}': true`).join(',')} })` : undefined].filter(Boolean).join('') ||
-    emptyValue ||
-    ''
-
-  // For mini mode, wrap the output with modifiers using the parser function
-  if (mini) {
-    baseSchemaOutput = parserZod.wrapWithMiniModifiers(baseSchemaOutput, parserZod.extractMiniModifiers(schemas))
-  }
-
-  const wrappedSchemaOutput = wrapOutput ? wrapOutput({ output: baseSchemaOutput, schema }) || baseSchemaOutput : baseSchemaOutput
-  const finalOutput = typeName ? `${wrappedSchemaOutput} as unknown as ${version === '4' ? 'z.ZodType' : 'ToZod'}<${typeName}>` : wrappedSchemaOutput
-
   return (
     <>
       <File.Source name={name} isExportable isIndexable>
-        <Const
-          export
-          name={name}
-          JSDoc={{
-            comments: [description ? `@description ${jsStringEscape(description)}` : undefined].filter(Boolean),
-          }}
-        >
-          {finalOutput}
+        <Const export name={name}>
+          {output}
         </Const>
       </File.Source>
       {inferTypeName && (
         <File.Source name={inferTypeName} isExportable isIndexable isTypeOnly>
-          {typeName && (
-            <Type export name={inferTypeName}>
-              {typeName}
-            </Type>
-          )}
-          {!typeName && (
-            <Type export name={inferTypeName}>
-              {`z.infer<typeof ${name}>`}
-            </Type>
-          )}
+          <Type export name={inferTypeName}>
+            {`z.infer<typeof ${name}>`}
+          </Type>
         </File.Source>
       )}
     </>

package/src/constants.ts

@@ -0,0 +1,5 @@
+/**
+ * Import paths that use a namespace import (`import * as z from '...'`).
+ * All other import paths use a named import (`import { z } from '...'`).
+ */
+export const ZOD_NAMESPACE_IMPORTS = new Set(['zod', 'zod/mini'] as const)

package/src/generators/zodGenerator.tsx

@@ -1,201 +1,248 @@
-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 { PluginZod } from '../types'
-
-export const zodGenerator = createReactGenerator<PluginZod>({
+import type { Adapter } from '@kubb/core'
+import { ast, defineGenerator } from '@kubb/core'
+import type { AdapterOas } from '@kubb/adapter-oas'
+import { File, jsxRendererSync } 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, ResolverZod } from '../types'
+import { buildSchemaNames } from '../utils.ts'
+
+type ZodPrinterEntry = { printer: ReturnType<typeof printerZod>; coercion: unknown; guidType: unknown; dateType: unknown }
+type ZodMiniPrinterEntry = { printer: ReturnType<typeof printerZodMini>; guidType: unknown }
+
+// Per-build caches: keyed on resolver (unique per plugin instance per build, GC'd when released)
+const zodPrinterCache = new WeakMap<ResolverZod, ZodPrinterEntry>()
+const zodMiniPrinterCache = new WeakMap<ResolverZod, ZodMiniPrinterEntry>()
+
+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,
-    })
-
-    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')
+  renderer: jsxRendererSync,
+  schema(node, ctx) {
+    const { adapter, config, resolver, root, inputNode } = 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 mapOperationSchema = ({ name, schema: schemaOriginal, description, keysToOmit: keysToOmitOriginal, ...options }: OperationSchemaType) => {
-      let schemaObject = schemaOriginal
-      let keysToOmit = keysToOmitOriginal
+    const mode = ctx.getMode(output)
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-      if ((schemaOriginal.anyOf || schemaOriginal.oneOf) && keysToOmitOriginal && keysToOmitOriginal.length > 0) {
-        schemaObject = structuredClone(schemaOriginal)
+    const imports = adapter.getImports(node, (schemaName) => ({
+      name: resolver.resolveSchemaName(schemaName),
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+    }))
 
-        // Remove $ref so the schema parser generates inline schema instead of a reference
-        delete schemaObject.$ref
+    const meta = {
+      name: resolver.resolveSchemaName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
+    } as const
 
-        for (const key of keysToOmitOriginal) {
-          delete schemaObject.properties?.[key]
-        }
+    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : undefined
 
-        if (Array.isArray(schemaObject.required)) {
-          schemaObject.required = schemaObject.required.filter((key) => !keysToOmitOriginal.includes(key))
-        }
+    const cyclicSchemas = ast.findCircularSchemas(inputNode.schemas)
 
-        keysToOmit = undefined
+    const schemaPrinter = mini ? getCachedMiniPrinter() : getCachedStdPrinter()
+    function getCachedStdPrinter() {
+      const cached = zodPrinterCache.get(resolver)
+      if (cached && cached.coercion === coercion && cached.guidType === guidType && cached.dateType === dateType) {
+        return cached.printer
       }
-
-      const hasProperties = Object.keys(schemaObject || {}).length > 0
-      const hasDefaults = Object.values(schemaObject.properties || {}).some((prop) => prop && Object.hasOwn(prop, 'default'))
-
-      const required = Array.isArray(schemaObject?.required) ? schemaObject.required.length > 0 : !!schemaObject?.required
-      const optional = !required && !hasDefaults && hasProperties && name.includes('Params')
-
-      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 p = printerZod({ coercion, guidType, dateType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
+      zodPrinterCache.set(resolver, { printer: p, coercion, guidType, dateType })
+      return p
+    }
+    function getCachedMiniPrinter() {
+      const cached = zodMiniPrinterCache.get(resolver)
+      if (cached && cached.guidType === guidType) {
+        return cached.printer
       }
+      const p = printerZodMini({ guidType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
+      zodMiniPrinterCache.set(resolver, { printer: p, guidType })
+      return p
+    }
 
-      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 coercion = name.includes('Params') ? { numbers: true, strings: false, dates: true } : globalCoercion
-
-      const zod = {
-        name: schemaManager.getName(name, { type: 'function' }),
-        inferTypeName: schemaManager.getName(name, { type: 'type' }),
-        file: schemaManager.getFile(name),
-      }
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(inputNode, { output, config })}
+        footer={resolver.resolveFooter(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 type = {
-        name: schemaManager.getName(name, {
-          type: 'type',
-          pluginName: pluginTsName,
-        }),
-        file: schemaManager.getFile(options.operationName || name, {
-          pluginName: pluginTsName,
-          group,
-        }),
-      }
+        <Zod name={meta.name} node={node} printer={schemaPrinter} inferTypeName={inferTypeName} />
+      </File>
+    )
+  },
+  operation(node, ctx) {
+    const { adapter, config, resolver, root, inputNode } = ctx
+    const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options
+    const dateType = (adapter as Adapter<AdapterOas>).options.dateType
+
+    const mode = ctx.getMode(output)
+    const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
+
+    const params = ast.caseParams(node.parameters, paramsCasing)
+
+    const meta = {
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+    } as const
+
+    const cyclicSchemas = ast.findCircularSchemas(inputNode.schemas)
+
+    function renderSchemaEntry({ schema, name, keysToOmit }: { schema: ast.SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
+      if (!schema) return null
+
+      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 cachedStd = zodPrinterCache.get(resolver)
+      const cachedMini = zodMiniPrinterCache.get(resolver)
+      const schemaPrinter = mini
+        ? keysToOmit?.length
+          ? printerZodMini({ guidType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
+          : cachedMini?.guidType === guidType
+            ? cachedMini.printer
+            : printerZodMini({ guidType, wrapOutput, resolver, cyclicSchemas, nodes: printer?.nodes })
+        : keysToOmit?.length
+          ? printerZod({ coercion, guidType, dateType, wrapOutput, resolver, keysToOmit, cyclicSchemas, nodes: printer?.nodes })
+          : cachedStd?.coercion === coercion && cachedStd?.guidType === guidType && cachedStd?.dateType === dateType
+            ? cachedStd.printer
+            : printerZod({ coercion, guidType, dateType, wrapOutput, resolver, 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(inputNode, { output, config })}
+        footer={resolver.resolveFooter(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 { config, resolver, root, inputNode } = 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 isZodImport = importPath === 'zod' || importPath === 'zod/mini'
-    const toZodPath = path.resolve(config.root, config.output.path, '.kubb/ToZod.ts')
+    const meta = {
+      file: resolver.resolveFile({ name: 'operations', extname: '.ts' }, { root, output, group }),
+    } as const
+
+    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(inputNode, { output, config })}
+        footer={resolver.resolveFooter(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'