@kubb/plugin-vue-query 5.0.0-alpha.9 → 5.0.0-beta.15

package/src/components/InfiniteQueryOptions.tsx

@@ -1,18 +1,22 @@
+import { getOperationParameters } from '@internals/shared'
 import { getNestedAccessor } from '@internals/utils'
-import { getDefaultValue, isOptional } from '@kubb/oas'
-import { Client } from '@kubb/plugin-client/components'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { ast } from '@kubb/core'
+import type { ResolverTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { Infinite, PluginVueQuery } from '../types.ts'
-import { QueryKey } from './QueryKey.tsx'
+import { resolveErrorNames } from '../utils.ts'
+import { buildQueryKeyParamsNode } from './QueryKey.tsx'
+import { buildEnabledCheck } from '@internals/tanstack-query'
+import { getQueryOptionsParams } from './QueryOptions.tsx'
 
 type Props = {
   name: string
   clientName: string
   queryKeyName: string
-  typeSchemas: OperationSchemas
+  node: ast.OperationNode
+  tsResolver: ResolverTs
   paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
@@ -24,105 +28,8 @@ type Props = {
   queryParam: Infinite['queryParam']
 }
 
-type GetParamsProps = {
-  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginVueQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-  typeSchemas: OperationSchemas
-}
-
-function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }: GetParamsProps) {
-  if (paramsType === 'object') {
-    const children = {
-      ...getPathParams(typeSchemas.pathParams, {
-        typed: true,
-        casing: paramsCasing,
-        override(item) {
-          return {
-            ...item,
-            type: `MaybeRefOrGetter<${item.type}>`,
-          }
-        },
-      }),
-      data: typeSchemas.request?.name
-        ? {
-            type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
-            optional: isOptional(typeSchemas.request?.schema),
-          }
-        : undefined,
-      params: typeSchemas.queryParams?.name
-        ? {
-            type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
-            optional: isOptional(typeSchemas.queryParams?.schema),
-          }
-        : undefined,
-      headers: typeSchemas.headerParams?.name
-        ? {
-            type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
-            optional: isOptional(typeSchemas.headerParams?.schema),
-          }
-        : undefined,
-    }
-
-    // Check if all children are optional or undefined
-    const allChildrenAreOptional = Object.values(children).every((child) => !child || child.optional)
-
-    return FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children,
-        default: allChildrenAreOptional ? '{}' : undefined,
-      },
-      config: {
-        type: typeSchemas.request?.name
-          ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }`
-          : 'Partial<RequestConfig> & { client?: Client }',
-        default: '{}',
-      },
-    })
-  }
-
-  return FunctionParams.factory({
-    pathParams: {
-      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-      children: getPathParams(typeSchemas.pathParams, {
-        typed: true,
-        casing: paramsCasing,
-        override(item) {
-          return {
-            ...item,
-            type: `MaybeRefOrGetter<${item.type}>`,
-          }
-        },
-      }),
-      default: getDefaultValue(typeSchemas.pathParams?.schema),
-    },
-    data: typeSchemas.request?.name
-      ? {
-          type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: `MaybeRefOrGetter<${typeSchemas.headerParams?.name}>`,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-    config: {
-      type: typeSchemas.request?.name
-        ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }`
-        : 'Partial<RequestConfig> & { client?: Client }',
-      default: '{}',
-    },
-  })
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
 
 export function InfiniteQueryOptions({
   name,
@@ -131,39 +38,70 @@ export function InfiniteQueryOptions({
   cursorParam,
   nextParam,
   previousParam,
-  typeSchemas,
-  paramsType,
+  node,
+  tsResolver,
   paramsCasing,
+  paramsType,
   dataReturnType,
   pathParamsType,
   queryParam,
   queryKeyName,
-}: Props): FabricReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-
-  const params = getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas })
-  const clientParams = Client.getParams({
-    paramsType,
-    paramsCasing,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
-  })
-  const queryKeyParams = QueryKey.getParams({
-    paramsCasing,
-    pathParamsType,
-    typeSchemas,
-  })
+}: Props): KubbReactNode {
+  const responseName = tsResolver.resolveResponseName(node)
+  const queryFnDataType = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const errorNames = resolveErrorNames(node, tsResolver)
+  const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
+
+  const isInitialPageParamDefined = initialPageParam !== undefined && initialPageParam !== null
+  const fallbackPageParamType =
+    typeof initialPageParam === 'number'
+      ? 'number'
+      : typeof initialPageParam === 'string'
+        ? initialPageParam.includes(' as ')
+          ? (() => {
+              const parts = initialPageParam.split(' as ')
+              return parts[parts.length - 1] ?? 'unknown'
+            })()
+          : 'string'
+        : typeof initialPageParam === 'boolean'
+          ? 'boolean'
+          : 'unknown'
+
+  const rawQueryParams = getOperationParameters(node).query
+  const queryParamsTypeName =
+    rawQueryParams.length > 0
+      ? (() => {
+          const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]!)
+          const individualName = tsResolver.resolveParamName(node, rawQueryParams[0]!)
+          return groupName !== individualName ? groupName : undefined
+        })()
+      : undefined
+
+  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : undefined
+  const pageParamType = queryParamType ? (isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType) : fallbackPageParamType
+
+  const paramsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+  const rawParamsCall = callPrinter.print(paramsNode) ?? ''
+  const clientCallStr = rawParamsCall.replace(/\bconfig\b(?=[^,]*$)/, '{ ...config, signal: config.signal ?? signal }')
+
+  const queryKeyParamsNode = buildQueryKeyParamsNode(node, { pathParamsType, paramsCasing, resolver: tsResolver })
+  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
+
+  const enabledSource = buildEnabledCheck(queryKeyParamsNode)
+  const enabledText = enabledSource
+    ? `enabled: () => ${enabledSource
+        .split(' && ')
+        .map((n) => `!!toValue(${n.trim()})`)
+        .join(' && ')},`
+    : ''
 
