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

package/src/types.ts

@@ -1,268 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-
-/**
- * The concrete resolver type for `@kubb/plugin-client`.
- * Extends the base `Resolver` with a `resolveName` helper for client function names.
- */
-export type ResolverClient = Resolver & {
-  /**
-   * Resolves the function name for a given raw operation name.
-   *
-   * @example Resolving operation names
-   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-   */
-  resolveName(this: ResolverClient, name: string): string
-  /**
-   * Resolves the output file name for a client module.
-   */
-  resolvePathName(this: ResolverClient, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-  /**
-   * Resolves the generated class name for class-based clients.
-   */
-  resolveClassName(this: ResolverClient, name: string): string
-  /**
-   * Resolves the generated class name for tag-based client groups.
-   */
-  resolveGroupName(this: ResolverClient, name: string): string
-  /**
-   * Resolves the generated SDK facade property name for a client class.
-   */
-  resolveClientPropertyName(this: ResolverClient, name: string): string
-  /**
-   * Resolves the URL helper function name for an operation.
-   *
-   * @example Resolving URL helper names
-   * `resolver.resolveUrlName(node) // -> 'getShowPetByIdUrl'`
-   */
-  resolveUrlName(this: ResolverClient, node: ast.OperationNode): string
-}
-
-/**
- * Use either a preset `client` type OR a custom `importPath`, not both.
- * `importPath` will override the default `client` preset when both are provided.
- * These options are mutually exclusive. `bundle` and `importPath` are also
- * mutually exclusive since `bundle` only has effect when `importPath` is not set.
- */
-export type ClientImportPath =
-  | {
-      /**
-       * HTTP client used by the generated code.
-       * - `'axios'` — imports from `@kubb/plugin-client/clients/axios`. Requires `axios` at runtime.
-       * - `'fetch'` — imports from `@kubb/plugin-client/clients/fetch`. Uses the global `fetch`.
-       *
-       * @default 'axios'
-       */
-      client?: 'axios' | 'fetch'
-      importPath?: never
-    }
-  | {
-      client?: never
-      /**
-       * Path to a custom client module. Generated files import their HTTP runtime from here
-       * instead of `@kubb/plugin-client/clients/{client}`. Accepts both relative paths and
-       * bare module specifiers; the value is used as-is.
-       *
-       * @note When combined with a query plugin, the module must export `Client`,
-       * `RequestConfig`, and `ResponseErrorConfig` types.
-       */
-      importPath: string
-      /**
-       * `bundle` has no effect when `importPath` is set.
-       * Use either `bundle` (with `client`) or `importPath`, not both.
-       */
-      bundle?: never
-    }
-
-/**
- * Discriminated union that ties `pathParamsType` to the `paramsType` values where it is meaningful.
- *
- * - `paramsType: 'object'` — all parameters (including path params) are merged into a single
- *   destructured object. `pathParamsType` is never reached in this code path and has no effect.
- * - `paramsType?: 'inline'` (or omitted) — each parameter group is a separate function argument.
- *   `pathParamsType` controls whether the path-param group itself is destructured (`'object'`)
- *   or spread as individual arguments (`'inline'`).
- */
-type ParamsTypeOptions =
-  | {
-      /**
-       * Every operation parameter (path, query, headers, body) is wrapped in a single
-       * destructured object argument.
-       */
-      paramsType: 'object'
-      /**
-       * `pathParamsType` has no effect when `paramsType` is `'object'`.
-       * Path params already live inside the single destructured object.
-       */
-      pathParamsType?: never
-    }
-  | {
-      /**
-       * Each parameter group is emitted as a separate positional function argument.
-       *
-       * @default 'inline'
-       */
-      paramsType?: 'inline'
-      /**
-       * How URL path parameters are arranged inside the inline argument list.
-       * - `'object'` groups them into one destructured object: `{ petId }: PathParams`.
-       * - `'inline'` emits each path param as its own argument: `petId: string`.
-       *
-       * @default 'inline'
-       */
-      pathParamsType?: 'object' | 'inline'
-    }
-
-export type Options = {
-  /**
-   * Where the generated client files are written and how they are exported.
-   *
-   * @default { path: 'clients', barrel: { type: 'named' } }
-   */
-  output?: Output
-  /**
-   * Split generated files into subfolders based on the operation's tag.
-   */
-  group?: Group
-  /**
-   * Skip operations matching at least one entry in the list.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Restrict generation to operations matching at least one entry in the list.
-   */
-  include?: Array<Include>
-  /**
-   * Apply a different options object to operations matching a pattern.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Emit an `operations.ts` file that re-exports every generated function grouped by HTTP method.
-   *
-   * @default false
-   */
-  operations?: boolean
-  /**
-   * Whether to also export the URL builder helpers (`get<Operation>Url`).
-   * - `'export'` exposes them via the barrel.
-   * - `false` keeps them private.
-   *
-   * @default false
-   */
-  urlType?: 'export' | false
-  /**
-   * Base URL prepended to every request. When omitted, falls back to the adapter's
-   * server URL (typically `servers[0].url`).
-   */
-  baseURL?: string
-  /**
-   * Shape of the value returned by each generated client function.
-   * - `'data'` — only the response body.
-   * - `'full'` — the full response config (body, status, headers, request).
-   *
-   * @default 'data'
-   */
-  dataReturnType?: 'data' | 'full'
-  /**
-   * Rename parameter properties in the generated client (path, query, headers).
-   * The HTTP request still uses the original spec names; Kubb writes the mapping for you.
-   *
-   * @note Use the same value on `@kubb/plugin-ts` so types stay compatible.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Validator applied to response bodies before they are returned to the caller.
-   * - `false` (default) — no validation. The client has no runtime parser; the response is
-   *   returned as-is, cast to the generated TypeScript type.
-   * - `'zod'` — pipes responses through schemas from `@kubb/plugin-zod`.
-   *
-   * @default false
-   */
-  parser?: false | 'zod'
-  /**
-   * Shape of the generated client.
-   * - `'function'` — one standalone async function per operation.
-   * - `'class'` — one class per tag with instance methods.
-   * - `'staticClass'` — one class per tag with static methods.
-   *
-   * @default 'function'
-   * @note Only `'function'` is compatible with query plugins.
-   */
-  clientType?: 'function' | 'class' | 'staticClass'
-  /**
-   * Copy the HTTP client runtime into the generated output so consumers do not need
-   * `@kubb/plugin-client` at runtime. When `false`, generated files import from
-   * `@kubb/plugin-client/clients/{client}`.
-   *
-   * @default false
-   */
-  bundle?: boolean
-  /**
-   * Generate a single SDK class composing every tag-based client into one entry point.
-   * Automatically enables `clientType: 'class'`.
-   *
-   * @example
-   * ```ts
-   * pluginClient({
-   *   sdk: { className: 'PetStoreSDK' },
-   * })
-   * // class PetStoreSDK {
-   * //   readonly petController: petController
-   * //   readonly storeController: storeController
-   * //   constructor(config = {}) { ... }
-   * // }
-   * ```
-   */
-  sdk?: {
-    /**
-     * Name of the generated SDK facade class. Also the file name.
-     */
-    className: string
-  }
-  /**
-   * Override how names and file paths are built for the generated client.
-   * Methods you omit fall back to the default resolver. `this` is bound to the
-   * full resolver, so `this.default(name)` delegates to the built-in implementation.
-   */
-  resolver?: Partial<ResolverClient> & ThisType<ResolverClient>
-  /**
-   * AST visitor applied to each operation node before code is printed.
-   * Return `null` or `undefined` to leave the node unchanged.
-   */
-  transformer?: ast.Visitor
-  /**
-   * Custom generators that run alongside the built-in client generators.
-   */
-  generators?: Array<Generator<PluginClient>>
-} & ClientImportPath &
-  ParamsTypeOptions
-
-type ResolvedOptions = {
-  output: Output
-  exclude: Array<Exclude>
-  include: Array<Include> | undefined
-  override: Array<Override<ResolvedOptions>>
-  group: Group | null
-  client: Options['client']
-  clientType: NonNullable<Options['clientType']>
-  bundle: NonNullable<Options['bundle']>
-  parser: NonNullable<Options['parser']>
-  urlType: NonNullable<Options['urlType']>
-  importPath: Options['importPath']
-  baseURL: Options['baseURL']
-  dataReturnType: NonNullable<Options['dataReturnType']>
-  pathParamsType: NonNullable<NonNullable<Options['pathParamsType']>>
-  paramsType: NonNullable<Options['paramsType']>
-  paramsCasing: Options['paramsCasing']
-  sdk: Options['sdk']
-  resolver: ResolverClient
-}
-
-export type PluginClient = PluginFactoryOptions<'plugin-client', Options, ResolvedOptions, ResolverClient>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-client': PluginClient
-    }
-  }
-}

