@kubb/plugin-client 5.0.0-beta.4 → 5.0.0-beta.42

package/src/components/StaticClassClient.tsx

@@ -1,19 +1,20 @@
+import { buildOperationComments, getContentTypeInfo, getOperationParameters } from '@internals/shared'
 import { buildJSDoc, URLPath } from '@internals/utils'
-import type { ast } from '@kubb/core'
+import { ast } from '@kubb/core'
 import type { ResolverTs } from '@kubb/plugin-ts'
 import { functionPrinter } from '@kubb/plugin-ts'
 import type { ResolverZod } from '@kubb/plugin-zod'
 import { File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginClient } from '../types.ts'
-import { buildClassClientParams, buildFormDataLine, buildGenerics, buildHeaders, buildRequestDataLine, buildReturnStatement, getComments } from '../utils.ts'
-import { Client } from './Client.tsx'
+import { buildClassClientParams, buildFormDataLine, buildGenerics, buildHeaders, buildRequestDataLine, buildReturnStatement } from '../utils.ts'
+import { buildClientParamsNode } from './Client.tsx'
 
 type OperationData = {
   node: ast.OperationNode
   name: string
   tsResolver: ResolverTs
-  zodResolver?: ResolverZod
+  zodResolver?: ResolverZod | null
 }
 
 type Props = {
@@ -21,7 +22,7 @@ type Props = {
   isExportable?: boolean
   isIndexable?: boolean
   operations: Array<OperationData>
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
@@ -34,8 +35,8 @@ type GenerateMethodProps = {
   node: ast.OperationNode
   name: string
   tsResolver: ResolverTs
-  zodResolver?: ResolverZod
-  baseURL: string | undefined
+  zodResolver?: ResolverZod | null
+  baseURL: string | null | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
   paramsType: PluginClient['resolvedOptions']['paramsType']
@@ -57,26 +58,25 @@ function generateMethod({
   paramsCasing,
   pathParamsType,
 }: GenerateMethodProps): string {
+  if (!ast.isHttpOperationNode(node)) return ''
   const path = new URLPath(node.path, { casing: paramsCasing })
-  const contentType = node.requestBody?.content?.[0]?.contentType ?? 'application/json'
-  const isFormData = contentType === 'multipart/form-data'
-  const headerParamsName =
-    node.parameters.filter((p) => p.in === 'header').length > 0
-      ? tsResolver.resolveHeaderParamsName(node, node.parameters.filter((p) => p.in === 'header')[0]!)
-      : undefined
-  const headers = buildHeaders(contentType, !!headerParamsName)
+  const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node)
+  const isFormData = !isMultipleContentTypes && contentType === 'multipart/form-data'
+  const { header: headerParams } = getOperationParameters(node)
+  const headerParamsName = headerParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, headerParams[0]!) : null
+  const headers = isMultipleContentTypes ? (headerParamsName ? ['...headers'] : []) : buildHeaders(contentType, !!headerParamsName)
   const generics = buildGenerics(node, tsResolver)
-  const paramsNode = Client.getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable: true })
+  const paramsNode = buildClientParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable: true })
   const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const clientParams = buildClassClientParams({ node, path, baseURL, tsResolver, isFormData, headers })
-  const jsdoc = buildJSDoc(getComments(node))
+  const clientParams = buildClassClientParams({ node, path, baseURL, tsResolver, isFormData, isMultipleContentTypes, hasFormData, headers })
+  const jsdoc = buildJSDoc(buildOperationComments(node, { link: 'urlPath', linkPosition: 'beforeDeprecated', splitLines: true }))
 
   const requestDataLine = buildRequestDataLine({ parser, node, zodResolver })
