@kubb/plugin-client 5.0.0-alpha.9 → 5.0.0-beta.4

package/src/generators/classClientGenerator.tsx

@@ -1,133 +1,135 @@
 import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
-import { usePluginDriver } from '@kubb/core/hooks'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import type { Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+import type { ast } from '@kubb/core'
+import { defineGenerator } from '@kubb/core'
+import type { ResolverTs } from '@kubb/plugin-ts'
 import { pluginTsName } from '@kubb/plugin-ts'
+import type { ResolverZod } from '@kubb/plugin-zod'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/react-fabric'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { ClassClient } from '../components/ClassClient'
 import { WrapperClient } from '../components/WrapperClient'
 import type { PluginClient } from '../types'
 
 type OperationData = {
-  operation: Operation
+  node: ast.OperationNode
   name: string
-  typeSchemas: OperationSchemas
-  zodSchemas: OperationSchemas | undefined
-  typeFile: KubbFile.File
-  zodFile: KubbFile.File
+  tsResolver: ResolverTs
+  zodResolver: ResolverZod | undefined
+  typeFile: ast.FileNode
+  zodFile: ast.FileNode | undefined
 }
 
 type Controller = {
   name: string
-  file: KubbFile.File
+  file: ast.FileNode
   operations: Array<OperationData>
 }
 
-export const classClientGenerator = createReactGenerator<PluginClient>({
-  name: 'classClient',
-  Operations({ operations, generator, plugin, config }) {
-    const { options, name: pluginName } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getName, getFile, getGroup, getSchemas } = useOperationManager(generator)
+function resolveTypeImportNames(node: ast.OperationNode, tsResolver: ResolverTs): Array<string> {
+  const names: Array<string | undefined> = [
+    node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined,
+    tsResolver.resolveResponseName(node),
+    ...node.parameters.filter((p) => p.in === 'path').map((p) => tsResolver.resolvePathParamsName(node, p)),
+    ...node.parameters.filter((p) => p.in === 'query').map((p) => tsResolver.resolveQueryParamsName(node, p)),
+    ...node.parameters.filter((p) => p.in === 'header').map((p) => tsResolver.resolveHeaderParamsName(node, p)),
+    ...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode)),
+  ]
+  return names.filter((n): n is string => Boolean(n))
+}
 
-    function buildOperationData(operation: Operation): OperationData {
-      const type = {
-        file: getFile(operation, { pluginName: pluginTsName }),
-        schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-      }
+function resolveZodImportNames(node: ast.OperationNode, zodResolver: ResolverZod): Array<string> {
+  const names: Array<string | undefined> = [
+    zodResolver.resolveResponseName?.(node),
+    node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined,
+  ]
+  return names.filter((n): n is string => Boolean(n))
+}
 
-      const zod = {
-        file: getFile(operation, { pluginName: pluginZodName }),
-        schemas: getSchemas(operation, { pluginName: pluginZodName, type: 'function' }),
-      }
+export const classClientGenerator = defineGenerator<PluginClient>({
+  name: 'classClient',
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { adapter, config, driver, resolver, root } = ctx
+    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, sdk } = ctx.options
+    const baseURL = ctx.options.baseURL ?? adapter.inputNode?.meta?.baseURL
+
+    const pluginTs = driver.getPlugin(pluginTsName)
+    if (!pluginTs) return null
+
+    const tsResolver = driver.getResolver(pluginTsName)
+    const tsPluginOptions = pluginTs.options
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
+    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
+
+    function buildOperationData(node: ast.OperationNode): OperationData {
+      const typeFile = tsResolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        { root, output: tsPluginOptions?.output ?? output, group: tsPluginOptions?.group },
+      )
+      const zodFile =
+        zodResolver && pluginZod?.options
+          ? zodResolver.resolveFile(
+              { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+              { root, output: pluginZod.options?.output ?? output, group: pluginZod.options?.group },
+            )
+          : undefined
 
       return {
-        operation,
-        name: getName(operation, { type: 'function' }),
-        typeSchemas: type.schemas,
-        zodSchemas: zod.schemas,
-        typeFile: type.file,
-        zodFile: zod.file,
+        node: node,
+        name: resolver.resolveName(node.operationId),
+        tsResolver,
+        zodResolver,
+        typeFile,
+        zodFile,
       }
     }
 
-    // Group operations by tag
-    const controllers = operations.reduce(
-      (acc, operation) => {
-        const group = getGroup(operation)
-        const groupName = group?.tag ? (options.group?.name?.({ group: camelCase(group.tag) }) ?? pascalCase(group.tag)) : 'Client'
-
-        if (!group?.tag && !options.group) {
-          // If no grouping, put all operations in a single class
-          const name = 'ApiClient'
-          const file = driver.getFile({
-            name,
-            extname: '.ts',
-            pluginName,
-          })
-
-          const operationData = buildOperationData(operation)
-          const previousFile = acc.find((item) => item.file.path === file.path)
+    const controllers = nodes.reduce((acc, operationNode) => {
+      const tag = operationNode.tags[0]
+      const groupName = tag ? (group?.name?.({ group: camelCase(tag) }) ?? pascalCase(tag)) : 'Client'
 
-          if (previousFile) {
-            previousFile.operations.push(operationData)
-          } else {
-            acc.push({ name, file, operations: [operationData] })
-          }
-        } else if (group?.tag) {
-          // Group by tag
-          const name = groupName
-          const file = driver.getFile({
-            name,
-            extname: '.ts',
-            pluginName,
-            options: { group },
-          })
+      if (!tag && !group) {
+        const name = 'ApiClient'
+        const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group })
+        const operationData = buildOperationData(operationNode)
+        const previous = acc.find((item) => item.file.path === file.path)
 
-          const operationData = buildOperationData(operation)
-          const previousFile = acc.find((item) => item.file.path === file.path)
-
-          if (previousFile) {
-            previousFile.operations.push(operationData)
-          } else {
-            acc.push({ name, file, operations: [operationData] })
-          }
+        if (previous) {
+          previous.operations.push(operationData)
+        } else {
+          acc.push({ name, file, operations: [operationData] })
+        }
+      } else if (tag) {
+        const name = groupName
+        const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group })
+        const operationData = buildOperationData(operationNode)
+        const previous = acc.find((item) => item.file.path === file.path)
+
+        if (previous) {
+          previous.operations.push(operationData)
+        } else {
+          acc.push({ name, file, operations: [operationData] })
         }
+      }
 
-        return acc
-      },
-      [] as Array<Controller>,
-    )
+      return acc
+    }, [] as Array<Controller>)
 
     function collectTypeImports(ops: Array<OperationData>) {
       const typeImportsByFile = new Map<string, Set<string>>()
-      const typeFilesByPath = new Map<string, KubbFile.File>()
+      const typeFilesByPath = new Map<string, ast.FileNode>()
 
       ops.forEach((op) => {
-        const { typeSchemas, typeFile } = op
-
-        if (!typeImportsByFile.has(typeFile.path)) {
-          typeImportsByFile.set(typeFile.path, new Set())
+        const names = resolveTypeImportNames(op.node, tsResolver)
+        if (!typeImportsByFile.has(op.typeFile.path)) {
+          typeImportsByFile.set(op.typeFile.path, new Set())
         }
-        const typeImports = typeImportsByFile.get(typeFile.path)!
-
-        if (typeSchemas.request?.name) typeImports.add(typeSchemas.request.name)
-        if (typeSchemas.response?.name) typeImports.add(typeSchemas.response.name)
-        if (typeSchemas.pathParams?.name) typeImports.add(typeSchemas.pathParams.name)
-        if (typeSchemas.queryParams?.name) typeImports.add(typeSchemas.queryParams.name)
-        if (typeSchemas.headerParams?.name) typeImports.add(typeSchemas.headerParams.name)
-        typeSchemas.statusCodes?.forEach((item) => {
-          if (item?.name) typeImports.add(item.name)
+        const imports = typeImportsByFile.get(op.typeFile.path)!
+        names.forEach((n) => {
+          imports.add(n)
         })
-        typeFilesByPath.set(typeFile.path, typeFile)
+        typeFilesByPath.set(op.typeFile.path, op.typeFile)
       })
 
       return { typeImportsByFile, typeFilesByPath }
@@ -135,19 +137,19 @@ export const classClientGenerator = createReactGenerator<PluginClient>({
 
     function collectZodImports(ops: Array<OperationData>) {
       const zodImportsByFile = new Map<string, Set<string>>()
-      const zodFilesByPath = new Map<string, KubbFile.File>()
+      const zodFilesByPath = new Map<string, ast.FileNode>()
 
       ops.forEach((op) => {
-        const { zodSchemas, zodFile } = op
-
-        if (!zodImportsByFile.has(zodFile.path)) {
-          zodImportsByFile.set(zodFile.path, new Set())
+        if (!op.zodFile || !zodResolver) return
+        const names = resolveZodImportNames(op.node, zodResolver)
+        if (!zodImportsByFile.has(op.zodFile.path)) {
+          zodImportsByFile.set(op.zodFile.path, new Set())
         }
-        const zodImports = zodImportsByFile.get(zodFile.path)!
-
-        if (zodSchemas?.response?.name) zodImports.add(zodSchemas.response.name)
-        if (zodSchemas?.request?.name) zodImports.add(zodSchemas.request.name)
-        zodFilesByPath.set(zodFile.path, zodFile)
+        const imports = zodImportsByFile.get(op.zodFile.path)!
+        names.forEach((n) => {
+          imports.add(n)
+        })
+        zodFilesByPath.set(op.zodFile.path, op.zodFile)
       })
 
       return { zodImportsByFile, zodFilesByPath }
@@ -156,10 +158,8 @@ export const classClientGenerator = createReactGenerator<PluginClient>({
     const files = controllers.map(({ name, file, operations: ops }) => {
       const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
       const { zodImportsByFile, zodFilesByPath } =
-        options.parser === 'zod'
-          ? collectZodImports(ops)
-          : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, KubbFile.File>() }
-      const hasFormData = ops.some((op) => op.operation.getContentType() === 'multipart/form-data')
+        parser === 'zod' ? collectZodImports(ops) : { zodImportsByFile: new Map<string, Set<string>>(), zodFilesByPath: new Map<string, ast.FileNode>() }
+      const hasFormData = ops.some((op) => op.node.requestBody?.content?.[0]?.contentType === 'multipart/form-data')
 
       return (
         <File
@@ -167,106 +167,83 @@ export const classClientGenerator = createReactGenerator<PluginClient>({
           baseName={file.baseName}
           path={file.path}
           meta={file.meta}
-          banner={getBanner({ oas, output: options.output, config: driver.config })}
-          footer={getFooter({ oas, output: options.output })}
+          banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+          footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
         >
-          {options.importPath ? (
+          {importPath ? (
             <>
-              <File.Import name={'fetch'} path={options.importPath} />
-              <File.Import name={['mergeConfig']} path={options.importPath} />
-              <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.importPath} isTypeOnly />
+              <File.Import name={'fetch'} path={importPath} />
+              <File.Import name={['mergeConfig']} path={importPath} />
+              <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
             </>
           ) : (
             <>
-              <File.Import name={['fetch']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-              <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-              <File.Import
-                name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-                root={file.path}
-                path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-                isTypeOnly
-              />
+              <File.Import name={['fetch']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} />
+              <File.Import name={['mergeConfig']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} />
+              <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} root={file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
             </>
           )}
 
-          {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />}
+          {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(root, '.kubb/config.ts')} />}
 
-          {Array.from(typeImportsByFile.entries()).map(([filePath, imports]) => {
+          {Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
             const typeFile = typeFilesByPath.get(filePath)
-            if (!typeFile) {
-              return null
-            }
-            const importNames = Array.from(imports).filter(Boolean)
-            if (importNames.length === 0) {
-              return null
-            }
+            if (!typeFile) return null
+            const importNames = Array.from(importSet).filter(Boolean)
+            if (importNames.length === 0) return null
             return <File.Import key={filePath} name={importNames} root={file.path} path={typeFile.path} isTypeOnly />
           })}
 
-          {options.parser === 'zod' &&
-            Array.from(zodImportsByFile.entries()).map(([filePath, imports]) => {
+          {parser === 'zod' &&
+            Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
               const zodFile = zodFilesByPath.get(filePath)
-              if (!zodFile) {
-                return null
-              }
-              const importNames = Array.from(imports).filter(Boolean)
-              if (importNames.length === 0) {
-                return null
-              }
-
+              if (!zodFile) return null
+              const importNames = Array.from(importSet).filter(Boolean)
+              if (importNames.length === 0) return null
               return <File.Import key={filePath} name={importNames} root={file.path} path={zodFile.path} />
             })}
 
           <ClassClient
             name={name}
             operations={ops}
-            baseURL={options.baseURL}
-            dataReturnType={options.dataReturnType}
-            pathParamsType={options.pathParamsType}
-            paramsCasing={options.paramsCasing}
-            paramsType={options.paramsType}
-            parser={options.parser}
+            baseURL={baseURL}
+            dataReturnType={dataReturnType}
+            pathParamsType={pathParamsType}
+            paramsCasing={paramsCasing}
+            paramsType={paramsType}
+            parser={parser}
           />
         </File>
       )
     })
 
-    if (options.wrapper) {
-      const wrapperFile = driver.getFile({
-        name: options.wrapper.className,
-        extname: '.ts',
-        pluginName,
-      })
+    if (sdk) {
+      const sdkFile = resolver.resolveFile({ name: sdk.className, extname: '.ts' }, { root, output, group })
 
       files.push(
         <File
-          key={wrapperFile.path}
-          baseName={wrapperFile.baseName}
-          path={wrapperFile.path}
-          meta={wrapperFile.meta}
-          banner={getBanner({ oas, output: options.output, config: driver.config })}
-          footer={getFooter({ oas, output: options.output })}
+          key={sdkFile.path}
+          baseName={sdkFile.baseName}
+          path={sdkFile.path}
+          meta={sdkFile.meta}
+          banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+          footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
         >
-          {options.importPath ? (
-            <File.Import name={['Client', 'RequestConfig']} path={options.importPath} isTypeOnly />
+          {importPath ? (
+            <File.Import name={['Client', 'RequestConfig']} path={importPath} isTypeOnly />
           ) : (
-            <File.Import
-              name={['Client', 'RequestConfig']}
-              root={wrapperFile.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
+            <File.Import name={['Client', 'RequestConfig']} root={sdkFile.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
           )}
 
           {controllers.map(({ name, file }) => (
-            <File.Import key={name} name={[name]} root={wrapperFile.path} path={file.path} />
+            <File.Import key={name} name={[name]} root={sdkFile.path} path={file.path} />
           ))}
 
-          <WrapperClient name={options.wrapper.className} classNames={controllers.map(({ name }) => name)} />
+          <WrapperClient name={sdk.className} classNames={controllers.map(({ name }) => name)} />
         </File>,
       )
     }
 
-    return files
+    return <>{files}</>
   },
 })

package/src/generators/clientGenerator.tsx

@@ -1,123 +1,136 @@
 import path from 'node:path'
-import { usePluginDriver } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
+import { ast, defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/react-fabric'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Client } from '../components/Client'
 import { Url } from '../components/Url.tsx'
 import type { PluginClient } from '../types'
 
-export const clientGenerator = createReactGenerator<PluginClient>({
+export const clientGenerator = defineGenerator<PluginClient>({
   name: 'client',
-  Operation({ config, plugin, operation, generator }) {
-    const driver = usePluginDriver()
-    const {
-      options,
-      options: { output, urlType },
-    } = plugin
-
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
-
-    const client = {
-      name: getName(operation, { type: 'function' }),
-      file: getFile(operation),
-    }
+  renderer: jsxRenderer,
+  operation(node, ctx) {
+    const { adapter, config, driver, resolver, root } = ctx
+    const { output, urlType, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, group } = ctx.options
+    const baseURL = ctx.options.baseURL ?? adapter.inputNode?.meta?.baseURL
 
-    const url = {
-      name: getName(operation, { type: 'function', suffix: 'url', prefix: 'get' }),
-      file: getFile(operation),
-    }
+    const pluginTs = driver.getPlugin(pluginTsName)
 
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
+    if (!pluginTs) {
+      return null
     }
 
-    const zod = {
-      file: getFile(operation, { pluginName: pluginZodName }),
-      schemas: getSchemas(operation, { pluginName: pluginZodName, type: 'function' }),
-    }
+    const tsResolver = driver.getResolver(pluginTsName)
+
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
+    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
+
+    const casedParams = ast.caseParams(node.parameters, paramsCasing)
+    const pathParams = casedParams.filter((p) => p.in === 'path')
+    const queryParams = casedParams.filter((p) => p.in === 'query')
+    const headerParams = casedParams.filter((p) => p.in === 'header')
 
-    const isFormData = operation.getContentType() === 'multipart/form-data'
+    const importedTypeNames = [
+      ...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
+      ...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
+      ...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
+      node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined,
+      tsResolver.resolveResponseName(node),
+      ...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode)),
+    ].filter(Boolean)
+
+    const importedZodNames =
+      zodResolver && parser === 'zod'
+        ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined].filter(Boolean)
+        : []
+
+    const meta = {
+      name: resolver.resolveName(node.operationId),
+      urlName: `get${resolver.resolveName(node.operationId).charAt(0).toUpperCase()}${resolver.resolveName(node.operationId).slice(1)}Url`,
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
+      fileTs: tsResolver.resolveFile(
+        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+        {
+          root,
+          output: pluginTs.options?.output ?? output,
+          group: pluginTs.options?.group,
+        },
+      ),
+      fileZod:
+        zodResolver && pluginZod?.options
+          ? zodResolver.resolveFile(
+              { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
+              {
+                root,
+                output: pluginZod.options.output ?? output,
+                group: pluginZod.options?.group,
+              },
+            )
+          : undefined,
+    } as const
+
+    const isFormData = node.requestBody?.content?.[0]?.contentType === 'multipart/form-data'
 
     return (
       <File
-        baseName={client.file.baseName}
-        path={client.file.path}
-        meta={client.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 })}
       >
-        {options.importPath ? (
+        {importPath ? (
           <>
-            <File.Import name={'fetch'} path={options.importPath} />
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.importPath} isTypeOnly />
+            <File.Import name={'fetch'} path={importPath} />
+            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
           </>
         ) : (
           <>
-            <File.Import name={['fetch']} root={client.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
+            <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={client.file.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
+              root={meta.file.path}
+              path={path.resolve(root, '.kubb/client.ts')}
               isTypeOnly
             />
           </>
         )}
 
-        {isFormData && type.schemas.request?.name && (
-          <File.Import name={['buildFormData']} root={client.file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />
+        {isFormData && node.requestBody?.content?.[0]?.schema && (
+          <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />
         )}
 
-        {options.parser === 'zod' && (
-          <File.Import
-            name={[zod.schemas.response.name, zod.schemas.request?.name].filter((x): x is string => Boolean(x))}
-            root={client.file.path}
-            path={zod.file.path}
-          />
+        {meta.fileZod && importedZodNames.length > 0 && <File.Import name={importedZodNames as string[]} root={meta.file.path} path={meta.fileZod.path} />}
+
+        {meta.fileTs && importedTypeNames.length > 0 && (
+          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
         )}
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter((x): x is string => Boolean(x))}
-          root={client.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
 
         <Url
-          name={url.name}
-          baseURL={options.baseURL}
-          pathParamsType={options.pathParamsType}
-          paramsCasing={options.paramsCasing}
-          paramsType={options.paramsType}
-          typeSchemas={type.schemas}
-          operation={operation}
+          name={meta.urlName}
+          baseURL={baseURL}
+          pathParamsType={pathParamsType}
+          paramsCasing={paramsCasing}
+          paramsType={paramsType}
+          node={node}
+          tsResolver={tsResolver}
           isIndexable={urlType === 'export'}
           isExportable={urlType === 'export'}
         />
 
         <Client
-          name={client.name}
-          urlName={url.name}
-          baseURL={options.baseURL}
-          dataReturnType={options.dataReturnType}
-          pathParamsType={options.pathParamsType}
-          paramsCasing={options.paramsCasing}
-          paramsType={options.paramsType}
-          typeSchemas={type.schemas}
-          operation={operation}
-          parser={options.parser}
-          zodSchemas={zod.schemas}
+          name={meta.name}
+          urlName={meta.urlName}
+          baseURL={baseURL}
+          dataReturnType={dataReturnType}
+          pathParamsType={pathParamsType}
+          paramsCasing={paramsCasing}
+          paramsType={paramsType}
+          node={node}
+          tsResolver={tsResolver}
+          zodResolver={zodResolver}
+          parser={parser}
         />
       </File>
     )