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

package/src/generators/groupedClientGenerator.tsx

@@ -1,47 +1,41 @@
 import { camelCase } from '@internals/utils'
-import { usePluginDriver } from '@kubb/core/hooks'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { File, Function } from '@kubb/react-fabric'
+import type { ast } from '@kubb/core'
+import { defineGenerator } from '@kubb/core'
+import { File, Function, jsxRenderer } from '@kubb/renderer-jsx'
 import type { PluginClient } from '../types'
 
-export const groupedClientGenerator = createReactGenerator<PluginClient>({
+export const groupedClientGenerator = defineGenerator<PluginClient>({
   name: 'groupedClient',
-  Operations({ operations, generator, plugin }) {
-    const { options, name: pluginName } = plugin
-    const driver = usePluginDriver()
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { config, resolver, adapter, root } = ctx
+    const { output, group } = ctx.options
 
-    const oas = useOas()
-    const { getName, getFile, getGroup } = useOperationManager(generator)
+    const controllers = nodes.reduce(
+      (acc, operationNode) => {
+        if (group?.type === 'tag') {
+          const tag = operationNode.tags[0]
+          const name = tag ? group?.name?.({ group: camelCase(tag) }) : undefined
 
-    const controllers = operations.reduce(
-      (acc, operation) => {
-        if (options.group?.type === 'tag') {
-          const group = getGroup(operation)
-          const name = group?.tag ? options.group?.name?.({ group: camelCase(group.tag) }) : undefined
-
-          if (!group?.tag || !name) {
+          if (!tag || !name) {
             return acc
           }
 
-          const file = driver.getFile({
-            name,
-            extname: '.ts',
-            pluginName,
-            options: { group },
-          })
+          const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group })
+          const clientFile = resolver.resolveFile(
+            { name: operationNode.operationId, extname: '.ts', tag: operationNode.tags[0] ?? 'default', path: operationNode.path },
+            { root, output, group },
+          )
 
           const client = {
-            name: getName(operation, { type: 'function' }),
-            file: getFile(operation),
+            name: resolver.resolveName(operationNode.operationId),
+            file: clientFile,
           }
 
-          const previousFile = acc.find((item) => item.file.path === file.path)
+          const previous = acc.find((item) => item.file.path === file.path)
 
-          if (previousFile) {
-            previousFile.clients.push(client)
+          if (previous) {
+            previous.clients.push(client)
           } else {
             acc.push({ name, file, clients: [client] })
           }
@@ -49,30 +43,34 @@ export const groupedClientGenerator = createReactGenerator<PluginClient>({
 
         return acc
       },
-      [] as Array<{ name: string; file: KubbFile.File; clients: Array<{ name: string; file: KubbFile.File }> }>,
+      [] as Array<{ name: string; file: ast.FileNode; clients: Array<{ name: string; file: ast.FileNode }> }>,
     )
 
-    return controllers.map(({ name, file, clients }) => {
-      return (
-        <File
-          key={file.path}
-          baseName={file.baseName}
-          path={file.path}
-          meta={file.meta}
-          banner={getBanner({ oas, output: options.output, config: driver.config })}
-          footer={getFooter({ oas, output: options.output })}
-        >
-          {clients.map((client) => (
-            <File.Import key={client.name} name={[client.name]} root={file.path} path={client.file.path} />
-          ))}
+    return (
+      <>
+        {controllers.map(({ name, file, clients }) => {
+          return (
+            <File
+              key={file.path}
+              baseName={file.baseName}
+              path={file.path}
+              meta={file.meta}
+              banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+              footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+            >
+              {clients.map((client) => (
+                <File.Import key={client.name} name={[client.name]} root={file.path} path={client.file.path} />
+              ))}
 
-          <File.Source name={name} isExportable isIndexable>
-            <Function export name={name}>
-              {`return { ${clients.map((client) => client.name).join(', ')} }`}
-            </Function>
-          </File.Source>
-        </File>
-      )
-    })
+              <File.Source name={name} isExportable isIndexable>
+                <Function export name={name}>
+                  {`return { ${clients.map((client) => client.name).join(', ')} }`}
+                </Function>
+              </File.Source>
+            </File>
+          )
+        })}
+      </>
+    )
   },
 })

package/src/generators/operationsGenerator.tsx

@@ -1,34 +1,27 @@
-import { usePluginDriver } from '@kubb/core/hooks'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { File } from '@kubb/react-fabric'
+import { defineGenerator } from '@kubb/core'
+import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { Operations } from '../components/Operations'
 import type { PluginClient } from '../types'
 
-export const operationsGenerator = createReactGenerator<PluginClient>({
+export const operationsGenerator = defineGenerator<PluginClient>({
   name: 'client',
-  Operations({ operations, plugin }) {
-    const {
-      name: pluginName,
-      options: { output },
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { config, resolver, adapter, root } = ctx
+    const { output, group } = ctx.options
 
     const name = 'operations'
-    const file = driver.getFile({ name, extname: '.ts', pluginName })
+    const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group })
 
     return (
       <File
         baseName={file.baseName}
         path={file.path}
         meta={file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
+        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
       >
-        <Operations name={name} operations={operations} />
+        <Operations name={name} nodes={nodes} />
       </File>
     )
   },

package/src/generators/staticClassClientGenerator.tsx

@@ -1,132 +1,127 @@
 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 { resolveOperationTypeNames } from '@internals/shared'
+import { camelCase } from '@internals/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 { StaticClassClient } from '../components/StaticClassClient'
 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 staticClassClientGenerator = createReactGenerator<PluginClient>({
-  name: 'staticClassClient',
-  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> {
+  return resolveOperationTypeNames(node, tsResolver, { order: 'body-response-first' })
+}
 
-    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 staticClassClientGenerator = defineGenerator<PluginClient>({
+  name: 'staticClassClient',
+  renderer: jsxRenderer,
+  operations(nodes, ctx) {
+    const { adapter, config, driver, resolver, root } = ctx
+    const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = 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)
-
-          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 },
-          })
-
-          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] })
-          }
+    const controllers = nodes.reduce((acc, operationNode) => {
+      const tag = operationNode.tags[0]
+      const groupName = tag ? (group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag)) : resolver.resolveGroupName('Client')
+
+      if (!tag && !group) {
+        const name = resolver.resolveClassName('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)
+
+        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 }
@@ -134,100 +129,93 @@ export const staticClassClientGenerator = 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 }
     }
 
-    return 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')
-
-      return (
-        <File
-          key={file.path}
-          baseName={file.baseName}
-          path={file.path}
-          meta={file.meta}
-          banner={getBanner({ oas, output: options.output, config: driver.config })}
-          footer={getFooter({ oas, output: options.output })}
-        >
-          {options.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']} 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
+    return (
+      <>
+        {controllers.map(({ name, file, operations: ops }) => {
+          const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops)
+          const { zodImportsByFile, zodFilesByPath } =
+            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?.some((e) => e.contentType === 'multipart/form-data') ?? false)
+
+          return (
+            <File
+              key={file.path}
+              baseName={file.baseName}
+              path={file.path}
+              meta={file.meta}
+              banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
+              footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+            >
+              {importPath ? (
+                <>
+                  <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(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(root, '.kubb/config.ts')} />}
+
+              {Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
+                const typeFile = typeFilesByPath.get(filePath)
+                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 />
+              })}
+
+              {parser === 'zod' &&
+                Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
+                  const zodFile = zodFilesByPath.get(filePath)
+                  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} />
+                })}
+
+              <StaticClassClient
+                name={name}
+                operations={ops}
+                baseURL={baseURL}
+                dataReturnType={dataReturnType}
+                pathParamsType={pathParamsType}
+                paramsCasing={paramsCasing}
+                paramsType={paramsType}
+                parser={parser}
               />
-            </>
-          )}
-
-          {hasFormData && <File.Import name={['buildFormData']} root={file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />}
-
-          {Array.from(typeImportsByFile.entries()).map(([filePath, imports]) => {
-            const typeFile = typeFilesByPath.get(filePath)
-            if (!typeFile) {
-              return null
-            }
-            const importNames = Array.from(imports).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]) => {
-              const zodFile = zodFilesByPath.get(filePath)
-              if (!zodFile) {
-                return null
-              }
-              const importNames = Array.from(imports).filter(Boolean)
-              if (importNames.length === 0) {
-                return null
-              }
-
-              return <File.Import key={filePath} name={importNames} root={file.path} path={zodFile.path} />
-            })}
-
-          <StaticClassClient
-            name={name}
-            operations={ops}
-            baseURL={options.baseURL}
-            dataReturnType={options.dataReturnType}
-            pathParamsType={options.pathParamsType}
-            paramsCasing={options.paramsCasing}
-            paramsType={options.paramsType}
-            parser={options.parser}
-          />
-        </File>
-      )
-    })
+            </File>
+          )
+        })}
+      </>
+    )
   },
 })

package/src/index.ts

@@ -1,2 +1,9 @@
-export { pluginClient, pluginClientName } from './plugin.ts'
-export type { ClientImportPath, PluginClient } from './types.ts'
+export { Client } from './components/Client.tsx'
+export { classClientGenerator } from './generators/classClientGenerator.tsx'
+export { clientGenerator } from './generators/clientGenerator.tsx'
+export { groupedClientGenerator } from './generators/groupedClientGenerator.tsx'
+export { operationsGenerator } from './generators/operationsGenerator.tsx'
+export { staticClassClientGenerator } from './generators/staticClassClientGenerator.tsx'
+export { default, pluginClient, pluginClientName } from './plugin.ts'
+export { resolverClient } from './resolvers/resolverClient.ts'
+export type { ClientImportPath, PluginClient, ResolverClient } from './types.ts'