-  // Determine if we should use the new nextParam/previousParam or fall back to legacy cursorParam behavior
   const hasNewParams = nextParam !== undefined || previousParam !== undefined
 
   let getNextPageParamExpr: string | undefined
   let getPreviousPageParamExpr: string | undefined
 
   if (hasNewParams) {
-    // Use the new nextParam and previousParam
     if (nextParam) {
       const accessor = getNestedAccessor(nextParam, 'lastPage')
       if (accessor) {
@@ -177,11 +115,9 @@ export function InfiniteQueryOptions({
       }
     }
   } else if (cursorParam) {
-    // Legacy behavior: use cursorParam for both next and previous
     getNextPageParamExpr = `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`
     getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`
   } else {
-    // Fallback behavior: page-based pagination
     if (dataReturnType === 'full') {
       getNextPageParamExpr =
         'getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1'
@@ -192,53 +128,54 @@ export function InfiniteQueryOptions({
     getPreviousPageParamExpr = 'getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1'
   }
 
-  const queryOptions = [
+  const queryOptionsArr = [
     `initialPageParam: ${typeof initialPageParam === 'string' ? JSON.stringify(initialPageParam) : initialPageParam}`,
     getNextPageParamExpr,
     getPreviousPageParamExpr,
   ].filter(Boolean)
 
   const infiniteOverrideParams =
-    queryParam && typeSchemas.queryParams?.name
+    queryParam && queryParamsTypeName
       ? `
-          if (!params) {
-           params = { }
-          }
-          params['${queryParam}'] = pageParam as unknown as ${typeSchemas.queryParams?.name}['${queryParam}']`
+          params = {
+            ...(params ?? {}),
+            ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
+          } as ${queryParamsTypeName}`
       : ''
 
-  const enabled = Object.entries(queryKeyParams.flatParams)
-    .map(([key, item]) => {
-      // Only include if the parameter exists and is NOT optional
-      // This ensures we only check required parameters
-      return item && !item.optional && !item.default ? key : undefined
-    })
-    .filter(Boolean)
-    .join('&& ')
-
-  const enabledText = enabled ? `enabled: !!(${enabled}),` : ''
+  if (infiniteOverrideParams) {
+    return (
+      <File.Source name={name} isExportable isIndexable>
+        <Function name={name} export params={paramsSignature}>
+          {`
+      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({
+       ${enabledText}
+       queryKey,
+       queryFn: async ({ signal, pageParam }) => {
+          ${infiniteOverrideParams}
+          return ${clientName}(${addToValueCalls(clientCallStr)})
+        },
+       ${queryOptionsArr.join(',\n')}
+      })
+`}
+        </Function>
+      </File.Source>
+    )
+  }
 
   return (
     <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={params.toConstructor()}>
+      <Function name={name} export params={paramsSignature}>
         {`
-      const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
-      return infiniteQueryOptions<${TData}, ${TError}, ${TData}, typeof queryKey, number>({
+      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+      return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({
        ${enabledText}
        queryKey,
-       queryFn: async ({ signal, pageParam }) => {
-          ${infiniteOverrideParams}
-          return ${clientName}(${clientParams.toCall({
-            transformName(name) {
-              if (name === 'config') {
-                return '{ ...config, signal: config.signal ?? signal }'
-              }
-
-              return `toValue(${name})`
-            },
-          })})
-       },
-       ${queryOptions.join(',\n')}
+       queryFn: async ({ signal }) => {
+          return ${clientName}(${addToValueCalls(clientCallStr)})
+        },
+       ${queryOptionsArr.join(',\n')}
       })
 `}
       </Function>
@@ -246,4 +183,24 @@ export function InfiniteQueryOptions({
   )
 }
 
-InfiniteQueryOptions.getParams = getParams
+function addToValueCalls(callStr: string): string {
+  // Step 1: Transform shorthand object params like { petId } → { petId: toValue(petId) }
+  let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner: string) => {
+    if (inner.includes(':') || inner.includes('...')) return match
+    const keys = inner
+      .split(',')
+      .map((k: string) => k.trim())
+      .filter(Boolean)
+    const wrapped = keys.map((k: string) => `${k}: toValue(${k})`).join(', ')
+    return `{ ${wrapped} }`
+  })
+
+  // Step 2: Handle standalone identifiers like `data, params`
+  result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name: string) => {
+    if (name === 'config' || name === 'signal' || name === 'undefined') return match
+    if (match.includes('toValue(')) return match
+    return `toValue(${name})`
+  })
+
+  return result
+}

