@kubb/plugin-swr 5.0.0-alpha.34 → 5.0.0-alpha.35

package/src/components/Mutation.tsx

@@ -1,25 +1,27 @@
-import type { Params } from '@kubb/core'
-import { FunctionParams } from '@kubb/core'
-import { isOptional, type Operation } from '@kubb/oas'
-import { ClientLegacy as Client } from '@kubb/plugin-client'
-import type { OperationSchemas } from '@kubb/plugin-oas'
-import { getComments, getPathParams } from '@kubb/plugin-oas/utils'
+import { ast } from '@kubb/core'
+import type { PluginTs } from '@kubb/plugin-ts'
+import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function, Type } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginSwr } from '../types.ts'
-import { MutationKey } from './MutationKey.tsx'
+import {
+  buildGroupParam,
+  buildMutationArgParams,
+  getComments,
+  resolveErrorNames,
+  resolveHeaderGroupType,
+  resolvePathParamType,
+  resolveQueryGroupType,
+} from '../utils.ts'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   typeName: string
   clientName: string
   mutationKeyName: string
   mutationKeyTypeName: string
-  typeSchemas: OperationSchemas
-  operation: Operation
+  node: ast.OperationNode
+  tsResolver: PluginTs['resolver']
   paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
   paramsType: PluginSwr['resolvedOptions']['paramsType']
   dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
@@ -31,102 +33,118 @@ type Props = {
   paramsToTrigger?: boolean
 }
 
-type GetParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
+const keysPrinter = functionPrinter({ mode: 'keys' })
+
+/**
+ * Default mutation hook params (paramsToTrigger=false):
+ * pathParams + queryParams + headers + options (NO data — it comes via useSWRMutation arg)
+ */
+function getParams(
+  node: ast.OperationNode,
+  options: {
+    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
+    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
+    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
+    resolver: PluginTs['resolver']
+    mutationKeyTypeName: string
+  },
+): ast.FunctionParametersNode {
+  const { paramsCasing, pathParamsType, dataReturnType, resolver, mutationKeyTypeName } = options
+
+  const responseName = resolver.resolveResponseName(node)
+  const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : undefined
+  const errorNames = resolveErrorNames(node, resolver)
+
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
+  const TExtraArg = requestName || 'never'
+
+  const casedParams = ast.caseParams(node.parameters, paramsCasing)
+  const pathParams = casedParams.filter((p) => p.in === 'path')
+  const queryParams = casedParams.filter((p) => p.in === 'query')
+  const headerParams = casedParams.filter((p) => p.in === 'header')
+
+  const queryGroupType = resolveQueryGroupType(node, queryParams, resolver)
+  const headerGroupType = resolveHeaderGroupType(node, headerParams, resolver)
 
-// Original getParams - used when paramsToTrigger is false (default)
-function getParams({ pathParamsType, paramsCasing, dataReturnType, typeSchemas, mutationKeyTypeName }: GetParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
-  const TExtraArg = typeSchemas.request?.name || 'never'
-
-  return FunctionParams.factory({
-    pathParams: {
-      mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-      children: getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-    },
-    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,
-    options: {
-      type: `
-{
+  const params: Array<ast.FunctionParameterNode | ast.ParameterGroupNode> = []
+
+  // Path params
+  if (pathParams.length) {
+    const pathChildren = pathParams.map((p) =>
+      ast.createFunctionParameter({ name: p.name, type: resolvePathParamType(node, p, resolver), optional: !p.required }),
+    )
+    params.push({
+      kind: 'ParameterGroup',
+      properties: pathChildren,
+      inline: pathParamsType === 'inline',
+      default: pathChildren.every((c) => c.optional) ? '{}' : undefined,
+    })
+  }
+
+  // Query params
+  params.push(...buildGroupParam('params', node, queryParams, queryGroupType, resolver))
+
+  // Header params
+  params.push(...buildGroupParam('headers', node, headerParams, headerGroupType, resolver))
+
+  // Options
+  params.push(
+    ast.createFunctionParameter({
+      name: 'options',
+      type: ast.createParamsType({
+        variant: 'reference',
+        name: `{
   mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${TExtraArg}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
   shouldFetch?: boolean,
-}
-`,
+}`,
+      }),
       default: '{}',
-    },
-  })
-}
+    }),
+  )
 
-type GetTriggerParamsProps = {
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
-  mutationArgTypeName: string
+  return ast.createFunctionParameters({ params })
 }
 
