@kubb/plugin-client 5.0.0-beta.56 → 5.0.0-beta.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "5.0.0-beta.56",
+  "version": "5.0.0-beta.64",
   "description": "Generate type-safe HTTP clients from your OpenAPI specification. Supports Axios, Fetch, and custom client adapters with full TypeScript inference and zero boilerplate.",
   "keywords": [
     "api-client",
@@ -22,7 +22,6 @@
     "directory": "packages/plugin-client"
   },
   "files": [
-    "src",
     "dist",
     "*.d.ts",
     "*.d.cts",
@@ -86,11 +85,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/ast": "5.0.0-beta.55",
-    "@kubb/core": "5.0.0-beta.55",
-    "@kubb/renderer-jsx": "5.0.0-beta.55",
-    "@kubb/plugin-ts": "5.0.0-beta.56",
-    "@kubb/plugin-zod": "5.0.0-beta.56"
+    "@kubb/ast": "5.0.0-beta.63",
+    "@kubb/core": "5.0.0-beta.63",
+    "@kubb/renderer-jsx": "5.0.0-beta.63",
+    "@kubb/plugin-ts": "5.0.0-beta.64",
+    "@kubb/plugin-zod": "5.0.0-beta.64"
   },
   "devDependencies": {
     "axios": "^1.17.0",
@@ -98,7 +97,7 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.55",
+    "@kubb/renderer-jsx": "5.0.0-beta.63",
     "axios": "^1.7.2"
   },
   "peerDependenciesMeta": {

package/src/clients/axios.ts

@@ -1,113 +0,0 @@
-import type { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios'
-import axios from 'axios'
-
-declare const AXIOS_BASE: string
-declare const AXIOS_HEADERS: string
-
-/**
- * Header values may be objects (e.g. JSON-encoded headers like `X-Filter` in the Linode API).
- * Non-string values are JSON-serialized before the request is sent.
- */
-export type HeaderValue = string | number | boolean | null | undefined | object
-export type HeadersInit = Array<[string, HeaderValue]> | Record<string, HeaderValue>
-
-/**
- * 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?: HeadersInit
-  paramsSerializer?: AxiosRequestConfig['paramsSerializer']
-  contentType?: string
-}
-
-/**
- * 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 = <TResponseData, _TError = unknown, TRequestData = unknown>(
-  config: RequestConfig<TRequestData>,
-  request?: unknown,
-) => Promise<ResponseConfig<TResponseData>>
-
-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: {
-        ...(Array.isArray(merged.headers) ? Object.fromEntries(merged.headers) : merged.headers),
-        ...(Array.isArray(config.headers) ? Object.fromEntries(config.headers) : config.headers),
-      },
-    }
-  }, {})
-}
-
-/**
- * Serializes header values into the string form axios ultimately puts on the wire.
- * Objects (including arrays) are JSON-stringified so spec-defined object headers like `X-Filter`
- * are sent in their canonical JSON-string form rather than `[object Object]`.
- */
-function serializeHeaders(headers: HeadersInit | undefined): Record<string, string> {
-  if (!headers) return {}
-  const entries = Array.isArray(headers) ? headers : Object.entries(headers)
-  const result: Record<string, string> = {}
-  for (const [key, value] of entries) {
-    if (value === undefined || value === null) continue
-    result[key] = typeof value === 'string' ? value : typeof value === 'object' ? JSON.stringify(value) : String(value)
-  }
-  return result
-}
-
-export const axiosInstance = axios.create(getConfig() as AxiosRequestConfig)
-
-export const client = async <TResponseData, TError = unknown, TRequestData = unknown>(
-  config: RequestConfig<TRequestData>,
-  _request?: unknown,
-): Promise<ResponseConfig<TResponseData>> => {
-  const requestConfig = mergeConfig(getConfig(), config)
-  const { contentType, headers, ...axiosConfig } = requestConfig
-  return axiosInstance
-    .request<TResponseData, ResponseConfig<TResponseData>>({
-      ...axiosConfig,
-      headers: {
-        ...(contentType && contentType !== 'multipart/form-data' ? { 'Content-Type': contentType } : {}),
-        ...serializeHeaders(headers),
-      },
-    })
-    .catch((e: AxiosError<TError>) => {
-      throw e
-    })
-}
-
-client.getConfig = getConfig
-client.setConfig = setConfig
-
-export default client

package/src/clients/fetch.ts

@@ -1,201 +0,0 @@
-/**
- * RequestCredentials
- */
-export type RequestCredentials = 'omit' | 'same-origin' | 'include'
-
-/**
- * Header values may be objects (e.g. JSON-encoded filter headers like `X-Filter`).
- * Non-string values are JSON-serialized before the request is sent.
- */
-export type HeaderValue = string | number | boolean | null | undefined | object
-export type HeadersInit = Array<[string, HeaderValue]> | Record<string, HeaderValue>
-
-/**
- * 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?: HeadersInit
-  credentials?: RequestCredentials
-  contentType?: string
-}
-
-/**
- * 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),
-      },
-    }
-  }, {})
-}
-
-/**
- * Serializes header values into the string form `fetch` expects.
- * Objects (including arrays) are JSON-stringified so spec-defined object
- * headers like `X-Filter` are sent in their canonical JSON-string form.
- */
-function serializeHeaders(headers: HeadersInit | undefined): Record<string, string> {
-  if (!headers) return {}
-  const entries = Array.isArray(headers) ? headers : Object.entries(headers)
-  const result: Record<string, string> = {}
-  for (const [key, value] of entries) {
-    if (value === undefined || value === null) continue
-    result[key] = typeof value === 'string' ? value : typeof value === 'object' ? JSON.stringify(value) : String(value)
-  }
-  return result
-}
-
-/**
- * Serializes the request body into the form `fetch` expects.
- * `FormData`, `URLSearchParams`, `Blob`, `ArrayBuffer` and string bodies are passed through
- * untouched. Plain objects are encoded as `URLSearchParams` for `application/x-www-form-urlencoded`
- * and JSON-serialized otherwise.
- */
-function serializeBody(data: unknown, contentType?: string): BodyInit | undefined {
-  if (data === undefined || data === null) return undefined
-  if (data instanceof FormData || data instanceof URLSearchParams || data instanceof Blob || data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
-    return data as BodyInit
-  }
-  if (typeof data === 'string') return data
-  if (contentType?.includes('application/x-www-form-urlencoded')) {
-    return new URLSearchParams(data as Record<string, string>)
-  }
-  return JSON.stringify(data)
-}
-
-/**
- * Picks a `responseType` from a `Content-Type` header, or `undefined` when it is not recognized.
- */
-function detectResponseType(contentType: string | null): RequestConfig['responseType'] {
-  if (!contentType) return undefined
-  if (contentType.includes('application/json') || contentType.includes('text/json')) return 'json'
-  if (contentType.includes('text/')) return 'text'
-  if (contentType.includes('image/') || contentType.includes('application/octet-stream')) return 'blob'
-  return undefined
-}
-
-/**
- * Parses a `fetch` response body.
- *
- * - Empty responses (204/205/304 or no body) resolve to `{}`.
- * - An explicit `responseType` (or one detected from the `Content-Type` header) forces the matching
- *   `Response` method.
- * - As a last resort the body is read as text and `JSON.parse`d, falling back to the raw text.
- */
-async function parseResponse<TData>(response: Response, responseType?: RequestConfig['responseType']): Promise<TData> {
-  if ([204, 205, 304].includes(response.status) || !response.body) {
-    return {} as TData
-  }
-
-  switch (responseType ?? detectResponseType(response.headers.get('Content-Type'))) {
-    case 'text':
-    case 'document':
-      return (await response.text()) as TData
-    case 'blob':
-      return (await response.blob()) as TData
-    case 'arraybuffer':
-      return (await response.arrayBuffer()) as TData
-    case 'stream':
-      return response.body as TData
-    case 'json':
-      return (await response.json()) as TData
-  }
-
-  // Explicit but unrecognized responseType keeps the JSON default; otherwise read text and parse it.
-  if (responseType) {
-    return (await response.json()) as TData
-  }
-  const text = await response.text()
-  if (!text) {
-    return {} as TData
-  }
-  try {
-    return JSON.parse(text) as TData
-  } catch {
-    return text as TData
-  }
-}
-
-export type ResponseErrorConfig<TError = unknown> = TError
-
-export type Client = <TResponseData, _TError = unknown, TRequestData = unknown>(
-  config: RequestConfig<TRequestData>,
-  request?: unknown,
-) => Promise<ResponseConfig<TResponseData>>
-
-export const client = async <TResponseData, _TError = unknown, RequestData = unknown>(
-  paramsConfig: RequestConfig<RequestData>,
-  _request?: unknown,
-): Promise<ResponseConfig<TResponseData>> => {
-  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 headers: Record<string, string> = {
-    ...(config.contentType && config.contentType !== 'multipart/form-data' ? { 'Content-Type': config.contentType } : {}),
-    ...serializeHeaders(config.headers),
-  }
-
-  const response = await globalThis.fetch(targetUrl, {
-    credentials: config.credentials || 'same-origin',
-    method: config.method?.toUpperCase(),
-    body: serializeBody(config.data, headers['Content-Type'] ?? headers['content-type']),
-    signal: config.signal,
-    headers,
-  })
-
-  const data = await parseResponse<TResponseData>(response, config.responseType)
-
-  return {
-    data,
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers as Headers,
-  }
-}
-
-client.getConfig = getConfig
-client.setConfig = setConfig
-
-export default client

package/src/components/ClassClient.tsx

@@ -1,161 +0,0 @@
-import { buildOperationComments, getContentTypeInfo, getOperationParameters } from '@internals/shared'
-import { Url } from '@internals/utils'
-import { buildJSDoc, stringify } from '@kubb/ast/utils'
-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,
-  buildQueryParamsLine,
-  buildRequestDataLine,
-  buildReturnStatement,
-  resolveQueryParamsParser,
-} from '../utils.ts'
-import { buildClientParamsNode } from './Client.tsx'
-
-type OperationData = {
-  node: ast.OperationNode
-  name: string
-  tsResolver: ResolverTs
-  zodResolver?: ResolverZod | null
-}
-
-type Props = {
-  name: string
-  isExportable?: boolean
-  isIndexable?: boolean
-  operations: Array<OperationData>
-  baseURL: string | null | undefined
-  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
-  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
-  paramsType: PluginClient['resolvedOptions']['pathParamsType']
-  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  children?: KubbReactNode
-}
-
-type GenerateMethodProps = {
-  node: ast.OperationNode
-  name: string
-  tsResolver: ResolverTs
-  zodResolver?: ResolverZod | null
-  baseURL: string | null | undefined
-  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  paramsType: PluginClient['resolvedOptions']['paramsType']
-  paramsCasing: PluginClient['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginClient['resolvedOptions']['pathParamsType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-function generateMethod({
-  node,
-  name,
-  tsResolver,
-  zodResolver,
-  baseURL,
-  dataReturnType,
-  parser,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-}: GenerateMethodProps): string {
-  if (!ast.isHttpOperationNode(node)) return ''
-  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, { dataReturnType, zodResolver, parser })
-  const paramsNode = buildClientParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable: true })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const { query: queryParams } = getOperationParameters(node)
-  const zodQueryParamsName =
-    zodResolver && resolveQueryParamsParser(parser) === 'zod' && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]!) : null
-  const clientParams = buildClassClientParams({
-    node,
-    url: Url.toTemplateString(node.path, { casing: paramsCasing }),
-    baseURL,
-    tsResolver,
-    isFormData,
-    isMultipleContentTypes,
-    hasFormData,
-    headers,
-    zodQueryParamsName,
-  })
-  const jsdoc = buildJSDoc(buildOperationComments(node, { link: 'urlPath', linkPosition: 'beforeDeprecated', splitLines: true }))
-
-  const requestDataLine = buildRequestDataLine({ parser, node, zodResolver })
-  const queryParamsLine = buildQueryParamsLine({ parser, node, zodResolver })
-  const formDataLine = buildFormDataLine(isFormData || (isMultipleContentTypes && hasFormData), !!node.requestBody?.content?.[0]?.schema)
-  const returnStatement = buildReturnStatement({ dataReturnType, parser, node, zodResolver, tsResolver })
-
-  const methodBody = [
-    `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ''}...requestConfig } = mergeConfig(this.#config, config)`,
-    '',
-    requestDataLine,
-    queryParamsLine,
-    formDataLine,
-    `const res = await request<${generics.join(', ')}>(${clientParams.toCall()})`,
-    returnStatement,
-  ]
-    .filter(Boolean)
-    .map((line) => `    ${line}`)
-    .join('\n')
-
-  return `${jsdoc}async ${name}(${paramsSignature}) {\n${methodBody}\n  }`
-}
-
-export function ClassClient({
-  name,
-  isExportable = true,
-  isIndexable = true,
-  operations,
-  baseURL,
-  dataReturnType,
-  parser,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  children,
-}: Props): KubbReactNode {
-  const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver }) =>
-    generateMethod({
-      node,
-      name: methodName,
-      tsResolver,
-      zodResolver,
-      baseURL,
-      dataReturnType,
-      parser,
-      paramsType,
-      paramsCasing,
-      pathParamsType,
-    }),
-  )
-
-  const classCode = `export class ${name} {
-  #config: Partial<RequestConfig> & { client?: Client }
-
-  constructor(config: Partial<RequestConfig> & { client?: Client } = {}) {
-    this.#config = config
-  }
-
-${methods.join('\n\n')}
-}`
-
-  return (
-    <File.Source name={name} isExportable={isExportable} isIndexable={isIndexable}>
-      {classCode}
-      {children}
-    </File.Source>
-  )
-}