package/src/utils.ts

@@ -1,159 +0,0 @@
-import { getOperationParameters, getResponseType, resolveSuccessNames } from '@internals/shared'
-import type { URLPath } from '@internals/utils'
-import { 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'
-
-/**
- * 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}'` : null,
-    hasHeaderParams ? '...headers' : null,
-  ].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 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)
-}
-
-/**
- * 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,
-  isMultipleContentTypes,
-  hasFormData,
-  headers,
-}: {
-  node: ast.OperationNode
-  path: URLPath
-  baseURL: string | null | undefined
-  tsResolver: ResolverTs
-  isFormData: boolean
-  isMultipleContentTypes: boolean
-  hasFormData: boolean
-  headers: Array<string>
-}) {
-  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
-  const responseType = getResponseType(node)
-
-  return createFunctionParams({
-    config: {
-      mode: 'object',
-      children: {
-        requestConfig: {
-          mode: 'inlineSpread',
-        },
-        method: {
-          value: JSON.stringify(ast.isHttpOperationNode(node) ? node.method.toUpperCase() : ''),
-        },
-        url: {
-          value: path.template,
-        },
-        baseURL: baseURL
-          ? {
-              value: JSON.stringify(baseURL),
-            }
-          : null,
-        params: queryParamsName ? {} : null,
-        data: requestName
-          ? {
-              value:
-                isMultipleContentTypes && hasFormData
-                  ? "contentType === 'multipart/form-data' ? formData as FormData : requestData"
-                  : isFormData
-                    ? 'formData as FormData'
-                    : 'requestData',
-            }
-          : null,
-        contentType: isMultipleContentTypes ? {} : null,
-        responseType: responseType ? { value: JSON.stringify(responseType) } : null,
-        headers: headers.length
-          ? {
-              value: `{ ${headers.join(', ')}, ...requestConfig.headers }`,
-            }
-          : null,
-      },
-    },
-  })
-}
-
-/**
- * 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 | null
-}): string {
-  const zodRequestName = zodResolver && parser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null
-  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 | null
-}): string {
-  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : null
-  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 !== 'zod') {
-    return 'return res'
-  }
-  return 'return res.data'
-}