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

package/src/types.ts

@@ -1,276 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, 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. The default
-   * appends a `Client` suffix (tag `pet` becomes `PetClient`) so the class never
-   * collides with the schema model of the same name in the barrel.
-   *
-   * @example Resolving tag-group class names
-   * `resolver.resolveGroupName('pet') // -> 'PetClient'`
-   */
-  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'
-    }
-
-/**
- * Where the generated client files are written and how they are exported, plus the optional
- * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
- *
- * @default { path: 'clients', barrel: { type: 'named' } }
- */
-export type Options = OutputOptions & {
-  /**
-   * 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 as a discriminated union keyed by HTTP status code.
-   *   Each member is `{ status: N; data: StatusNType; statusText: string }`,
-   *   so narrowing on `res.status` also narrows `res.data` to the matching response type.
-   *
-   * @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 request and response bodies using schemas from `@kubb/plugin-zod`.
-   * - `false` (default): no validation. The response is returned as-is.
-   * - `'zod'`: validates response bodies only (backward-compatible shorthand).
-   * - `{ request?: 'zod'; response?: 'zod' }`: opt in per direction. `request` validates the
-   *   request body and query parameters before the call. `response` validates the response body.
-   *
-   * @default false
-   * @example Response only (shorthand)
-   * `parser: 'zod'`
-   * @example Both directions
-   * `parser: { request: 'zod', response: 'zod' }`
-   */
-  parser?: false | 'zod' | { request?: 'zod'; response?: '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 petClient: PetClient
-   * //   readonly storeClient: StoreClient
-   * //   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,259 +0,0 @@
-import { buildStatusUnionType, getOperationParameters, getResponseType, resolveSuccessNames } from '@internals/shared'
-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'
-
-type ParserOption = PluginClient['resolvedOptions']['parser']
-
-/**
- * Returns `true` when any direction of the parser uses Zod (used for dependency checks).
- */
-export function isParserEnabled(parser: ParserOption | undefined | false): boolean {
-  if (!parser) return false
-  if (parser === 'zod') return true
-  return !!(parser.request || parser.response)
-}
-
-/**
- * Returns `'zod'` when request body parsing is enabled, `null` otherwise.
- * The string shorthand `'zod'` also enables request body parsing (existing behavior).
- */
-export function resolveRequestParser(parser: ParserOption | undefined | false): 'zod' | null {
-  if (!parser) return null
-  if (parser === 'zod') return 'zod'
-  return parser.request ?? null
-}
-
-/**
- * Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise.
- * Only the object form `{ request: 'zod' }` enables query-params parsing.
- * The string shorthand `'zod'` does not, preserving its existing behavior.
- */
-export function resolveQueryParamsParser(parser: ParserOption | undefined | false): 'zod' | null {
-  if (!parser || parser === 'zod') return null
-  return parser.request ?? null
-}
-
-/**
- * Returns `'zod'` when response-direction parsing is enabled, `null` otherwise.
- * `parser: 'zod'` (string shorthand) maps to response parsing and returns `'zod'`.
- */
-export function resolveResponseParser(parser: ParserOption | undefined | false): 'zod' | null {
-  if (!parser) return null
-  if (parser === 'zod') return 'zod'
-  return parser.response ?? null
-}
-
-export { buildStatusUnionType }
-
-/**
- * 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>
-}
-
-/**
- * Returns the generic type arguments — response, error, and request body — for a generated
- * client call.
- *
- * When `dataReturnType` is `'full'`, the response generic widens to a union of all documented
- * status types. When `parser` is `'zod'` and a request body schema exists, the request type
- * uses `z.output<typeof schema>` to reflect post-transform types (e.g. date coercion).
- */
-export function buildGenerics(
-  node: ast.OperationNode,
-  tsResolver: ResolverTs,
-  options: {
-    dataReturnType?: PluginClient['resolvedOptions']['dataReturnType']
-    zodResolver?: ResolverZod | null
-    parser?: PluginClient['resolvedOptions']['parser']
-  } = {},
-): Array<string> {
-  const allStatusNames = node.responses.map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode))
-  const successNames = resolveSuccessNames(node, tsResolver)
-  const responseName =
-    options.dataReturnType === 'full'
-      ? allStatusNames.length > 0
-        ? allStatusNames.join(' | ')
-        : tsResolver.resolveResponseName(node)
-      : 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'}>`
-
-  const zodRequestName =
-    options.parser === 'zod' && options.zodResolver && node.requestBody?.content?.[0]?.schema ? (options.zodResolver.resolveDataName?.(node) ?? null) : null
-
-  const requestGenericType = zodRequestName ? `z.output<typeof ${zodRequestName}>` : requestName || 'unknown'
-
-  return [responseName, TError, requestGenericType].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,
-  url,
-  baseURL,
-  tsResolver,
-  isFormData,
-  isMultipleContentTypes,
-  hasFormData,
-  headers,
-  zodQueryParamsName,
-}: {
-  node: ast.OperationNode
-  url: string
-  baseURL: string | null | undefined
-  tsResolver: ResolverTs
-  isFormData: boolean
-  isMultipleContentTypes: boolean
-  hasFormData: boolean
-  headers: Array<string>
-  zodQueryParamsName?: string | null
-}) {
-  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: url,
-        },
-        baseURL: baseURL
-          ? {
-              value: JSON.stringify(baseURL),
-            }
-          : null,
-        params: queryParamsName ? (zodQueryParamsName ? { value: 'requestParams' } : {}) : 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 when `parser.request === 'zod'`, otherwise assigns data directly.
- */
-export function buildRequestDataLine({
-  parser,
-  node,
-  zodResolver,
-}: {
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  node: ast.OperationNode
-  zodResolver?: ResolverZod | null
-}): string {
-  const requestParser = resolveRequestParser(parser)
-  const zodRequestName = zodResolver && requestParser === 'zod' && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null
-  if (requestParser === 'zod' && zodRequestName) {
-    return `const requestData = ${zodRequestName}.parse(data)`
-  }
-  if (node.requestBody?.content?.[0]?.schema) {
-    return 'const requestData = data'
-  }
-  return ''
-}
-
-/**
- * Builds the query parameters parsing line for client methods.
- * Returns an empty string when no query params exist or query-params parsing is not enabled.
- * Only the object form `parser: { request: 'zod' }` triggers this. `parser: 'zod'` does not.
- */
-export function buildQueryParamsLine({
-  parser,
-  node,
-  zodResolver,
-}: {
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  node: ast.OperationNode
-  zodResolver?: ResolverZod | null
-}): string {
-  if (resolveQueryParamsParser(parser) !== 'zod' || !zodResolver) return ''
-  const { query: queryParams } = getOperationParameters(node)
-  if (queryParams.length === 0) return ''
-  const zodQueryParamsName = zodResolver.resolveQueryParamsName?.(node, queryParams[0]!)
-  if (!zodQueryParamsName) return ''
-  return `const requestParams = ${zodQueryParamsName}.parse(params)`
-}
-
-/**
- * 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.
- * When `dataReturnType` is `'full'`, casts the response to the status-discriminated union type.
- * When `parser.response` is `'zod'`, pipes the response body through the Zod schema before returning.
- */
-export function buildReturnStatement({
-  dataReturnType,
-  parser,
-  node,
-  zodResolver,
-  tsResolver,
-}: {
-  dataReturnType: PluginClient['resolvedOptions']['dataReturnType']
-  parser: PluginClient['resolvedOptions']['parser'] | undefined
-  node: ast.OperationNode
-  zodResolver?: ResolverZod | null
-  tsResolver?: ResolverTs | null
-}): string {
-  const responseParser = resolveResponseParser(parser)
-  const zodResponseName = zodResolver && responseParser === 'zod' ? zodResolver.resolveResponseName?.(node) : null
-
-  if (dataReturnType === 'full' && tsResolver) {
-    const unionType = buildStatusUnionType(node, tsResolver)
-    if (responseParser === 'zod' && zodResponseName) {
-      return `return {...res, data: ${zodResponseName}.parse(res.data)} as ${unionType}`
-    }
-    return `return res as ${unionType}`
-  }
-
-  if (dataReturnType === 'data' && responseParser === 'zod' && zodResponseName) {
-    return `return ${zodResponseName}.parse(res.data)`
-  }
-  return 'return res.data'
-}