@kubb/plugin-client 5.0.0-alpha.8 → 5.0.0-beta.3

package/src/components/StaticClassClient.tsx

@@ -1,36 +1,40 @@
 import { buildJSDoc, URLPath } from '@internals/utils'
-import type { Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments } from '@kubb/plugin-oas/utils'
-import { File, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { 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'
 
+type OperationData = {
+  node: ast.OperationNode
+  name: string
+  tsResolver: ResolverTs
+  zodResolver?: ResolverZod
+}
+
 type Props = {
   name: string
   isExportable?: boolean
   isIndexable?: boolean
-  operations: Array<{
-    operation: Operation
-    name: string
-    typeSchemas: OperationSchemas
-    zodSchemas: OperationSchemas | undefined
-  }>
+  operations: Array<OperationData>
   baseURL: string | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
-  children?: FabricReactNode
+  children?: KubbReactNode
 }
 
 type GenerateMethodProps = {
-  operation: Operation
+  node: ast.OperationNode
   name: string
-  typeSchemas: OperationSchemas
-  zodSchemas: OperationSchemas | undefined
+  tsResolver: ResolverTs
+  zodResolver?: ResolverZod
   baseURL: string | undefined
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
@@ -39,115 +43,13 @@ type GenerateMethodProps = {
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
 }
 
-function buildHeaders(contentType: string, hasHeaderParams: boolean): Array<string> {
-  return [
-    contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : undefined,
-    hasHeaderParams ? '...headers' : undefined,
-  ].filter(Boolean) as Array<string>
-}
-
-function buildGenerics(typeSchemas: OperationSchemas): Array<string> {
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  return [typeSchemas.response.name, TError, typeSchemas.request?.name || 'unknown'].filter(Boolean)
-}
-
-function buildClientParams({
-  operation,
-  path,
-  baseURL,
-  typeSchemas,
-  isFormData,
-  headers,
-}: {
-  operation: Operation
-  path: URLPath
-  baseURL: string | undefined
-  typeSchemas: OperationSchemas
-  isFormData: boolean
-  headers: Array<string>
-}) {
-  return FunctionParams.factory({
-    config: {
-      mode: 'object',
-      children: {
-        requestConfig: {
-          mode: 'inlineSpread',
-        },
-        method: {
-          value: JSON.stringify(operation.method.toUpperCase()),
-        },
-        url: {
-          value: path.template,
-        },
-        baseURL: baseURL
-          ? {
-              value: JSON.stringify(baseURL),
-            }
-          : undefined,
-        params: typeSchemas.queryParams?.name ? {} : undefined,
-        data: typeSchemas.request?.name
-          ? {
-              value: isFormData ? 'formData as FormData' : 'requestData',
-            }
-          : undefined,
-        headers: headers.length
-          ? {
-              value: `{ ${headers.join(', ')}, ...requestConfig.headers }`,
-            }
-          : undefined,
-      },
-    },
-  })
-}
-
-function buildRequestDataLine({
-  parser,
-  zodSchemas,
-  typeSchemas,
-}: {
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  zodSchemas: OperationSchemas | undefined
-  typeSchemas: OperationSchemas
-}): string {
-  if (parser === 'zod' && zodSchemas?.request?.name) {
-    return `const requestData = ${zodSchemas.request.name}.parse(data)`
-  }
-  if (typeSchemas?.request?.name) {
-    return 'const requestData = data'
-  }
-  return ''
-}
-
-function buildFormDataLine(isFormData: boolean, hasRequest: boolean): string {
-  return isFormData && hasRequest ? 'const formData = buildFormData(requestData)' : ''
-}
-
-function buildReturnStatement({
-  dataReturnType,
-  parser,
-  zodSchemas,
-}: {
-  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  zodSchemas: OperationSchemas | undefined
-}): string {
-  if (dataReturnType === 'full' && parser === 'zod' && zodSchemas) {
-    return `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`
-  }
-  if (dataReturnType === 'data' && parser === 'zod' && zodSchemas) {
-    return `return ${zodSchemas.response.name}.parse(res.data)`
-  }
-  if (dataReturnType === 'full' && parser === 'client') {
-    return 'return res'
-  }
-  return 'return res.data'
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
 function generateMethod({
-  operation,
+  node,
   name,
-  typeSchemas,
-  zodSchemas,
+  tsResolver,
+  zodResolver,
   baseURL,
   dataReturnType,
   parser,
@@ -155,18 +57,23 @@ function generateMethod({
   paramsCasing,
   pathParamsType,
 }: GenerateMethodProps): string {
-  const path = new URLPath(operation.path, { casing: paramsCasing })
-  const contentType = operation.getContentType()
+  const path = new URLPath(node.path, { casing: paramsCasing })
+  const contentType = node.requestBody?.content?.[0]?.contentType ?? 'application/json'
   const isFormData = contentType === 'multipart/form-data'
-  const headers = buildHeaders(contentType, !!typeSchemas.headerParams?.name)
-  const generics = buildGenerics(typeSchemas)
-  const params = Client.getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas, isConfigurable: true })
-  const clientParams = buildClientParams({ operation, path, baseURL, typeSchemas, isFormData, headers })
-  const jsdoc = buildJSDoc(getComments(operation))
+  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 generics = buildGenerics(node, tsResolver)
+  const paramsNode = Client.getParams({ 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 requestDataLine = buildRequestDataLine({ parser, zodSchemas, typeSchemas })
-  const formDataLine = buildFormDataLine(isFormData, !!typeSchemas?.request?.name)
-  const returnStatement = buildReturnStatement({ dataReturnType, parser, zodSchemas })
+  const requestDataLine = buildRequestDataLine({ parser, node, zodResolver })
+  const formDataLine = buildFormDataLine(isFormData, !!node.requestBody?.content?.[0]?.schema)
+  const returnStatement = buildReturnStatement({ dataReturnType, parser, node, zodResolver })
 
   const methodBody = [
     'const { client: request = fetch, ...requestConfig } = mergeConfig(this.#config, config)',
@@ -180,8 +87,7 @@ function generateMethod({
     .map((line) => `    ${line}`)
     .join('\n')
 
-  // Indent static method by 2 spaces, body by 4 spaces (matching snapshot)
-  return `${jsdoc}  static async ${name}(${params.toConstructor()}) {\n${methodBody}\n  }`
+  return `${jsdoc}  static async ${name}(${paramsSignature}) {\n${methodBody}\n  }`
 }
 
 export function StaticClassClient({
@@ -196,13 +102,13 @@ export function StaticClassClient({
   paramsCasing,
   pathParamsType,
   children,
-}: Props): FabricReactNode {
-  const methods = operations.map(({ operation, name: methodName, typeSchemas, zodSchemas }) =>
+}: Props): KubbReactNode {
+  const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver }) =>
     generateMethod({
-      operation,
+      node,
       name: methodName,
-      typeSchemas,
-      zodSchemas,
+      tsResolver,
+      zodResolver,
       baseURL,
       dataReturnType,
       parser,

package/src/components/Url.tsx

@@ -1,15 +1,13 @@
 import { isValidVarName, URLPath } from '@internals/utils'
-import { getDefaultValue, type Operation } from '@kubb/oas'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getParamsMapping, getPathParams } from '@kubb/plugin-oas/utils'
-import { Const, File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { ast } from '@kubb/core'
+import type { ResolverTs } from '@kubb/plugin-ts'
+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 of the function
-   */
   name: string
   isExportable?: boolean
   isIndexable?: boolean
@@ -18,45 +16,33 @@ type Props = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['pathParamsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
-  operation: Operation
+  node: ast.OperationNode
+  tsResolver: ResolverTs
 }
 
 type GetParamsProps = {
   paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
   paramsType: PluginClient['resolvedOptions']['paramsType']
   pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
+  node: ast.OperationNode
+  tsResolver: ResolverTs
 }
 
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, {
-      typed: true,
-      casing: paramsCasing,
-    })
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
 
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children: {
-          ...pathParams,
-        },
-      },
-    })
+function getParams({ 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,
+    parameters: node.parameters.filter((p) => p.in === 'path'),
+    requestBody: undefined,
   }
 
-  return FunctionParams.factory({
-    pathParams: typeSchemas.pathParams?.name
-      ? {
-          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-          children: getPathParams(typeSchemas.pathParams, {
-            typed: true,
-            casing: paramsCasing,
-          }),
-          default: getDefaultValue(typeSchemas.pathParams?.schema),
-        }
-      : undefined,
+  return ast.createOperationParams(urlNode, {
+    paramsType: paramsType === 'object' ? 'object' : 'inline',
+    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
+    paramsCasing,
+    resolver: tsResolver,
   })
 }
 
@@ -64,34 +50,38 @@ export function Url({
   name,
   isExportable = true,
   isIndexable = true,
-  typeSchemas,
   baseURL,
   paramsType,
   paramsCasing,
   pathParamsType,
-  operation,
-}: Props): FabricReactNode {
-  const path = new URLPath(operation.path)
-  const params = getParams({
+  node,
+  tsResolver,
+}: Props): KubbReactNode {
+  const path = new URLPath(node.path)
+
+  const paramsNode = getParams({
     paramsType,
     paramsCasing,
     pathParamsType,
-    typeSchemas,
+    node,
+    tsResolver,
   })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
-  // Generate pathParams mapping when paramsCasing is used
-  const pathParamsMapping = paramsCasing ? getParamsMapping(typeSchemas.pathParams, { casing: paramsCasing }) : undefined
+  const originalPathParams = node.parameters.filter((p) => p.in === 'path')
+  const casedPathParams = ast.caseParams(originalPathParams, paramsCasing)
+  const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : undefined
 
   return (
     <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
-      <Function name={name} export={isExportable} params={params.toConstructor()}>
+      <Function name={name} export={isExportable} params={paramsSignature}>
         {pathParamsMapping &&
           Object.entries(pathParamsMapping)
-            .filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName))
+            .filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName)
             .map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`)
             .join('\n')}
-        {pathParamsMapping && <br />}
-        <Const name={'res'}>{`{ method: '${operation.method.toUpperCase()}', url: ${path.toTemplateString({ prefix: baseURL })} as const }`}</Const>
+        {pathParamsMapping && Object.keys(pathParamsMapping).length > 0 && <br />}
+        <Const name={'res'}>{`{ method: '${node.method.toUpperCase()}', url: ${path.toTemplateString({ prefix: baseURL })} as const }`}</Const>
         <br />
         return res
       </Function>

package/src/components/WrapperClient.tsx

@@ -1,6 +1,6 @@
 import { camelCase } from '@internals/utils'
-import { File } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import { File } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 
 type Props = {
   name: string
@@ -9,7 +9,7 @@ type Props = {
   isIndexable?: boolean
 }
 
-export function WrapperClient({ name, classNames, isExportable = true, isIndexable = true }: Props): FabricReactNode {
+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')
 

package/src/functionParams.ts

@@ -0,0 +1,118 @@
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+
+type ParamLeaf = {
+  type?: string
+  optional?: boolean
+  default?: string
+  value?: string
+  mode?: 'inlineSpread'
+}
+
+type ParamGroup = {
+  mode: 'object' | 'inlineSpread'
+  children: Record<string, ParamLeaf | undefined>
+  default?: string
+}
+
+type ParamSpec = ParamLeaf | ParamGroup
+
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
+
+function isGroup(spec: ParamSpec): spec is ParamGroup {
+  return 'children' in spec
+}
+
+function createType(type?: string) {
+  return type ? ast.createParamsType({ variant: 'reference', name: type }) : undefined
+}
+
+function createDeclarationLeaf(name: string, spec: ParamLeaf): ast.FunctionParameterNode {
+  if (spec.default !== undefined) {
+    return ast.createFunctionParameter({
+      name,
+      type: createType(spec.type),
+      default: spec.default,
+      rest: spec.mode === 'inlineSpread',
+    })
+  }
+
+  return ast.createFunctionParameter({
+    name,
+    type: createType(spec.type),
+    optional: !!spec.optional,
+    rest: spec.mode === 'inlineSpread',
+  })
+}
+
+function createDeclarationParam(name: string, spec: ParamSpec): ast.FunctionParameterNode | ast.ParameterGroupNode {
+  if (isGroup(spec)) {
+    return ast.createParameterGroup({
+      inline: spec.mode === 'inlineSpread',
+      default: spec.default,
+      properties: Object.entries(spec.children)
+        .filter(([, child]) => child !== undefined)
+        .map(([childName, child]) => createDeclarationLeaf(childName, child!)),
+    })
+  }
+
+  return createDeclarationLeaf(name, spec)
+}
+
+function createCallParam(name: string, spec: ParamSpec): ast.FunctionParameterNode | ast.ParameterGroupNode {
+  if (isGroup(spec)) {
+    return ast.createParameterGroup({
+      inline: spec.mode === 'inlineSpread',
+      properties: Object.entries(spec.children)
+        .filter(([, child]) => child !== undefined)
+        .map(([childName, child]) =>
+          ast.createFunctionParameter({
+            name:
+              child?.mode === 'inlineSpread'
+                ? spec.mode === 'inlineSpread'
+                  ? (child.value ?? childName)
+                  : `...${child.value ?? childName}`
+                : child?.value
+                  ? `${childName}: ${child.value}`
+                  : childName,
+            rest: spec.mode === 'inlineSpread' && child?.mode === 'inlineSpread',
+          }),
+        ),
+    })
+  }
+
+  return ast.createFunctionParameter({
+    name: spec.value ?? name,
+    rest: spec.mode === 'inlineSpread',
+  })
+}
+
+/**
+ * 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]>
+
+  return {
+    toConstructor() {
+      return (
+        declarationPrinter.print(
+          ast.createFunctionParameters({
+            params: entries.map(([name, spec]) => createDeclarationParam(name, spec)),
+          }),
+        ) ?? ''
+      )
+    },
+    toCall() {
+      return (
+        callPrinter.print(
+          ast.createFunctionParameters({
+            params: entries.map(([name, spec]) => createCallParam(name, spec)),
+          }),
+        ) ?? ''
+      )
+    },
+  }
+}