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

package/src/generators/suspenseInfiniteQueryGenerator.tsx

@@ -1,19 +1,27 @@
 import path from 'node:path'
+import { getOperationParameters, operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
+import { resolveZodSchemaNames } from '@internals/tanstack-query'
 import { ast, defineGenerator } from '@kubb/core'
 import { Client, pluginClientName } from '@kubb/plugin-client'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { difference } from 'remeda'
 import { QueryKey, SuspenseInfiniteQuery, SuspenseInfiniteQueryOptions } from '../components'
 import type { PluginReactQuery } from '../types'
-import { transformName } from '../utils.ts'
 
+/**
+ * Built-in generator for `useSuspenseInfiniteQuery` hooks. Enabled when both
+ * `suspense` and `infinite` are configured. Combines suspense semantics with
+ * cursor-based pagination — handlers throw promises while loading and pull
+ * additional pages on demand.
+ */
 export const suspenseInfiniteQueryGenerator = defineGenerator<PluginReactQuery>({
   name: 'react-suspense-infinite-query',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operation(node, ctx) {
-    const { adapter, config, driver, resolver, root } = ctx
+    if (!ast.isHttpOperationNode(node)) return null
+    const { config, driver, resolver, root } = ctx
     const {
       output,
       query,
@@ -26,7 +34,6 @@ export const suspenseInfiniteQueryGenerator = defineGenerator<PluginReactQuery>(
       parser,
       client: clientOptions,
       group,
-      transformers,
       customOptions,
     } = ctx.options
 
@@ -40,13 +47,13 @@ export const suspenseInfiniteQueryGenerator = defineGenerator<PluginReactQuery>(
       !isQuery &&
       difference(mutation ? mutation.methods : [], query ? query.methods : []).some((method) => node.method.toLowerCase() === method.toLowerCase())
     const isSuspense = !!suspense
-    const infiniteOptions = infinite && typeof infinite === 'object' ? infinite : undefined
+    const infiniteOptions = infinite && typeof infinite === 'object' ? infinite : null
 
     if (!isQuery || isMutation || !isSuspense || !infiniteOptions) return null
 
     // Validate queryParam exists in operation's query parameters
     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 = infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false
     const hasCursorParam = !infiniteOptions.cursorParam || true
 
@@ -54,64 +61,46 @@ export const suspenseInfiniteQueryGenerator = defineGenerator<PluginReactQuery>(
 
     const importPath = query ? query.importPath : '@tanstack/react-query'
 
-    const baseName = resolver.resolveName(node.operationId)
-    const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
-    const queryName = transformName(`use${capitalize(baseName)}SuspenseInfinite`, 'function', transformers)
-    const queryOptionsName = transformName(`${baseName}SuspenseInfiniteQueryOptions`, 'function', transformers)
-    const queryKeyName = transformName(`${baseName}SuspenseInfiniteQueryKey`, 'const', transformers)
-    const queryKeyTypeName = transformName(`${capitalize(baseName)}SuspenseInfiniteQueryKey`, 'type', transformers)
-    const clientBaseName = transformName(`${baseName}SuspenseInfinite`, 'function', transformers)
+    const queryName = resolver.resolveSuspenseInfiniteQueryName(node)
+    const queryOptionsName = resolver.resolveSuspenseInfiniteQueryOptionsName(node)
+    const queryKeyName = resolver.resolveSuspenseInfiniteQueryKeyName(node)
+    const queryKeyTypeName = resolver.resolveSuspenseInfiniteQueryKeyTypeName(node)
+    const clientBaseName = resolver.resolveSuspenseInfiniteClientName(node)
 
     const meta = {
-      file: resolver.resolveFile({ name: queryName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-      fileTs: tsResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
-      ),
+      file: resolver.resolveFile(operationFileEntry(node, queryName), { root, output, group: group ?? undefined }),
+      fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+        root,
+        output: pluginTs.options?.output ?? output,
+        group: pluginTs.options?.group ?? undefined,
+      }),
     }
 
-    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 importedTypeNames = [
-      node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined,
-      tsResolver.resolveResponseName(node),
-      ...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
-      ...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
-      ...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
-      ...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode)),
-    ].filter(Boolean)
-
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
+    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing, order: 'body-response-first' })
+
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : null
+    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null
     const fileZod = zodResolver
-      ? zodResolver.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          { root, output: pluginZod?.options?.output ?? output, group: pluginZod?.options?.group },
-        )
-      : undefined
-    const zodSchemaNames =
-      zodResolver && parser === 'zod'
-        ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined].filter(Boolean)
-        : []
+      ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+          root,
+          output: pluginZod?.options?.output ?? output,
+          group: pluginZod?.options?.group ?? undefined,
+        })
+      : null
+    const zodSchemaNames = resolveZodSchemaNames(node, zodResolver)
 
     const clientPlugin = driver.getPlugin(pluginClientName)
     const hasClientPlugin = clientPlugin?.name === pluginClientName
     const shouldUseClientPlugin = hasClientPlugin && clientOptions.clientType !== 'class'