-// New getParams - used when paramsToTrigger is true
-function getTriggerParams({ dataReturnType, typeSchemas, mutationKeyTypeName, mutationArgTypeName }: GetTriggerParamsProps) {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+/**
+ * Trigger-mode params (paramsToTrigger=true): just `options`
+ */
+function getTriggerParams(
+  node: ast.OperationNode,
+  options: {
+    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
+    resolver: PluginTs['resolver']
+    mutationKeyTypeName: string
+    mutationArgTypeName: string
+  },
+): ast.FunctionParametersNode {
+  const { dataReturnType, resolver, mutationKeyTypeName, mutationArgTypeName } = options
 
-  return FunctionParams.factory({
-    options: {
-      type: `
-{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-}
-`,
-      default: '{}',
-    },
-  })
-}
+  const responseName = resolver.resolveResponseName(node)
+  const requestName = node.requestBody?.schema ? resolver.resolveDataName(node) : undefined
+  const errorNames = resolveErrorNames(node, resolver)
 
-type GetMutationParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  typeSchemas: OperationSchemas
-}
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
 
-function getMutationParams({ paramsCasing, typeSchemas }: GetMutationParamsProps) {
-  return 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,
+  return ast.createFunctionParameters({
+    params: [
+      ast.createFunctionParameter({
+        name: 'options',
+        type: ast.createParamsType({
+          variant: 'reference',
+          name: `{
+  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
+  shouldFetch?: boolean,
+}`,
+        }),
+        default: '{}',
+      }),
+    ],
   })
 }
 
@@ -139,91 +157,78 @@ export function Mutation({
   paramsCasing,
   pathParamsType,
   dataReturnType,
-  typeSchemas,
-  operation,
+  node,
+  tsResolver,
   paramsToTrigger = false,
 }: Props): KubbReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+  const responseName = tsResolver.resolveResponseName(node)
+  const requestName = node.requestBody?.schema ? tsResolver.resolveDataName(node) : undefined
+  const errorNames = resolveErrorNames(node, tsResolver)
 
-  const mutationKeyParams = MutationKey.getParams({
-    pathParamsType,
-    typeSchemas,
-  })
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
 