-  const formDataLine = buildFormDataLine(isFormData, !!node.requestBody?.content?.[0]?.schema)
+  const formDataLine = buildFormDataLine(isFormData || (isMultipleContentTypes && hasFormData), !!node.requestBody?.content?.[0]?.schema)
   const returnStatement = buildReturnStatement({ dataReturnType, parser, node, zodResolver })
 
   const methodBody = [
-    'const { client: request = fetch, ...requestConfig } = mergeConfig(this.#config, config)',
+    `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ''}...requestConfig } = mergeConfig(this.#config, config)`,
     '',
     requestDataLine,
     formDataLine,
@@ -127,4 +127,3 @@ export function StaticClassClient({
     </File.Source>
   )
 }
-StaticClassClient.getParams = Client.getParams

package/src/components/Url.tsx

@@ -1,3 +1,4 @@
+import { buildParamsMapping, getOperationParameters } from '@internals/shared'
 import { isValidVarName, URLPath } from '@internals/utils'
 import { ast } from '@kubb/core'
 import type { ResolverTs } from '@kubb/plugin-ts'
@@ -5,14 +6,13 @@ import { functionPrinter } from '@kubb/plugin-ts'
 import { Const, File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginClient } from '../types.ts'
-import { buildParamsMapping } from '../utils.ts'
 
 type Props = {
   name: string
   isExportable?: boolean
   isIndexable?: boolean
 
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
@@ -30,7 +30,7 @@ type GetParamsProps = {
 
 const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver }: GetParamsProps): ast.FunctionParametersNode {
+export function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver }: GetParamsProps): ast.FunctionParametersNode {
   // Build a URL-only node with only path params (no body, query, header)
   const urlNode: ast.OperationNode = {
     ...node,
@@ -57,9 +57,10 @@ export function Url({
   node,
   tsResolver,
 }: Props): KubbReactNode {
+  if (!ast.isHttpOperationNode(node)) return null
   const path = new URLPath(node.path)
 
-  const paramsNode = getParams({
+  const paramsNode = buildUrlParamsNode({
     paramsType,
     paramsCasing,
     pathParamsType,
@@ -68,9 +69,9 @@ export function Url({
   })
   const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
-  const originalPathParams = node.parameters.filter((p) => p.in === 'path')
-  const casedPathParams = ast.caseParams(originalPathParams, paramsCasing)
-  const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : undefined
+  const { path: originalPathParams } = getOperationParameters(node)
+  const { path: casedPathParams } = getOperationParameters(node, { paramsCasing })
+  const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : null
 
   return (
     <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
@@ -88,5 +89,3 @@ export function Url({
     </File.Source>
   )
 }
-
-Url.getParams = getParams

package/src/components/WrapperClient.tsx

@@ -1,17 +1,21 @@
-import { camelCase } from '@internals/utils'
 import { File } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 
+type ClientController = {
+  className: string
+  propertyName: string
+}
+
 type Props = {
   name: string
-  classNames: Array<string>
+  controllers: Array<ClientController>
   isExportable?: boolean
   isIndexable?: boolean
 }
 
-export function WrapperClient({ name, classNames, isExportable = true, isIndexable = true }: Props): KubbReactNode {
-  const properties = classNames.map((className) => `  readonly ${camelCase(className)}: ${className}`).join('\n')
-  const assignments = classNames.map((className) => `    this.${camelCase(className)} = new ${className}(config)`).join('\n')
+export function WrapperClient({ name, controllers, isExportable = true, isIndexable = true }: Props): KubbReactNode {
+  const properties = controllers.map(({ className, propertyName }) => `  readonly ${propertyName}: ${className}`).join('\n')
+  const assignments = controllers.map(({ className, propertyName }) => `    this.${propertyName} = new ${className}(config)`).join('\n')
 
   const classCode = `export class ${name} {
 ${properties}

package/src/functionParams.ts

@@ -11,7 +11,7 @@ type ParamLeaf = {
 
 type ParamGroup = {
   mode: 'object' | 'inlineSpread'
-  children: Record<string, ParamLeaf | undefined>
+  children: Record<string, ParamLeaf | null | undefined>
   default?: string
 }
 
@@ -25,14 +25,14 @@ function isGroup(spec: ParamSpec): spec is ParamGroup {
 }
 
 function createType(type?: string) {
-  return type ? ast.createParamsType({ variant: 'reference', name: type }) : undefined
+  return type ? ast.createParamsType({ variant: 'reference', name: type }) : null
 }
 
 function createDeclarationLeaf(name: string, spec: ParamLeaf): ast.FunctionParameterNode {
   if (spec.default !== undefined) {
     return ast.createFunctionParameter({
       name,
-      type: createType(spec.type),
+      type: createType(spec.type) ?? undefined,
       default: spec.default,
       rest: spec.mode === 'inlineSpread',
     })
@@ -40,7 +40,7 @@ function createDeclarationLeaf(name: string, spec: ParamLeaf): ast.FunctionParam
 
   return ast.createFunctionParameter({
     name,
-    type: createType(spec.type),
+    type: createType(spec.type) ?? undefined,
     optional: !!spec.optional,
     rest: spec.mode === 'inlineSpread',
   })
@@ -52,7 +52,7 @@ function createDeclarationParam(name: string, spec: ParamSpec): ast.FunctionPara
       inline: spec.mode === 'inlineSpread',
       default: spec.default,
       properties: Object.entries(spec.children)
-        .filter(([, child]) => child !== undefined)
+        .filter(([, child]) => child != null)
         .map(([childName, child]) => createDeclarationLeaf(childName, child!)),
     })
   }
@@ -65,7 +65,7 @@ function createCallParam(name: string, spec: ParamSpec): ast.FunctionParameterNo
     return ast.createParameterGroup({
       inline: spec.mode === 'inlineSpread',
       properties: Object.entries(spec.children)
-        .filter(([, child]) => child !== undefined)
+        .filter(([, child]) => child != null)
         .map(([childName, child]) =>
           ast.createFunctionParameter({
             name:
@@ -92,8 +92,8 @@ function createCallParam(name: string, spec: ParamSpec): ast.FunctionParameterNo
  * Creates function parameter builders for generating function signatures and calls.
  * Returns utilities to output constructor signatures (`toConstructor()`) or call expressions (`toCall()`).
  */
-export function createFunctionParams(params: Record<string, ParamSpec | undefined>) {
-  const entries = Object.entries(params).filter(([, spec]) => spec !== undefined) as Array<[string, ParamSpec]>
+export function createFunctionParams(params: Record<string, ParamSpec | null | undefined>) {
+  const entries = Object.entries(params).filter(([, spec]) => spec != null) as Array<[string, ParamSpec]>
 
   return {
     toConstructor() {

package/src/generators/classClientGenerator.tsx

@@ -1,12 +1,12 @@
 import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
-import type { ast } from '@kubb/core'
-import { defineGenerator } from '@kubb/core'
+import { operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
+import { camelCase } from '@internals/utils'
+import { ast, 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, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { ClassClient } from '../components/ClassClient'
 import { WrapperClient } from '../components/WrapperClient'
 import type { PluginClient } from '../types'
@@ -15,65 +15,65 @@ type OperationData = {
   node: ast.OperationNode
   name: string
   tsResolver: ResolverTs
-  zodResolver: ResolverZod | undefined
+  zodResolver: ResolverZod | null
   typeFile: ast.FileNode
-  zodFile: ast.FileNode | undefined
+  zodFile: ast.FileNode | null
 }
 
 type Controller = {
   name: string
+  propertyName: string
   file: ast.FileNode
   operations: Array<OperationData>
 }
 
 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))
+  return resolveOperationTypeNames(node, tsResolver, { order: 'body-response-first' })
 }
 
 function resolveZodImportNames(node: ast.OperationNode, zodResolver: ResolverZod): Array<string> {
-  const names: Array<string | undefined> = [
+  const names: Array<string | null | undefined> = [
     zodResolver.resolveResponseName?.(node),
-    node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined,
+    node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
   ]
   return names.filter((n): n is string => Boolean(n))
 }
 
+/**
+ * Built-in `operations` generator for `@kubb/plugin-client` when
+ * `clientType: 'class'`. Emits one class per tag, with one instance method
+ * per operation and a shared constructor for request configuration.
+ */
 export const classClientGenerator = defineGenerator<PluginClient>({
   name: 'classClient',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operations(nodes, ctx) {
-    const { adapter, config, driver, resolver, root } = ctx
+    const { 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 baseURL = ctx.options.baseURL ?? ctx.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
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : null
+    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null
 
     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 typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+        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
+          ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+              root,
+              output: pluginZod.options?.output ?? output,
+              group: pluginZod.options?.group ?? undefined,
+            })
+          : null
 
       return {
         node: node,
@@ -86,30 +86,34 @@ export const classClientGenerator = defineGenerator<PluginClient>({
     }
 
     const controllers = nodes.reduce((acc, operationNode) => {
+      if (!ast.isHttpOperationNode(operationNode)) return acc
       const tag = operationNode.tags[0]
-      const groupName = tag ? (group?.name?.({ group: camelCase(tag) }) ?? pascalCase(tag)) : 'Client'
+      const groupName = tag ? (group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag)) : resolver.resolveGroupName('Client')
 
       if (!tag && !group) {
-        const name = 'ApiClient'
-        const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group })
+        const name = resolver.resolveClassName('ApiClient')
+        const file = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group: group ?? undefined })
         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] })
+          acc.push({ name, propertyName: resolver.resolveClientPropertyName(name), file, operations: [operationData] })
         }
-      } else if (tag) {
+        return acc
+      }
+
+      if (tag) {
         const name = groupName
-        const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group })
+        const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group: group ?? undefined })
         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] })
+          acc.push({ name, propertyName: resolver.resolveClientPropertyName(name), file, operations: [operationData] })
         }
       }
 
@@ -159,7 +163,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
       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?.[0]?.contentType === 'multipart/form-data')
+      const hasFormData = ops.some((op) => op.node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') ?? false)
 
       return (
         <File
@@ -167,18 +171,18 @@ export const classClientGenerator = defineGenerator<PluginClient>({
           baseName={file.baseName}
           path={file.path}
           meta={file.meta}
-          banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-          footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+          banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName } })}
+          footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName } })}
         >
           {importPath ? (
             <>
-              <File.Import name={'fetch'} path={importPath} />
+              <File.Import name={'client'} 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={['client']} 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 />
             </>
@@ -218,7 +222,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
     })
 
     if (sdk) {
-      const sdkFile = resolver.resolveFile({ name: sdk.className, extname: '.ts' }, { root, output, group })
+      const sdkFile = resolver.resolveFile({ name: sdk.className, extname: '.ts' }, { root, output, group: group ?? undefined })
 
       files.push(
         <File
@@ -226,8 +230,8 @@ export const classClientGenerator = defineGenerator<PluginClient>({
           baseName={sdkFile.baseName}
           path={sdkFile.path}
           meta={sdkFile.meta}
-          banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-          footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+          banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: sdkFile.path, baseName: sdkFile.baseName } })}
+          footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: sdkFile.path, baseName: sdkFile.baseName } })}
         >
           {importPath ? (
             <File.Import name={['Client', 'RequestConfig']} path={importPath} isTypeOnly />
@@ -239,7 +243,7 @@ export const classClientGenerator = defineGenerator<PluginClient>({
             <File.Import key={name} name={[name]} root={sdkFile.path} path={file.path} />
           ))}
 
-          <WrapperClient name={sdk.className} classNames={controllers.map(({ name }) => name)} />
+          <WrapperClient name={sdk.className} controllers={controllers.map(({ name, propertyName }) => ({ className: name, propertyName }))} />
         </File>,
       )
     }

package/src/generators/clientGenerator.tsx

@@ -1,19 +1,26 @@
 import path from 'node:path'
+import { operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
 import { ast, defineGenerator } from '@kubb/core'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { Client } from '../components/Client'
 import { Url } from '../components/Url.tsx'
 import type { PluginClient } from '../types'
 
+/**
+ * Built-in operation generator for `@kubb/plugin-client`. Emits one async
+ * function per OpenAPI operation, plus the matching URL helper. Used when
+ * `clientType: 'function'` (the default).
+ */
 export const clientGenerator = defineGenerator<PluginClient>({
   name: 'client',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operation(node, ctx) {
-    const { adapter, config, driver, resolver, root } = ctx
+    if (!ast.isHttpOperationNode(node)) return null
+    const { 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 baseURL = ctx.options.baseURL ?? ctx.meta.baseURL
 
     const pluginTs = driver.getPlugin(pluginTsName)
 
@@ -23,71 +30,55 @@ export const clientGenerator = defineGenerator<PluginClient>({
 
     const tsResolver = driver.getResolver(pluginTsName)
 
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : null
+    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null
 
-    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 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 importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing })
 
     const importedZodNames =
       zodResolver && parser === 'zod'
-        ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined].filter(Boolean)
+        ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter(
+            (name): name is string => Boolean(name),
+          )
         : []
 
     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,
-        },
-      ),
+      urlName: resolver.resolveUrlName(node),
+      file: resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group: group ?? undefined }),
+      fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+        root,
+        output: pluginTs.options?.output ?? output,
+        group: pluginTs.options?.group ?? undefined,
+      }),
       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,
+          ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+              root,
+              output: pluginZod.options.output ?? output,
+              group: pluginZod.options?.group ?? undefined,
+            })
+          : null,
     } as const
 
-    const isFormData = node.requestBody?.content?.[0]?.contentType === 'multipart/form-data'
+    const hasFormData = node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') ?? false
 
     return (
       <File
         baseName={meta.file.baseName}
         path={meta.file.path}
         meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
         {importPath ? (
           <>
-            <File.Import name={'fetch'} path={importPath} />
+            <File.Import name={'client'} path={importPath} />
             <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={importPath} isTypeOnly />
           </>
         ) : (
           <>
-            <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />
+            <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
               root={meta.file.path}
@@ -97,11 +88,9 @@ export const clientGenerator = defineGenerator<PluginClient>({
           </>
         )}
 
-        {isFormData && node.requestBody?.content?.[0]?.schema && (
-          <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />
-        )}
+        {hasFormData && <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />}
 
-        {meta.fileZod && importedZodNames.length > 0 && <File.Import name={importedZodNames as string[]} root={meta.file.path} path={meta.fileZod.path} />}
+        {meta.fileZod && importedZodNames.length > 0 && <File.Import name={importedZodNames as Array<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 />

package/src/generators/groupedClientGenerator.tsx

@@ -1,30 +1,36 @@
 import { camelCase } from '@internals/utils'
 import type { ast } from '@kubb/core'
 import { defineGenerator } from '@kubb/core'
-import { File, Function, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, Function, jsxRendererSync } from '@kubb/renderer-jsx'
 import type { PluginClient } from '../types'
 
+/**
+ * Emits one aggregate file per tag/group when `group` is configured. Each
+ * file re-exports every client function for that group, so callers can
+ * `import { petController } from './gen/clients'` instead of importing
+ * each operation individually.
+ */
 export const groupedClientGenerator = defineGenerator<PluginClient>({
   name: 'groupedClient',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operations(nodes, ctx) {
-    const { config, resolver, adapter, root } = ctx
+    const { config, resolver, root } = ctx
     const { output, group } = ctx.options
 
     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 name = tag ? group?.name?.({ group: camelCase(tag) }) : null
 
           if (!tag || !name) {
             return acc
           }
 
-          const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group })
+          const file = resolver.resolveFile({ name, extname: '.ts', tag }, { root, output, group: group ?? undefined })
           const clientFile = resolver.resolveFile(
             { name: operationNode.operationId, extname: '.ts', tag: operationNode.tags[0] ?? 'default', path: operationNode.path },
-            { root, output, group },
+            { root, output, group: group ?? undefined },
           )
 
           const client = {
@@ -55,8 +61,8 @@ export const groupedClientGenerator = defineGenerator<PluginClient>({
               baseName={file.baseName}
               path={file.path}
               meta={file.meta}
-              banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-              footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+              banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName, isAggregation: true } })}
+              footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: file.path, baseName: file.baseName, isAggregation: true } })}
             >
               {clients.map((client) => (
                 <File.Import key={client.name} name={[client.name]} root={file.path} path={client.file.path} />