@kubb/plugin-swr 5.0.0-alpha.9 → 5.0.0-beta.36

package/src/components/Mutation.tsx

@@ -1,130 +1,76 @@
-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, Type } 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, 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 { buildRequestConfigType, getComments, resolveErrorNames } from '../utils.ts'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
-  typeName: string
   clientName: string
   mutationKeyName: string
   mutationKeyTypeName: string
-  typeSchemas: OperationSchemas
-  operation: Operation
+  mutationArgTypeName: string
+  node: ast.OperationNode
+  tsResolver: ResolverTs
   paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
   paramsType: PluginSwr['resolvedOptions']['paramsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  /**
-   * When true, mutation parameters are passed via trigger() instead of as hook arguments
-   * @default false
-   */
-  paramsToTrigger?: boolean
-}
-
-type GetParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
   pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
   dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
 }
 
-// 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: `
-{
-  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${TExtraArg}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-}
-`,
-      default: '{}',
-    },
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
+const keysPrinter = functionPrinter({ mode: 'keys' })
+
+function createMutationArgParams(
+  node: ast.OperationNode,
+  options: {
+    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
+    resolver: ResolverTs
+  },
+): ast.FunctionParametersNode {
+  return ast.createOperationParams(node, {
+    paramsType: 'inline',
+    pathParamsType: 'inline',
+    paramsCasing: options.paramsCasing,
+    resolver: options.resolver,
   })
 }
 
-type GetTriggerParamsProps = {
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-  mutationKeyTypeName: string
-  mutationArgTypeName: string
-}
-
-// 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'}>`
-
-  return FunctionParams.factory({
-    options: {
-      type: `
-{
+function buildMutationParamsNode(
+  node: ast.OperationNode,
+  options: {
+    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
+    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
+    mutationKeyTypeName: string
+    mutationArgTypeName: string
+    resolver: ResolverTs
+  },
+): ast.FunctionParametersNode {
+  const { dataReturnType, mutationKeyTypeName, mutationArgTypeName, 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'}>`
+
+  return ast.createFunctionParameters({
+    params: [
+      ast.createFunctionParameter({
+        name: 'options',
+        type: ast.createParamsType({
+          variant: 'reference',
+          name: `{
   mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
+  client?: ${buildRequestConfigType(node, resolver)},
   shouldFetch?: boolean,
-}
-`,
-      default: '{}',
-    },
-  })
-}
-
-type GetMutationParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  typeSchemas: OperationSchemas
-}
-
-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,
+}`,
+        }),
+        default: '{}',
+      }),
+    ],
   })
 }
 
@@ -133,144 +79,77 @@ export function Mutation({
   clientName,
   mutationKeyName,
   mutationKeyTypeName,
-  paramsType,
+  mutationArgTypeName,
   paramsCasing,
+  paramsType,
   pathParamsType,
   dataReturnType,
-  typeSchemas,
-  operation,
-  paramsToTrigger = false,
-}: Props): FabricReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+  node,
+  tsResolver,
+}: Props): KubbReactNode {
+  const responseName = tsResolver.resolveResponseName(node)
+  const errorNames = resolveErrorNames(node, tsResolver)
 
-  const mutationKeyParams = MutationKey.getParams({
-    pathParamsType,
-    typeSchemas,
-  })
-
-  const clientParams = Client.getParams({
-    paramsCasing,
-    paramsType,
-    typeSchemas,
-    pathParamsType,
-    isConfigurable: true,
-  })
-
-  // Use the new trigger-based approach when paramsToTrigger is true
-  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 params = getTriggerParams({
-      dataReturnType,
-      typeSchemas,
-      mutationKeyTypeName,
-      mutationArgTypeName,
-    })
-
-    const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName].filter(Boolean)
-
-    const mutationArg = mutationParams.toConstructor()
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
 
-    return (
-      <>
-        <File.Source name={mutationArgTypeName} isExportable isIndexable isTypeOnly>
-          <Type name={mutationArgTypeName} export>
-            {hasMutationParams ? `{${mutationArg}}` : 'never'}
-          </Type>
-        </File.Source>
-        <File.Source name={name} isExportable isIndexable>
-          <Function
-            name={name}
-            export
-            params={params.toConstructor()}
-            JSDoc={{
-              comments: getComments(operation),
-            }}
-          >
-            {`
-        const { mutation: mutationOptions, client: config = {}, shouldFetch = true } = options ?? {}
-        const mutationKey = ${mutationKeyName}(${mutationKeyParams.toCall()})
-
-        return useSWRMutation<${generics.join(', ')}>(
-          shouldFetch ? mutationKey : null,
-          async (_url${hasMutationParams ? `, { arg: ${argParams.toCall()} }` : ''}) => {
-            return ${clientName}(${clientParams.toCall()})
-          },
-          mutationOptions
-        )
-    `}
-          </Function>
-        </File.Source>
-      </>
-    )
-  }
+  const mutationArgParamsNode = createMutationArgParams(node, { paramsCasing, resolver: tsResolver })
+  const hasMutationParams = mutationArgParamsNode.params.length > 0
+  const argTypeBody = hasMutationParams ? (declarationPrinter.print(mutationArgParamsNode) ?? '') : ''
+  const argKeysStr = hasMutationParams ? (keysPrinter.print(mutationArgParamsNode) ?? '') : ''
 
-  // Original behavior (default)
-  const generics = [
-    TData,
-    TError,
-    `${mutationKeyTypeName} | null`,
-    typeSchemas.request?.name, // TExtraArg - the arg type for useSWRMutation
-  ].filter(Boolean)
+  const generics = [TData, TError, `${mutationKeyTypeName} | null`, mutationArgTypeName]
 
-  const params = getParams({
+  const paramsNode = buildMutationParamsNode(node, {
     paramsCasing,
-    pathParamsType,
     dataReturnType,
-    typeSchemas,
     mutationKeyTypeName,
+    mutationArgTypeName,
+    resolver: tsResolver,
+  })
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+
+  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) ?? ''
 
   return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-      >
-        {`
+    <>
+      <File.Source name={mutationArgTypeName} isExportable isIndexable isTypeOnly>
+        <Type name={mutationArgTypeName} export>
+          {hasMutationParams ? `{ ${argTypeBody} }` : 'never'}
+        </Type>
+      </File.Source>
+      <File.Source name={name} isExportable isIndexable>
+        <Function name={name} export params={paramsSignature} JSDoc={{ 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${hasMutationParams ? `, { arg: { ${argKeysStr} } }` : ''}) => {
+            return ${clientName}(${clientCallStr})
           },
           mutationOptions
         )
     `}
-      </Function>
-    </File.Source>
+        </Function>
+      </File.Source>
+    </>
   )
 }

package/src/components/MutationKey.tsx

@@ -1 +1,25 @@
-export { MutationKey } from '@internals/tanstack-query'
+import type { Transformer } from '@internals/tanstack-query'
+import { MutationKey as SharedMutationKey } from '@internals/tanstack-query'
+import type { ast } from '@kubb/core'
+import { File, Type } from '@kubb/renderer-jsx'
+import type { KubbReactNode } from '@kubb/renderer-jsx/types'
+
+type Props = {
+  name: string
+  typeName: string
+  node: ast.OperationNode
+  paramsCasing: 'camelcase' | undefined
+  pathParamsType: 'object' | 'inline'
+  transformer: Transformer | undefined
+}
+
+export function MutationKey({ name, typeName, node, paramsCasing, pathParamsType, transformer }: Props): KubbReactNode {
+  return (
+    <>
+      <SharedMutationKey name={name} node={node} paramsCasing={paramsCasing} pathParamsType={pathParamsType} transformer={transformer} />
+      <File.Source name={typeName} isExportable isIndexable isTypeOnly>
+        <Type export name={typeName}>{`ReturnType<typeof ${name}>`}</Type>
+      </File.Source>
+    </>
+  )
+}

package/src/components/Query.tsx

@@ -1,189 +1,124 @@
-import { getDefaultValue, isOptional, type Operation } from '@kubb/oas'
-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 } 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 { getEnabledParamNames, markParamsOptional } from '@internals/tanstack-query'
 import type { PluginSwr } from '../types.ts'
-import { QueryKey } from './QueryKey.tsx'
-import { QueryOptions } from './QueryOptions.tsx'
+import { buildQueryKeyParams, getComments, resolveErrorNames } from '../utils.ts'
+import { getQueryOptionsParams } from './QueryOptions.tsx'
 
 type Props = {
-  /**
-   * Name of the function
-   */
   name: string
   queryOptionsName: string
   queryKeyName: string
   queryKeyTypeName: string
-  typeSchemas: OperationSchemas
+  node: ast.OperationNode
+  tsResolver: ResolverTs
   paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
   paramsType: PluginSwr['resolvedOptions']['paramsType']
   pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
   dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  operation: Operation
 }
 
-type GetParamsProps = {
-  paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
-  paramsType: PluginSwr['resolvedOptions']['paramsType']
-  pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
-  typeSchemas: OperationSchemas
-}
+const declarationPrinter = functionPrinter({ mode: 'declaration' })
+const callPrinter = functionPrinter({ mode: 'call' })
 
-function getParams({ paramsType, paramsCasing, pathParamsType, 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'}>`
+function buildQueryParamsNode(
+  node: ast.OperationNode,
+  options: {
+    paramsType: PluginSwr['resolvedOptions']['paramsType']
+    paramsCasing: PluginSwr['resolvedOptions']['paramsCasing']
+    pathParamsType: PluginSwr['resolvedOptions']['pathParamsType']
+    dataReturnType: PluginSwr['resolvedOptions']['client']['dataReturnType']
+    resolver: ResolverTs
+  },
+): ast.FunctionParametersNode {
+  const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options
+  const responseName = resolver.resolveResponseName(node)
+  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : undefined
+  const errorNames = resolveErrorNames(node, resolver)
 
-  if (paramsType === 'object') {
-    const pathParams = getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing })
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
 
-    const children = {
-      ...pathParams,
-      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,
-    }
-
-    // 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,
-      },
-      options: {
-        type: `
-{
-  query?: Parameters<typeof useSWR<${[TData, TError].join(', ')}>>[2],
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
+  const optionsParam = ast.createFunctionParameter({
+    name: 'options',
+    type: ast.createParamsType({
+      variant: 'reference',
+      name: `{
+  query?: SWRConfiguration<${[TData, TError].join(', ')}>,
+  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
   shouldFetch?: boolean,
   immutable?: boolean
-}
-`,
-        default: '{}',
-      },
-    })
-  }
+}`,
+    }),
+    default: '{}',
+  })
 
