Options

Pass these options to pluginVueQuery(). Shared options link to Shared plugin options for details.

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 infiniteQueryOptions and useInfiniteQuery for operations that declare the query parameter named in infinite.queryParam. Needs hooks: true.

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 code for TanStack Query's getNextPageParam, copied into the generated code as written, such as '(lastPage) => (lastPage.hasNext ? lastPage.number + 1 : undefined)'. Use it when the next page must be computed instead of read from a field. Takes precedence over nextParam and cursorParam.

Without getNextPageParam, nextParam or cursorParam, the composable counts pages up from initialPageParam until a page is an empty array. This works only for array responses, so generation warns when the response is an object.

infinite.getPreviousPageParam

Source code for TanStack Query's getPreviousPageParam, copied into the generated code as written. Takes precedence over previousParam and cursorParam.

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. Strings are copied into the generated code as written, so wrap a string literal 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.

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 = {
  // plus the shared name, file, and imports members
  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
  }
}