-    const clientResolver = shouldUseClientPlugin ? driver.getResolver(pluginClientName) : undefined
+    const clientResolver = shouldUseClientPlugin ? driver.getResolver(pluginClientName) : null
 
     const clientFile = shouldUseClientPlugin
-      ? clientResolver?.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          {
-            root,
-            output: clientPlugin?.options?.output ?? output,
-            group: clientPlugin?.options?.group,
-          },
-        )
-      : undefined
+      ? clientResolver?.resolveFile(operationFileEntry(node, node.operationId), {
+          root,
+          output: clientPlugin?.options?.output ?? output,
+          group: clientPlugin?.options?.group ?? undefined,
+        })
+      : null
 
     const resolvedClientName = shouldUseClientPlugin ? (clientResolver?.resolveName(node.operationId) ?? clientBaseName) : clientBaseName
 
@@ -120,29 +109,27 @@ export const suspenseInfiniteQueryGenerator = defineGenerator<PluginReactQuery>(
         baseName={meta.file.baseName}
         path={meta.file.path}
         meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
-        {parser === 'zod' && fileZod && zodSchemaNames.length > 0 && (
-          <File.Import name={zodSchemaNames as string[]} root={meta.file.path} path={fileZod.path} />
-        )}
+        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.path} />}
         {clientOptions.importPath ? (
           <>
-            {!shouldUseClientPlugin && <File.Import name={'fetch'} path={clientOptions.importPath} />}
+            {!shouldUseClientPlugin && <File.Import name={'client'} path={clientOptions.importPath} />}
             <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={clientOptions.importPath} isTypeOnly />
             {clientOptions.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={clientOptions.importPath} isTypeOnly />}
           </>
         ) : (
           <>
-            {!shouldUseClientPlugin && <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />}
+            {!shouldUseClientPlugin && <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />}
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
               root={meta.file.path}
-              path={path.resolve(root, '.kubb/fetch.ts')}
+              path={path.resolve(root, '.kubb/client.ts')}
               isTypeOnly
             />
             {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
+              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
             )}
           </>
         )}

package/src/generators/suspenseQueryGenerator.tsx

@@ -1,33 +1,28 @@
 import path from 'node:path'
+import { operationFileEntry, resolveOperationTypeNames } from '@internals/shared'
+import { resolveZodSchemaNames } from '@internals/tanstack-query'
 import { ast, defineGenerator } from '@kubb/core'
 import { Client, pluginClientName } from '@kubb/plugin-client'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { File, jsxRenderer } from '@kubb/renderer-jsx'
+import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { difference } from 'remeda'
 import { QueryKey, QueryOptions, SuspenseQuery } from '../components'
 import type { PluginReactQuery } from '../types'
-import { transformName } from '../utils.ts'
 
