Options

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

Options overview

Option details

client

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

infinite

Adds infinite-query output for cursor- or page-based pagination. Pass an object to configure how the cursor is read, or false (the default) to skip. Output is emitted for an operation only when it declares a query parameter matching infinite.queryParam and hooks is true. Without hooks: true, infinite produces no file at all, not even the factory.

export function getPetsInfiniteQueryOptions(/* ... */) {
  return infiniteQueryOptions({ queryKey, queryFn, initialPageParam, getNextPageParam })
}

export function useGetPetsInfiniteQuery(/* ... */) {
  return useInfiniteQuery(getPetsInfiniteQueryOptions(/* ... */))
}

infinite.queryParam

Name of the query parameter that holds 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, such as '(lastPage) => (lastPage.hasNext ? lastPage.number + 1 : undefined)'. Takes precedence over nextParam and cursorParam. Type string | null, default null.

Without any of getNextPageParam, nextParam or cursorParam, the composable 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. Type string | null, default null.

query

Decides which operations are treated as queries. The plugin generates a queryOptions factory for each match by default. Pass false to skip, or set hooks to also emit useQuery.

query.methods

HTTP methods treated as queries. A matching operation generates a queryOptions factory instead of a mutation.

query.importPath

Module specifier for the generated import { queryOptions } from '...'.

queryKey

Builds the queryKey for each query composable. The callback receives the operation node, the active casing and the variant ('query' or 'infiniteQuery') and returns the key array. String values are inlined verbatim, so wrap literals in JSON.stringify(...). The default adds infinite: true to infinite keys so they never share a cache entry with the plain query.

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

export const getUserByNameQueryKey = () => [{ variant: 'query', operationId: 'getUserByName' }] as const

mutation

Decides which operations are treated as mutations. The plugin generates a mutationKey helper for each match by default. Pass false to skip, or set hooks to also emit useMutation.

mutation.methods

HTTP methods treated as mutations. A matching operation generates mutation output instead of a query.

mutation.importPath

Module specifier for the generated import { useMutation } from '...', emitted when hooks is set.

mutationKey

Builds the mutationKey for each mutation composable, useful for batching invalidations. It takes the same props as queryKey with variant: 'mutation' and inlines strings the same way, so wrap literals in JSON.stringify(...).

hooks

Controls whether use* composables are emitted. The default false writes only the queryOptions, queryKey, and mutationKey factory helpers. Set true to also generate useQuery, useInfiniteQuery, and useMutation.

infinite is gated on hooks too, writing nothing while hooks is false.

resolver

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

type ResolverVueQueryPatch = {
  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
    optionsName?(node: OperationNode): string
    keyName?(node: OperationNode): string
    keyTypeName?(node: OperationNode): string
    clientName?(node: OperationNode): string
  }
  infiniteQuery?: { /* same members as query */ }
  mutation?: {
    name?(node: OperationNode): string
    keyName?(node: OperationNode): string
    typeName?(node: OperationNode): string
  }
}