Defined in: packages/vue-query/src/queryClient.ts:44
Vue-aware subclass of @tanstack/query-core's QueryClient. Methods that accept options (such as CancelOptions or InvalidateOptions) or filters (such as the QueryFilters accepted by invalidateQueries) also accept a MaybeRefDeep version of it, so you can pass refs directly without unwrapping them yourself — e.g. queryClient.invalidateQueries({ queryKey: ['post', myRef] }). Install one on your app with VueQueryPlugin, or retrieve it with useQueryClient.
QueryClient
new QueryClient(config): QueryClient;Defined in: packages/vue-query/src/queryClient.ts:45
QueryClientConfig = {}
QueryClient
QC.constructoroptional isRestoring: Ref<boolean, boolean>;Defined in: packages/vue-query/src/queryClient.ts:58
true while a clientPersister passed to VueQueryPlugin is restoring the cache. Queries don't fetch while this is true. Defaults to false if no persister is configured.
cancelQueries<TTaggedQueryKey>(filters?, options?): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:185
Cancels outgoing fetches for queries matching the given filters. Most useful when performing optimistic updates, since any outgoing refetch that resolves afterwards would otherwise overwrite the optimistic update. By default (revert: true), a cancelled query's data is reverted to its state before the outgoing fetch started.
The returned promise never rejects, even if individual cancellations fail.
TTaggedQueryKey extends readonly unknown[] = readonly unknown[]
QueryFilters<TTaggedQueryKey>
MaybeRefDeep<CancelOptions>
Promise<void>
await queryClient.cancelQueries({ queryKey: ['posts'], exact: true })QC.cancelQueriesclear(): void;Defined in: packages/query-core/src/queryClient.ts:1083
Clears both the query cache and the mutation cache this client is connected to.
void
import { QueryClient } from '@tanstack/query-core'
const queryClient = new QueryClient()
queryClient.clear()QC.cleardefaultMutationOptions<T>(options?): T;Defined in: packages/query-core/src/queryClient.ts:1057
The mutation counterpart of QueryClient#defaultQueryOptions. Called by framework adapters (e.g. inside useMutation) to merge queryClient.setMutationDefaults for the given mutationKey, then the client's defaultOptions.mutations, then the caller's options on top. A no-op if the options are already defaulted (_defaulted: true).
T extends MutationOptions<any, any, any, any>
T
T
QC.defaultMutationOptionsdefaultQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>(options): DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;Defined in: packages/query-core/src/queryClient.ts:970
Called by framework adapters (e.g. inside useQuery) to resolve the options passed by the caller into their final, defaulted form: merging queryClient.setQueryDefaults for the given queryKey, then the client's own defaultOptions.queries, then the caller's options on top. A no-op if the options are already defaulted (_defaulted: true).
TQueryFnData = unknown
TError = Error
TData = TQueryFnData
TQueryData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = never
QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> | DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
QC.defaultQueryOptionsensureInfiniteQueryData<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<InfiniteData<TData, TPageParam>>;Defined in: packages/query-core/src/queryClient.ts:735
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = unknown
EnsureInfiniteQueryDataOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
Promise<InfiniteData<TData, TPageParam>>
Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
QC.ensureInfiniteQueryDataensureQueryData<TQueryFnData, TError, TData, TQueryKey>(options): Promise<TData>;Defined in: packages/vue-query/src/queryClient.ts:83
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>
Promise<TData>
Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
QC.ensureQueryDataensureQueryData<TQueryFnData, TError, TData, TQueryKey>(options): Promise<TData>;Defined in: packages/vue-query/src/queryClient.ts:91
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
MaybeRefDeep<EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey, never>>
Promise<TData>
Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
QC.ensureQueryDatafetchInfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<InfiniteData<TData, TPageParam>>;Defined in: packages/vue-query/src/queryClient.ts:464
TQueryFnData = unknown
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = unknown
FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
Promise<InfiniteData<TData, TPageParam>>
Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.
QC.fetchInfiniteQueryfetchInfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<InfiniteData<TData, TPageParam>>;Defined in: packages/vue-query/src/queryClient.ts:479
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = unknown
MaybeRefDeep<FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>
Promise<InfiniteData<TData, TPageParam>>
Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.
QC.fetchInfiniteQueryfetchQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<TData>;Defined in: packages/vue-query/src/queryClient.ts:313
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = never
FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
Promise<TData>
Use queryClient.query(options) instead. This method will be removed in the next major version.
QC.fetchQueryfetchQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<TData>;Defined in: packages/vue-query/src/queryClient.ts:328
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = never
MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>> | () => FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
Promise<TData>
Use queryClient.query(options) instead. This method will be removed in the next major version.
QC.fetchQuerygetDefaultOptions(): DefaultOptions;Defined in: packages/query-core/src/queryClient.ts:818
Returns the default options that were set when creating the client, or via QueryClient#setDefaultOptions.
import { QueryClient } from '@tanstack/query-core'
const queryClient = new QueryClient()
const defaultOptions = queryClient.getDefaultOptions()QC.getDefaultOptionsgetMutationCache(): MutationCache;Defined in: packages/query-core/src/queryClient.ts:802
Returns the mutation cache this client is connected to.
MutationCache
import { QueryClient } from '@tanstack/query-core'
const queryClient = new QueryClient()
const mutationCache = queryClient.getMutationCache()
const mutations = mutationCache.findAll({ status: 'pending' })QC.getMutationCachegetMutationDefaults(mutationKey): MutationObserverOptions<any, any, any, any>;Defined in: packages/vue-query/src/queryClient.ts:612
Returns the default options registered for mutations whose mutation key partially matches the given mutationKey, via QueryClient#setMutationDefaults. If multiple registered defaults match, they are merged together in registration order.
MaybeRefDeep<readonly unknown[]>
MutationObserverOptions<any, any, any, any>
const defaultOptions = queryClient.getMutationDefaults(['addPost'])QC.getMutationDefaultsgetQueriesData<TData>(filters): [readonly unknown[], TData | undefined][];Defined in: packages/vue-query/src/queryClient.ts:114
Imperative (non-reactive) way to retrieve the cached data of multiple queries at once. Only queries matching the given filters are returned; if none match, an empty array is returned.
Because the matched queries can hold data of different shapes (e.g. a broad filter can match queries with unrelated data types), the TQueryFnData generic defaults to unknown rather than being inferred. Passing a more specific type is a convenience for call sites that know every matched query holds the same shape — it is not checked against the actual cache contents.
TData = unknown
MaybeRefDeep<QueryFilters<readonly unknown[]>>
[readonly unknown[], TData | undefined][]
const data = queryClient.getQueriesData({ queryKey: ['posts'] })QC.getQueriesDatagetQueryCache(): QueryCache;Defined in: packages/query-core/src/queryClient.ts:786
Returns the query cache this client is connected to.
QueryCache
import { QueryClient } from '@tanstack/query-core'
const queryClient = new QueryClient()
const queryCache = queryClient.getQueryCache()
const queries = queryCache.findAll({ queryKey: ['posts'] })QC.getQueryCachegetQueryData<TData, TTaggedQueryKey>(queryKey):
| InferDataFromTag<TData, TTaggedQueryKey>
| undefined;Defined in: packages/vue-query/src/queryClient.ts:68
Imperative (non-reactive) way to retrieve data for a QueryKey. Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
Hint: Do not use this function inside a component, because it won't receive updates. Use useQuery to create a QueryObserver that subscribes to changes.
TData = unknown
TTaggedQueryKey extends readonly unknown[] = readonly unknown[]
TTaggedQueryKey
| InferDataFromTag<TData, TTaggedQueryKey> | undefined
QC.getQueryDatagetQueryData<TData>(queryKey): TData | undefined;Defined in: packages/vue-query/src/queryClient.ts:71
TData = unknown
MaybeRefDeep<readonly unknown[]>
TData | undefined
QC.getQueryDatagetQueryDefaults(queryKey): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, "queryKey">;Defined in: packages/vue-query/src/queryClient.ts:589
Returns the default options registered for queries whose query key partially matches the given queryKey, via QueryClient#setQueryDefaults. If multiple registered defaults match, they are merged together in registration order.
MaybeRefDeep<readonly unknown[]>
OmitKeyof<QueryObserverOptions<any, any, any, any, any>, "queryKey">
const defaultOptions = queryClient.getQueryDefaults(['posts'])QC.getQueryDefaultsgetQueryState<TData, TError>(queryKey):
| QueryState<TData, TError>
| undefined;Defined in: packages/vue-query/src/queryClient.ts:161
Imperative (non-reactive) way to retrieve an existing query's state. If the query does not exist, undefined is returned.
TData = unknown
TError = Error
MaybeRefDeep<readonly unknown[]>
| QueryState<TData, TError> | undefined
const state = queryClient.getQueryState(['posts'])
console.log(state?.dataUpdatedAt)QC.getQueryStateinfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<TData[] extends InfiniteData<TQueryFnData, unknown>[] ? InfiniteData<TQueryFnData, TPageParam> : TData>;Defined in: packages/vue-query/src/queryClient.ts:397
Asynchronous method to fetch and cache an infinite query, resolving with an InfiniteData object or throwing with the error.
Behaves like QueryClient#query, accepting the same options (minus initialPageParam), plus the required initialPageParam, and an optional pages / getNextPageParam pair used to refetch a fixed number of pages from the start.
This method replaces the deprecated fetchInfiniteQuery, and — combined with { staleTime: 'static' } — the deprecated ensureInfiniteQueryData.
TQueryFnData = unknown
TError = Error
TData = InfiniteData<TQueryFnData, unknown>
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = unknown
InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
Promise<TData[] extends InfiniteData<TQueryFnData, unknown>[] ? InfiniteData<TQueryFnData, TPageParam> : TData>
try {
const data = await queryClient.infiniteQuery({ queryKey, queryFn, initialPageParam: 0 })
console.log(data.pages)
} catch (error) {
console.log(error)
}QC.infiniteQueryinfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<TData[] extends InfiniteData<TQueryFnData, unknown>[] ? InfiniteData<TQueryFnData, TPageParam> : TData>;Defined in: packages/vue-query/src/queryClient.ts:416
TQueryFnData = unknown
TError = Error
TData = InfiniteData<TQueryFnData, unknown>
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = unknown
MaybeRefDeep<InfiniteQueryExecuteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>
Promise<TData[] extends InfiniteData<TQueryFnData, unknown>[] ? InfiniteData<TQueryFnData, TPageParam> : TData>
QC.infiniteQueryinvalidateQueries<TTaggedQueryKey>(filters?, options?): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:196
Marks queries matching the given filters as invalidated. Unlike QueryClient#removeQueries, invalidated queries stay in the cache.
Unless filters.refetchType is 'none', matching queries are then refetched via QueryClient#refetchQueries, using filters.refetchType if set, otherwise filters.type, otherwise 'active'.
TTaggedQueryKey extends readonly unknown[] = readonly unknown[]
InvalidateQueryFilters<TTaggedQueryKey> | () => InvalidateQueryFilters<TTaggedQueryKey>
MaybeRefDeep<InvalidateOptions>
Promise<void>
await queryClient.invalidateQueries({ queryKey: ['posts'], refetchType: 'active' })QC.invalidateQueriesisFetching(filters): number;Defined in: packages/vue-query/src/queryClient.ts:60
Returns the number of queries in the cache that are currently fetching, optionally matching a set of filters. This includes background-fetching, loading new pages, and loading more infinite query results.
MaybeRefDeep<QueryFilters<readonly unknown[]>> = {}
number
if (queryClient.isFetching()) {
console.log('At least one query is fetching!')
}QC.isFetchingisMutating(filters): number;Defined in: packages/vue-query/src/queryClient.ts:64
Returns the number of mutations in the cache that are currently pending, optionally matching a set of filters.
MaybeRefDeep<MutationFilters<unknown, Error, unknown, unknown>> = {}
number
if (queryClient.isMutating()) {
console.log('At least one mutation is pending!')
}QC.isMutatingmount(): void;Defined in: packages/query-core/src/queryClient.ts:104
Called by a framework adapter's QueryClientProvider-equivalent when it mounts, to start listening for focus/online events and resume paused mutations. Ref-counted via an internal mount count, so nested or multiple providers sharing the same QueryClient don't tear down the shared listeners until the last one unmounts.
void
QC.mountprefetchInfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:519
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = unknown
FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
Promise<void>
use void queryClient.infiniteQuery(options) instead. You can swallow errors with .catch(noop). This method will be removed in the next major version.
QC.prefetchInfiniteQueryprefetchInfiniteQuery<TQueryFnData, TError, TData, TQueryKey, TPageParam>(options): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:534
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = unknown
MaybeRefDeep<FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>>
Promise<void>
use void queryClient.infiniteQuery(options) instead. You can swallow errors with .catch(noop). This method will be removed in the next major version.
QC.prefetchInfiniteQueryprefetchQuery<TQueryFnData, TError, TData, TQueryKey>(options): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:364
TQueryFnData = unknown
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
Promise<void>
Use queryClient.query(options) instead. You can swallow errors with .catch(noop). This method will be removed in the next major version.
QC.prefetchQueryprefetchQuery<TQueryFnData, TError, TData, TQueryKey>(options): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:372
TQueryFnData = unknown
TError = Error
TData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, never>>
Promise<void>
Use queryClient.query(options) instead. You can swallow errors with .catch(noop). This method will be removed in the next major version.
QC.prefetchQueryquery<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>(options): Promise<TData>;Defined in: packages/vue-query/src/queryClient.ts:252
Asynchronous method to fetch and cache a query, resolving with the data or throwing with the error.
If the query already exists in the cache and its data is not stale (per the given staleTime), the cached data is returned without fetching. Otherwise, the query is fetched and the promise resolves once the fetch settles. If a select function is provided, it is applied to the data in both cases (cached or freshly fetched) before it is returned.
Unlike a reactive observer, retries are disabled by default here (retry: false) unless explicitly configured, since there is no component to catch a thrown error and retry through re-render.
The accepted options are QueryObserverOptions minus the fields that only make sense for a reactive observer — enabled, refetchInterval, refetchIntervalInBackground, refetchOnWindowFocus, refetchOnReconnect, refetchOnMount, retryOnMount, notifyOnChangeProps, throwOnError, suspense, and placeholderData are not part of this method's options.
This method replaces the deprecated fetchQuery, and — combined with { staleTime: 'static' } — the deprecated ensureQueryData.
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = never
QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>
Promise<TData>
try {
const data = await queryClient.query({ queryKey, queryFn, staleTime: 10000 })
} catch (error) {
console.log(error)
}QC.queryquery<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>(options): Promise<TData>;Defined in: packages/vue-query/src/queryClient.ts:269
TQueryFnData
TError = Error
TData = TQueryFnData
TQueryData = TQueryFnData
TQueryKey extends readonly unknown[] = readonly unknown[]
TPageParam = never
MaybeRefDeep<QueryExecuteOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>>
Promise<TData>
QC.queryrefetchQueries<TTaggedQueryKey>(filters?, options?): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:236
Refetches queries matching the given filters, regardless of whether they are stale. Without filters, every query in the cache is refetched. Queries that are disabled, or static (only have observers with a static staleTime), are never refetched.
By default (cancelRefetch: true), a currently running fetch is cancelled before the new one starts. The returned promise resolves once all matching queries have settled; it does not reject on individual query failures unless throwOnError is set.
TTaggedQueryKey extends readonly unknown[] = readonly unknown[]
RefetchQueryFilters<TTaggedQueryKey>
MaybeRefDeep<RefetchOptions>
Promise<void>
// refetch all active queries partially matching a query key:
await queryClient.refetchQueries({ queryKey: ['posts'], type: 'active' })QC.refetchQueriesremoveQueries<TTaggedQueryKey>(filters?): void;Defined in: packages/vue-query/src/queryClient.ts:167
Removes queries from the cache that match the given filters. Unlike QueryClient#invalidateQueries or QueryClient#refetchQueries, this removes matching queries from the cache instead of refetching them. Without filters, every query in the cache is removed.
TTaggedQueryKey extends readonly unknown[] = readonly unknown[]
QueryFilters<TTaggedQueryKey>
void
queryClient.removeQueries({ queryKey: ['posts'], exact: true })QC.removeQueriesresetQueries<TTaggedQueryKey>(filters?, options?): Promise<void>;Defined in: packages/vue-query/src/queryClient.ts:174
Resets queries matching the given filters back to their initial state (e.g. any initialData), notifying subscribers rather than removing them. Active queries among the matched set are then refetched, and the returned promise resolves once that refetch settles.
TTaggedQueryKey extends readonly unknown[] = readonly unknown[]
QueryFilters<TTaggedQueryKey>
MaybeRefDeep<ResetOptions>
Promise<void>
await queryClient.resetQueries({ queryKey: ['posts'], exact: true })QC.resetQueriesresumePausedMutations(): Promise<unknown>;Defined in: packages/query-core/src/queryClient.ts:767
Resumes mutations that were paused because there was no network connection. Does nothing (resolving immediately) if the client is currently offline.
Promise<unknown>
import { QueryClient } from '@tanstack/query-core'
const queryClient = new QueryClient()
await queryClient.resumePausedMutations()QC.resumePausedMutationssetDefaultOptions(options): void;Defined in: packages/vue-query/src/queryClient.ts:571
Dynamically sets the default options for this client, overwriting any previously defined default options.
MaybeRefDeep<DefaultOptions<Error>>
void
import { QueryClient } from '@tanstack/query-core'
const queryClient = new QueryClient()
queryClient.setDefaultOptions({
queries: {
staleTime: Infinity,
},
})QC.setDefaultOptionssetMutationDefaults<TData, TError, TVariables, TOnMutateResult>(mutationKey, options): void;Defined in: packages/vue-query/src/queryClient.ts:595
Sets default options for mutations whose mutation key partially matches the given mutationKey. As with QueryClient#setQueryDefaults, the order of registration matters when several registered defaults match the same mutation key.
TData = unknown
TError = Error
TVariables = void
TOnMutateResult = unknown
MaybeRefDeep<readonly unknown[]>
MaybeRefDeep<MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>>
void
QueryClient#getMutationDefaults
queryClient.setMutationDefaults(['addPost'], { mutationFn: addPost })QC.setMutationDefaultssetQueriesData<TData>(
filters,
updater,
options): [readonly unknown[], TData | undefined][];Defined in: packages/vue-query/src/queryClient.ts:149
Synchronous way to immediately update the cached data of multiple queries at once, using filters or partial query key matching. Only queries that already exist and match the given filters are updated; no new cache entries are created. Internally this calls QueryClient#setQueryData for each matching query.
TData
MaybeRefDeep<QueryFilters<readonly unknown[]>>
Updater<TData | undefined, TData | undefined>
MaybeRefDeep<SetDataOptions> = {}
[readonly unknown[], TData | undefined][]
queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>
oldPosts ? oldPosts.filter((post) => post.id !== deletedId) : oldPosts,
)QC.setQueriesDatasetQueryData<TQueryFnData, TTaggedQueryKey, TInferredQueryFnData>(
queryKey,
updater,
options?): NoInfer<TInferredQueryFnData> | undefined;Defined in: packages/vue-query/src/queryClient.ts:120
Synchronous way to immediately update a query's cached data. If the updater (or the value passed) resolves to undefined, the cache is left untouched and no query is created; otherwise, if the query does not exist yet, it will be created. To update multiple queries at once by partially matching query keys, use QueryClient#setQueriesData instead.
Updates must be performed immutably: do not mutate oldData, or data previously retrieved via QueryClient#getQueryData, in place.
TQueryFnData = unknown
TTaggedQueryKey extends readonly unknown[] = readonly unknown[]
TInferredQueryFnData = InferDataFromTag<TQueryFnData, TTaggedQueryKey>
TTaggedQueryKey
The query key to set data for.
Updater<NoInfer<TInferredQueryFnData> | undefined, NoInfer<TInferredQueryFnData> | undefined>
Either the new data, or a function that receives the current data (which may be undefined) and returns the new data.
MaybeRefDeep<SetDataOptions>
NoInfer<TInferredQueryFnData> | undefined
queryClient.setQueryData(['posts'], newPosts)
// Or, using an updater function that receives the current data:
queryClient.setQueryData(['posts'], (oldPosts) => [...oldPosts, newPost])QC.setQueryDatasetQueryData<TQueryFnData, TData>(
queryKey,
updater,
options?): NoInfer<TData> | undefined;Defined in: packages/vue-query/src/queryClient.ts:132
TQueryFnData
TData = NoUnknown<TQueryFnData>
MaybeRefDeep<readonly unknown[]>
Updater<NoInfer<TData> | undefined, NoInfer<TData> | undefined>
MaybeRefDeep<SetDataOptions>
NoInfer<TData> | undefined
QC.setQueryDatasetQueryDefaults<TQueryFnData, TError, TData, TQueryData>(queryKey, options): void;Defined in: packages/vue-query/src/queryClient.ts:575
Sets default options for queries whose query key partially matches the given queryKey.
If several registered query defaults match a given query key, they are merged together in registration order by QueryClient#getQueryDefaults, so register defaults from the most generic key to the least generic one — more specific defaults should be registered after more generic ones so they take precedence.
TQueryFnData = unknown
TError = Error
TData = TQueryFnData
TQueryData = TQueryFnData
MaybeRefDeep<readonly unknown[]>
MaybeRefDeep<Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryData>, "queryKey">>
void
queryClient.setQueryDefaults(['posts'], { queryFn: fetchPosts })
await queryClient.query({ queryKey: ['posts'] })QC.setQueryDefaultsunmount(): void;Defined in: packages/query-core/src/queryClient.ts:127
The inverse of QueryClient#mount — called by a framework adapter's QueryClientProvider-equivalent when it unmounts. Only tears down the focus/online listeners once the mount count returns to 0.
void
QC.unmount