+/**
+ * Built-in generator for `useSuspenseQuery` hooks. Enabled when
+ * `pluginReactQuery({ suspense: {} })`. Emits one `useFooSuspenseQuery` hook
+ * per query operation. Suspense queries throw promises while loading and
+ * require a `<Suspense>` boundary in the React tree. TanStack Query v5+ only.
+ */
 export const suspenseQueryGenerator = defineGenerator<PluginReactQuery>({
   name: 'react-suspense-query',
-  renderer: jsxRenderer,
+  renderer: jsxRendererSync,
   operation(node, ctx) {
-    const { adapter, config, driver, resolver, root } = ctx
-    const {
-      output,
-      query,
-      mutation,
-      suspense,
-      paramsCasing,
-      paramsType,
-      pathParamsType,
-      parser,
-      client: clientOptions,
-      group,
-      transformers,
-      customOptions,
-    } = ctx.options
+    if (!ast.isHttpOperationNode(node)) return null
+    const { config, driver, resolver, root } = ctx
+    const { output, query, mutation, suspense, paramsCasing, paramsType, pathParamsType, parser, client: clientOptions, group, customOptions } = ctx.options
 
     const pluginTs = driver.getPlugin(pluginTsName)
     if (!pluginTs) return null
@@ -45,64 +40,50 @@ export const suspenseQueryGenerator = defineGenerator<PluginReactQuery>({
 
     const importPath = query ? query.importPath : '@tanstack/react-query'
 
-    const baseName = resolver.resolveName(node.operationId)
-    const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1)
-    const queryName = transformName(`use${capitalize(baseName)}Suspense`, 'function', transformers)
-    const queryOptionsName = transformName(`${baseName}SuspenseQueryOptions`, 'function', transformers)
-    const queryKeyName = transformName(`${baseName}SuspenseQueryKey`, 'const', transformers)
-    const queryKeyTypeName = transformName(`${capitalize(baseName)}SuspenseQueryKey`, 'type', transformers)
-    const clientName = transformName(`${baseName}Suspense`, 'function', transformers)
+    const queryName = resolver.resolveSuspenseQueryName(node)
+    const queryOptionsName = resolver.resolveSuspenseQueryOptionsName(node)
+    const queryKeyName = resolver.resolveSuspenseQueryKeyName(node)
+    const queryKeyTypeName = resolver.resolveSuspenseQueryKeyTypeName(node)
+    const clientName = resolver.resolveSuspenseClientName(node)
 
     const meta = {
-      file: resolver.resolveFile({ name: queryName, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
-      fileTs: tsResolver.resolveFile(
-        { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-        { root, output: pluginTs.options?.output ?? output, group: pluginTs.options?.group },
-      ),
+      file: resolver.resolveFile(operationFileEntry(node, queryName), { root, output, group: group ?? undefined }),
+      fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+        root,
+        output: pluginTs.options?.output ?? output,
+        group: pluginTs.options?.group ?? undefined,
+      }),
     }
 
-    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 importedTypeNames = [
-      node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : undefined,
-      tsResolver.resolveResponseName(node),
-      ...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
-      ...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
-      ...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
-      ...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode)),
-    ].filter((name): name is string => !!name && name !== queryKeyTypeName)
-
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
+    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, {
+      paramsCasing,
+      exclude: [queryKeyTypeName],
+      order: 'body-response-first',
+    })
+
+    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : null
+    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null
     const fileZod = zodResolver
-      ? zodResolver.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          { root, output: pluginZod?.options?.output ?? output, group: pluginZod?.options?.group },
-        )
-      : undefined
-    const zodSchemaNames =
-      zodResolver && parser === 'zod'
-        ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : undefined].filter(Boolean)
-        : []
+      ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+          root,
+          output: pluginZod?.options?.output ?? output,
+          group: pluginZod?.options?.group ?? undefined,
+        })
+      : null
+    const zodSchemaNames = resolveZodSchemaNames(node, zodResolver)
 
     const clientPlugin = driver.getPlugin(pluginClientName)
     const hasClientPlugin = clientPlugin?.name === pluginClientName
     const shouldUseClientPlugin = hasClientPlugin && clientOptions.clientType !== 'class'
-    const clientResolver = shouldUseClientPlugin ? driver.getResolver(pluginClientName) : undefined
+    const clientResolver = shouldUseClientPlugin ? driver.getResolver(pluginClientName) : null
 
     const clientFile = shouldUseClientPlugin
-      ? clientResolver?.resolveFile(
-          { name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path },
-          {
-            root,
-            output: clientPlugin?.options?.output ?? output,
-            group: clientPlugin?.options?.group,
-          },
-        )
-      : undefined
+      ? clientResolver?.resolveFile(operationFileEntry(node, node.operationId), {
+          root,
+          output: clientPlugin?.options?.output ?? output,
+          group: clientPlugin?.options?.group ?? undefined,
+        })
+      : null
 
     const resolvedClientName = shouldUseClientPlugin ? (clientResolver?.resolveName(node.operationId) ?? clientName) : clientName
 
