@kubb/plugin-vue-query 5.0.0-beta.56 → 5.0.0-beta.73

package/src/components/InfiniteQueryOptions.tsx

@@ -1,191 +0,0 @@
-import { getOperationParameters } from '@internals/shared'
-import { getNestedAccessor } from '@kubb/ast/utils'
-import type { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { Infinite, PluginVueQuery } from '../types.ts'
-import { buildStatusUnionType, resolveErrorNames, resolveSuccessNames } from '../utils.ts'
-import { buildQueryKeyParamsNode } from './QueryKey.tsx'
-import { getEnabledParamNames, markParamsOptional } from '@internals/tanstack-query'
-import { getQueryOptionsParams } from './QueryOptions.tsx'
-
-type Props = {
-  name: string
-  clientName: string
-  queryKeyName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginVueQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
-  initialPageParam: Infinite['initialPageParam']
-  cursorParam: Infinite['cursorParam']
-  nextParam: Infinite['nextParam']
-  previousParam: Infinite['previousParam']
-  queryParam: Infinite['queryParam']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-export function InfiniteQueryOptions({
-  name,
-  clientName,
-  initialPageParam,
-  cursorParam,
-  nextParam,
-  previousParam,
-  node,
-  tsResolver,
-  paramsCasing,
-  paramsType,
-  dataReturnType,
-  pathParamsType,
-  queryParam,
-  queryKeyName,
-}: Props): KubbReactNode {
-  const successNames = resolveSuccessNames(node, tsResolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
-  const queryFnDataType = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, tsResolver)
-  const errorNames = resolveErrorNames(node, tsResolver)
-  const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const isInitialPageParamDefined = initialPageParam !== undefined && initialPageParam !== null
-  const fallbackPageParamType =
-    typeof initialPageParam === 'number'
-      ? 'number'
-      : typeof initialPageParam === 'string'
-        ? initialPageParam.includes(' as ')
-          ? (() => {
-              const parts = initialPageParam.split(' as ')
-              return parts[parts.length - 1] ?? 'unknown'
-            })()
-          : 'string'
-        : typeof initialPageParam === 'boolean'
-          ? 'boolean'
-          : 'unknown'
-
-  const rawQueryParams = getOperationParameters(node).query
-  const queryParamsTypeName =
-    rawQueryParams.length > 0
-      ? (() => {
-          const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]!)
-          const individualName = tsResolver.resolveParamName(node, rawQueryParams[0]!)
-          return groupName !== individualName ? groupName : null
-        })()
-      : null
-
-  const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null
-  const pageParamType = queryParamType ? (isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType) : fallbackPageParamType
-
-  const queryKeyParamsNode = buildQueryKeyParamsNode(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
-
-  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
-  const enabledText = enabledNames.length ? `enabled: () => ${enabledNames.map((n) => `!!toValue(${n})`).join(' && ')},` : ''
-
-  const paramsNode = markParamsOptional(getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver }), enabledNames)
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const rawParamsCall = callPrinter.print(paramsNode) ?? ''
-  const clientCallStr = rawParamsCall.replace(/\bconfig\b(?=[^,]*$)/, '{ ...config, signal: config.signal ?? signal }')
-
-  const hasNewParams = nextParam != null || previousParam != null
-
-  const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
-    if (hasNewParams) {
-      const nextAccessor = nextParam ? getNestedAccessor(nextParam, 'lastPage') : null
-      const prevAccessor = previousParam ? getNestedAccessor(previousParam, 'firstPage') : null
-      return [
-        nextAccessor ? `getNextPageParam: (lastPage) => ${nextAccessor}` : null,
-        prevAccessor ? `getPreviousPageParam: (firstPage) => ${prevAccessor}` : null,
-      ] as const
-    }
-    if (cursorParam) {
-      return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`] as const
-    }
-    return [
-      dataReturnType === 'full'
-        ? 'getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1'
-        : 'getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1',
-      'getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1',
-    ] as const
-  })()
-
-  const queryOptionsArr = [
-    `initialPageParam: ${typeof initialPageParam === 'string' ? JSON.stringify(initialPageParam) : initialPageParam}`,
-    getNextPageParamExpr,
-    getPreviousPageParamExpr,
-  ].filter(Boolean)
-
-  const infiniteOverrideParams =
-    queryParam && queryParamsTypeName
-      ? `params = {
-      ...(params ?? {}),
-      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
-    } as ${queryParamsTypeName}`
-      : ''
-
-  if (infiniteOverrideParams) {
-    return (
-      <File.Source name={name} isExportable isIndexable>
-        <Function name={name} export params={paramsSignature}>
-          {`
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ''}
-  queryKey,
-  queryFn: async ({ signal, pageParam }) => {
-    ${infiniteOverrideParams}
-    return ${clientName}(${addToValueCalls(clientCallStr, enabledNames)})
-  },
-  ${queryOptionsArr.join(',\n  ')}
-})
-`}
-        </Function>
-      </File.Source>
-    )
-  }
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature}>
-        {`
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ''}
-  queryKey,
-  queryFn: async ({ signal }) => {
-    return ${clientName}(${addToValueCalls(clientCallStr, enabledNames)})
-  },
-  ${queryOptionsArr.join(',\n  ')}
-})
-`}
-      </Function>
-    </File.Source>
-  )
-}
-
-function addToValueCalls(callStr: string, enabledNames: ReadonlyArray<string> = []): string {
-  const optional = new Set(enabledNames)
-  // Step 1: Transform shorthand object params like { petId } → { petId: toValue(petId) }
-  // Params that drive the `enabled` guard are optional, so assert non-null: toValue(petId!)
-  let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner: string) => {
-    if (inner.includes(':') || inner.includes('...')) return match
-    const keys = inner
-      .split(',')
-      .map((k: string) => k.trim())
-      .filter(Boolean)
-    const wrapped = keys.map((k: string) => `${k}: toValue(${optional.has(k) ? `${k}!` : k})`).join(', ')
-    return `{ ${wrapped} }`
-  })
-
-  // Step 2: Handle standalone identifiers like `data, params`
-  result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name: string) => {
-    if (name === 'config' || name === 'signal' || name === 'undefined') return match
-    if (match.includes('toValue(')) return match
-    return `toValue(${optional.has(name) ? `${name}!` : name})`
-  })
-
-  return result
-}

package/src/components/Mutation.tsx

@@ -1,150 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginVueQuery } from '../types.ts'
-import { buildRequestConfigType, buildStatusUnionType, getComments, resolveErrorNames, resolveSuccessNames, wrapWithMaybeRefOrGetter } from '../utils.ts'
-
-type Props = {
-  name: string
-  typeName: string
-  clientName: string
-  mutationKeyName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginVueQuery['resolvedOptions']['paramsType']
-  dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
-  pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-const keysPrinter = functionPrinter({ mode: 'keys' })
-
-function createMutationArgParams(
-  node: ast.OperationNode,
-  options: {
-    paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  return ast.createOperationParams(node, {
-    paramsType: 'inline',
-    pathParamsType: 'inline',
-    paramsCasing: options.paramsCasing,
-    resolver: options.resolver,
-  })
-}
-
-function buildMutationParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-    dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { paramsCasing, dataReturnType, resolver } = options
-  const successNames = resolveSuccessNames(node, resolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : resolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, resolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, resolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const mutationArgParamsNode = createMutationArgParams(node, { paramsCasing, resolver })
-
-  const wrappedParamsNode = wrapWithMaybeRefOrGetter(mutationArgParamsNode)
-  const TRequestWrapped = wrappedParamsNode.params.length > 0 ? (declarationPrinter.print(wrappedParamsNode) ?? '') : ''
-
-  return ast.createFunctionParameters({
-    params: [
-      ast.createFunctionParameter({
-        name: 'options',
-        type: ast.createParamsType({
-          variant: 'reference',
-          name: `{
-  mutation?: MutationObserverOptions<${[TData, TError, TRequestWrapped ? `{${TRequestWrapped}}` : 'undefined', 'TContext'].join(', ')}> & { client?: QueryClient },
-  client?: ${buildRequestConfigType(node, resolver)},
-}`,
-        }),
-        default: '{}',
-      }),
-    ],
-  })
-}
-
-export function Mutation({
-  name,
-  clientName,
-  paramsCasing,
-  paramsType,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-  mutationKeyName,
-}: Props): KubbReactNode {
-  const successNames = resolveSuccessNames(node, tsResolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, tsResolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, tsResolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const mutationArgParamsNode = createMutationArgParams(node, {
-    paramsCasing,
-    resolver: tsResolver,
-  })
-  const hasMutationParams = mutationArgParamsNode.params.length > 0
-  const TRequest = hasMutationParams ? (declarationPrinter.print(mutationArgParamsNode) ?? '') : ''
-  const argKeysStr = hasMutationParams ? (keysPrinter.print(mutationArgParamsNode) ?? '') : ''
-
-  const generics = [TData, TError, TRequest ? `{${TRequest}}` : 'undefined', 'TContext'].join(', ')
-
-  const mutationKeyParamsNode = ast.createFunctionParameters({ params: [] })
-  const mutationKeyParamsCall = callPrinter.print(mutationKeyParamsNode) ?? ''
-
-  const clientCallParamsNode = ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver: tsResolver,
-    extraParams: [
-      ast.createFunctionParameter({
-        name: 'config',
-        type: ast.createParamsType({
-          variant: 'reference',
-          name: buildRequestConfigType(node, tsResolver),
-        }),
-        default: '{}',
-      }),
-    ],
-  })
-  const clientCallStr = callPrinter.print(clientCallParamsNode) ?? ''
-
-  const paramsNode = buildMutationParamsNode(node, { paramsCasing, dataReturnType, resolver: tsResolver })
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature} JSDoc={{ comments: getComments(node) }} generics={['TContext']}>
-        {`
-        const { mutation = {}, client: config = {} } = options ?? {}
-        const { client: queryClient, ...mutationOptions } = mutation;
-        const mutationKey = mutationOptions?.mutationKey ?? ${mutationKeyName}(${mutationKeyParamsCall})
-
-        return useMutation<${generics}>({
-          mutationFn: async(${hasMutationParams ? `{ ${argKeysStr} }` : ''}) => {
-            return ${clientName}(${clientCallStr})
-          },
-          mutationKey,
-          ...mutationOptions
-        }, queryClient)
-    `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/MutationKey.tsx

@@ -1 +0,0 @@
-export { MutationKey } from '@internals/tanstack-query'

package/src/components/Query.tsx

@@ -1,126 +0,0 @@
-import { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import type { PluginVueQuery } from '../types.ts'
-import { getEnabledParamNames, markParamsOptional } from '@internals/tanstack-query'
-import { buildStatusUnionType, getComments, resolveErrorNames, resolveSuccessNames, wrapWithMaybeRefOrGetter } from '../utils.ts'
-import { buildQueryKeyParamsNode } from './QueryKey.tsx'
-import { getQueryOptionsParams } from './QueryOptions.tsx'
-
-type Props = {
-  name: string
-  queryOptionsName: string
-  queryKeyName: string
-  queryKeyTypeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginVueQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-function buildQueryParamsNode(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginVueQuery['resolvedOptions']['paramsType']
-    paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-    dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options
-  const successNames = resolveSuccessNames(node, resolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : resolver.resolveResponseName(node)
-  const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null
-  const errorNames = resolveErrorNames(node, resolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, resolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const optionsParam = ast.createFunctionParameter({
-    name: 'options',
-    type: ast.createParamsType({
-      variant: 'reference',
-      name: `{
-  query?: Partial<UseQueryOptions<${[TData, TError, 'TData', 'TQueryData', 'TQueryKey'].join(', ')}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : 'Partial<RequestConfig> & { client?: Client }'}
-}`,
-    }),
-    default: '{}',
-  })
-
-  // Vue-query wraps operation params with MaybeRefOrGetter
-  const baseParams = ast.createOperationParams(node, {
-    paramsType,
-    pathParamsType: paramsType === 'object' ? 'object' : pathParamsType === 'object' ? 'object' : 'inline',
-    paramsCasing,
-    resolver,
-    extraParams: [optionsParam],
-  })
-
-  return wrapWithMaybeRefOrGetter(baseParams, (name) => name === 'options')
-}
-
-export function Query({
-  name,
-  queryKeyTypeName,
-  queryOptionsName,
-  queryKeyName,
-  paramsType,
-  paramsCasing,
-  pathParamsType,
-  dataReturnType,
-  node,
-  tsResolver,
-}: Props): KubbReactNode {
-  const successNames = resolveSuccessNames(node, tsResolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, tsResolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, tsResolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-  const returnType = `UseQueryReturnType<${['TData', TError].join(', ')}> & { queryKey: TQueryKey }`
-  const generics = [`TData = ${TData}`, `TQueryData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`]
-
-  const queryKeyParamsNode = buildQueryKeyParamsNode(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
-  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
-
-  const queryOptionsParamsNode = getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver })
-  const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? ''
-
-  const paramsNode = markParamsOptional(
-    buildQueryParamsNode(node, { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver: tsResolver }),
-    enabledNames,
-  )
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export generics={generics.join(', ')} params={paramsSignature} JSDoc={{ comments: getComments(node) }}>
-        {`
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = (resolvedOptions && 'queryKey' in resolvedOptions ? toValue(resolvedOptions.queryKey) : undefined) ?? ${queryKeyName}(${queryKeyParamsCall})
-
-       const query = useQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),
-        ...resolvedOptions,
-        queryKey
-       } as unknown as UseQueryOptions<${TData}, ${TError}, TData, ${TData}, TQueryKey>, toValue(queryClient)) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `}
-      </Function>
-    </File.Source>
-  )
-}

package/src/components/QueryKey.tsx

@@ -1,52 +0,0 @@
-import type { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function, Type } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import { getEnabledParamNames, markParamsOptional, queryKeyTransformer } from '@internals/tanstack-query'
-import type { Transformer } from '../types.ts'
-import { buildQueryKeyParams, wrapWithMaybeRefOrGetter } from '../utils.ts'
-
-type Props = {
-  name: string
-  typeName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: 'camelcase' | undefined
-  pathParamsType: 'object' | 'inline'
-  transformer: Transformer | null | undefined
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-
-export function buildQueryKeyParamsNode(
-  node: ast.OperationNode,
-  options: { pathParamsType: 'object' | 'inline'; paramsCasing: 'camelcase' | undefined; resolver: ResolverTs },
-): ast.FunctionParametersNode {
-  return wrapWithMaybeRefOrGetter(buildQueryKeyParams(node, options))
-}
-
-export function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer }: Props): KubbReactNode {
-  const baseParamsNode = buildQueryKeyParamsNode(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const paramsNode = markParamsOptional(baseParamsNode, getEnabledParamNames(baseParamsNode))
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const keys = (transformer ?? queryKeyTransformer)({
-    node,
-    casing: paramsCasing,
-  })
-
-  return (
-    <>
-      <File.Source name={name} isExportable isIndexable>
-        <Function.Arrow name={name} export params={paramsSignature} singleLine>
-          {`[${keys.join(', ')}] as const`}
-        </Function.Arrow>
-      </File.Source>
-      <File.Source name={typeName} isExportable isIndexable isTypeOnly>
-        <Type name={typeName} export>
-          {`ReturnType<typeof ${name}>`}
-        </Type>
-      </File.Source>
-    </>
-  )
-}

package/src/components/QueryOptions.tsx

@@ -1,116 +0,0 @@
-import type { ast } from '@kubb/core'
-import type { ResolverTs } from '@kubb/plugin-ts'
-import { functionPrinter } from '@kubb/plugin-ts'
-import { File, Function } from '@kubb/renderer-jsx'
-import type { KubbReactNode } from '@kubb/renderer-jsx/types'
-import { buildQueryOptionsParams, getEnabledParamNames, markParamsOptional } from '@internals/tanstack-query'
-import type { PluginVueQuery } from '../types.ts'
-import { buildStatusUnionType, resolveErrorNames, resolveSuccessNames, wrapWithMaybeRefOrGetter } from '../utils.ts'
-import { buildQueryKeyParamsNode } from './QueryKey.tsx'
-
-type Props = {
-  name: string
-  clientName: string
-  queryKeyName: string
-  node: ast.OperationNode
-  tsResolver: ResolverTs
-  paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-  paramsType: PluginVueQuery['resolvedOptions']['paramsType']
-  pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-  dataReturnType: PluginVueQuery['resolvedOptions']['client']['dataReturnType']
-}
-
-const declarationPrinter = functionPrinter({ mode: 'declaration' })
-const callPrinter = functionPrinter({ mode: 'call' })
-
-export function getQueryOptionsParams(
-  node: ast.OperationNode,
-  options: {
-    paramsType: PluginVueQuery['resolvedOptions']['paramsType']
-    paramsCasing: PluginVueQuery['resolvedOptions']['paramsCasing']
-    pathParamsType: PluginVueQuery['resolvedOptions']['pathParamsType']
-    resolver: ResolverTs
-  },
-): ast.FunctionParametersNode {
-  return wrapWithMaybeRefOrGetter(buildQueryOptionsParams(node, options), (name) => name === 'config')
-}
-
-export function QueryOptions({
-  name,
-  clientName,
-  dataReturnType,
-  node,
-  tsResolver,
-  paramsCasing,
-  paramsType,
-  pathParamsType,
-  queryKeyName,
-}: Props): KubbReactNode {
-  const successNames = resolveSuccessNames(node, tsResolver)
-  const responseName = successNames.length > 0 ? successNames.join(' | ') : tsResolver.resolveResponseName(node)
-  const errorNames = resolveErrorNames(node, tsResolver)
-
-  const TData = dataReturnType === 'data' ? responseName : buildStatusUnionType(node, tsResolver)
-  const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(' | ') : 'Error'}>`
-
-  const queryKeyParamsNode = buildQueryKeyParamsNode(node, { pathParamsType, paramsCasing, resolver: tsResolver })
-  const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? ''
-
-  const enabledNames = getEnabledParamNames(queryKeyParamsNode)
-  const enabledText = enabledNames.length ? `enabled: () => ${enabledNames.map((n) => `!!toValue(${n})`).join(' && ')},` : ''
-
-  const paramsNode = markParamsOptional(getQueryOptionsParams(node, { paramsType, paramsCasing, pathParamsType, resolver: tsResolver }), enabledNames)
-  const paramsSignature = declarationPrinter.print(paramsNode) ?? ''
-  const rawParamsCall = callPrinter.print(paramsNode) ?? ''
-
-  // Transform: wrap non-config params with toValue(), add signal to config
-  const clientCallStr = rawParamsCall.replace(/\bconfig\b(?=[^,]*$)/, '{ ...config, signal: config.signal ?? signal }')
-
-  return (
-    <File.Source name={name} isExportable isIndexable>
-      <Function name={name} export params={paramsSignature}>
-        {`
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return queryOptions<${TData}, ${TError}, ${TData}>({${enabledText ? `\n       ${enabledText}` : ''}
-       queryKey,
-       queryFn: async ({ signal }) => {
-          return ${clientName}(${addToValueCalls(clientCallStr, enabledNames)})
-       },
-      })
-`}
-      </Function>
-    </File.Source>
-  )
-}
-
-/**
- * Wraps parameter names with `toValue()` in the client call string,
- * except for 'config'-related params (which are already plain objects).
- *
- * Handles both inline params (`petId, config`) and object shorthand
- * params (`{ petId }, config`) by expanding to `{ petId: toValue(petId) }`.
- */
-function addToValueCalls(callStr: string, enabledNames: ReadonlyArray<string> = []): string {
-  const optional = new Set(enabledNames)
-  // Step 1: Transform shorthand object params like { petId } → { petId: toValue(petId) }
-  // Params that drive the `enabled` guard are optional, so assert non-null: toValue(petId!)
-  let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner: string) => {
-    // Only transform simple shorthand (no colons, no spread)
-    if (inner.includes(':') || inner.includes('...')) return match
-    const keys = inner
-      .split(',')
-      .map((k: string) => k.trim())
-      .filter(Boolean)
-    const wrapped = keys.map((k: string) => `${k}: toValue(${optional.has(k) ? `${k}!` : k})`).join(', ')
-    return `{ ${wrapped} }`
-  })
-
-  // Step 2: Handle standalone identifiers like `data, params`
-  result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name: string) => {
-    if (name === 'config' || name === 'signal' || name === 'undefined') return match
-    if (match.includes('toValue(')) return match
-    return `toValue(${optional.has(name) ? `${name}!` : name})`
-  })
-
-  return result
-}

package/src/components/index.ts

@@ -1,7 +0,0 @@
-export { InfiniteQuery } from './InfiniteQuery.tsx'
-export { InfiniteQueryOptions } from './InfiniteQueryOptions.tsx'
-export { Mutation } from './Mutation.tsx'
-export { MutationKey } from './MutationKey.tsx'
-export { Query } from './Query.tsx'
-export { QueryKey } from './QueryKey.tsx'
-export { QueryOptions } from './QueryOptions.tsx'

package/src/generators/index.ts

@@ -1,3 +0,0 @@
-export { infiniteQueryGenerator } from './infiniteQueryGenerator.tsx'
-export { mutationGenerator } from './mutationGenerator.tsx'
-export { queryGenerator } from './queryGenerator.tsx'