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

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
+import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
 
 /**
  * The concrete resolver type for `@kubb/plugin-client`.
@@ -7,10 +7,39 @@ import type { ast, Exclude, Generator, Group, Include, Output, Override, PluginF
 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
 }
 
 /**
@@ -22,9 +51,10 @@ export type ResolverClient = Resolver & {
 export type ClientImportPath =
   | {
       /**
-       * Which client should be used to do the HTTP calls.
-       * - 'axios' uses axios client for HTTP requests.
-       * - 'fetch' uses native fetch API for HTTP requests.
+       * 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'
@@ -33,9 +63,12 @@ export type ClientImportPath =
   | {
       client?: never
       /**
-       * Client import path for API calls.
-       * Used as `import client from '${importPath}'`.
-       * Accepts relative and absolute paths; path changes are not performed.
+       * 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
       /**
@@ -57,142 +90,155 @@ export type ClientImportPath =
 type ParamsTypeOptions =
   | {
       /**
-       * All parameters — path, query, headers, and body — are merged into a single
+       * Every operation parameter (path, query, headers, body) is wrapped in a single
        * destructured object argument.
-       * - 'object' returns the params and pathParams as an object.
-       * @default 'inline'
        */
       paramsType: 'object'
       /**
        * `pathParamsType` has no effect when `paramsType` is `'object'`.
-       * Path params are already inside the single destructured object.
+       * Path params already live inside the single destructured object.
        */
       pathParamsType?: never
     }
   | {
       /**
-       * Each parameter group is emitted as a separate function argument.
-       * - 'inline' returns the params as comma separated params.
+       * Each parameter group is emitted as a separate positional function argument.
+       *
        * @default 'inline'
        */
       paramsType?: 'inline'
       /**
-       * Controls how path parameters are arranged within the inline argument list.
-       * - 'object' groups path params into a destructured object: `{ petId }: PathParams`.
-       * - 'inline' emits each path param as its own argument: `petId: string`.
+       * 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 = {
-  /**
-   * Specify the export location for the files and define the behavior of the output.
-   * @default { path: 'clients', barrelType: 'named' }
-   */
-  output?: Output
-  /**
-   * Group the clients based on the provided name.
-   */
-  group?: Group
+/**
+ * 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 & {
   /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
+   * Skip operations matching at least one entry in the list.
    */
   exclude?: Array<Exclude>
   /**
-   * Array containing include parameters to include tags/operations/methods/paths.
+   * Restrict generation to operations matching at least one entry in the list.
    */
   include?: Array<Include>
   /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
+   * Apply a different options object to operations matching a pattern.
    */
   override?: Array<Override<ResolvedOptions>>
   /**
-   * Create `operations.ts` file with all operations grouped by methods.
+   * Emit an `operations.ts` file that re-exports every generated function grouped by HTTP method.
+   *
    * @default false
    */
   operations?: boolean
   /**
-   * Export urls that are used by operation x.
-   * - 'export' makes them part of your barrel file.
-   * - false does not make them exportable.
+   * Whether to also export the URL builder helpers (`get<Operation>Url`).
+   * - `'export'` exposes them via the barrel.
+   * - `false` keeps them private.
+   *
    * @default false
-   * @example getGetPetByIdUrl
    */
   urlType?: 'export' | false
   /**
-   * Allows you to set a custom base url for all generated calls.
+   * Base URL prepended to every request. When omitted, falls back to the adapter's
+   * server URL (typically `servers[0].url`).
    */
   baseURL?: string
   /**
-   * ReturnType that is used when calling the client.
-   * - 'data' returns ResponseConfig[data].
-   * - 'full' returns ResponseConfig.
+   * 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'
   /**
-   * How to style your params, by default no casing is applied.
-   * - 'camelcase' uses camelCase for pathParams, queryParams and headerParams names
-   * @note response types (data/body) are not affected by this option
+   * 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'
   /**
-   * Which parser can be used before returning the data.
-   * - 'client' returns the data as-is from the client.
-   * - 'zod' uses @kubb/plugin-zod to parse the data.
-   * @default 'client'
+   * 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?: 'client' | 'zod'
+  parser?: false | 'zod' | { request?: 'zod'; response?: 'zod' }
   /**
-   * How to generate the client code.
-   * - 'function' generates standalone functions for each operation.
-   * - 'class' generates a class with methods for each operation.
-   * - 'staticClass' generates a class with static methods for each operation.
+   * 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'
   /**
-   * Bundle the selected client into the generated `.kubb` directory.
-   * When disabled the generated clients will import the shared runtime from `@kubb/plugin-client/clients/*`.
+   * 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
-   * In version 5 of Kubb this is by default true
    */
   bundle?: boolean
   /**
-   * Generate an SDK facade class that composes all tag-based client classes into a single entry point.
-   * Setting this option automatically enables `clientType: 'class'`.
+   * Generate a single SDK class composing every tag-based client into one entry point.
+   * Automatically enables `clientType: 'class'`.
+   *
    * @example
    * ```ts
    * pluginClient({
    *   sdk: { className: 'PetStoreSDK' },
    * })
-   * // Generates a class with a shared constructor config and one property per tag:
    * // class PetStoreSDK {
-   * //   readonly petController: petController
-   * //   readonly storeController: storeController
+   * //   readonly petClient: PetClient
+   * //   readonly storeClient: StoreClient
    * //   constructor(config = {}) { ... }
    * // }
    * ```
    */
   sdk?: {
     /**
-     * Name of the generated SDK facade class.
+     * Name of the generated SDK facade class. Also the file name.
      */
     className: string
   }
   /**
-   * Override individual resolver methods. Any method you omit falls back to the
-   * preset resolver's implementation. Use `this.default(...)` to call it.
+   * 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>
   /**
-   * Single AST visitor applied to each node before printing.
-   * Return `null` or `undefined` from a method to leave the node unchanged.
+   * AST visitor applied to each operation node before code is printed.
+   * Return `null` or `undefined` to leave the node unchanged.
    */
   transformer?: ast.Visitor
   /**
-   * Define some generators next to the client generators.
+   * Custom generators that run alongside the built-in client generators.
    */
   generators?: Array<Generator<PluginClient>>
 } & ClientImportPath &