@@ -111,29 +92,27 @@ export const suspenseQueryGenerator = defineGenerator<PluginReactQuery>({
         baseName={meta.file.baseName}
         path={meta.file.path}
         meta={meta.file.meta}
-        banner={resolver.resolveBanner(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
+        banner={resolver.resolveBanner(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
+        footer={resolver.resolveFooter(ctx.meta, { output, config, file: { path: meta.file.path, baseName: meta.file.baseName } })}
       >
-        {parser === 'zod' && fileZod && zodSchemaNames.length > 0 && (
-          <File.Import name={zodSchemaNames as string[]} root={meta.file.path} path={fileZod.path} />
-        )}
+        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.path} />}
         {clientOptions.importPath ? (
           <>
-            {!shouldUseClientPlugin && <File.Import name={'fetch'} path={clientOptions.importPath} />}
+            {!shouldUseClientPlugin && <File.Import name={'client'} path={clientOptions.importPath} />}
             <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={clientOptions.importPath} isTypeOnly />
             {clientOptions.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={clientOptions.importPath} isTypeOnly />}
           </>
         ) : (
           <>
-            {!shouldUseClientPlugin && <File.Import name={['fetch']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} />}
+            {!shouldUseClientPlugin && <File.Import name={['client']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} />}
             <File.Import
               name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
               root={meta.file.path}
-              path={path.resolve(root, '.kubb/fetch.ts')}
+              path={path.resolve(root, '.kubb/client.ts')}
               isTypeOnly
             />
             {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.ts')} isTypeOnly />
+              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
             )}
           </>
         )}
@@ -181,6 +160,7 @@ export const suspenseQueryGenerator = defineGenerator<PluginReactQuery>({
           paramsType={paramsType}
           pathParamsType={pathParamsType}
           dataReturnType={clientOptions.dataReturnType || 'data'}
+          suspense
         />
 
         {suspense && (

package/src/plugin.ts

@@ -1,14 +1,13 @@
 import path from 'node:path'
-import { camelCase } from '@internals/utils'
-import { ast, definePlugin, type Group } from '@kubb/core'
+import { createGroupConfig } from '@internals/shared'
+import { ast, definePlugin } from '@kubb/core'
 import { pluginClientName } from '@kubb/plugin-client'
 import { source as axiosClientSource } from '@kubb/plugin-client/templates/clients/axios.source'
 import { source as fetchClientSource } from '@kubb/plugin-client/templates/clients/fetch.source'
 import { source as configSource } from '@kubb/plugin-client/templates/config.source'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
-import { MutationKey } from './components/MutationKey.tsx'
-import { QueryKey } from './components/QueryKey.tsx'
+import { mutationKeyTransformer, queryKeyTransformer } from '@internals/tanstack-query'
 import {
   customHookOptionsFileGenerator,
   hookOptionsGenerator,
@@ -21,8 +20,37 @@ import {
 import { resolverReactQuery } from './resolvers/resolverReactQuery.ts'
 import type { PluginReactQuery } from './types.ts'
 
+/**
+ * Canonical plugin name for `@kubb/plugin-react-query`. Used for driver lookups
+ * and cross-plugin dependency references.
+ */
 export const pluginReactQueryName = 'plugin-react-query' satisfies PluginReactQuery['name']
 
+/**
+ * Generates one TanStack Query hook per OpenAPI operation for React. Queries
+ * become `useFooQuery`/`useFooSuspenseQuery`/`useFooInfiniteQuery`; mutations
+ * become `useFooMutation`. Each hook is fully typed: query keys, input
+ * variables, response data, and error shape all come from the spec.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginReactQuery } from '@kubb/plugin-react-query'
+ *
+ * export default defineConfig({
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginReactQuery({
+ *       output: { path: './hooks' },
+ *       suspense: {},
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
 export const pluginReactQuery = definePlugin<PluginReactQuery>((options) => {
   const {
     output = { path: 'hooks', barrelType: 'named' },
@@ -30,16 +58,15 @@ export const pluginReactQuery = definePlugin<PluginReactQuery>((options) => {
     exclude = [],
     include,
     override = [],
-    parser = 'client',
+    parser = false,
     suspense = {},
     infinite = false,
-    transformers = {},
     paramsType = 'inline',
     pathParamsType = paramsType === 'object' ? 'object' : options.pathParamsType || 'inline',
     mutation = {},
     query = {},
-    mutationKey = MutationKey.getTransformer,
-    queryKey = QueryKey.getTransformer,
+    mutationKey = mutationKeyTransformer,
+    queryKey = queryKeyTransformer,
     customOptions,
     paramsCasing,
     client,
@@ -61,33 +88,20 @@ export const pluginReactQuery = definePlugin<PluginReactQuery>((options) => {
       mutationGenerator,
       hookOptionsGenerator,
       customHookOptionsFileGenerator,
-    ].filter(Boolean)
+    ].filter((generator): generator is NonNullable<typeof generator> => Boolean(generator))
 
-  const groupConfig = group
-    ? ({
-        ...group,
-        name: group.name
-          ? group.name
-          : (ctx: { group: string }) => {
-              if (group.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Controller`
-            },
-      } satisfies Group)
-    : undefined
+  const groupConfig = createGroupConfig(group, { suffix: 'Controller', honorName: true })
 
   return {
     name: pluginReactQueryName,
     options,
-    dependencies: [pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter(Boolean),
+    dependencies: [pluginTsName, parser === 'zod' ? pluginZodName : undefined].filter((dependency): dependency is string => Boolean(dependency)),
     hooks: {
       'kubb:plugin:setup'(ctx) {
         const resolver = userResolver ? { ...resolverReactQuery, ...userResolver } : resolverReactQuery
 
         ctx.setOptions({
           output,
-          transformers,
           client: {
             bundle: client?.bundle,
             baseURL: client?.baseURL,
@@ -119,14 +133,14 @@ export const pluginReactQuery = definePlugin<PluginReactQuery>((options) => {
             ? {
                 queryParam: 'id',
                 initialPageParam: 0,
-                cursorParam: undefined,
-                nextParam: undefined,
-                previousParam: undefined,
+                cursorParam: null,
+                nextParam: null,
+                previousParam: null,
                 ...infinite,
               }
             : false,
           suspense,
-          customOptions: customOptions ? { name: 'useCustomHookOptions', ...customOptions } : undefined,
+          customOptions: customOptions ? { name: 'useCustomHookOptions', ...customOptions } : null,
           parser,
           paramsType,
           pathParamsType,
@@ -154,11 +168,11 @@ export const pluginReactQuery = definePlugin<PluginReactQuery>((options) => {
 
         if (client?.bundle && !hasClientPlugin && !clientImportPath) {
           ctx.injectFile({
-            baseName: 'fetch.ts',
-            path: path.resolve(root, '.kubb/fetch.ts'),
+            baseName: 'client.ts',
+            path: path.resolve(root, '.kubb/client.ts'),
             sources: [
               ast.createSource({
-                name: 'fetch',
+                name: 'client',
                 nodes: [ast.createText(clientName === 'fetch' ? fetchClientSource : axiosClientSource)],
                 isExportable: true,
                 isIndexable: true,

package/src/resolvers/resolverReactQuery.ts

@@ -2,21 +2,117 @@ import { camelCase } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
 import type { PluginReactQuery } from '../types.ts'
 
+function capitalize(name: string): string {
+  return `${name.charAt(0).toUpperCase()}${name.slice(1)}`
+}
+
 /**
- * Naming convention resolver for React Query plugin.
+ * Default resolver used by `@kubb/plugin-react-query`. Decides the names and
+ * file paths for every generated TanStack Query hook (`useFooQuery`,
+ * `useFooMutation`, `useFooInfiniteQuery`, ...) and its companion helpers
+ * (`fooQueryKey`, `fooQueryOptions`).
+ *
+ * Functions and files use camelCase; hooks get the `use` prefix; suspense and
+ * infinite variants are suffixed with `Suspense`/`Infinite`.
  *
- * Provides default naming helpers using camelCase for functions and file paths.
+ * @example Resolve hook and helper names
+ * ```ts
+ * import { resolverReactQuery } from '@kubb/plugin-react-query'
  *
- * @example
- * `resolverReactQuery.default('list pets', 'function')  // → 'listPets'`
+ * resolverReactQuery.resolveQueryName(operationNode)       // 'useGetPetById'
+ * resolverReactQuery.resolveMutationName(operationNode)    // 'useUpdatePet'
+ * resolverReactQuery.resolveQueryKeyName(operationNode)    // 'getPetByIdQueryKey'
+ * resolverReactQuery.resolveQueryOptionsName(operationNode) // 'getPetByIdQueryOptions'
+ * ```
  */
-export const resolverReactQuery = defineResolver<PluginReactQuery>((ctx) => ({
+export const resolverReactQuery = defineResolver<PluginReactQuery>(() => ({
   name: 'default',
   pluginName: 'plugin-react-query',
   default(name, type) {
     return camelCase(name, { isFile: type === 'file' })
   },
   resolveName(name) {
-    return ctx.default(name, 'function')
+    return this.default(name, 'function')
+  },
+  resolvePathName(name, type) {
+    return this.default(name, type)
+  },
+  resolveQueryName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}`
+  },
+  resolveSuspenseQueryName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}Suspense`
+  },
+  resolveInfiniteQueryName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}Infinite`
+  },
+  resolveSuspenseInfiniteQueryName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}SuspenseInfinite`
+  },
+  resolveMutationName(node) {
+    return `use${capitalize(this.resolveName(node.operationId))}`
+  },
+  resolveQueryOptionsName(node) {
+    return `${this.resolveName(node.operationId)}QueryOptions`
+  },
+  resolveSuspenseQueryOptionsName(node) {
+    return `${this.resolveName(node.operationId)}SuspenseQueryOptions`
+  },
+  resolveInfiniteQueryOptionsName(node) {
+    return `${this.resolveName(node.operationId)}InfiniteQueryOptions`
+  },
+  resolveSuspenseInfiniteQueryOptionsName(node) {
+    return `${this.resolveName(node.operationId)}SuspenseInfiniteQueryOptions`
+  },
+  resolveMutationOptionsName(node) {
+    return `${this.resolveName(node.operationId)}MutationOptions`
+  },
+  resolveQueryKeyName(node) {
+    return `${this.resolveName(node.operationId)}QueryKey`
+  },
+  resolveSuspenseQueryKeyName(node) {
+    return `${this.resolveName(node.operationId)}SuspenseQueryKey`
+  },
+  resolveInfiniteQueryKeyName(node) {
+    return `${this.resolveName(node.operationId)}InfiniteQueryKey`
+  },
+  resolveSuspenseInfiniteQueryKeyName(node) {
+    return `${this.resolveName(node.operationId)}SuspenseInfiniteQueryKey`
+  },
+  resolveMutationKeyName(node) {
+    return `${this.resolveName(node.operationId)}MutationKey`
+  },
+  resolveQueryKeyTypeName(node) {
+    return `${capitalize(this.resolveName(node.operationId))}QueryKey`
+  },
+  resolveSuspenseQueryKeyTypeName(node) {
+    return `${capitalize(this.resolveName(node.operationId))}SuspenseQueryKey`
+  },
+  resolveInfiniteQueryKeyTypeName(node) {
+    return `${capitalize(this.resolveName(node.operationId))}InfiniteQueryKey`
+  },
+  resolveSuspenseInfiniteQueryKeyTypeName(node) {
+    return `${capitalize(this.resolveName(node.operationId))}SuspenseInfiniteQueryKey`
+  },
+  resolveMutationTypeName(node) {
+    return capitalize(this.resolveName(node.operationId))
+  },
+  resolveClientName(node) {
+    return this.resolveName(node.operationId)
+  },
+  resolveSuspenseClientName(node) {
+    return `${this.resolveName(node.operationId)}Suspense`
+  },
+  resolveInfiniteClientName(node) {
+    return `${this.resolveName(node.operationId)}Infinite`
+  },
+  resolveSuspenseInfiniteClientName(node) {
+    return `${this.resolveName(node.operationId)}SuspenseInfinite`
+  },
+  resolveHookOptionsName() {
+    return 'HookOptions'
+  },
+  resolveCustomHookOptionsName() {
+    return 'getCustomHookOptions'
   },
 }))