-  return FunctionParams.factory({
-    pathParams: typeSchemas.pathParams?.name
-      ? {
-          mode: pathParamsType === 'object' ? 'object' : 'inlineSpread',
-          children: getPathParams(typeSchemas.pathParams, { typed: true, casing: paramsCasing }),
-          default: getDefaultValue(typeSchemas.pathParams?.schema),
-        }
-      : undefined,
-    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,
-    options: {
-      type: `
-{
-  query?: Parameters<typeof useSWR<${[TData, TError].join(', ')}>>[2],
-  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'},
-  shouldFetch?: boolean,
-  immutable?: boolean
-}
-`,
-      default: '{}',
-    },
+  return ast.createOperationParams(node, {
+    paramsType,
+    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
+    paramsCasing,
+    resolver,
+    extraParams: [optionsParam],
   })
 }
 
 export function Query({
   name,
-  typeSchemas,
-  queryKeyName,
   queryKeyTypeName,
   queryOptionsName,
-  operation,
-  dataReturnType,
+  queryKeyName,
   paramsType,
   paramsCasing,
   pathParamsType,
-}: Props): FabricReactNode {
-  const TData = dataReturnType === 'data' ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`
-  const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(' | ') || 'Error'}>`
+  dataReturnType,
+  node,
+  tsResolver,
+}: Props): KubbReactNode {
+  const responseName = tsResolver.resolveResponseName(node)
+  const errorNames = resolveErrorNames(node, tsResolver)
+
+  const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
+  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
   const generics = [TData, TError, `${queryKeyTypeName} | null`]
 
-  const queryKeyParams = QueryKey.getParams({
-    pathParamsType,
-    typeSchemas,
-    paramsCasing,
-  })
-  const params = getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    dataReturnType,
-    typeSchemas,
-  })
+  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
+  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
+  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
 