-  const clientParams = Client.getParams({
-    paramsCasing,
+  // Client call params (path + body + query + headers + config)
+  const clientCallParamsNode = ast.createOperationParams(node, {
     paramsType,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
+    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
+    paramsCasing,
+    resolver: tsResolver,
+    extraParams: [
+      ast.createFunctionParameter({
+        name: 'config',
+        type: ast.createParamsType({
+          variant: 'reference',
+          name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }',
+        }),
+        default: '{}',
+      }),
+    ],
   })
+  const clientCallStr = callPrinter.print(clientCallParamsNode) ?? ''
 
-  // Use the new trigger-based approach when paramsToTrigger is true
+  // paramsToTrigger mode
   if (paramsToTrigger) {
-    // Build the mutation params type (for arg destructuring)
-    const mutationParams = getMutationParams({
-      paramsCasing,
-      typeSchemas,
-    })
-
-    // Get the arg type name
     const mutationArgTypeName = `${mutationKeyTypeName.replace('MutationKey', '')}MutationArg`
 
-    // Check if there are any mutation params (path, data, params, headers)
-    const hasMutationParams = Object.keys(mutationParams.params).length > 0
-
-    // Build the arg type for useSWRMutation
-    const argParams = FunctionParams.factory({
-      data: {
-        mode: 'object',
-        children: Object.entries(mutationParams.params).reduce((acc, [key, value]) => {
-          if (value) {
-            acc[key] = {
-              ...value,
-              type: undefined,
-            }
-          }
-          return acc
-        }, {} as Params),
-      },
-    })
+    const mutationArgParamsNode = buildMutationArgParams(node, { paramsCasing, resolver: tsResolver })
+    const hasMutationParams = mutationArgParamsNode.params.length > 0
 
-    const params = getTriggerParams({
-      dataReturnType,
-      typeSchemas,
-      mutationKeyTypeName,
-      mutationArgTypeName,
-    })
+    // Declaration for the type alias
+    const mutationArgDeclaration = hasMutationParams ? (declarationPrinter.print(mutationArgParamsNode) ?? '') : ''
 
-    const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName].filter(Boolean)
+    // Destructured keys for the arg in the callback
+    const argKeysStr = hasMutationParams ? (keysPrinter.print(mutationArgParamsNode) ?? '') : ''
+
+    const paramsNode = getTriggerParams(node, { dataReturnType, resolver: tsResolver, mutationKeyTypeName, mutationArgTypeName })
+    const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
-    const mutationArg = mutationParams.toConstructor()
+    const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName].filter(Boolean)
 
     return (
       <>
         <File.Source name={mutationArgTypeName} isExportable isIndexable isTypeOnly>
           <Type name={mutationArgTypeName} export>
-            {hasMutationParams ? `{${mutationArg}}` : 'never'}
+            {hasMutationParams ? `{${mutationArgDeclaration}}` : 'never'}
           </Type>
         </File.Source>
         <File.Source name={name} isExportable isIndexable>
           <Function
             name={name}
             export
-            params={params.toConstructor()}
+            params={paramsSignature}
             JSDoc={{
-              comments: getComments(operation),
+              comments: getComments(node),
             }}
           >
             {`
         const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
+        const mutationKey = ${mutationKeyName}()
 
         return useSWRMutation<${generics.join(', ')}>(
           shouldFetch ? mutationKey : null,
-          async (_url${hasMutationParams ? `, { arg: ${argParams.toCall()} }` : ''}) => {
-            return ${clientName}(${clientParams.toCall()})
+          async (_url${hasMutationParams ? `, { arg: { ${argKeysStr} } }` : ''}) => {
+            return ${clientName}(${clientCallStr})
           },
           mutationOptions
         )
@@ -234,40 +239,30 @@ export function Mutation({
     )
   }
 
-  // Original behavior (default)
-  const generics = [
-    TData,
-    TError,
-    `${mutationKeyTypeName} | null`,
-    typeSchemas.request?.name, // TExtraArg - the arg type for useSWRMutation
-  ].filter(Boolean)
+  // Default behavior (paramsToTrigger=false)
+  const generics = [TData, TError, `${mutationKeyTypeName} | null`, requestName].filter(Boolean)
 
-  const params = getParams({
-    paramsCasing,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-    mutationKeyTypeName,
-  })
+  const paramsNode = getParams(node, { paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver, mutationKeyTypeName })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
   return (
     <File.Source name={name} isExportable isIndexable>
       <Function
         name={name}
         export
-        params={params.toConstructor()}
+        params={paramsSignature}
         JSDoc={{
-          comments: getComments(operation),
+          comments: getComments(node),
         }}
       >
         {`
         const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
+        const mutationKey = ${mutationKeyName}()
 
         return useSWRMutation<${generics.join(', ')}>(
           shouldFetch ? mutationKey : null,
-          async (_url${typeSchemas.request?.name ? ', { arg: data }' : ''}) => {
-            return ${clientName}(${clientParams.toCall()})
+          async (_url${requestName ? ', { arg: data }' : ''}) => {
+            return ${clientName}(${clientCallStr})
           },
           mutationOptions
         )

package/src/components/MutationKey.tsx

@@ -1 +1,50 @@
-export { MutationKey } from '@internals/tanstack-query'
+import { URLPath } from '@internals/utils'
+import { ast } from '@kubb/core'
+import { functionPrinter } from '@kubb/plugin-ts'
+import { File, Function, Type } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+import type { Transformer } from '../types.ts'
+
+type Props = {
+  name: string
+  typeName: string
+  node: ast.OperationNode
+  paramsCasing: 'camelcase' | undefined
+  pathParamsType: 'object' | 'inline'
+  transformer: Transformer | undefined
+}
+
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+
+function getParams(): ast.FunctionParametersNode {
+  return ast.createFunctionParameters({ params: [] })
+}
+
+const getTransformer: Transformer = ({ node, casing }) => {
+  const path = new URLPath(node.path, { casing })
+  return [`{ url: '${path.toURLPath()}' }`]
+}
+
+export function MutationKey({ name, paramsCasing, node, typeName, transformer = getTransformer }: Props): KubbReactNode {
+  const paramsNode = getParams()
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+  const keys = transformer({ node, casing: paramsCasing })
+
+  return (
+    <>
+      <File.Source name={name} isExportable isIndexable>
+        <Function.Arrow name={name} export params={paramsSignature} singleLine>
+          {`[${keys.join(', ')}] as const`}
+        </Function.Arrow>
+      </File.Source>
+      <File.Source name={typeName} isExportable isIndexable isTypeOnly>
+        <Type name={typeName} export>
+          {`ReturnType<typeof ${name}>`}
+        </Type>
+      </File.Source>
+    </>
+  )
+}
+
+MutationKey.getParams = getParams
+MutationKey.getTransformer = getTransformer