@kubb/plugin-client 5.0.0-beta.3 → 5.0.0-beta.30

package/src/utils.ts

@@ -1,51 +1,19 @@
-import { URLPath } from '@internals/utils'
+import { getOperationParameters, resolveSuccessNames } from '@internals/shared'
+import type { 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,
+    contentType !== 'application/json' && contentType !== 'multipart/form-data' ? `'Content-Type': '${contentType}'` : null,
+    hasHeaderParams ? '...headers' : null,
   ].filter(Boolean) as Array<string>
 }
 
@@ -54,8 +22,9 @@ export function buildHeaders(contentType: string, hasHeaderParams: boolean): Arr
  * 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 successNames = resolveSuccessNames(node, tsResolver)
+  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
+  const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null
   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)
@@ -71,20 +40,22 @@ export function buildClassClientParams({
   baseURL,
   tsResolver,
   isFormData,
+  isMultipleContentTypes,
+  hasFormData,
   headers,
 }: {
   node: ast.OperationNode
   path: URLPath
-  baseURL: string | undefined
+  baseURL: string | null | undefined
   tsResolver: ResolverTs
   isFormData: boolean
+  isMultipleContentTypes: boolean
+  hasFormData: 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
+  const { query: queryParams } = getOperationParameters(node)
+  const queryParamsName = queryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, queryParams[0]!) : null
+  const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null
 
   return createFunctionParams({
     config: {
@@ -103,18 +74,24 @@ export function buildClassClientParams({
           ? {
               value: JSON.stringify(baseURL),
             }
-          : undefined,
-        params: queryParamsName ? {} : undefined,
+          : null,
+        params: queryParamsName ? {} : null,
         data: requestName
           ? {
-              value: isFormData ? 'formData as FormData' : 'requestData',
+              value:
+                isMultipleContentTypes && hasFormData
+                  ? "contentType === 'multipart/form-data' ? formData as FormData : requestData"
+                  : isFormData
+                    ? 'formData as FormData'
+                    : 'requestData',
             }
-          : undefined,
+          : null,
+        contentType: isMultipleContentTypes ? {} : null,
         headers: headers.length
           ? {
               value: `{ ${headers.join(', ')}, ...requestConfig.headers }`,
             }
-          : undefined,
+          : null,
       },
     },
   })
@@ -131,9 +108,9 @@ export function buildRequestDataLine({
 }: {
   parser: PluginClient['resolvedOptions']['parser'] | undefined
   node: ast.OperationNode
-  zodResolver?: ResolverZod
+  zodResolver?: ResolverZod | null
 }): string {
-  const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined
+  const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null
   if (parser === 'zod' && zodRequestName) {
     return `const requestData = ${zodRequestName}.parse(data)`
   }
@@ -164,9 +141,9 @@ export function buildReturnStatement({
   dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
   parser: PluginClient['resolvedOptions']['parser'] | undefined
   node: ast.OperationNode
-  zodResolver?: ResolverZod
+  zodResolver?: ResolverZod | null
 }): string {
-  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : undefined
+  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : null
   if (dataReturnType === 'full' && parser === 'zod' && zodResponseName) {
     return `return {...res, data: ${zodResponseName}.parse(res.data)}`
   }

package/templates/clients/axios.ts

@@ -1,73 +0,0 @@
-import type { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios'
-import axios from 'axios'
-
-declare const AXIOS_BASE: string
-declare const AXIOS_HEADERS: string
-
-/**
- * Subset of AxiosRequestConfig
- */
-export type RequestConfig<TData = unknown> = {
-  baseURL?: string
-  url?: string
-  method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD'
-  params?: unknown
-  data?: TData | FormData
-  responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream'
-  signal?: AbortSignal
-  validateStatus?: (status: number) => boolean
-  headers?: AxiosRequestConfig['headers']
-}
-
-/**
- * Subset of AxiosResponse
- */
-export type ResponseConfig<TData = unknown> = {
-  data: TData
-  status: number
-  statusText: string
-  headers: AxiosResponse['headers']
-}
-
-export type ResponseErrorConfig<TError = unknown> = AxiosError<TError>
-
-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,
-  headers: typeof AXIOS_HEADERS !== 'undefined' ? JSON.parse(AXIOS_HEADERS) : undefined,
-}
-
-export const getConfig = () => _config
-
-export const setConfig = (config: RequestConfig) => {
-  _config = config
-  return getConfig()
-}
-
-export const mergeConfig = <T extends RequestConfig>(...configs: Array<Partial<T>>): Partial<T> => {
-  return configs.reduce<Partial<T>>((merged, config) => {
-    return {
-      ...merged,
-      ...config,
-      headers: {
-        ...merged.headers,
-        ...config.headers,
-      },
-    }
-  }, {})
-}
-
-export const axiosInstance = axios.create(getConfig())
-
-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
-  })
-}
-
-fetch.getConfig = getConfig
-fetch.setConfig = setConfig

package/templates/clients/fetch.ts

@@ -1,96 +0,0 @@
-/**
- * RequestCredentials
- */
-export type RequestCredentials = 'omit' | 'same-origin' | 'include'
-
-/**
- * Subset of FetchRequestConfig
- */
-export type RequestConfig<TData = unknown> = {
-  baseURL?: string
-  url?: string
-  method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD'
-  params?: unknown
-  data?: TData | FormData
-  responseType?: 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream'
-  signal?: AbortSignal
-  headers?: [string, string][] | Record<string, string>
-  credentials?: RequestCredentials
-}
-
-/**
- * Subset of FetchResponse
- */
-export type ResponseConfig<TData = unknown> = {
-  data: TData
-  status: number
-  statusText: string
-  headers: Headers
-}
-
-let _config: Partial<RequestConfig> = {}
-
-export const getConfig = () => _config
-
-export const setConfig = (config: Partial<RequestConfig>) => {
-  _config = config
-  return getConfig()
-}
-
-export const mergeConfig = <T extends RequestConfig>(...configs: Array<Partial<T>>): Partial<T> => {
-  return configs.reduce<Partial<T>>((merged, config) => {
-    return {
-      ...merged,
-      ...config,
-      headers: {
-        ...(Array.isArray(merged.headers) ? Object.fromEntries(merged.headers) : merged.headers),
-        ...(Array.isArray(config.headers) ? Object.fromEntries(config.headers) : config.headers),
-      },
-    }
-  }, {})
-}
-
-export type ResponseErrorConfig<TError = unknown> = TError
-
-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>,
-  _request?: unknown,
-): Promise<ResponseConfig<TData>> => {
-  const normalizedParams = new URLSearchParams()
-
-  const config = mergeConfig(getConfig(), paramsConfig)
-
-  Object.entries(config.params || {}).forEach(([key, value]) => {
-    if (value !== undefined) {
-      normalizedParams.append(key, value === null ? 'null' : value.toString())
-    }
-  })
-
-  let targetUrl = [config.baseURL, config.url].filter(Boolean).join('')
-
-  if (config.params) {
-    targetUrl += `?${normalizedParams}`
-  }
-
-  const response = await globalThis.fetch(targetUrl, {
-    credentials: config.credentials || 'same-origin',
-    method: config.method?.toUpperCase(),
-    body: config.data instanceof FormData ? config.data : JSON.stringify(config.data),
-    signal: config.signal,
-    headers: config.headers,
-  })
-
-  const data = [204, 205, 304].includes(response.status) || !response.body ? {} : await response.json()
-
-  return {
-    data: data as TData,
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers as Headers,
-  }
-}
-
-fetch.getConfig = getConfig
-fetch.setConfig = setConfig

package/templates/config.ts

@@ -1,43 +0,0 @@
-export function buildFormData<T = unknown>(data: T): FormData {
-  const formData = new FormData()
-
-  function appendData(key: string, value: any) {
-    if (value instanceof Blob) {
-      formData.append(key, value)
-      return
-    }
-    if (value instanceof Date) {
-      formData.append(key, value.toISOString())
-      return
-    }
-    if (typeof value === 'number' || typeof value === 'boolean') {
-      formData.append(key, String(value))
-      return
-    }
-    if (typeof value === 'string') {
-      formData.append(key, value)
-      return
-    }
-    if (typeof value === 'object') {
-      formData.append(key, new Blob([JSON.stringify(value)], { type: 'application/json' }))
-      return
-    }
-  }
-
-  if (data) {
-    Object.entries(data).forEach(([key, value]) => {
-      if (value === undefined || value === null) return
-
-      if (Array.isArray(value)) {
-        for (const valueItem of value) {
-          if (valueItem === undefined || valueItem === null) continue
-          appendData(key, valueItem)
-        }
-      } else {
-        appendData(key, value)
-      }
-    })
-  }
-
-  return formData
-}