@kubb/plugin-react-query 5.0.0-beta.10 → 5.0.0-beta.101

package/src/generators/queryGenerator.tsx

@@ -1,180 +0,0 @@
-import path from 'node:path'
-import { resolveOperationTypeNames } from '@internals/shared'
-import { resolveZodSchemaNames } from '@internals/tanstack-query'
-import { 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 { difference } from 'remeda'
-import { Query, QueryKey, QueryOptions } from '../components'
-import type { PluginReactQuery } from '../types'
-
-export const queryGenerator = defineGenerator<PluginReactQuery>({
-  name: 'react-query',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    const { adapter, 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)
-
-    // query: false means "this IS a query op, but skip the useQuery hook"
-    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
-    const isMutation =
-      mutation !== false &&
-      !isQuery &&
-      difference(mutation ? mutation.methods : [], query ? query.methods : []).some((method) => node.method.toLowerCase() === method.toLowerCase())
-
-    if (!isQuery || isMutation) return null
-
-    const importPath = query ? query.importPath : '@tanstack/react-query'
-
-    const queryName = resolver.resolveQueryName(node)
-    const queryOptionsName = resolver.resolveQueryOptionsName(node)
-    const queryKeyName = resolver.resolveQueryKeyName(node)
-    const queryKeyTypeName = resolver.resolveQueryKeyTypeName(node)
-    const clientName = resolver.resolveClientName(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 },
-      ),
-    }
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, {
-      paramsCasing,
-      exclude: [queryKeyTypeName],
-      order: 'body-response-first',
-    })
-
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
-    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 = 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 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
-
-    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(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        {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} />}
-            <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')} />}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
-            {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.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={['queryOptions']} path={importPath} />
-
-        <QueryOptions
-          name={queryOptionsName}
-          clientName={resolvedClientName}
-          queryKeyName={queryKeyName}
-          node={node}
-          tsResolver={tsResolver}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-          dataReturnType={clientOptions.dataReturnType || 'data'}
-        />
-
-        {query && (
-          <>
-            <File.Import name={['useQuery']} path={importPath} />
-            <File.Import name={['QueryKey', 'QueryClient', 'QueryObserverOptions', 'UseQueryResult']} path={importPath} isTypeOnly />
-            <Query
-              name={queryName}
-              queryOptionsName={queryOptionsName}
-              queryKeyName={queryKeyName}
-              queryKeyTypeName={queryKeyTypeName}
-              node={node}
-              tsResolver={tsResolver}
-              paramsCasing={paramsCasing}
-              paramsType={paramsType}
-              pathParamsType={pathParamsType}
-              dataReturnType={clientOptions.dataReturnType || 'data'}
-              customOptions={customOptions}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})

package/src/generators/suspenseInfiniteQueryGenerator.tsx

@@ -1,203 +0,0 @@
-import path from 'node:path'
-import { getOperationParameters, resolveOperationTypeNames } from '@internals/shared'
-import { resolveZodSchemaNames } from '@internals/tanstack-query'
-import { 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 { difference } from 'remeda'
-import { QueryKey, SuspenseInfiniteQuery, SuspenseInfiniteQueryOptions } from '../components'
-import type { PluginReactQuery } from '../types'
-
-export const suspenseInfiniteQueryGenerator = defineGenerator<PluginReactQuery>({
-  name: 'react-suspense-infinite-query',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    const { adapter, config, driver, resolver, root } = ctx
-    const {
-      output,
-      query,
-      mutation,
-      infinite,
-      suspense,
-      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 isMutation =
-      mutation !== false &&
-      !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
-
-    if (!isQuery || isMutation || !isSuspense || !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
-    const hasCursorParam = !infiniteOptions.cursorParam || true
-
-    if (!hasQueryParam || !hasCursorParam) return null
-
-    const importPath = query ? query.importPath : '@tanstack/react-query'
-
-    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 },
-      ),
-    }
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing, order: 'body-response-first' })
-
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
-    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 = 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 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
-
-    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(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        {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} />}
-            <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')} />}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
-            {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.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} />
-
-        <SuspenseInfiniteQueryOptions
-          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={['useSuspenseInfiniteQuery']} path={importPath} />
-        <File.Import name={['QueryKey', 'QueryClient', 'UseSuspenseInfiniteQueryOptions', 'UseSuspenseInfiniteQueryResult']} path={importPath} isTypeOnly />
-
-        <SuspenseInfiniteQuery
-          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/suspenseQueryGenerator.tsx

@@ -1,181 +0,0 @@
-import path from 'node:path'
-import { resolveOperationTypeNames } from '@internals/shared'
-import { resolveZodSchemaNames } from '@internals/tanstack-query'
-import { 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 { difference } from 'remeda'
-import { QueryKey, QueryOptions, SuspenseQuery } from '../components'
-import type { PluginReactQuery } from '../types'
-
-export const suspenseQueryGenerator = defineGenerator<PluginReactQuery>({
-  name: 'react-suspense-query',
-  renderer: jsxRenderer,
-  operation(node, ctx) {
-    const { adapter, 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
-    const tsResolver = driver.getResolver(pluginTsName)
-
-    // query: false means "this IS a query op" (suspense hooks still generate)
-    const isQuery = query === false || (!!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase()))
-    const isMutation =
-      mutation !== false &&
-      !isQuery &&
-      difference(mutation ? mutation.methods : [], query ? query.methods : []).some((method) => node.method.toLowerCase() === method.toLowerCase())
-    const isSuspense = !!suspense
-
-    if (!isQuery || isMutation || !isSuspense) return null
-
-    const importPath = query ? query.importPath : '@tanstack/react-query'
-
-    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 },
-      ),
-    }
-
-    const importedTypeNames = resolveOperationTypeNames(node, tsResolver, {
-      paramsCasing,
-      exclude: [queryKeyTypeName],
-      order: 'body-response-first',
-    })
-
-    const pluginZod = parser === 'zod' ? driver.getPlugin(pluginZodName) : undefined
-    const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : undefined
-    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 = 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 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
-
-    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(adapter.inputNode, { output, config })}
-        footer={resolver.resolveFooter(adapter.inputNode, { output, config })}
-      >
-        {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} />}
-            <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')} />}
-            <File.Import
-              name={['Client', 'RequestConfig', 'ResponseErrorConfig']}
-              root={meta.file.path}
-              path={path.resolve(root, '.kubb/fetch.ts')}
-              isTypeOnly
-            />
-            {clientOptions.dataReturnType === 'full' && (
-              <File.Import name={['ResponseConfig']} root={meta.file.path} path={path.resolve(root, '.kubb/fetch.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={['queryOptions']} path={importPath} />
-
-        <QueryOptions
-          name={queryOptionsName}
-          clientName={resolvedClientName}
-          queryKeyName={queryKeyName}
-          node={node}
-          tsResolver={tsResolver}
-          paramsCasing={paramsCasing}
-          paramsType={paramsType}
-          pathParamsType={pathParamsType}
-          dataReturnType={clientOptions.dataReturnType || 'data'}
-        />
-
-        {suspense && (
-          <>
-            <File.Import name={['useSuspenseQuery']} path={importPath} />
-            <File.Import name={['QueryKey', 'QueryClient', 'UseSuspenseQueryOptions', 'UseSuspenseQueryResult']} path={importPath} isTypeOnly />
-            <SuspenseQuery
-              name={queryName}
-              queryOptionsName={queryOptionsName}
-              queryKeyName={queryKeyName}
-              queryKeyTypeName={queryKeyTypeName}
-              node={node}
-              tsResolver={tsResolver}
-              paramsCasing={paramsCasing}
-              paramsType={paramsType}
-              pathParamsType={pathParamsType}
-              dataReturnType={clientOptions.dataReturnType || 'data'}
-              customOptions={customOptions}
-            />
-          </>
-        )}
-      </File>
-    )
-  },
-})

package/src/index.ts

@@ -1,2 +0,0 @@
-export { default, pluginReactQuery, pluginReactQueryName } from './plugin.ts'
-export type { PluginReactQuery } from './types.ts'