@kubb/plugin-react-query 5.0.0-beta.3 → 5.0.0-beta.30

package/src/components/SuspenseInfiniteQuery.tsx

@@ -1,11 +1,11 @@
+import { getOperationParameters } from '@internals/shared'
 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 { Infinite, PluginReactQuery } from '../types.ts'
-import { getComments, resolveErrorNames } from '../utils.ts'
-import { QueryKey } from './QueryKey.tsx'
+import { buildQueryKeyParams, getComments, resolveErrorNames, resolveSuccessNames } from '../utils.ts'
 import { getQueryOptionsParams } from './QueryOptions.tsx'
 
 type Props = {
@@ -27,7 +27,7 @@ type Props = {
 const declarationPrinter = functionPrinter({ mode: 'declaration' })
 const callPrinter = functionPrinter({ mode: 'call' })
 
-function getParams(
+function buildSuspenseInfiniteQueryParamsNode(
   node: ast.OperationNode,
   options: {
     paramsType: PluginReactQuery['resolvedOptions']['paramsType']
@@ -39,7 +39,7 @@ function getParams(
   },
 ): ast.FunctionParametersNode {
   const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options
-  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : undefined
+  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null
 
   const optionsParam = ast.createFunctionParameter({
     name: 'options',
@@ -77,7 +77,8 @@ export function SuspenseInfiniteQuery({
   initialPageParam,
   queryParam,
 }: Props): KubbReactNode {
-  const responseName = tsResolver.resolveResponseName(node)
+  const successNames = resolveSuccessNames(node, tsResolver)
+  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
   const errorNames = resolveErrorNames(node, tsResolver)
 
   const responseType = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
@@ -98,17 +99,17 @@ export function SuspenseInfiniteQuery({
           ? 'boolean'
           : 'unknown'
 
-  const rawQueryParams = node.parameters.filter((p) => p.in === 'query')
+  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
+          return groupName !== individualName ? groupName : null
         })()
-      : undefined
+      : null
 
-  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : undefined
+  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null
   const pageParamType = queryParamType ? (isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType) : fallbackPageParamType
 
   const returnType = 'UseSuspenseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }'
@@ -120,13 +121,20 @@ export function SuspenseInfiniteQuery({
     `TPageParam = ${pageParamType}`,
   ]
 
-  const queryKeyParamsNode = QueryKey.getParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
+  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
   const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
 
   const queryOptionsParamsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
   const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? ''
 
-  const paramsNode = getParams(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver, pageParamGeneric: 'TPageParam' })
+  const paramsNode = buildSuspenseInfiniteQueryParamsNode(node, {
+    paramsType,
+    paramsCasing,
+    pathParamsType,
+    dataReturnType,
+    resolver: tsResolver,
+    pageParamGeneric: 'TPageParam',
+  })
   const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
   return (
@@ -152,5 +160,3 @@ export function SuspenseInfiniteQuery({
     </File.Source>
   )
 }
-
-SuspenseInfiniteQuery.getParams = getParams

package/src/components/SuspenseInfiniteQueryOptions.tsx

@@ -1,3 +1,4 @@
+import { getOperationParameters } from '@internals/shared'
 import { getNestedAccessor } from '@internals/utils'
 import type { ast } from '@kubb/core'
 import type { ResolverTs } from '@kubb/plugin-ts'
@@ -5,9 +6,9 @@ import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { Infinite, PluginReactQuery } from '../types.ts'
-import { resolveErrorNames } from '../utils.ts'
-import { QueryKey } from './QueryKey.tsx'
-import { buildEnabledCheck, getQueryOptionsParams } from './QueryOptions.tsx'
+import { buildQueryKeyParams, resolveErrorNames, resolveSuccessNames } from '../utils.ts'
+import { buildEnabledCheck } from '@internals/tanstack-query'
+import { getQueryOptionsParams } from './QueryOptions.tsx'
 
 type Props = {
   name: string
@@ -45,7 +46,8 @@ export function SuspenseInfiniteQueryOptions({
   queryParam,
   queryKeyName,
 }: Props): KubbReactNode {
-  const responseName = tsResolver.resolveResponseName(node)
+  const successNames = resolveSuccessNames(node, tsResolver)
+  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
   const queryFnDataType = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
   const errorNames = resolveErrorNames(node, tsResolver)
   const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
@@ -65,17 +67,17 @@ export function SuspenseInfiniteQueryOptions({
           ? 'boolean'
           : 'unknown'
 
-  const rawQueryParams = node.parameters.filter((p) => p.in === 'query')
+  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
+          return groupName !== individualName ? groupName : null
         })()
-      : undefined
+      : null
 
-  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : undefined
+  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null
   const pageParamType = queryParamType ? (isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType) : fallbackPageParamType
 
   const paramsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
@@ -83,43 +85,33 @@ export function SuspenseInfiniteQueryOptions({
   const rawParamsCall = callPrinter.print(paramsNode) ?? ''
   const clientCallStr = rawParamsCall.replace(/\bconfig\b(?=[^,]*$)/, '{ ...config, signal: config.signal ?? signal }')
 
-  const queryKeyParamsNode = QueryKey.getParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
+  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
   const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
 
   const enabledSource = buildEnabledCheck(queryKeyParamsNode)
   const enabledText = enabledSource ? `enabled: !!(${enabledSource}),` : ''
 
-  const hasNewParams = nextParam !== undefined || previousParam !== undefined
+  const hasNewParams = nextParam != null || previousParam != null
 
-  let getNextPageParamExpr: string | undefined
-  let getPreviousPageParamExpr: string | undefined
-
-  if (hasNewParams) {
-    if (nextParam) {
-      const accessor = getNestedAccessor(nextParam, 'lastPage')
-      if (accessor) {
-        getNextPageParamExpr = `getNextPageParam: (lastPage) => ${accessor}`
-      }
-    }
-    if (previousParam) {
-      const accessor = getNestedAccessor(previousParam, 'firstPage')
-      if (accessor) {
-        getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => ${accessor}`
-      }
+  const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
+    if (hasNewParams) {
+      const nextAccessor = nextParam ? getNestedAccessor(nextParam, 'lastPage') : null
+      const prevAccessor = previousParam ? getNestedAccessor(previousParam, 'firstPage') : null
+      return [
+        nextAccessor ? `getNextPageParam: (lastPage) => ${nextAccessor}` : null,
+        prevAccessor ? `getPreviousPageParam: (firstPage) => ${prevAccessor}` : null,
+      ] as const
     }
-  } else if (cursorParam) {
-    getNextPageParamExpr = `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`
-    getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`
-  } else {
-    if (dataReturnType === 'full') {
-      getNextPageParamExpr =
-        'getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1'
-    } else {
-      getNextPageParamExpr =
-        'getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1'
+    if (cursorParam) {
+      return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`] as const
     }
-    getPreviousPageParamExpr = 'getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1'
-  }
+    return [
+      dataReturnType === 'full'
+        ? 'getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1'
+        : 'getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1',
+      'getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1',
+    ] as const
+  })()
 
   const queryOptionsArr = [
     `initialPageParam: ${typeof initialPageParam === 'string' ? JSON.stringify(initialPageParam) : initialPageParam}`,
@@ -175,13 +167,3 @@ export function SuspenseInfiniteQueryOptions({
     </File.Source>
   )
 }
-
-SuspenseInfiniteQueryOptions.getParams = (
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-    paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-    resolver: ResolverTs
-  },
-) => getQueryOptionsParams(node, options)

package/src/components/SuspenseQuery.tsx

@@ -4,8 +4,7 @@ import { functionPrinter } from '@kubb/plugin-ts'
 import { File, Function } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import type { PluginReactQuery } from '../types.ts'
-import { getComments, resolveErrorNames } from '../utils.ts'
-import { QueryKey } from './QueryKey.tsx'
+import { buildQueryKeyParams, getComments, resolveErrorNames, resolveSuccessNames } from '../utils.ts'
 import { getQueryOptionsParams } from './QueryOptions.tsx'
 
 type Props = {
@@ -25,7 +24,7 @@ type Props = {
 const declarationPrinter = functionPrinter({ mode: 'declaration' })
 const callPrinter = functionPrinter({ mode: 'call' })
 
-function getParams(
+function buildSuspenseQueryParamsNode(
   node: ast.OperationNode,
   options: {
     paramsType: PluginReactQuery['resolvedOptions']['paramsType']
@@ -36,8 +35,9 @@ function getParams(
   },
 ): 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 successNames = resolveSuccessNames(node, resolver)
+  const responseName = successNames.length > 0 ? successNames.join(' | ') : resolver.resolveResponseName(node)
+  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null
   const errorNames = resolveErrorNames(node, resolver)
 
   const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
@@ -77,7 +77,8 @@ export function SuspenseQuery({
   tsResolver,
   customOptions,
 }: Props): KubbReactNode {
-  const responseName = tsResolver.resolveResponseName(node)
+  const successNames = resolveSuccessNames(node, tsResolver)
+  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
   const errorNames = resolveErrorNames(node, tsResolver)
 
   const TData = dataReturnType === 'data' ? responseName : `ResponseConfig<${responseName}>`
@@ -85,13 +86,13 @@ export function SuspenseQuery({
   const returnType = `UseSuspenseQueryResult<${'TData'}, ${TError}> & { queryKey: TQueryKey }`
   const generics = [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`]
 
-  const queryKeyParamsNode = QueryKey.getParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
+  const queryKeyParamsNode = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
   const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
 
   const queryOptionsParamsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
   const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? ''
 
-  const paramsNode = getParams(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver })
+  const paramsNode = buildSuspenseQueryParamsNode(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver })
   const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
 
   return (
@@ -117,5 +118,3 @@ export function SuspenseQuery({
     </File.Source>
   )
 }
-
-SuspenseQuery.getParams = getParams

package/src/generators/customHookOptionsFileGenerator.tsx

@@ -2,34 +2,38 @@ import fs from 'node:fs'
 import path from 'node:path'
 
 import { defineGenerator } from '@kubb/core'
-import { File, Function, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, Function, jsxRendererSync } from '@kubb/renderer-jsx'
 import type { PluginReactQuery } from '../types'
-import { transformName } from '../utils.ts'
 
+/**
+ * Scaffolds the user-editable `useCustomHookOptions` file when
+ * `pluginReactQuery({ customOptions: { ... } })` is configured. The file is
+ * only created when it does not already exist, so user edits persist across
+ * regeneration.
+ */
 export const customHookOptionsFileGenerator = defineGenerator<PluginReactQuery>({
   name: 'react-query-custom-hook-options-file',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operations(nodes, ctx) {
     const { resolver, config, root } = ctx
-    const { output, customOptions, query, group, transformers } = ctx.options
+    const { output, customOptions, query, group } = ctx.options
 
     if (!customOptions) return null
 
     const override = output.override ?? config.output.override ?? false
     const { importPath, name } = customOptions
+    const hookOptionsName = resolver.resolveHookOptionsName()
+    const customHookOptionsName = resolver.resolveCustomHookOptionsName()
 
     const reactQueryImportPath = query ? query.importPath : '@tanstack/react-query'
 
-    const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
-
     let hookFilePath: string
     const firstNode = nodes[0]
     if (firstNode) {
-      const baseName = resolver.resolveName(firstNode.operationId)
-      const hookName = transformName(`use${capitalize(baseName)}`, 'function', transformers)
+      const hookName = resolver.resolveQueryName(firstNode)
       const hookFile = resolver.resolveFile(
         { name: hookName, extname: '.ts', tag: firstNode.tags[0] ?? 'default', path: firstNode.path },
-        { root, output, group },
+        { root, output, group: group ?? undefined },
       )
       hookFilePath = hookFile.path
     } else {
@@ -55,9 +59,9 @@ export const customHookOptionsFileGenerator = defineGenerator<PluginReactQuery>(
       <File baseName={file.baseName} path={file.path}>
         <File.Import name={['QueryClient']} path={reactQueryImportPath} isTypeOnly />
         <File.Import name={['useQueryClient']} path={reactQueryImportPath} />
-        <File.Import name={['HookOptions']} root={file.path} path={path.resolve(root, './index.ts')} />
+        <File.Import name={[hookOptionsName]} root={file.path} path={path.resolve(root, './index.ts')} />
         <File.Source name={file.name} isExportable isIndexable>
-          <Function name="getCustomHookOptions" params="{ queryClient }: { queryClient: QueryClient }" returnType="Partial<HookOptions>">
+          <Function name={customHookOptionsName} params="{ queryClient }: { queryClient: QueryClient }" returnType={`Partial<${hookOptionsName}>`}>
             {`return {
               // TODO: Define custom hook options here
               // Example:
@@ -70,13 +74,13 @@ export const customHookOptionsFileGenerator = defineGenerator<PluginReactQuery>(
           </Function>
           <Function
             name={name}
-            generics="T extends keyof HookOptions"
+            generics={`T extends keyof ${hookOptionsName}`}
             params="{ hookName, operationId }: { hookName: T, operationId: string }"
-            returnType="HookOptions[T]"
+            returnType={`${hookOptionsName}[T]`}
             export
           >
             {`const queryClient = useQueryClient()
-            const customOptions = getCustomHookOptions({ queryClient })
+            const customOptions = ${customHookOptionsName}({ queryClient })
             return customOptions[hookName] ?? {}`}
           </Function>
         </File.Source>

package/src/generators/hookOptionsGenerator.tsx

@@ -1,41 +1,46 @@
+import { getOperationParameters } from '@internals/shared'
 import { defineGenerator } from '@kubb/core'
-import { File, jsxRenderer, Type } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync, Type } from '@kubb/renderer-jsx'
 import type { KubbReactNode } from '@kubb/renderer-jsx/types'
 import { difference } from 'remeda'
 import type { PluginReactQuery } from '../types'
-import { resolveOperationOverrides, transformName } from '../utils.ts'
+import { resolveOperationOverrides } from '../utils.ts'
 
 type QueryOption = PluginReactQuery['resolvedOptions']['query']
 type MutationOption = PluginReactQuery['resolvedOptions']['mutation']
 
+/**
+ * Emits the `HookOptions` type used by `customOptions`. Enabled when
+ * `pluginReactQuery({ customOptions: { ... } })`. The generated type lists
+ * every hook keyed by name so user-supplied options stay in sync with the
+ * generated hooks at compile time.
+ */
 export const hookOptionsGenerator = defineGenerator<PluginReactQuery>({
   name: 'react-query-hook-options',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operations(nodes, ctx) {
-    const { resolver, config, root, adapter } = ctx
-    const { output, customOptions, query, mutation, suspense, infinite, group, transformers, override } = ctx.options
+    const { resolver, config, root } = ctx
+    const { output, customOptions, query, mutation, suspense, infinite, group, override } = ctx.options
 
     if (!customOptions) return null
 
-    const resolvedFile = resolver.resolveFile({ name: 'HookOptions', extname: '.ts' }, { root, output, group })
+    const name = resolver.resolveHookOptionsName()
+    const resolvedFile = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group: group ?? undefined })
     const hookOptionsFile = {
       ...resolvedFile,
-      baseName: 'HookOptions.ts' as const,
-      path: resolvedFile.path.replace(/hookOptions\.ts$/, 'HookOptions.ts'),
+      baseName: `${name}.ts` as const,
+      path: resolvedFile.path.replace(/[^/\\]+\.ts$/, `${name}.ts`),
     }
 
-    const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
-
-    const imports: KubbReactNode[] = []
+    const imports: Array<KubbReactNode> = []
     const hookOptions: Record<string, string> = {}
 
     for (const node of nodes) {
-      const baseName = resolver.resolveName(node.operationId)
       const opOverrides = resolveOperationOverrides(node, override)
       const nodeQuery: QueryOption = 'query' in opOverrides ? (opOverrides.query as QueryOption) : query
       const nodeMutation: MutationOption = 'mutation' in opOverrides ? (opOverrides.mutation as MutationOption) : mutation
       const nodeInfinite = 'infinite' in opOverrides ? opOverrides.infinite : infinite
-      const nodeInfiniteOptions = nodeInfinite && typeof nodeInfinite === 'object' ? nodeInfinite : undefined
+      const nodeInfiniteOptions = nodeInfinite && typeof nodeInfinite === 'object' ? nodeInfinite : null
 
       // query: false means "still a query but skip the useQuery hook"
       const isQueryOp =
@@ -50,21 +55,21 @@ export const hookOptionsGenerator = defineGenerator<PluginReactQuery>({
       const isInfiniteOp = !!nodeInfiniteOptions
 
       if (isQueryOp) {
-        const queryOptionsName = transformName(`${baseName}QueryOptions`, 'function', transformers)
-        const queryHookName = transformName(`use${capitalize(baseName)}`, 'function', transformers)
+        const queryOptionsName = resolver.resolveQueryOptionsName(node)
+        const queryHookName = resolver.resolveQueryName(node)
         const queryHookFile = resolver.resolveFile(
           { name: queryHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          { root, output, group },
+          { root, output, group: group ?? undefined },
         )
         imports.push(<File.Import name={[queryOptionsName]} root={hookOptionsFile.path} path={queryHookFile.path} />)
         hookOptions[queryHookName] = `Partial<ReturnType<typeof ${queryOptionsName}>>`
 
         if (isSuspenseOp) {
-          const suspenseOptionsName = transformName(`${baseName}SuspenseQueryOptions`, 'function', transformers)
-          const suspenseHookName = transformName(`use${capitalize(baseName)}Suspense`, 'function', transformers)
+          const suspenseOptionsName = resolver.resolveSuspenseQueryOptionsName(node)
+          const suspenseHookName = resolver.resolveSuspenseQueryName(node)
           const suspenseHookFile = resolver.resolveFile(
             { name: suspenseHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-            { root, output, group },
+            { root, output, group: group ?? undefined },
           )
           imports.push(<File.Import name={[suspenseOptionsName]} root={hookOptionsFile.path} path={suspenseHookFile.path} />)
           hookOptions[suspenseHookName] = `Partial<ReturnType<typeof ${suspenseOptionsName}>>`
@@ -73,25 +78,25 @@ export const hookOptionsGenerator = defineGenerator<PluginReactQuery>({
         if (isInfiniteOp) {
           // Validate queryParam
           const normalizeKey = (key: string) => key.replace(/\?$/, '')
-          const queryParamKeys = node.parameters.filter((p) => p.in === 'query').map((p) => p.name)
+          const queryParamKeys = getOperationParameters(node).query.map((p) => p.name)
           const hasQueryParam = nodeInfiniteOptions!.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === nodeInfiniteOptions!.queryParam) : false
 
           if (hasQueryParam) {
-            const infiniteOptionsName = transformName(`${baseName}InfiniteQueryOptions`, 'function', transformers)
-            const infiniteHookName = transformName(`use${capitalize(baseName)}Infinite`, 'function', transformers)
+            const infiniteOptionsName = resolver.resolveInfiniteQueryOptionsName(node)
+            const infiniteHookName = resolver.resolveInfiniteQueryName(node)
             const infiniteHookFile = resolver.resolveFile(
               { name: infiniteHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-              { root, output, group },
+              { root, output, group: group ?? undefined },
             )
             imports.push(<File.Import name={[infiniteOptionsName]} root={hookOptionsFile.path} path={infiniteHookFile.path} />)
             hookOptions[infiniteHookName] = `Partial<ReturnType<typeof ${infiniteOptionsName}>>`
 
             if (isSuspenseOp) {
-              const suspenseInfiniteOptionsName = transformName(`${baseName}SuspenseInfiniteQueryOptions`, 'function', transformers)
-              const suspenseInfiniteHookName = transformName(`use${capitalize(baseName)}SuspenseInfinite`, 'function', transformers)
+              const suspenseInfiniteOptionsName = resolver.resolveSuspenseInfiniteQueryOptionsName(node)
+              const suspenseInfiniteHookName = resolver.resolveSuspenseInfiniteQueryName(node)
               const suspenseInfiniteHookFile = resolver.resolveFile(
                 { name: suspenseInfiniteHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-                { root, output, group },
+                { root, output, group: group ?? undefined },
               )
               imports.push(<File.Import name={[suspenseInfiniteOptionsName]} root={hookOptionsFile.path} path={suspenseInfiniteHookFile.path} />)
               hookOptions[suspenseInfiniteHookName] = `Partial<ReturnType<typeof ${suspenseInfiniteOptionsName}>>`
@@ -101,26 +106,24 @@ export const hookOptionsGenerator = defineGenerator<PluginReactQuery>({
       }
 
       if (isMutationOp) {
-        const mutationOptionsName = transformName(`${baseName}MutationOptions`, 'function', transformers)
-        const mutationHookName = transformName(`use${capitalize(baseName)}`, 'function', transformers)
+        const mutationOptionsName = resolver.resolveMutationOptionsName(node)
+        const mutationHookName = resolver.resolveMutationName(node)
         const mutationHookFile = resolver.resolveFile(
           { name: mutationHookName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          { root, output, group },
+          { root, output, group: group ?? undefined },
         )
         imports.push(<File.Import name={[mutationOptionsName]} root={hookOptionsFile.path} path={mutationHookFile.path} />)
         hookOptions[mutationHookName] = `Partial<ReturnType<typeof ${mutationOptionsName}>>`
       }
     }
 
-    const name = 'HookOptions'
-
     return (
       <File
         baseName={hookOptionsFile.baseName}
         path={hookOptionsFile.path}
         meta={hookOptionsFile.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: hookOptionsFile.path, baseName: hookOptionsFile.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: hookOptionsFile.path, baseName: hookOptionsFile.baseName } })}
       >
         {imports}
         <File.Source name={name} isExportable isIndexable isTypeOnly>