@kubb/plugin-react-query 5.0.0-alpha.9 → 5.0.0-beta.100

package/src/generators/hookOptionsGenerator.tsx

@@ -1,196 +0,0 @@
-import { usePluginDriver } from '@kubb/core/hooks'
-import type { Operation } from '@kubb/oas'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { File, Type } from '@kubb/react-fabric'
-import { difference } from 'remeda'
-import type { PluginReactQuery } from '../types'
-
-export const hookOptionsGenerator = createReactGenerator<PluginReactQuery>({
-  name: 'react-query-hook-options',
-  Operations({ operations, plugin, generator }) {
-    const {
-      options,
-      options: { output },
-      name: pluginName,
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getName, getFile } = useOperationManager(generator)
-
-    if (!options.customOptions) {
-      return null
-    }
-
-    const name = 'HookOptions'
-    const file = driver.getFile({ name, extname: '.ts', pluginName })
-
-    const getOperationOptions = (operation: Operation) => {
-      const operationOptions = generator.getOptions(operation, operation.method)
-      return { ...options, ...operationOptions }
-    }
-
-    const isQuery = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      return typeof operationOptions.query === 'boolean' ? true : operationOptions.query?.methods.some((method) => operation.method === method)
-    }
-
-    const isMutation = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      return (
-        operationOptions.mutation !== false &&
-        !isQuery(operation) &&
-        difference(operationOptions.mutation ? operationOptions.mutation.methods : [], operationOptions.query ? operationOptions.query.methods : []).some(
-          (method) => operation.method === method,
-        )
-      )
-    }
-
-    const isSuspense = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      return !!operationOptions.suspense
-    }
-
-    const isInfinite = (operation: Operation) => {
-      const operationOptions = getOperationOptions(operation)
-      const infiniteOptions = operationOptions.infinite && typeof operationOptions.infinite === 'object' ? operationOptions.infinite : undefined
-      return !!infiniteOptions
-    }
-
-    // Query/mutation hooks
-    const getHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use' })
-    }
-
-    const getHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use' })
-    }
-
-    // Query hooks
-    const getQueryHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'QueryOptions' })
-    }
-
-    const getQueryHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getQueryHookOptions(operation)]} root={file.path} path={getHookFile(operation).path} />
-    }
-
-    // Mutation hooks
-    const getMutationHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'MutationOptions' })
-    }
-
-    const getMutationHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getMutationHookOptions(operation)]} root={file.path} path={getHookFile(operation).path} />
-    }
-
-    // Suspense hooks
-    const getSuspenseHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use', suffix: 'suspense' })
-    }
-
-    const getSuspenseHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use', suffix: 'suspense' })
-    }
-
-    const getSuspenseHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'SuspenseQueryOptions' })
-    }
-
-    const getSuspenseHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getSuspenseHookOptions(operation)]} root={file.path} path={getSuspenseHookFile(operation).path} />
-    }
-
-    // Infinite hooks
-    const getInfiniteHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use', suffix: 'infinite' })
-    }
-
-    const getInfiniteHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use', suffix: 'infinite' })
-    }
-
-    const getInfiniteHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'InfiniteQueryOptions' })
-    }
-
-    const getInfiniteHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getInfiniteHookOptions(operation)]} root={file.path} path={getInfiniteHookFile(operation).path} />
-    }
-
-    // Suspense infinite hooks
-    const getSuspenseInfiniteHookName = (operation: Operation) => {
-      return getName(operation, { type: 'function', prefix: 'use', suffix: 'suspenseInfinite' })
-    }
-
-    const getSuspenseInfiniteHookFile = (operation: Operation) => {
-      return getFile(operation, { prefix: 'use', suffix: 'suspenseInfinite' })
-    }
-
-    const getSuspenseInfiniteHookOptions = (operation: Operation) => {
-      return getName(operation, { type: 'function', suffix: 'SuspenseInfiniteQueryOptions' })
-    }
-
-    const getSuspenseInfiniteHookOptionsImport = (operation: Operation) => {
-      return <File.Import name={[getSuspenseInfiniteHookOptions(operation)]} root={file.path} path={getSuspenseInfiniteHookFile(operation).path} />
-    }
-
-    const imports = operations
-      .flatMap((operation) => {
-        if (isQuery(operation)) {
-          return [
-            getQueryHookOptionsImport(operation),
-            isSuspense(operation) ? getSuspenseHookOptionsImport(operation) : undefined,
-            isInfinite(operation) ? getInfiniteHookOptionsImport(operation) : undefined,
-            isSuspense(operation) && isInfinite(operation) ? getSuspenseInfiniteHookOptionsImport(operation) : undefined,
-          ].filter(Boolean)
-        }
-        if (isMutation(operation)) {
-          return [getMutationHookOptionsImport(operation)]
-        }
-        return []
-      })
-      .filter(Boolean)
-
-    const hookOptions = operations.reduce(
-      (acc, operation) => {
-        if (isQuery(operation)) {
-          acc[getHookName(operation)] = `Partial<ReturnType<typeof ${getQueryHookOptions(operation)}>>`
-          if (isSuspense(operation)) {
-            acc[getSuspenseHookName(operation)] = `Partial<ReturnType<typeof ${getSuspenseHookOptions(operation)}>>`
-          }
-          if (isInfinite(operation)) {
-            acc[getInfiniteHookName(operation)] = `Partial<ReturnType<typeof ${getInfiniteHookOptions(operation)}>>`
-          }
-          if (isSuspense(operation) && isInfinite(operation)) {
-            acc[getSuspenseInfiniteHookName(operation)] = `Partial<ReturnType<typeof ${getSuspenseInfiniteHookOptions(operation)}>>`
-          }
-        }
-        if (isMutation(operation)) {
-          acc[getHookName(operation)] = `Partial<ReturnType<typeof ${getMutationHookOptions(operation)}>>`
-        }
-        return acc
-      },
-      {} as Record<string, string>,
-    )
-
-    return (
-      <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        {imports}
-        <File.Source name={name} isExportable isIndexable isTypeOnly>
-          <Type export name={name}>
-            {`{ ${Object.keys(hookOptions).map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`)} }`}
-          </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,214 +0,0 @@
-import path from 'node:path'
-import { usePluginDriver } from '@kubb/core/hooks'
-import { pluginClientName } from '@kubb/plugin-client'
-import { Client } from '@kubb/plugin-client/components'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/react-fabric'
-import { difference } from 'remeda'
-import { InfiniteQuery, InfiniteQueryOptions, QueryKey } from '../components'
-import type { PluginReactQuery } from '../types'
-
-export const infiniteQueryGenerator = createReactGenerator<PluginReactQuery>({
-  name: 'react-infinite-query',
-  Operation({ config, operation, generator, plugin }) {
-    const {
-      options,
-      options: { output },
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
-
-    const isQuery = typeof options.query === 'boolean' ? true : options.query?.methods.some((method) => operation.method === method)
-    const isMutation = difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some(
-      (method) => operation.method === method,
-    )
-    const infiniteOptions = options.infinite && typeof options.infinite === 'object' ? options.infinite : undefined
-
-    const importPath = options.query ? options.query.importPath : '@tanstack/react-query'
-
-    const query = {
-      name: getName(operation, { type: 'function', prefix: 'use', suffix: 'infinite' }),
-      typeName: getName(operation, { type: 'type' }),
-      file: getFile(operation, { prefix: 'use', suffix: 'infinite' }),
-    }
-
-    const hasClientPlugin = !!driver.getPluginByName(pluginClientName)
-    // Class-based clients are not compatible with query hooks, so we generate inline clients
-    const shouldUseClientPlugin = hasClientPlugin && options.client.clientType !== 'class'
-    const client = {
-      name: shouldUseClientPlugin
-        ? getName(operation, {
-            type: 'function',
-            pluginName: pluginClientName,
-          })
-        : getName(operation, {
-            type: 'function',
-            suffix: 'infinite',
-          }),
-      file: getFile(operation, { pluginName: pluginClientName }),
-    }
-
-    const queryOptions = {
-      name: getName(operation, { type: 'function', suffix: 'InfiniteQueryOptions' }),
-    }
-
-    const queryKey = {
-      name: getName(operation, { type: 'const', suffix: 'InfiniteQueryKey' }),
-      typeName: getName(operation, { type: 'type', suffix: 'InfiniteQueryKey' }),
-    }
-
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      //todo remove type?
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
-
-    const zod = {
-      file: getFile(operation, { pluginName: pluginZodName }),
-      schemas: getSchemas(operation, { pluginName: pluginZodName, type: 'function' }),
-    }
-
-    if (!isQuery || isMutation || !infiniteOptions) {
-      return null
-    }
-
-    const normalizeKey = (key?: string | null) => (key ?? '').replace(/\?$/, '')
-    const queryParam = infiniteOptions.queryParam
-    const cursorParam = infiniteOptions.cursorParam
-    const queryParamKeys = type.schemas.queryParams?.keys ?? []
-    const responseKeys = [...(type.schemas.responses?.flatMap((item) => item.keys ?? []) ?? []), ...(type.schemas.response?.keys ?? [])]
-
-    const hasQueryParam = queryParam ? queryParamKeys.some((key) => normalizeKey(key) === queryParam) : false
-    const hasCursorParam = cursorParam ? responseKeys.some((key) => normalizeKey(key) === cursorParam) : true
-
-    if (!hasQueryParam || !hasCursorParam) {
-      return null
-    }
-
-    return (
-      <File
-        baseName={query.file.baseName}
-        path={query.file.path}
-        meta={query.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        {options.parser === 'zod' && (
-          <File.Import name={[zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean)} root={query.file.path} path={zod.file.path} />
-        )}
-        {options.client.importPath ? (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={'fetch'} path={options.client.importPath} />}
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
-            {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
-          </>
-        ) : (
-          <>
-            {!shouldUseClientPlugin && (
-              <File.Import name={['fetch']} root={query.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-            )}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={query.file.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
-            {options.client.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={query.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} isTypeOnly />
-            )}
-          </>
-        )}
-
-        {shouldUseClientPlugin && <File.Import name={[client.name]} root={query.file.path} path={client.file.path} />}
-        {!shouldUseClientPlugin && (
-          <File.Import name={['buildFormData']} root={query.file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />
-        )}
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter(Boolean)}
-          root={query.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
-        <QueryKey
-          name={queryKey.name}
-          typeName={queryKey.typeName}
-          operation={operation}
-          paramsCasing={options.paramsCasing}
-          pathParamsType={options.pathParamsType}
-          typeSchemas={type.schemas}
-          transformer={options.queryKey}
-        />
-        {!shouldUseClientPlugin && (
-          <Client
-            name={client.name}
-            baseURL={options.client.baseURL}
-            operation={operation}
-            typeSchemas={type.schemas}
-            zodSchemas={zod.schemas}
-            dataReturnType={options.client.dataReturnType || 'data'}
-            paramsCasing={options.client?.paramsCasing || options.paramsCasing}
-            paramsType={options.paramsType}
-            pathParamsType={options.pathParamsType}
-            parser={options.parser}
-          />
-        )}
-        {options.customOptions && <File.Import name={[options.customOptions.name]} path={options.customOptions.importPath} />}
-        {infiniteOptions && (
-          <>
-            <File.Import name={['InfiniteData']} isTypeOnly path={importPath} />
-            <File.Import name={['infiniteQueryOptions']} path={importPath} />
-            <InfiniteQueryOptions
-              name={queryOptions.name}
-              clientName={client.name}
-              queryKeyName={queryKey.name}
-              typeSchemas={type.schemas}
-              paramsCasing={options.paramsCasing}
-              paramsType={options.paramsType}
-              pathParamsType={options.pathParamsType}
-              dataReturnType={options.client.dataReturnType || 'data'}
-              cursorParam={infiniteOptions.cursorParam}
-              nextParam={infiniteOptions.nextParam}
-              previousParam={infiniteOptions.previousParam}
-              initialPageParam={infiniteOptions.initialPageParam}
-              queryParam={infiniteOptions.queryParam}
-            />
-          </>
-        )}
-        {infiniteOptions && (
-          <>
-            <File.Import name={['useInfiniteQuery']} path={importPath} />
-            <File.Import name={['QueryKey', 'QueryClient', 'InfiniteQueryObserverOptions', 'UseInfiniteQueryResult']} path={importPath} isTypeOnly />
-            <InfiniteQuery
-              name={query.name}
-              queryOptionsName={queryOptions.name}
-              typeSchemas={type.schemas}
-              paramsCasing={options.paramsCasing}
-              paramsType={options.paramsType}
-              pathParamsType={options.pathParamsType}
-              operation={operation}
-              dataReturnType={options.client.dataReturnType || 'data'}
-              queryKeyName={queryKey.name}
-              queryKeyTypeName={queryKey.typeName}
-              initialPageParam={infiniteOptions.initialPageParam}
-              queryParam={infiniteOptions.queryParam}
-              customOptions={options.customOptions}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})

package/src/generators/mutationGenerator.tsx

@@ -1,195 +0,0 @@
-import path from 'node:path'
-import { usePluginDriver } from '@kubb/core/hooks'
-import { pluginClientName } from '@kubb/plugin-client'
-import { Client } from '@kubb/plugin-client/components'
-import { createReactGenerator } from '@kubb/plugin-oas/generators'
-import { useOas, useOperationManager } from '@kubb/plugin-oas/hooks'
-import { getBanner, getFooter } from '@kubb/plugin-oas/utils'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { File } from '@kubb/react-fabric'
-import { difference } from 'remeda'
-import { Mutation, MutationKey } from '../components'
-import { MutationOptions } from '../components/MutationOptions.tsx'
-import type { PluginReactQuery } from '../types'
-
-export const mutationGenerator = createReactGenerator<PluginReactQuery>({
-  name: 'react-query',
-  Operation({ config, plugin, operation, generator }) {
-    const {
-      options,
-      options: { output },
-    } = plugin
-    const driver = usePluginDriver()
-
-    const oas = useOas()
-    const { getSchemas, getName, getFile } = useOperationManager(generator)
-
-    const isQuery = !!options.query && options.query?.methods.some((method) => operation.method === method)
-    const isMutation =
-      options.mutation !== false &&
-      !isQuery &&
-      difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some((method) => operation.method === method)
-
-    const importPath = options.mutation ? options.mutation.importPath : '@tanstack/react-query'
-
-    const mutation = {
-      name: getName(operation, { type: 'function', prefix: 'use' }),
-      typeName: getName(operation, { type: 'type' }),
-      file: getFile(operation, { prefix: 'use' }),
-    }
-
-    const type = {
-      file: getFile(operation, { pluginName: pluginTsName }),
-      //todo remove type?
-      schemas: getSchemas(operation, { pluginName: pluginTsName, type: 'type' }),
-    }
-
-    const zod = {
-      file: getFile(operation, { pluginName: pluginZodName }),
-      schemas: getSchemas(operation, { pluginName: pluginZodName, type: 'function' }),
-    }
-
-    const hasClientPlugin = !!driver.getPluginByName(pluginClientName)
-    // Class-based clients are not compatible with query hooks, so we generate inline clients
-    const shouldUseClientPlugin = hasClientPlugin && options.client.clientType !== 'class'
-    const client = {
-      name: shouldUseClientPlugin
-        ? getName(operation, {
-            type: 'function',
-            pluginName: pluginClientName,
-          })
-        : getName(operation, {
-            type: 'function',
-          }),
-      file: getFile(operation, { pluginName: pluginClientName }),
-    }
-
-    const mutationOptions = {
-      name: getName(operation, { type: 'function', suffix: 'MutationOptions' }),
-    }
-
-    const mutationKey = {
-      name: getName(operation, { type: 'const', suffix: 'MutationKey' }),
-      typeName: getName(operation, { type: 'type', suffix: 'MutationKey' }),
-    }
-
-    if (!isMutation) {
-      return null
-    }
-
-    return (
-      <File
-        baseName={mutation.file.baseName}
-        path={mutation.file.path}
-        meta={mutation.file.meta}
-        banner={getBanner({ oas, output, config: driver.config })}
-        footer={getFooter({ oas, output })}
-      >
-        {options.parser === 'zod' && (
-          <File.Import name={[zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean)} root={mutation.file.path} path={zod.file.path} />
-        )}
-        {options.client.importPath ? (
-          <>
-            {!shouldUseClientPlugin && <File.Import name={'fetch'} path={options.client.importPath} />}
-            <File.Import name={['Client', 'RequestConfig', 'ResponseErrorConfig']} path={options.client.importPath} isTypeOnly />
-            {options.client.dataReturnType === 'full' && <File.Import name={['ResponseConfig']} path={options.client.importPath} isTypeOnly />}
-          </>
-        ) : (
-          <>
-            {!shouldUseClientPlugin && (
-              <File.Import name={['fetch']} root={mutation.file.path} path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')} />
-            )}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={mutation.file.path}
-              path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
-            {options.client.dataReturnType === 'full' && (
-              <File.Import
-                name={['ResponseConfig']}
-                root={mutation.file.path}
-                path={path.resolve(config.root, config.output.path, '.kubb/fetch.ts')}
-                isTypeOnly
-              />
-            )}
-          </>
-        )}
-        {shouldUseClientPlugin && <File.Import name={[client.name]} root={mutation.file.path} path={client.file.path} />}
-        {!shouldUseClientPlugin && (
-          <File.Import name={['buildFormData']} root={mutation.file.path} path={path.resolve(config.root, config.output.path, '.kubb/config.ts')} />
-        )}
-        {options.customOptions && <File.Import name={[options.customOptions.name]} path={options.customOptions.importPath} />}
-        <File.Import
-          name={[
-            type.schemas.request?.name,
-            type.schemas.response.name,
-            type.schemas.pathParams?.name,
-            type.schemas.queryParams?.name,
-            type.schemas.headerParams?.name,
-            ...(type.schemas.statusCodes?.map((item) => item.name) || []),
-          ].filter(Boolean)}
-          root={mutation.file.path}
-          path={type.file.path}
-          isTypeOnly
-        />
-
-        <MutationKey
-          name={mutationKey.name}
-          typeName={mutationKey.typeName}
-          operation={operation}
-          pathParamsType={options.pathParamsType}
-          typeSchemas={type.schemas}
-          paramsCasing={options.paramsCasing}
-          transformer={options.mutationKey}
-        />
-
-        {!shouldUseClientPlugin && (
-          <Client
-            name={client.name}
-            baseURL={options.client.baseURL}
-            operation={operation}
-            typeSchemas={type.schemas}
-            zodSchemas={zod.schemas}
-            dataReturnType={options.client.dataReturnType || 'data'}
-            paramsCasing={options.client?.paramsCasing || options.paramsCasing}
-            paramsType={options.paramsType}
-            pathParamsType={options.pathParamsType}
-            parser={options.parser}
-          />
-        )}
-        <File.Import name={['mutationOptions']} path={importPath} />
-
-        <MutationOptions
-          name={mutationOptions.name}
-          clientName={client.name}
-          mutationKeyName={mutationKey.name}
-          typeSchemas={type.schemas}
-          paramsCasing={options.paramsCasing}
-          paramsType={options.paramsType}
-          pathParamsType={options.pathParamsType}
-          dataReturnType={options.client.dataReturnType || 'data'}
-        />
-        {options.mutation && (
-          <>
-            <File.Import name={['useMutation']} path={importPath} />
-            <File.Import name={['UseMutationOptions', 'UseMutationResult', 'QueryClient']} path={importPath} isTypeOnly />
-            <Mutation
-              name={mutation.name}
-              mutationOptionsName={mutationOptions.name}
-              typeName={mutation.typeName}
-              typeSchemas={type.schemas}
-              operation={operation}
-              dataReturnType={options.client.dataReturnType || 'data'}
-              paramsCasing={options.paramsCasing}
-              pathParamsType={options.pathParamsType}
-              mutationKeyName={mutationKey.name}
-              customOptions={options.customOptions}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})