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

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, jsxRendererSync } 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: jsxRendererSync,
-  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, jsxRendererSync, 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: jsxRendererSync,
-  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>
-    )
-  },
-})

package/src/generators/index.ts

@@ -1,7 +0,0 @@
-export { customHookOptionsFileGenerator } from './customHookOptionsFileGenerator.tsx'
-export { hookOptionsGenerator } from './hookOptionsGenerator.tsx'
-export { infiniteQueryGenerator } from './infiniteQueryGenerator.tsx'
-export { mutationGenerator } from './mutationGenerator.tsx'
-export { queryGenerator } from './queryGenerator.tsx'
-export { suspenseInfiniteQueryGenerator } from './suspenseInfiniteQueryGenerator.tsx'
-export { suspenseQueryGenerator } from './suspenseQueryGenerator.tsx'

package/src/generators/infiniteQueryGenerator.tsx

@@ -1,200 +0,0 @@
-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, jsxRendererSync } from '@kubb/renderer-jsx'
-import { InfiniteQuery, InfiniteQueryOptions, QueryKey } from '../components'
-import type { PluginReactQuery } from '../types'
-
-/**
- * Built-in generator for `useInfiniteQuery` hooks. Enabled when
- * `pluginReactQuery({ infinite: { ... } })`. Emits one `useFooInfiniteQuery`
- * hook per query operation, wiring the configured `nextParam` /
- * `previousParam` paths into TanStack Query's cursor-based pagination.
- */
-export const infiniteQueryGenerator = defineGenerator<PluginReactQuery>({
-  name: 'react-infinite-query',
-  renderer: jsxRendererSync,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    const { config, driver, resolver, root } = ctx
-    const { output, query, mutation, infinite, paramsCasing, paramsType, pathParamsType, parser, client: clientOptions, group, customOptions } = ctx.options
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
-    const queryMethods = new Set(query ? query.methods : [])
-    const isMutation =
-      mutation !== false &&
-      !isQuery &&
-      (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
-    const infiniteOptions = infinite && typeof infinite === 'object' ? infinite : null
-
-    if (!isQuery || isMutation || !infiniteOptions) return null
-
-    // Validate queryParam exists in operation's query parameters
-    const normalizeKey = (key: string) => key.replace(/\?$/, '')
-    const queryParamKeys = getOperationParameters(node).query.map((p) => p.name)
-    const hasQueryParam = infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false
-    // cursorParam validation against response schema keys is skipped in v5 (complex schema inspection)
-    const hasCursorParam = !infiniteOptions.cursorParam || true
-
-    if (!hasQueryParam || !hasCursorParam) return null
-
-    const importPath = query ? query.importPath : '@tanstack/react-query'
-
-    const queryName = resolver.resolveInfiniteQueryName(node)
-    const queryOptionsName = resolver.resolveInfiniteQueryOptionsName(node)
-    const queryKeyName = resolver.resolveInfiniteQueryKeyName(node)
-    const queryKeyTypeName = resolver.resolveInfiniteQueryKeyTypeName(node)
-    const clientBaseName = resolver.resolveInfiniteClientName(node)
-
-    const meta = {
-      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 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(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) : null
-
-    const clientFile = shouldUseClientPlugin
-      ? 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
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        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 } })}
-      >
-        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.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={['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/client.ts')}
-              isTypeOnly
-            />
-            {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
-            )}
-          </>
-        )}
-        {shouldUseClientPlugin && clientFile && <File.Import name={[resolvedClientName]} root={meta.file.path} path={clientFile.path} />}
-        {!shouldUseClientPlugin && <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />}
-        {customOptions && <File.Import name={[customOptions.name]} path={customOptions.importPath} />}
-        {meta.fileTs && importedTypeNames.length > 0 && (
-          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
-        )}
-
-        <QueryKey
-          name={queryKeyName}
-          typeName={queryKeyTypeName}
-          node={node}
-          tsResolver={tsResolver}
-          pathParamsType={pathParamsType}
-          paramsCasing={paramsCasing}
-          transformer={ctx.options.queryKey}
-        />
-
-        {!shouldUseClientPlugin && (
-          <Client
-            name={resolvedClientName}
-            baseURL={clientOptions.baseURL}
-            dataReturnType={clientOptions.dataReturnType || 'data'}
-            paramsCasing={clientOptions.paramsCasing || paramsCasing}
-            paramsType={paramsType}
-            pathParamsType={pathParamsType}
-            parser={parser}
-            node={node}
-            tsResolver={tsResolver}
-            zodResolver={zodResolver}
-          />
-        )}
-
-        <File.Import name={['InfiniteData']} isTypeOnly path={importPath} />
-        <File.Import name={['infiniteQueryOptions']} path={importPath} />
-
-        <InfiniteQueryOptions
-          name={queryOptionsName}
-          clientName={resolvedClientName}
-          queryKeyName={queryKeyName}
-          node={node}
-          tsResolver={tsResolver}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-          dataReturnType={clientOptions.dataReturnType || 'data'}
-          cursorParam={infiniteOptions.cursorParam}
-          nextParam={infiniteOptions.nextParam}
-          previousParam={infiniteOptions.previousParam}
-          initialPageParam={infiniteOptions.initialPageParam}
-          queryParam={infiniteOptions.queryParam}
-        />
-
-        <File.Import name={['useInfiniteQuery']} path={importPath} />
-        <File.Import name={['QueryKey', 'QueryClient', 'InfiniteQueryObserverOptions', 'UseInfiniteQueryResult']} path={importPath} isTypeOnly />
-
-        <InfiniteQuery
-          name={queryName}
-          queryOptionsName={queryOptionsName}
-          queryKeyName={queryKeyName}
-          queryKeyTypeName={queryKeyTypeName}
-          node={node}
-          tsResolver={tsResolver}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-          dataReturnType={clientOptions.dataReturnType || 'data'}
-          initialPageParam={infiniteOptions.initialPageParam}
-          queryParam={infiniteOptions.queryParam}
-          customOptions={customOptions}
-        />
-      </File>
-    )
-  },
-})

