@kubb/plugin-react-query 5.0.0-beta.56 → 5.0.0-beta.64

package/src/components/SuspenseInfiniteQuery.tsx

@@ -1,161 +0,0 @@
-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 { buildQueryKeyParams, buildStatusUnionType, getComments, resolveErrorNames, resolveSuccessNames } from '../utils.ts'
-import { getQueryOptionsParams } from './QueryOptions.tsx'
-
-type Props = {
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginReactQuery['resolvedOptions']['client']['dataReturnType']
-  customOptions: PluginReactQuery['resolvedOptions']['customOptions']
-  initialPageParam: Infinite['initialPageParam']
-  queryParam?: Infinite['queryParam']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-function buildSuspenseInfiniteQueryParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-    paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-    dataReturnType: PluginReactQuery['resolvedOptions']['client']['dataReturnType']
-    resolver: ResolverTs
-    pageParamGeneric: string
-  },
-): ast.FunctionParametersNode {
-  const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options
-  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null
-
-  const optionsParam = ast.createFunctionParameter({
-    name: 'options',
-    type: ast.createParamsType({
-      variant: 'reference',
-      name: `{
-  query?: Partial<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'}
-}`,
-    }),
-    default: '{}',
-  })
-
-  return ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver,
-    extraParams: [optionsParam],
-  })
-}
-
-export function SuspenseInfiniteQuery({
-  name,
-  queryKeyTypeName,
-  queryOptionsName,
-  queryKeyName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-  customOptions,
-  initialPageParam,
-  queryParam,
-}: Props): KubbReactNode {
-  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 : buildStatusUnionType(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 : null
-        })()
-      : null
-
-  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null
-  const pageParamType = queryParamType ? (isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType) : fallbackPageParamType
-
-  const returnType = 'UseSuspenseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }'
-  const generics = [
-    `TQueryFnData = ${responseType}`,
-    `TError = ${errorType}`,
-    'TData = InfiniteData<TQueryFnData>',
-    `TQueryKey extends QueryKey = ${queryKeyTypeName}`,
-    `TPageParam = ${pageParamType}`,
-  ]
-
-  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 = buildSuspenseInfiniteQueryParamsNode(node, {
-    paramsType,
-    paramsCasing,
-    pathParamsType,
-    dataReturnType,
-    resolver: tsResolver,
-    pageParamGeneric: 'TPageParam',
-  })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export generics={generics.join(', ')} params={paramsSignature} returnType={undefined} JSDoc={{ comments: getComments(node) }}>
-        {`
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ''}
-
-       const query = useSuspenseInfiniteQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? '\n        ...customOptions,' : ''}
-        ...resolvedOptions,
-        queryKey,
-       } as unknown as UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/SuspenseInfiniteQueryOptions.tsx

@@ -1,162 +0,0 @@
-import { getOperationParameters } from '@internals/shared'
-import { getNestedAccessor } from '@kubb/ast/utils'
-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, PluginReactQuery } from '../types.ts'
-import { buildQueryKeyParams, buildStatusUnionType, resolveErrorNames, resolveSuccessNames } from '../utils.ts'
-import { getQueryOptionsParams } from './QueryOptions.tsx'
-
-type Props = {
-  name: string
-  clientName: string
-  queryKeyName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginReactQuery['resolvedOptions']['client']['dataReturnType']
-  initialPageParam: Infinite['initialPageParam']
-  cursorParam: Infinite['cursorParam']
-  nextParam: Infinite['nextParam']
-  previousParam: Infinite['previousParam']
-  queryParam: Infinite['queryParam']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-export function SuspenseInfiniteQueryOptions({
-  name,
-  clientName,
-  initialPageParam,
-  cursorParam,
-  nextParam,
-  previousParam,
-  node,
-  tsResolver,
-  paramsCasing,
-  paramsType,
-  dataReturnType,
-  pathParamsType,
-  queryParam,
-  queryKeyName,
-}: Props): KubbReactNode {
-  const successNames = resolveSuccessNames(node, tsResolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
-  const queryFnDataType = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, tsResolver)
-  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 : null
-        })()
-      : null
-
-  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null
-  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 = buildQueryKeyParams(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
-
-  const hasNewParams = nextParam != null || previousParam != null
-
-  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
-    }
-    if (cursorParam) {
-      return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`] as const
-    }
-    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}`,
-    getNextPageParamExpr,
-    getPreviousPageParamExpr,
-  ].filter(Boolean)
-
-  const infiniteOverrideParams =
-    queryParam && queryParamsTypeName
-      ? `params = {
-      ...(params ?? {}),
-      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
-    } as ${queryParamsTypeName}`
-      : ''
-
-  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}>, typeof queryKey, ${pageParamType}>({
-  queryKey,
-  queryFn: async ({ signal, pageParam }) => {
-    ${infiniteOverrideParams}
-    return ${clientName}(${clientCallStr})
-  },
-  ${queryOptionsArr.join(',\n  ')}
-})
-`}
-        </Function>
-      </File.Source>
-    )
-  }
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature}>
-        {`
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
-  queryKey,
-  queryFn: async ({ signal }) => {
-    return ${clientName}(${clientCallStr})
-  },
-  ${queryOptionsArr.join(',\n  ')}
-})
-`}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/SuspenseQuery.tsx