-  const queryOptionsParams = QueryOptions.getParams({
-    paramsCasing,
-    paramsType,
-    pathParamsType,
-    typeSchemas,
-  })
+  const queryOptionsParamsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
+  const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? ''
+
+  const paramsNode = markParamsOptional(
+    buildQueryParamsNode(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver }),
+    enabledNames,
+  )
+  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
+
+  // SWR has no `enabled` option; fold the param-presence check into the null-key gate
+  // so passing `undefined` for a required param disables the request (mirrors React Query #60).
+  const shouldFetchExpr = enabledNames.length ? `shouldFetch && !!(${enabledNames.join(' && ')})` : 'shouldFetch'
 
   return (
     <File.Source name={name} isExportable isIndexable>
-      <Function
-        name={name}
-        export
-        params={params.toConstructor()}
-        JSDoc={{
-          comments: getComments(operation),
-        }}
-      >
+      <Function name={name} export params={paramsSignature} JSDoc={{ comments: getComments(node) }}>
         {`
        const { query: queryOptions, client: config = {}, shouldFetch = true, immutable } = options ?? {}
 
-       const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
+       const queryKey = ${queryKeyName}(${queryKeyParamsCall})
 
        return useSWR<${generics.join(', ')}>(
-        shouldFetch ? queryKey : null,
+        ${shouldFetchExpr} ? queryKey : null,
         {
-          ...${queryOptionsName}(${queryOptionsParams.toCall()}),
+          ...${queryOptionsName}(${queryOptionsParamsCall}),
           ...(immutable ? {
               revalidateIfStale: false,
               revalidateOnFocus: false,
               revalidateOnReconnect: false
             } : { }),
-          ...queryOptions
+          ...queryOptions,
         }
        )
        `}