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

package/src/utils.ts

@@ -0,0 +1,180 @@
+import { URLPath } from '@internals/utils'
+import type { ast } from '@kubb/core'
+import type { ResolverTs } from '@kubb/plugin-ts'
+import type { ResolverZod } from '@kubb/plugin-zod'
+import { createFunctionParams } from './functionParams.ts'
+import type { PluginClient } from './types.ts'
+
+/**
+ * Extracts documentation comments from an operation node.
+ * Includes description, summary, link, and deprecation information.
+ */
+export function getComments(node: ast.OperationNode): Array<string> {
+  return [
+    node.description && `@description ${node.description}`,
+    node.summary && `@summary ${node.summary}`,
+    node.path && `{@link ${new URLPath(node.path).URL}}`,
+    node.deprecated && '@deprecated',
+  ]
+    .filter((x): x is string => Boolean(x))
+    .flatMap((text) => text.split(/\r?\n/).map((line) => line.trim()))
+    .filter((x): x is string => Boolean(x))
+}
+
+/**
+ * Builds a mapping of original parameter names to their transformed (cased) names.
+ * Returns undefined if no names have changed.
+ */
+export function buildParamsMapping(originalParams: Array<ast.ParameterNode>, casedParams: Array<ast.ParameterNode>): Record<string, string> | undefined {
+  const mapping: Record<string, string> = {}
+  let hasChanged = false
+  originalParams.forEach((param, i) => {
+    const casedName = casedParams[i]?.name ?? param.name
+    mapping[param.name] = casedName
+    if (param.name !== casedName) {
+      hasChanged = true
+    }
+  })
+  return hasChanged ? mapping : undefined
+}
+
+/**
+ * Builds HTTP headers array for a client request.
+ * Includes Content-Type (if not default) and spreads header parameters if present.
+ */
+export 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>
+}
+
+/**
+ * Builds TypeScript generic parameters for a client method.
+ * Includes response type, error type, and optional request type.
+ */
+export function buildGenerics(node: ast.OperationNode, tsResolver: ResolverTs): Array<string> {
+  const responseName = tsResolver.resolveResponseName(node)
+  const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined
+  const errorNames = node.responses.filter((r) => Number.parseInt(r.statusCode, 10) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
+  return [responseName, TError, requestName || 'unknown'].filter(Boolean)
+}
+
+/**
+ * Builds the parameters object for a class-based client method.
+ * Includes URL, method, base URL, headers, and request/response data.
+ */
+export function buildClassClientParams({
+  node,
+  path,
+  baseURL,
+  tsResolver,
+  isFormData,
+  headers,
+}: {
+  node: ast.OperationNode
+  path: URLPath
+  baseURL: string | undefined
+  tsResolver: ResolverTs
+  isFormData: boolean
+  headers: Array<string>
+}) {
+  const queryParamsName =
+    node.parameters.filter((p) => p.in === 'query').length > 0
+      ? tsResolver.resolveQueryParamsName(node, node.parameters.filter((p) => p.in === 'query')[0]!)
+      : undefined
+  const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined
+
+  return createFunctionParams({
+    config: {
+      mode: 'object',
+      children: {
+        requestConfig: {
+          mode: 'inlineSpread',
+        },
+        method: {
+          value: JSON.stringify(node.method.toUpperCase()),
+        },
+        url: {
+          value: path.template,
+        },
+        baseURL: baseURL
+          ? {
+              value: JSON.stringify(baseURL),
+            }
+          : undefined,
+        params: queryParamsName ? {} : undefined,
+        data: requestName
+          ? {
+              value: isFormData ? 'formData as FormData' : 'requestData',
+            }
+          : undefined,
+        headers: headers.length
+          ? {
+              value: `{ ${headers.join(', ')}, ...requestConfig.headers }`,
+            }
+          : undefined,
+      },
+    },
+  })
+}
+
+/**
+ * Builds the request data parsing line for client methods.
+ * Applies Zod validation if configured, otherwise uses data directly.
+ */
+export function buildRequestDataLine({
+  parser,
+  node,
+  zodResolver,
+}: {
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  node: ast.OperationNode
+  zodResolver?: ResolverZod
+}): string {
+  const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined
+  if (parser === 'zod' && zodRequestName) {
+    return `const requestData = ${zodRequestName}.parse(data)`
+  }
+  if (node.requestBody?.content?.[0]?.schema) {
+    return 'const requestData = data'
+  }
+  return ''
+}
+
+/**
+ * Builds the form data conversion line for file upload requests.
+ * Returns empty string if not applicable.
+ */
+export function buildFormDataLine(isFormData: boolean, hasRequest: boolean): string {
+  return isFormData && hasRequest ? 'const formData = buildFormData(requestData)' : ''
+}
+
+/**
+ * Builds the return statement for a client method.
+ * Applies Zod validation to response data if configured, otherwise returns raw response.
+ */
+export function buildReturnStatement({
+  dataReturnType,
+  parser,
+  node,
+  zodResolver,
+}: {
+  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
+  parser: PluginClient['resolvedOptions']['parser'] | undefined
+  node: ast.OperationNode
+  zodResolver?: ResolverZod
+}): string {
+  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : undefined
+  if (dataReturnType === 'full' && parser === 'zod' && zodResponseName) {
+    return `return {...res, data: ${zodResponseName}.parse(res.data)}`
+  }
+  if (dataReturnType === 'data' && parser === 'zod' && zodResponseName) {
+    return `return ${zodResponseName}.parse(res.data)`
+  }
+  if (dataReturnType === 'full' && parser === 'client') {
+    return 'return res'
+  }
+  return 'return res.data'
+}

package/templates/clients/axios.ts

@@ -31,7 +31,7 @@ export type ResponseConfig<TData = unknown> = {
 
 export type ResponseErrorConfig<TError = unknown> = AxiosError<TError>
 
-export type Client = <TData, _TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>) => Promise<ResponseConfig<TData>>
+export type Client = <TData, _TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>, request?: unknown) => Promise<ResponseConfig<TData>>
 
 let _config: Partial<RequestConfig> = {
   baseURL: typeof AXIOS_BASE !== 'undefined' ? AXIOS_BASE : undefined,
@@ -60,7 +60,10 @@ export const mergeConfig = <T extends RequestConfig>(...configs: Array<Partial<T
 
 export const axiosInstance = axios.create(getConfig())
 
-export const fetch = async <TData, TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>): Promise<ResponseConfig<TData>> => {
+export const fetch = async <TData, TError = unknown, TVariables = unknown>(
+  config: RequestConfig<TVariables>,
+  _request?: unknown,
+): Promise<ResponseConfig<TData>> => {
   return axiosInstance.request<TData, ResponseConfig<TData>>(mergeConfig(getConfig(), config)).catch((e: AxiosError<TError>) => {
     throw e
   })

package/templates/clients/fetch.ts

@@ -52,9 +52,12 @@ export const mergeConfig = <T extends RequestConfig>(...configs: Array<Partial<T
 
 export type ResponseErrorConfig<TError = unknown> = TError
 
-export type Client = <TData, _TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>) => Promise<ResponseConfig<TData>>
+export type Client = <TData, _TError = unknown, TVariables = unknown>(config: RequestConfig<TVariables>, request?: unknown) => Promise<ResponseConfig<TData>>
 
-export const fetch = async <TData, _TError = unknown, TVariables = unknown>(paramsConfig: RequestConfig<TVariables>): Promise<ResponseConfig<TData>> => {
+export const fetch = async <TData, _TError = unknown, TVariables = unknown>(
+  paramsConfig: RequestConfig<TVariables>,
+  _request?: unknown,
+): Promise<ResponseConfig<TData>> => {
   const normalizedParams = new URLSearchParams()
 
   const config = mergeConfig(getConfig(), paramsConfig)