@kubb/plugin-zod 5.0.0-alpha.29 → 5.0.0-alpha.30

package/src/generators/zodGenerator.tsx

@@ -1,7 +1,6 @@
-import path from 'node:path'
-import { caseParams, transform } from '@kubb/ast'
+import { caseParams } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
-import { defineGenerator, getMode } from '@kubb/core'
+import { defineGenerator } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
@@ -13,31 +12,28 @@ import { buildSchemaNames } from '../utils.ts'
 
 export const zodGenerator = defineGenerator<PluginZod>({
   name: 'zod',
-  type: 'react',
-  Schema({ node, adapter, options, config, resolver, plugin }) {
+  schema(node, options) {
+    const { adapter, config, resolver, root } = this
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    if (!transformedNode.name) {
+    if (!node.name) {
       return
     }
 
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-    const imports = adapter.getImports(transformedNode, (schemaName) => ({
+    const imports = adapter.getImports(node, (schemaName) => ({
       name: resolver.resolveSchemaName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
     const meta = {
-      name: resolver.resolveSchemaName(transformedNode.name),
-      file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
+      name: resolver.resolveSchemaName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
-    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(transformedNode.name) : undefined
+    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : undefined
 
     const schemaPrinter = mini
       ? printerZodMini({ guidType, wrapOutput, resolver, schemaName: meta.name, nodes: printer?.nodes })
@@ -52,29 +48,23 @@ export const zodGenerator = defineGenerator<PluginZod>({
         footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
       >
         <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {mode === 'split' &&
-          imports.map((imp) => <File.Import key={[transformedNode.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+        {mode === 'split' && imports.map((imp) => <File.Import key={[node.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
 
-        <Zod name={meta.name} node={transformedNode} printer={schemaPrinter} inferTypeName={inferTypeName} />
+        <Zod name={meta.name} node={node} printer={schemaPrinter} inferTypeName={inferTypeName} />
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver, plugin }) {
+  operation(node, options) {
+    const { adapter, config, resolver, root } = this
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-    const params = caseParams(transformedNode.parameters, paramsCasing)
+    const params = caseParams(node.parameters, paramsCasing)
 
     const meta = {
-      file: resolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
-        { root, output, group },
-      ),
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
     } as const
 
     function renderSchemaEntry({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
@@ -102,22 +92,22 @@ export const zodGenerator = defineGenerator<PluginZod>({
 
     const paramSchemas = params.map((param) => renderSchemaEntry({ schema: param.schema, name: resolver.resolveParamName(node, param) }))
 
-    const responseSchemas = transformedNode.responses.map((res) =>
+    const responseSchemas = node.responses.map((res) =>
       renderSchemaEntry({
         schema: res.schema,
-        name: resolver.resolveResponseStatusName(transformedNode, res.statusCode),
+        name: resolver.resolveResponseStatusName(node, res.statusCode),
         keysToOmit: res.keysToOmit,
       }),
     )
 
-    const requestSchema = transformedNode.requestBody?.schema
+    const requestSchema = node.requestBody?.schema
       ? renderSchemaEntry({
           schema: {
-            ...transformedNode.requestBody.schema,
-            description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description,
+            ...node.requestBody.schema,
+            description: node.requestBody.description ?? node.requestBody.schema.description,
           },
-          name: resolver.resolveDataName(transformedNode),
-          keysToOmit: transformedNode.requestBody.keysToOmit,
+          name: resolver.resolveDataName(node),
+          keysToOmit: node.requestBody.keysToOmit,
         })
       : null
 
@@ -136,14 +126,13 @@ export const zodGenerator = defineGenerator<PluginZod>({
       </File>
     )
   },
-  Operations({ nodes, adapter, options, config, resolver, plugin }) {
+  operations(nodes, options) {
+    const { adapter, config, resolver, root } = this
     const { output, importPath, group, operations, paramsCasing } = options
 
     if (!operations) {
       return
     }
-
-    const root = path.resolve(config.root, config.output.path)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const meta = {
@@ -151,13 +140,11 @@ export const zodGenerator = defineGenerator<PluginZod>({
     } as const
 
     const transformedOperations = nodes.map((node) => {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-      const params = caseParams(transformedNode.parameters, paramsCasing)
+      const params = caseParams(node.parameters, paramsCasing)
 
       return {
-        node: transformedNode,
-        data: buildSchemaNames(transformedNode, { params, resolver }),
+        node,
+        data: buildSchemaNames(node, { params, resolver }),
       }
     })
 

package/src/generators/zodGeneratorLegacy.tsx

@@ -1,7 +1,6 @@
-import path from 'node:path'
-import { caseParams, createProperty, createSchema, transform } from '@kubb/ast'
+import { caseParams, createProperty, createSchema } from '@kubb/ast'
 import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
-import { defineGenerator, getMode } from '@kubb/core'
+import { defineGenerator } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Operations } from '../components/Operations.tsx'
 import { Zod } from '../components/Zod.tsx'
@@ -167,29 +166,27 @@ function buildLegacySchemaNames(node: OperationNode, params: Array<ParameterNode
 
 export const zodGeneratorLegacy = defineGenerator<PluginZod>({
   name: 'zod-legacy',
-  type: 'react',
-  Schema({ node, adapter, options, config, resolver, plugin }) {
+  schema(node, options) {
+    const { adapter, config, resolver, root } = this
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
 
-    if (!transformedNode.name) {
+    if (!node.name) {
       return
     }
 
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-    const imports = adapter.getImports(transformedNode, (schemaName) => ({
+    const imports = adapter.getImports(node, (schemaName) => ({
       name: resolver.resolveSchemaName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
-    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(transformedNode.name) : undefined
+    const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : undefined
 
     const meta = {
-      name: resolver.resolveSchemaName(transformedNode.name),
-      file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
+      name: resolver.resolveSchemaName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
     const schemaPrinter = mini
@@ -205,29 +202,23 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
         footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
       >
         <File.Import name={isZodImport ? 'z' : ['z']} path={importPath} isNameSpace={isZodImport} />
-        {mode === 'split' &&
-          imports.map((imp) => <File.Import key={[transformedNode.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
+        {mode === 'split' && imports.map((imp) => <File.Import key={[node.name, imp.path].join('-')} root={meta.file.path} path={imp.path} name={imp.name} />)}
 
-        <Zod name={meta.name} node={transformedNode} printer={schemaPrinter} inferTypeName={inferTypeName} />
+        <Zod name={meta.name} node={node} printer={schemaPrinter} inferTypeName={inferTypeName} />
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver, plugin }) {
+  operation(node, options) {
+    const { adapter, config, resolver, root } = this
     const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
-    const params = caseParams(transformedNode.parameters, paramsCasing)
+    const params = caseParams(node.parameters, paramsCasing)
 
     const meta = {
-      file: resolver.resolveFile(
-        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
-        { root, output, group },
-      ),
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
     } as const
 
     function renderSchemaEntry({ schema, name, keysToOmit }: { schema: SchemaNode | null; name: string; keysToOmit?: Array<string> }) {
@@ -257,8 +248,8 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
     const queryParams = params.filter((p) => p.in === 'query')
     const headerParams = params.filter((p) => p.in === 'header')
 
-    const responseSchemas = transformedNode.responses.map((res) => {
-      const responseName = resolver.resolveResponseStatusName(transformedNode, res.statusCode)
+    const responseSchemas = node.responses.map((res) => {
+      const responseName = resolver.resolveResponseStatusName(node, res.statusCode)
       return renderSchemaEntry({
         schema: {
           ...res.schema,
@@ -269,14 +260,14 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
       })
     })
 
-    const requestSchema = transformedNode.requestBody?.schema
+    const requestSchema = node.requestBody?.schema
       ? renderSchemaEntry({
           schema: {
-            ...transformedNode.requestBody.schema,
-            description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description,
+            ...node.requestBody.schema,
+            description: node.requestBody.description ?? node.requestBody.schema.description,
           },
-          name: resolver.resolveDataName(transformedNode),
-          keysToOmit: transformedNode.requestBody.keysToOmit,
+          name: resolver.resolveDataName(node),
+          keysToOmit: node.requestBody.keysToOmit,
         })
       : null
 
@@ -284,31 +275,31 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
       pathParams.length > 0
         ? renderSchemaEntry({
             schema: buildGroupedParamsSchema({ params: pathParams, optional: pathParams.every((p) => !p.required) }),
-            name: resolver.resolvePathParamsName(transformedNode, pathParams[0]!),
+            name: resolver.resolvePathParamsName(node, pathParams[0]!),
           })
         : null,
       queryParams.length > 0
         ? renderSchemaEntry({
             schema: buildGroupedParamsSchema({ params: queryParams, optional: queryParams.every((p) => !p.required) }),
-            name: resolver.resolveQueryParamsName(transformedNode, queryParams[0]!),
+            name: resolver.resolveQueryParamsName(node, queryParams[0]!),
           })
         : null,
       headerParams.length > 0
         ? renderSchemaEntry({
             schema: buildGroupedParamsSchema({ params: headerParams, optional: headerParams.every((p) => !p.required) }),
-            name: resolver.resolveHeaderParamsName(transformedNode, headerParams[0]!),
+            name: resolver.resolveHeaderParamsName(node, headerParams[0]!),
           })
         : null,
     ]
 
     const legacyResponsesSchema = renderSchemaEntry({
-      schema: buildLegacyResponsesSchemaNode(transformedNode, { resolver }),
-      name: resolver.resolveResponsesName(transformedNode),
+      schema: buildLegacyResponsesSchemaNode(node, { resolver }),
+      name: resolver.resolveResponsesName(node),
     })
 
     const legacyResponseSchema = renderSchemaEntry({
-      schema: buildLegacyResponseUnionSchemaNode(transformedNode, { resolver }),
-      name: resolver.resolveResponseName(transformedNode),
+      schema: buildLegacyResponseUnionSchemaNode(node, { resolver }),
+      name: resolver.resolveResponseName(node),
     })
 
     return (
@@ -328,14 +319,13 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
       </File>
     )
   },
-  Operations({ nodes, adapter, options, config, resolver, plugin }) {
+  operations(nodes, options) {
+    const { adapter, config, resolver, root } = this
     const { output, importPath, group, operations, paramsCasing } = options
 
     if (!operations) {
       return
     }
-
-    const root = path.resolve(config.root, config.output.path)
     const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath as 'zod' | 'zod/mini')
 
     const meta = {
@@ -343,13 +333,11 @@ export const zodGeneratorLegacy = defineGenerator<PluginZod>({
     } as const
 
     const transformedOperations = nodes.map((node) => {
-      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-      const params = caseParams(transformedNode.parameters, paramsCasing)
+      const params = caseParams(node.parameters, paramsCasing)
 
       return {
-        node: transformedNode,
-        data: buildLegacySchemaNames(transformedNode, params, resolver),
+        node,
+        data: buildLegacySchemaNames(node, params, resolver),
       }
     })
 

package/src/plugin.ts

@@ -1,8 +1,6 @@
-import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { walk } from '@kubb/ast'
-import type { OperationNode } from '@kubb/ast/types'
-import { createPlugin, type Group, getBarrelFiles, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from '@kubb/core'
+import { createPlugin, type Group, getPreset, mergeGenerators } from '@kubb/core'
+import { version } from '../package.json'
 import { presets } from './presets.ts'
 import type { PluginZod } from './types.ts'
 
@@ -59,11 +57,15 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     generators: userGenerators,
   })
 
+  const generators = preset.generators ?? []
+  const mergedGenerator = mergeGenerators(generators)
+
   let resolveNameWarning = false
   let resolvePathWarning = false
 
   return {
     name: pluginZodName,
+    version,
     get resolver() {
       return preset.resolver
     },
@@ -73,6 +75,9 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     get options() {
       return {
         output,
+        exclude,
+        include,
+        override,
         group: group
           ? ({
               ...group,
@@ -99,65 +104,34 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     },
     resolvePath(baseName, pathMode, options) {
       if (!resolvePathWarning) {
-        this.events.emit('warn', 'Do not use resolvePath for pluginZod, use resolverZod.resolvePath instead')
+        this.warn('Do not use resolvePath for pluginZod, use resolverZod.resolvePath instead')
         resolvePathWarning = true
       }
 
       return this.plugin.resolver.resolvePath(
         { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
-        { root: path.resolve(this.config.root, this.config.output.path), output, group: this.plugin.options.group },
+        { root: this.root, output, group: this.plugin.options.group },
       )
     },
     resolveName(name, type) {
       if (!resolveNameWarning) {
-        this.events.emit('warn', 'Do not use resolveName for pluginZod, use resolverZod.default instead')
+        this.warn('Do not use resolveName for pluginZod, use resolverZod.default instead')
         resolveNameWarning = true
       }
 
       return this.plugin.resolver.default(name, type)
     },
-    async install() {
-      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this
-
-      const root = path.resolve(config.root, config.output.path)
-
-      if (!adapter) {
-        throw new Error(`[${pluginZodName}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`)
-      }
-
-      await openInStudio({ ast: true })
-
-      const collectedOperations: Array<OperationNode> = []
-      const generatorContext = { generators: preset.generators, plugin, resolver, exclude, include, override, fabric, adapter, config, driver }
-
-      await walk(rootNode, {
-        depth: 'shallow',
-        async schema(schemaNode) {
-          await runGeneratorSchema(schemaNode, generatorContext)
-        },
-        async operation(operationNode) {
-          const baseOptions = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
-
-          if (baseOptions !== null) {
-            collectedOperations.push(operationNode)
-          }
-
-          await runGeneratorOperation(operationNode, generatorContext)
-        },
-      })
-
-      await runGeneratorOperations(collectedOperations, generatorContext)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+    async schema(node, options) {
+      return mergedGenerator.schema?.call(this, node, options)
+    },
+    async operation(node, options) {
+      return mergedGenerator.operation?.call(this, node, options)
+    },
+    async operations(nodes, options) {
+      return mergedGenerator.operations?.call(this, nodes, options)
+    },
+    async buildStart() {
+      await this.openInStudio({ ast: true })
     },
   }
 })

package/src/types.ts

@@ -192,7 +192,7 @@ export type Options = {
    */
   resolver?: Partial<ResolverZod> & ThisType<ResolverZod>
   /**
-   * Override individual printer node handlers to customise rendering of specific schema types.
+   * Override individual printer node handlers to customize rendering of specific schema types.
    *
    * Each key is a `SchemaType` (e.g. `'date'`, `'string'`). The function replaces the
    * built-in handler for that type. Use `this.transform` to recurse into nested schema nodes.
@@ -223,6 +223,9 @@ export type Options = {
 
 type ResolvedOptions = {
   output: Output
+  exclude: Array<Exclude>
+  include: Array<Include> | undefined
+  override: Array<Override<ResolvedOptions>>
   group: Group | undefined
   dateType: NonNullable<Options['dateType']>
   typed: NonNullable<Options['typed']>
@@ -238,3 +241,11 @@ type ResolvedOptions = {
 }
 
 export type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions, ResolverZod>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-zod': PluginZod
+    }
+  }
+}