@@ -1,119 +0,0 @@
-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 { PluginReactQuery } from '../types.ts'
-import { buildQueryKeyParams, buildStatusUnionType, getComments, resolveErrorNames, resolveSuccessNames } from '../utils.ts'
-import { getQueryOptionsParams } from './QueryOptions.tsx'
-
-type Props = {
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginReactQuery['resolvedOptions']['client']['dataReturnType']
-  customOptions: PluginReactQuery['resolvedOptions']['customOptions']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-function buildSuspenseQueryParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginReactQuery['resolvedOptions']['paramsType']
-    paramsCasing: PluginReactQuery['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginReactQuery['resolvedOptions']['pathParamsType']
-    dataReturnType: PluginReactQuery['resolvedOptions']['client']['dataReturnType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options
-  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 : buildStatusUnionType(node, resolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const optionsParam = ast.createFunctionParameter({
-    name: 'options',
-    type: ast.createParamsType({
-      variant: 'reference',
-      name: `{
-  query?: Partial<UseSuspenseQueryOptions<${[TData, TError, 'TData', 'TQueryKey'].join(', ')}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'}
-}`,
-    }),
-    default: '{}',
-  })
-
-  return ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver,
-    extraParams: [optionsParam],
-  })
-}
-
-export function SuspenseQuery({
-  name,
-  queryKeyTypeName,
-  queryOptionsName,
-  queryKeyName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-  customOptions,
-}: Props): KubbReactNode {
-  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 : buildStatusUnionType(node, tsResolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-  const returnType = `UseSuspenseQueryResult<${'TData'}, ${TError}> & { queryKey: TQueryKey }`
-  const generics = [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`]
-
-  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 = buildSuspenseQueryParamsNode(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export generics={generics.join(', ')} params={paramsSignature} returnType={undefined} JSDoc={{ comments: getComments(node) }}>
-        {`
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ''}
-
-       const query = useSuspenseQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? '\n        ...customOptions,' : ''}
-        ...resolvedOptions,
-        queryKey,
-       } as unknown as UseSuspenseQueryOptions, queryClient) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/index.ts

@@ -1,11 +0,0 @@
-export { InfiniteQuery } from './InfiniteQuery.tsx'
-export { InfiniteQueryOptions } from './InfiniteQueryOptions.tsx'
-export { Mutation } from './Mutation.tsx'
-export { MutationKey } from './MutationKey.tsx'
-export { MutationOptions } from './MutationOptions.tsx'
-export { Query } from './Query.tsx'
-export { QueryKey } from './QueryKey.tsx'
-export { QueryOptions } from './QueryOptions.tsx'
-export { SuspenseInfiniteQuery } from './SuspenseInfiniteQuery.tsx'
-export { SuspenseInfiniteQueryOptions } from './SuspenseInfiniteQueryOptions.tsx'
-export { SuspenseQuery } from './SuspenseQuery.tsx'

