Options

Pass these options to pluginReactQuery(). Shared options link to Shared plugin options, which documents their behavior once.

Options overview

Option details

client

Selects which registered client plugin the hooks call. A single registered client is auto-detected. Set client when several are registered.

infinite

Adds infinite-query output for pagination. Pass an object to configure the cursor, or false (the default) to skip. Emitted only for operations with a query parameter matching infinite.queryParam.

With hooks at its default of false, setting infinite produces no file at all, not even the infiniteQueryOptions factory. Set hooks: true alongside infinite to generate the file and its useInfiniteQuery hook.

infinite.queryParam

Query parameter that carries the page cursor.

infinite.initialPageParam

Initial value for pageParam on the first fetch.

infinite.nextParam

Path to the next-page cursor on the response, as dot notation ('pagination.next.id') or array form (['pagination', 'next', 'id']).

infinite.previousParam

Path to the previous-page cursor on the response, in the same dot or array form.

infinite.cursorParam

Deprecated path to the cursor field, read for both getNextPageParam and getPreviousPageParam when set. Use nextParam and previousParam instead.

infinite.getNextPageParam

Source of TanStack Query's getNextPageParam, inlined verbatim, for a next page that has to be computed rather than read from a field. Takes precedence over nextParam and cursorParam. Defaults to null.

infinite: {
  queryParam: 'page',
  getNextPageParam: '(lastPage) => (lastPage.hasNext ? lastPage.number + 1 : undefined)',
  getPreviousPageParam: '(firstPage) => (firstPage.number > 0 ? firstPage.number - 1 : undefined)',
}

Without any of getNextPageParam, nextParam or cursorParam, the hook counts pages up from initialPageParam and stops on an empty array. That only works for responses that are arrays, so generation warns for an operation whose response is an object.

infinite.getPreviousPageParam

Source of TanStack Query's getPreviousPageParam, inlined verbatim. Takes precedence over previousParam and cursorParam. Defaults to null.

suspense

Adds a suspense variant alongside the regular query output. Pass an empty object ({}) to enable, or leave it as false (the default) to skip it. TanStack Query v5+ only.

With hooks at its default of false, enabling suspense produces no file at all, not even the suspenseQueryOptions factory. Set hooks: true alongside suspense to generate the file and its useSuspenseQuery hook.

query

Which operations become queries, emitting a queryOptions factory by default. Pass false to skip, or set hooks to also emit useQuery.

query.methods

HTTP methods treated as queries.

query.importPath

Module for the queryOptions and useQuery imports.

queryKey

Builds the queryKey for each hook from the operation node, casing and variant. String values are inlined verbatim, so wrap literals in JSON.stringify(...).

variant is the hook the key is built for: 'query', 'suspenseQuery', 'infiniteQuery' or 'suspenseInfiniteQuery'. The default key adds infinite: true for the infinite variants, because TanStack Query stores InfiniteData under an infinite key and the plain hook for the same request must not share it.

queryKey: ({ node, variant }) => [JSON.stringify({ variant, operationId: node.operationId })]

mutation

Which operations become mutations, emitting a mutationOptions factory by default. Set false to skip, or set hooks to also emit useMutation.

mutation.methods

HTTP methods treated as mutations.

mutation.importPath

Module for the mutationOptions and useMutation imports.

mutationKey

Builds the mutationKey for each mutation hook, for batched invalidations or useMutationState. Same props and string-inlining caveat as queryKey, with variant set to 'mutation'.

customOptions

Routes every hook through your own function that returns extra options such as onSuccess or select. Also emits a HookOptions type so your wrapper stays in sync.

customOptions.importPath

Module of your custom-options hook, imported as a named import.

customOptions.name

Exported name of your custom-options hook.

hooks

When false (the default), only the queryOptions, mutationOptions, queryKey and mutationKey helpers are written, using factory imports that work across TanStack Query adapters. Set true to also generate useQuery, useSuspenseQuery, useInfiniteQuery, useSuspenseInfiniteQuery, and useMutation.

suspense, infinite and customOptions are gated on hooks too: with hooks: false, enabling any of them writes nothing.

resolver

Overrides generated file and symbol names. Omitted members keep resolverReactQuery. The shared members (name, file, imports) and the this context are described under resolver.

type ResolverReactQueryPatch = {
  name?(name: string): string
  file?: {
    baseName?(params: { name: string; extname: string }): string
    path?(params: { baseName: string; output: Output }): string
  }
  imports?(options: ResolveImportsOptions): Array<ImportNode>
  query?: {
    name?(node: OperationNode): string         // → 'useGetPetById'
    optionsName?(node: OperationNode): string  // → 'getPetByIdQueryOptions'
    keyName?(node: OperationNode): string       // → 'getPetByIdQueryKey'
    keyTypeName?(node: OperationNode): string   // → 'GetPetByIdQueryKey'
    clientName?(node: OperationNode): string    // → 'getPetById'
  }
  suspenseQuery?: { /* same members as query */ }
  infiniteQuery?: { /* same members as query */ }
  suspenseInfiniteQuery?: { /* same members as query */ }
  mutation?: {
    name?(node: OperationNode): string          // → 'useUpdatePet'
    optionsName?(node: OperationNode): string
    keyName?(node: OperationNode): string
    typeName?(node: OperationNode): string      // → 'UpdatePet'
  }
  hook?: {
    optionsName?(): string
    customOptionsName?(): string
  }
}