package/src/generators/mutationGenerator.tsx

@@ -1,173 +0,0 @@
-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, jsxRendererSync } from '@kubb/renderer-jsx'
-import { Mutation, MutationKey, MutationOptions } from '../components'
-import type { PluginReactQuery } from '../types'
-
-/**
- * Built-in generator for `useMutation` hooks. Emits one `useFooMutation` hook
- * per POST/PUT/DELETE operation (configurable via `mutation.methods`) plus
- * the matching `fooMutationKey` / `fooMutationOptions` helpers.
- */
-export const mutationGenerator = defineGenerator<PluginReactQuery>({
-  name: 'react-query-mutation',
-  renderer: jsxRendererSync,
-  operation(node, ctx) {
-    if (!ast.isHttpOperationNode(node)) return null
-    const { config, driver, resolver, root } = ctx
-    const { output, query, mutation, paramsCasing, paramsType, pathParamsType, parser, client: clientOptions, group, customOptions } = ctx.options
-
-    const pluginTs = driver.getPlugin(pluginTsName)
-    if (!pluginTs) return null
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
-    const queryMethods = new Set(query ? query.methods : [])
-    const isMutation =
-      mutation !== false &&
-      !isQuery &&
-      (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
-
-    if (!isMutation) return null
-
-    const importPath = mutation ? mutation.importPath : '@tanstack/react-query'
-
-    const mutationHookName = resolver.resolveMutationName(node)
-    const mutationTypeName = resolver.resolveMutationTypeName(node)
-    const mutationOptionsName = resolver.resolveMutationOptionsName(node)
-    const mutationKeyName = resolver.resolveMutationKeyName(node)
-    const clientName = resolver.resolveClientName(node)
-
-    const meta = {
-      file: resolver.resolveFile(operationFileEntry(node, mutationHookName), { root, output, group: group ?? undefined }),
-      fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
-        root,
-        output: pluginTs.options?.output ?? output,
-        group: pluginTs.options?.group ?? 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(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) : null
-
-    const clientFile = shouldUseClientPlugin
-      ? 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
-
-    return (
-      <File
-        baseName={meta.file.baseName}
-        path={meta.file.path}
-        meta={meta.file.meta}
-        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 } })}
-      >
-        {fileZod && zodSchemaNames.length > 0 && <File.Import name={zodSchemaNames} root={meta.file.path} path={fileZod.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={['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/client.ts')}
-              isTypeOnly
-            />
-            {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/client.ts')} isTypeOnly />
-            )}
-          </>
-        )}
-        {shouldUseClientPlugin && clientFile && <File.Import name={[resolvedClientName]} root={meta.file.path} path={clientFile.path} />}
-        {!shouldUseClientPlugin && node.requestBody?.content?.some((e) => e.contentType === 'multipart/form-data') && (
-          <File.Import name={['buildFormData']} root={meta.file.path} path={path.resolve(root, '.kubb/config.ts')} />
-        )}
-        {customOptions && <File.Import name={[customOptions.name]} path={customOptions.importPath} />}
-        {meta.fileTs && importedTypeNames.length > 0 && (
-          <File.Import name={Array.from(new Set(importedTypeNames))} root={meta.file.path} path={meta.fileTs.path} isTypeOnly />
-        )}
-
-        <MutationKey name={mutationKeyName} node={node} pathParamsType={pathParamsType} paramsCasing={paramsCasing} transformer={ctx.options.mutationKey} />
-
-        {!shouldUseClientPlugin && (
-          <Client
-            name={resolvedClientName}
-            baseURL={clientOptions.baseURL}
-            dataReturnType={clientOptions.dataReturnType || 'data'}
-            paramsCasing={clientOptions.paramsCasing || paramsCasing}
-            paramsType={paramsType}
-            pathParamsType={pathParamsType}
-            parser={parser}
-            node={node}
-            tsResolver={tsResolver}
-            zodResolver={zodResolver}
-          />
-        )}
-
-        <File.Import name={['mutationOptions']} path={importPath} />
-
-        <MutationOptions
-          name={mutationOptionsName}
-          clientName={resolvedClientName}
-          mutationKeyName={mutationKeyName}
-          node={node}
-          tsResolver={tsResolver}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-          dataReturnType={clientOptions.dataReturnType || 'data'}
-        />
-
-        {mutation && (
-          <>
-            <File.Import name={['useMutation']} path={importPath} />
-            <File.Import name={['UseMutationOptions', 'UseMutationResult', 'QueryClient']} path={importPath} isTypeOnly />
-            <Mutation
-              name={mutationHookName}
-              typeName={mutationTypeName}
-              mutationOptionsName={mutationOptionsName}
-              mutationKeyName={mutationKeyName}
-              node={node}
-              tsResolver={tsResolver}
-              dataReturnType={clientOptions.dataReturnType || 'data'}
-              paramsCasing={paramsCasing}
-              pathParamsType={pathParamsType}
-              customOptions={customOptions}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})