package/src/components/Mutation.tsx

@@ -1,81 +1,77 @@
-import { isOptional, type Operation } from '@kubb/oas'
-import { Client } from '@kubb/plugin-client/components'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
-import { File, Function, FunctionParams } from '@kubb/react-fabric'
-import type { FabricReactNode, Params } from '@kubb/react-fabric/types'
+import { ast } from '@kubb/core'
+import type { ResolverTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginVueQuery } from '../types.ts'
-import { MutationKey } from './MutationKey.tsx'
+import { buildRequestConfigType, getComments, resolveErrorNames, wrapWithMaybeRefOrGetter } from '../utils.ts'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   typeName: string
   clientName: string
   mutationKeyName: string
-  typeSchemas: OperationSchemas
-  operation: Operation
+  node: ast.OperationNode
+  tsResolver: ResolverTs
   paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
   paramsType: PluginVueQuery['resolvedOptions']['paramsType']
   dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
   pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
 }
 
-type GetParamsProps = {
-  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
+const keysPrinter = functionPrinter({ mode: 'keys' })
 
-function getParams({ paramsCasing, dataReturnType, typeSchemas }: GetParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-
-  const mutationParams = FunctionParams.factory({
-    ...getPathParams(typeSchemas.pathParams, {
-      typed: true,
-      casing: paramsCasing,
-      override(item) {
-        return {
-          ...item,
-          type: `MaybeRefOrGetter<${item.type}>`,
-        }
-      },
-    }),
-    data: typeSchemas.request?.name
-      ? {
-          type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: `MaybeRefOrGetter<${typeSchemas.headerParams?.name}>`,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
+function createMutationArgParams(
+  node: ast.OperationNode,
+  options: {
+    paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
+    resolver: ResolverTs
+  },
+): ast.FunctionParametersNode {
+  return ast.createOperationParams(node, {
+    paramsType: 'inline',
+    pathParamsType: 'inline',
+    paramsCasing: options.paramsCasing,
+    resolver: options.resolver,
   })
-  const TRequest = mutationParams.toConstructor()
-
-  return FunctionParams.factory({
-    options: {
-      type: `
-{
-  mutation?: MutationObserverOptions<${[TData, TError, TRequest ? `{${TRequest}}` : 'void', 'TContext'].join(', ')}> & { client?: QueryClient },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
 }
-`,
-      default: '{}',
-    },
+
+function buildMutationParamsNode(
+  node: ast.OperationNode,
+  options: {
+    paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
+    dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
+    resolver: ResolverTs
+  },
+): ast.FunctionParametersNode {
+  const { paramsCasing, dataReturnType, resolver } = options
+  const responseName = resolver.resolveResponseName(node)
+  const errorNames = resolveErrorNames(node, resolver)
+
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
+
+  const mutationArgParamsNode = createMutationArgParams(node, { paramsCasing, resolver })
+
+  const wrappedParamsNode = wrapWithMaybeRefOrGetter(mutationArgParamsNode)
+  const TRequestWrapped = wrappedParamsNode.params.length > 0 ? (declarationPrinter.print(wrappedParamsNode) ?? '') : ''
+
+  return ast.createFunctionParameters({
+    params: [
+      ast.createFunctionParameter({
+        name: 'options',
+        type: ast.createParamsType({
+          variant: 'reference',
+          name: `{
+  mutation?: MutationObserverOptions<${[TData, TError, TRequestWrapped ? `{${TRequestWrapped}}` : 'void', 'TContext'].join(', ')}> & { client?: QueryClient },
+  client?: ${buildRequestConfigType(node, resolver)},
+}`,
+        }),
+        default: '{}',
+      }),
+    ],
   })
 }
 
@@ -86,94 +82,61 @@ export function Mutation({
   paramsType,
   pathParamsType,
   dataReturnType,
-  typeSchemas,
-  operation,
+  node,
+  tsResolver,
   mutationKeyName,
-}: Props): FabricReactNode {
-  const mutationKeyParams = MutationKey.getParams({
-    pathParamsType,
-    typeSchemas,
-  })
+}: Props): KubbReactNode {
+  const responseName = tsResolver.resolveResponseName(node)
+  const errorNames = resolveErrorNames(node, tsResolver)
 
-  const params = getParams({
-    paramsCasing,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-  })
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
 
-  const clientParams = Client.getParams({
+  const mutationArgParamsNode = createMutationArgParams(node, {
     paramsCasing,
-    paramsType,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
+    resolver: tsResolver,
   })
+  const hasMutationParams = mutationArgParamsNode.params.length > 0
+  const TRequest = hasMutationParams ? (declarationPrinter.print(mutationArgParamsNode) ?? '') : ''
+  const argKeysStr = hasMutationParams ? (keysPrinter.print(mutationArgParamsNode) ?? '') : ''
 
-  const mutationParams = FunctionParams.factory({
-    ...getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-    data: typeSchemas.request?.name
-      ? {
-          type: typeSchemas.request?.name,
-          optional: isOptional(typeSchemas.request?.schema),
-        }
-      : undefined,
-    params: typeSchemas.queryParams?.name
-      ? {
-          type: typeSchemas.queryParams?.name,
-          optional: isOptional(typeSchemas.queryParams?.schema),
-        }
-      : undefined,
-    headers: typeSchemas.headerParams?.name
-      ? {
-          type: typeSchemas.headerParams?.name,
-          optional: isOptional(typeSchemas.headerParams?.schema),
-        }
-      : undefined,
-  })
-  const dataParams = FunctionParams.factory({
-    data: {
-      // No use of pathParams because useMutation can only take one argument in object form,
-      // see https://tanstack.com/query/latest/docs/framework/react/reference/useMutation#usemutation
-      mode: 'object',
-      children: Object.entries(mutationParams.params).reduce((acc, [key, value]) => {
-        if (value) {
-          acc[key] = {
-            ...value,
-            type: undefined,
-          }
-        }
-
-        return acc
-      }, {} as Params),
-    },
-  })
+  const generics = [TData, TError, TRequest ? `{${TRequest}}` : 'void', 'TContext'].join(', ')
 
-  const TRequest = mutationParams.toConstructor()
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+  const mutationKeyParamsNode = ast.createFunctionParameters({ params: [] })
+  const mutationKeyParamsCall = callPrinter.print(mutationKeyParamsNode) ?? ''
 
-  const generics = [TData, TError, TRequest ? `{${TRequest}}` : 'void', 'TContext'].join(', ')
+  const clientCallParamsNode = ast.createOperationParams(node, {
+    paramsType,
+    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
+    paramsCasing,
+    resolver: tsResolver,
+    extraParams: [
+      ast.createFunctionParameter({
+        name: 'config',
+        type: ast.createParamsType({
+          variant: 'reference',
+          name: buildRequestConfigType(node, tsResolver),
+        }),
+        default: '{}',
+      }),
+    ],
+  })
+  const clientCallStr = callPrinter.print(clientCallParamsNode) ?? ''
+
+  const paramsNode = buildMutationParamsNode(node, { paramsCasing, dataReturnType, resolver: tsResolver })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
   return (
     <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-        generics={['TContext']}
-      >
+      <Function name={name} export params={paramsSignature} JSDoc={{ comments: getComments(node) }} generics={['TContext']}>
         {`
         const { mutation = {}, client: config = {} } = options ?? {}
         const { client: queryClient, ...mutationOptions } = mutation;
-        const mutationKey = mutationOptions?.mutationKey ?? ${mutationKeyName}(${mutationKeyParams.toCall()})
+        const mutationKey = mutationOptions?.mutationKey ?? ${mutationKeyName}(${mutationKeyParamsCall})
 
         return useMutation<${generics}>({
-          mutationFn: async(${dataParams.toConstructor()}) => {
-            return ${clientName}(${clientParams.toCall()})
+          mutationFn: async(${hasMutationParams ? `{ ${argKeysStr} }` : ''}) => {
+            return ${clientName}(${clientCallStr})
           },
           mutationKey,
           ...mutationOptions