package/src/generators/customHookOptionsFileGenerator.tsx

@@ -1,90 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { defineGenerator } from '@kubb/core'
-import { File, Function, jsxRenderer } from '@kubb/renderer-jsx'
-import type { PluginReactQuery } from '../types'
-
-/**
- * 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,
-  operations(nodes, ctx) {
-    const { resolver, config, root } = ctx
-    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'
-
-    let hookFilePath: string
-    const firstNode = nodes[0]
-    if (firstNode) {
-      const hookName = resolver.resolveQueryName(firstNode)
-      const hookFile = resolver.resolveFile(
-        { name: hookName, extname: '.ts', tag: firstNode.tags[0] ?? 'default', path: firstNode.path },
-        { root, output, group: group ?? undefined },
-      )
-      hookFilePath = hookFile.path
-    } else {
-      hookFilePath = path.resolve(root, 'index.ts')
-    }
-
-    const ensureExtension = (filePath: string, extname: string) => {
-      if (path.extname(filePath) === '') return filePath + extname
-      return filePath
-    }
-
-    const basePath = path.dirname(hookFilePath)
-    const actualFilePath = ensureExtension(importPath, '.ts')
-    const file = {
-      baseName: path.basename(actualFilePath) as `${string}.${string}`,
-      name: path.basename(actualFilePath, path.extname(actualFilePath)),
-      path: path.resolve(basePath, actualFilePath),
-    }
-
-    if (fs.existsSync(file.path) && !override) return null
-
-    return (
-      <File baseName={file.baseName} path={file.path}>
-        <File.Import name={['QueryClient']} path={reactQueryImportPath} isTypeOnly />
-        <File.Import name={['useQueryClient']} path={reactQueryImportPath} />
-        <File.Import name={[hookOptionsName]} root={file.path} path={path.resolve(root, './index.ts')} />
-        <File.Source name={file.name} isExportable isIndexable>
-          <Function name={customHookOptionsName} params="{ queryClient }: { queryClient: QueryClient }" returnType={`Partial<${hookOptionsName}>`}>
-            {`return {
-              // TODO: Define custom hook options here
-              // Example:
-              // useUpdatePetHook: {
-              //   onSuccess: () => {
-              //     void queryClient.invalidateQueries({ queryKey: ['pet'] })
-              //   }
-              // }
-            }`}
-          </Function>
-          <Function
-            name={name}
-            generics={`T extends keyof ${hookOptionsName}`}
-            params="{ hookName, operationId }: { hookName: T, operationId: string }"
-            returnType={`${hookOptionsName}[T]`}
-            export
-          >
-            {`const queryClient = useQueryClient()
-            const customOptions = ${customHookOptionsName}({ queryClient })
-            return customOptions[hookName] ?? {}`}
-          </Function>
-        </File.Source>
-      </File>
-    )
-  },
-})

package/src/generators/hookOptionsGenerator.tsx

@@ -1,129 +0,0 @@
-import { getOperationParameters, operationFileEntry } from '@internals/shared'
-import { ast, defineGenerator } from '@kubb/core'
-import { File, jsxRenderer, Type } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginReactQuery } from '../types'
-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,
-  operations(nodes, ctx) {
-    const { resolver, config, root } = ctx
-    const { output, customOptions, query, mutation, suspense, infinite, group, override } = ctx.options
-
-    if (!customOptions) return null
-
-    const name = resolver.resolveHookOptionsName()
-    const resolvedFile = resolver.resolveFile({ name, extname: '.ts' }, { root, output, group: group ?? undefined })
-    const hookOptionsFile = {
-      ...resolvedFile,
-      baseName: `${name}.ts` as const,
-      path: resolvedFile.path.replace(/[^/\\]+\.ts$/, `${name}.ts`),
-    }
-
-    const imports: Array<KubbReactNode> = []
-    const hookOptions: Record<string, string> = {}
-
-    for (const node of nodes) {
-      if (!ast.isHttpOperationNode(node)) continue
-      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 : null
-
-      // query: false means "still a query but skip the useQuery hook"
-      const isQueryOp =
-        nodeQuery === false
-          ? !!query && query.methods.some((m) => node.method.toLowerCase() === m.toLowerCase())
-          : !!nodeQuery && nodeQuery.methods.some((m) => node.method.toLowerCase() === m.toLowerCase())
-      const nodeQueryMethods = new Set(nodeQuery ? nodeQuery.methods : [])
-      const isMutationOp =
-        nodeMutation !== false &&
-        !isQueryOp &&
-        (nodeMutation ? nodeMutation.methods : []).some((m) => !nodeQueryMethods.has(m) && node.method.toLowerCase() === m.toLowerCase())
-      const isSuspenseOp = !!suspense
-      const isInfiniteOp = !!nodeInfiniteOptions
-
-      if (isQueryOp) {
-        const queryOptionsName = resolver.resolveQueryOptionsName(node)
-        const queryHookName = resolver.resolveQueryName(node)
-        const queryHookFile = resolver.resolveFile(operationFileEntry(node, queryHookName), { 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 = resolver.resolveSuspenseQueryOptionsName(node)
-          const suspenseHookName = resolver.resolveSuspenseQueryName(node)
-          const suspenseHookFile = resolver.resolveFile(operationFileEntry(node, suspenseHookName), { root, output, group: group ?? undefined })
-          imports.push(<File.Import name={[suspenseOptionsName]} root={hookOptionsFile.path} path={suspenseHookFile.path} />)
-          hookOptions[suspenseHookName] = `Partial<ReturnType<typeof ${suspenseOptionsName}>>`
-        }
-
-        if (isInfiniteOp) {
-          // Validate queryParam
-          const normalizeKey = (key: string) => key.replace(/\?$/, '')
-          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 = resolver.resolveInfiniteQueryOptionsName(node)
-            const infiniteHookName = resolver.resolveInfiniteQueryName(node)
-            const infiniteHookFile = resolver.resolveFile(operationFileEntry(node, infiniteHookName), { 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 = resolver.resolveSuspenseInfiniteQueryOptionsName(node)
-              const suspenseInfiniteHookName = resolver.resolveSuspenseInfiniteQueryName(node)
-              const suspenseInfiniteHookFile = resolver.resolveFile(operationFileEntry(node, suspenseInfiniteHookName), {
-                root,
-                output,
-                group: group ?? undefined,
-              })
-              imports.push(<File.Import name={[suspenseInfiniteOptionsName]} root={hookOptionsFile.path} path={suspenseInfiniteHookFile.path} />)
-              hookOptions[suspenseInfiniteHookName] = `Partial<ReturnType<typeof ${suspenseInfiniteOptionsName}>>`
-            }
-          }
-        }
-      }
-
-      if (isMutationOp) {
-        const mutationOptionsName = resolver.resolveMutationOptionsName(node)
-        const mutationHookName = resolver.resolveMutationName(node)
-        const mutationHookFile = resolver.resolveFile(operationFileEntry(node, mutationHookName), { root, output, group: group ?? undefined })
-        imports.push(<File.Import name={[mutationOptionsName]} root={hookOptionsFile.path} path={mutationHookFile.path} />)
-        hookOptions[mutationHookName] = `Partial<ReturnType<typeof ${mutationOptionsName}>>`
-      }
-    }
-
-    return (
-      <File
-        baseName={hookOptionsFile.baseName}
-        path={hookOptionsFile.path}
-        meta={hookOptionsFile.meta}
-        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>
-          <Type export name={name}>
-            {`{ ${Object.keys(hookOptions)
-              .map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`)
-              .join(', ')} }`}
-          </Type>
-        </File.Source>
-      </File>
-    )
-  },
-})