@@ -203,7 +249,7 @@ type ResolvedOptions = {
   exclude: Array<Exclude>
   include: Array<Include> | undefined
   override: Array<Override<ResolvedOptions>>
-  group: Group | undefined
+  group: Group | null
   client: Options['client']
   clientType: NonNullable<Options['clientType']>
   bundle: NonNullable<Options['bundle']>

package/src/utils.ts

@@ -1,64 +1,101 @@
-import { URLPath } from '@internals/utils'
-import type { ast } from '@kubb/core'
+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']
+
 /**
- * Extracts documentation comments from an operation node.
- * Includes description, summary, link, and deprecation information.
+ * Returns `true` when any direction of the parser uses Zod (used for dependency checks).
  */
-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))
+export function isParserEnabled(parser: ParserOption | undefined | false): boolean {
+  if (!parser) return false
+  if (parser === 'zod') return true
+  return !!(parser.request || parser.response)
 }
 
 /**
- * Builds a mapping of original parameter names to their transformed (cased) names.
- * Returns undefined if no names have changed.
+ * Returns `'zod'` when request body parsing is enabled, `null` otherwise.
+ * The string shorthand `'zod'` also enables request body parsing (existing behavior).
  */
-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
+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}'` : undefined,
-    hasHeaderParams ? '...headers' : undefined,
+    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.
+ * 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): Array<string> {
-  const responseName = tsResolver.resolveResponseName(node)
-  const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined
+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'}>`
-  return [responseName, TError, requestName || 'unknown'].filter(Boolean)
+
+  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)
 }
 
 /**
@@ -67,24 +104,29 @@ export function buildGenerics(node: ast.OperationNode, tsResolver: ResolverTs):
  */
 export function buildClassClientParams({
   node,
-  path,
+  url,
   baseURL,
   tsResolver,
   isFormData,
+  isMultipleContentTypes,
+  hasFormData,
   headers,
+  zodQueryParamsName,
 }: {
   node: ast.OperationNode
-  path: URLPath
-  baseURL: string | undefined
+  url: string
+  baseURL: string | null | undefined
   tsResolver: ResolverTs
   isFormData: boolean
+  isMultipleContentTypes: boolean
+  hasFormData: boolean
   headers: Array<string>
+  zodQueryParamsName?: string | null
 }) {
-  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
+  const responseType = getResponseType(node)
 
   return createFunctionParams({
     config: {
@@ -94,27 +136,34 @@ export function buildClassClientParams({
           mode: 'inlineSpread',
         },
         method: {
-          value: JSON.stringify(node.method.toUpperCase()),
+          value: JSON.stringify(ast.isHttpOperationNode(node) ? node.method.toUpperCase() : ''),
         },
         url: {
-          value: path.template,
+          value: url,
         },
         baseURL: baseURL
           ? {
               value: JSON.stringify(baseURL),
             }
-          : undefined,
-        params: queryParamsName ? {} : undefined,
+          : null,
+        params: queryParamsName ? (zodQueryParamsName ? { value: 'requestParams' } : {}) : 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,
+        responseType: responseType ? { value: JSON.stringify(responseType) } : null,
         headers: headers.length
           ? {
               value: `{ ${headers.join(', ')}, ...requestConfig.headers }`,
             }
-          : undefined,
+          : null,
       },
     },
   })
@@ -122,7 +171,7 @@ export function buildClassClientParams({
 
 /**
  * Builds the request data parsing line for client methods.
- * Applies Zod validation if configured, otherwise uses data directly.
+ * Applies Zod validation when `parser.request === 'zod'`, otherwise assigns data directly.
  */
 export function buildRequestDataLine({
   parser,
@@ -131,10 +180,11 @@ 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
-  if (parser === 'zod' && zodRequestName) {
+  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) {
@@ -143,6 +193,28 @@ export function buildRequestDataLine({
   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.
@@ -153,28 +225,35 @@ export function buildFormDataLine(isFormData: boolean, hasRequest: boolean): str
 
 /**
  * Builds the return statement for a client method.
- * Applies Zod validation to response data if configured, otherwise returns raw response.
+ * 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
+  zodResolver?: ResolverZod | null
+  tsResolver?: ResolverTs | null
 }): string {
-  const zodResponseName = zodResolver && parser === 'zod' ? zodResolver.resolveResponseName?.(node) : undefined
-  if (dataReturnType === 'full' && parser === 'zod' && zodResponseName) {
-    return `return {...res, data: ${zodResponseName}.parse(res.data)}`
+  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' && parser === 'zod' && zodResponseName) {
+
+  if (dataReturnType === 'data' && responseParser === 'zod' && zodResponseName) {
     return `return ${zodResponseName}.parse(res.data)`
   }
-  if (dataReturnType === 'full' && parser === 'client') {
-    return 'return res'
-  }
   return 'return res.data'
 }