Open History to see the last commit
1import {
2 QueryFilters,
3 Updater,
4 hashQueryKey,
5 noop,
6 parseFilterArgs,
7 parseQueryArgs,
8 partialMatchKey,
9 hashQueryKeyByOptions,
10 MutationFilters,
11} from './utils'
12import type {
13 QueryClientConfig,
14 DefaultOptions,
15 FetchInfiniteQueryOptions,
16 FetchQueryOptions,
17 InfiniteData,
18 InvalidateOptions,
19 InvalidateQueryFilters,
20 MutationKey,
21 MutationObserverOptions,
22 MutationOptions,
23 QueryFunction,
24 QueryKey,
25 QueryObserverOptions,
26 QueryOptions,
27 RefetchOptions,
28 RefetchQueryFilters,
29 ResetOptions,
30 ResetQueryFilters,
31 SetDataOptions,
32} from './types'
33import type { QueryState } from './query'
34import { QueryCache } from './queryCache'
35import { MutationCache } from './mutationCache'
36import { focusManager } from './focusManager'
37import { onlineManager } from './onlineManager'
38import { notifyManager } from './notifyManager'
39import { infiniteQueryBehavior } from './infiniteQueryBehavior'
40import { CancelOptions } from './types'
41β
42// TYPES
43β
44interface QueryDefaults {
45 queryKey: QueryKey
46 defaultOptions: QueryOptions<any, any, any>
47}
48β
49interface MutationDefaults {
50 mutationKey: MutationKey
51 defaultOptions: MutationOptions<any, any, any, any>
52}
53β
54// CLASS
55β
56export class QueryClient {
57 private queryCache: QueryCache
58 private mutationCache: MutationCache
59 private defaultOptions: DefaultOptions
60 private queryDefaults: QueryDefaults[]
61 private mutationDefaults: MutationDefaults[]
62 private unsubscribeFocus?: () => void
63 private unsubscribeOnline?: () => void
64β
65 constructor(config: QueryClientConfig = {}) {
66 this.queryCache = config.queryCache || new QueryCache()
67 this.mutationCache = config.mutationCache || new MutationCache()
68 this.defaultOptions = config.defaultOptions || {}
69 this.queryDefaults = []
70 this.mutationDefaults = []
71 }
72β
73 mount(): void {
74 this.unsubscribeFocus = focusManager.subscribe(() => {
75 if (focusManager.isFocused() && onlineManager.isOnline()) {
76 this.mutationCache.onFocus()
77 this.queryCache.onFocus()
78 }
79 })
80 this.unsubscribeOnline = onlineManager.subscribe(() => {
81 if (focusManager.isFocused() && onlineManager.isOnline()) {
82 this.mutationCache.onOnline()
83 this.queryCache.onOnline()
84 }
85 })
86 }
87β
88 unmount(): void {
89 this.unsubscribeFocus?.()
90 this.unsubscribeOnline?.()
91 }
92β
93 isFetching(filters?: QueryFilters): number
94 isFetching(queryKey?: QueryKey, filters?: QueryFilters): number
95 isFetching(arg1?: QueryKey | QueryFilters, arg2?: QueryFilters): number {
96 const [filters] = parseFilterArgs(arg1, arg2)
97 filters.fetching = true
98 return this.queryCache.findAll(filters).length
99 }
100β
101 isMutating(filters?: MutationFilters): number {
102 return this.mutationCache.findAll({ ...filters, fetching: true }).length
103 }
104β
105 getQueryData<TData = unknown>(
106 queryKey: QueryKey,
107 filters?: QueryFilters
108 ): TData | undefined {
109 return this.queryCache.find<TData>(queryKey, filters)?.state.data
110 }
111β
112 getQueriesData<TData = unknown>(queryKey: QueryKey): [QueryKey, TData][]
113 getQueriesData<TData = unknown>(filters: QueryFilters): [QueryKey, TData][]
114 getQueriesData<TData = unknown>(
115 queryKeyOrFilters: QueryKey | QueryFilters
116 ): [QueryKey, TData][] {
117 return this.getQueryCache()
118 .findAll(queryKeyOrFilters)
119 .map(({ queryKey, state }) => {
120 const data = state.data as TData
121 return [queryKey, data]
122 })
123 }
124β
125 setQueryData<TData>(
126 queryKey: QueryKey,
127 updater: Updater<TData | undefined, TData>,
128 options?: SetDataOptions
129 ): TData {
130 const parsedOptions = parseQueryArgs(queryKey)
131 const defaultedOptions = this.defaultQueryOptions(parsedOptions)
132 return this.queryCache
133 .build(this, defaultedOptions)
134 .setData(updater, options)
135 }
136β
137 setQueriesData<TData>(
138 queryKey: QueryKey,
139 updater: Updater<TData | undefined, TData>,
140 options?: SetDataOptions
141 ): [QueryKey, TData][]
142β
143 setQueriesData<TData>(
144 filters: QueryFilters,
145 updater: Updater<TData | undefined, TData>,
146 options?: SetDataOptions
147 ): [QueryKey, TData][]
148β
149 setQueriesData<TData>(
150 queryKeyOrFilters: QueryKey | QueryFilters,
151 updater: Updater<TData | undefined, TData>,
152 options?: SetDataOptions
153 ): [QueryKey, TData][] {
154 return notifyManager.batch(() =>
155 this.getQueryCache()
156 .findAll(queryKeyOrFilters)
157 .map(({ queryKey }) => [
158 queryKey,
159 this.setQueryData<TData>(queryKey, updater, options),
160 ])
161 )
162 }
163β
164 getQueryState<TData = unknown, TError = undefined>(
165 queryKey: QueryKey,
166 filters?: QueryFilters
167 ): QueryState<TData, TError> | undefined {
168 return this.queryCache.find<TData, TError>(queryKey, filters)?.state
169 }
170β
171 removeQueries(filters?: QueryFilters): void
172 removeQueries(queryKey?: QueryKey, filters?: QueryFilters): void
173 removeQueries(arg1?: QueryKey | QueryFilters, arg2?: QueryFilters): void {
174 const [filters] = parseFilterArgs(arg1, arg2)
175 const queryCache = this.queryCache
176 notifyManager.batch(() => {
177 queryCache.findAll(filters).forEach(query => {
178 queryCache.remove(query)
179 })
180 })
181 }
182β
183 resetQueries<TPageData = unknown>(
184 filters?: ResetQueryFilters<TPageData>,
185 options?: ResetOptions
186 ): Promise<void>
187 resetQueries<TPageData = unknown>(
188 queryKey?: QueryKey,
189 filters?: ResetQueryFilters<TPageData>,
190 options?: ResetOptions
191 ): Promise<void>
192 resetQueries(
193 arg1?: QueryKey | ResetQueryFilters,
194 arg2?: ResetQueryFilters | ResetOptions,
195 arg3?: ResetOptions
196 ): Promise<void> {
197 const [filters, options] = parseFilterArgs(arg1, arg2, arg3)
198 const queryCache = this.queryCache
199β
200 const refetchFilters: RefetchQueryFilters = {
201 ...filters,
202 active: true,
203 }
204β
205 return notifyManager.batch(() => {
206 queryCache.findAll(filters).forEach(query => {
207 query.reset()
208 })
209 return this.refetchQueries(refetchFilters, options)
210 })
211 }
212β
213 cancelQueries(filters?: QueryFilters, options?: CancelOptions): Promise<void>
214 cancelQueries(
215 queryKey?: QueryKey,
216 filters?: QueryFilters,
217 options?: CancelOptions
218 ): Promise<void>
219 cancelQueries(
220 arg1?: QueryKey | QueryFilters,
221 arg2?: QueryFilters | CancelOptions,
222 arg3?: CancelOptions
223 ): Promise<void> {
224 const [filters, cancelOptions = {}] = parseFilterArgs(arg1, arg2, arg3)
225β
226 if (typeof cancelOptions.revert === 'undefined') {
227 cancelOptions.revert = true
228 }
229β
230 const promises = notifyManager.batch(() =>
231 this.queryCache.findAll(filters).map(query => query.cancel(cancelOptions))
232 )
233β
234 return Promise.all(promises).then(noop).catch(noop)
235 }
236β
237 invalidateQueries<TPageData = unknown>(
238 filters?: InvalidateQueryFilters<TPageData>,
239 options?: InvalidateOptions
240 ): Promise<void>
241 invalidateQueries<TPageData = unknown>(
242 queryKey?: QueryKey,
243 filters?: InvalidateQueryFilters<TPageData>,
244 options?: InvalidateOptions
245 ): Promise<void>
246 invalidateQueries(
247 arg1?: QueryKey | InvalidateQueryFilters,
248 arg2?: InvalidateQueryFilters | InvalidateOptions,
249 arg3?: InvalidateOptions
250 ): Promise<void> {
251 const [filters, options] = parseFilterArgs(arg1, arg2, arg3)
252β
253 const refetchFilters: RefetchQueryFilters = {
254 ...filters,
255 // if filters.refetchActive is not provided and filters.active is explicitly false,
256 // e.g. invalidateQueries({ active: false }), we don't want to refetch active queries
257 active: filters.refetchActive ?? filters.active ?? true,
258 inactive: filters.refetchInactive ?? false,
259 }
260β
261 return notifyManager.batch(() => {
262 this.queryCache.findAll(filters).forEach(query => {
263 query.invalidate()
264 })
265 return this.refetchQueries(refetchFilters, options)
266 })
267 }
268β
269 refetchQueries<TPageData = unknown>(
270 filters?: RefetchQueryFilters<TPageData>,
271 options?: RefetchOptions
272 ): Promise<void>
273 refetchQueries<TPageData = unknown>(
274 queryKey?: QueryKey,
275 filters?: RefetchQueryFilters<TPageData>,
276 options?: RefetchOptions
277 ): Promise<void>
278 refetchQueries(
279 arg1?: QueryKey | RefetchQueryFilters,
280 arg2?: RefetchQueryFilters | RefetchOptions,
281 arg3?: RefetchOptions
282 ): Promise<void> {
283 const [filters, options] = parseFilterArgs(arg1, arg2, arg3)
284β
285 const promises = notifyManager.batch(() =>
286 this.queryCache.findAll(filters).map(query =>
287 query.fetch(undefined, {
288 ...options,
289 meta: { refetchPage: filters?.refetchPage },
290 })
291 )
292 )
293β
294 let promise = Promise.all(promises).then(noop)
295β
296 if (!options?.throwOnError) {
297 promise = promise.catch(noop)
298 }
299β
300 return promise
301 }
302β
303 fetchQuery<
304 TQueryFnData = unknown,
305 TError = unknown,
306 TData = TQueryFnData,
307 TQueryKey extends QueryKey = QueryKey
308 >(
309 options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
310 ): Promise<TData>
311 fetchQuery<
312 TQueryFnData = unknown,
313 TError = unknown,
314 TData = TQueryFnData,
315 TQueryKey extends QueryKey = QueryKey
316 >(
317 queryKey: TQueryKey,
318 options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
319 ): Promise<TData>
320 fetchQuery<
321 TQueryFnData = unknown,
322 TError = unknown,
323 TData = TQueryFnData,
324 TQueryKey extends QueryKey = QueryKey
325 >(
326 queryKey: TQueryKey,
327 queryFn: QueryFunction<TQueryFnData, TQueryKey>,
328 options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
329 ): Promise<TData>
330 fetchQuery<
331 TQueryFnData,
332 TError,
333 TData = TQueryFnData,
334 TQueryKey extends QueryKey = QueryKey
335 >(
336 arg1: TQueryKey | FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
337 arg2?:
338 | QueryFunction<TQueryFnData, TQueryKey>
339 | FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
340 arg3?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
341 ): Promise<TData> {
342 const parsedOptions = parseQueryArgs(arg1, arg2, arg3)
343 const defaultedOptions = this.defaultQueryOptions(parsedOptions)
344β
345 // https://github.com/tannerlinsley/react-query/issues/652
346 if (typeof defaultedOptions.retry === 'undefined') {
347 defaultedOptions.retry = false
348 }
349β
350 const query = this.queryCache.build(this, defaultedOptions)
351β
352 return query.isStaleByTime(defaultedOptions.staleTime)
353 ? query.fetch(defaultedOptions)
354 : Promise.resolve(query.state.data as TData)
355 }
356β
357 prefetchQuery<
358 TQueryFnData = unknown,
359 TError = unknown,
360 TData = TQueryFnData,
361 TQueryKey extends QueryKey = QueryKey
362 >(
363 options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
364 ): Promise<void>
365 prefetchQuery<
366 TQueryFnData = unknown,
367 TError = unknown,
368 TData = TQueryFnData,
369 TQueryKey extends QueryKey = QueryKey
370 >(
371 queryKey: TQueryKey,
372 options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
373 ): Promise<void>
374 prefetchQuery<
375 TQueryFnData = unknown,
376 TError = unknown,
377 TData = TQueryFnData,
378 TQueryKey extends QueryKey = QueryKey
379 >(
380 queryKey: TQueryKey,
381 queryFn: QueryFunction<TQueryFnData, TQueryKey>,
382 options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
383 ): Promise<void>
384 prefetchQuery<
385 TQueryFnData = unknown,
386 TError = unknown,
387 TData = TQueryFnData,
388 TQueryKey extends QueryKey = QueryKey
389 >(
390 arg1: TQueryKey | FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
391 arg2?:
392 | QueryFunction<TQueryFnData, TQueryKey>
393 | FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
394 arg3?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
395 ): Promise<void> {
396 return this.fetchQuery(arg1 as any, arg2 as any, arg3)
397 .then(noop)
398 .catch(noop)
399 }
400β
401 fetchInfiniteQuery<
402 TQueryFnData = unknown,
403 TError = unknown,
404 TData = TQueryFnData,
405 TQueryKey extends QueryKey = QueryKey
406 >(
407 options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
408 ): Promise<InfiniteData<TData>>
409 fetchInfiniteQuery<
410 TQueryFnData = unknown,
411 TError = unknown,
412 TData = TQueryFnData,
413 TQueryKey extends QueryKey = QueryKey
414 >(
415 queryKey: TQueryKey,
416 options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
417 ): Promise<InfiniteData<TData>>
418 fetchInfiniteQuery<
419 TQueryFnData = unknown,
420 TError = unknown,
421 TData = TQueryFnData,
422 TQueryKey extends QueryKey = QueryKey
423 >(
424 queryKey: TQueryKey,
425 queryFn: QueryFunction<TQueryFnData, TQueryKey>,
426 options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
427 ): Promise<InfiniteData<TData>>
428 fetchInfiniteQuery<
429 TQueryFnData,
430 TError,
431 TData = TQueryFnData,
432 TQueryKey extends QueryKey = QueryKey
433 >(
434 arg1:
435 | TQueryKey
436 | FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
437 arg2?:
438 | QueryFunction<TQueryFnData, TQueryKey>
439 | FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
440 arg3?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
441 ): Promise<InfiniteData<TData>> {
442 const parsedOptions = parseQueryArgs(arg1, arg2, arg3)
443 parsedOptions.behavior = infiniteQueryBehavior<
444 TQueryFnData,
445 TError,
446 TData
447 >()
448 return this.fetchQuery(parsedOptions)
449 }
450β
451 prefetchInfiniteQuery<
452 TQueryFnData = unknown,
453 TError = unknown,
454 TData = TQueryFnData,
455 TQueryKey extends QueryKey = QueryKey
456 >(
457 options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
458 ): Promise<void>
459 prefetchInfiniteQuery<
460 TQueryFnData = unknown,
461 TError = unknown,
462 TData = TQueryFnData,
463 TQueryKey extends QueryKey = QueryKey
464 >(
465 queryKey: TQueryKey,
466 options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
467 ): Promise<void>
468 prefetchInfiniteQuery<
469 TQueryFnData = unknown,
470 TError = unknown,
471 TData = TQueryFnData,
472 TQueryKey extends QueryKey = QueryKey
473 >(
474 queryKey: TQueryKey,
475 queryFn: QueryFunction<TQueryFnData, TQueryKey>,
476 options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
477 ): Promise<void>
478 prefetchInfiniteQuery<
479 TQueryFnData,
480 TError,
481 TData = TQueryFnData,
482 TQueryKey extends QueryKey = QueryKey
483 >(
484 arg1:
485 | TQueryKey
486 | FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
487 arg2?:
488 | QueryFunction<TQueryFnData, TQueryKey>
489 | FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
490 arg3?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
491 ): Promise<void> {
492 return this.fetchInfiniteQuery(arg1 as any, arg2 as any, arg3)
493 .then(noop)
494 .catch(noop)
495 }
496β
497 cancelMutations(): Promise<void> {
498 const promises = notifyManager.batch(() =>
499 this.mutationCache.getAll().map(mutation => mutation.cancel())
500 )
501 return Promise.all(promises).then(noop).catch(noop)
502 }
503β
504 resumePausedMutations(): Promise<void> {
505 return this.getMutationCache().resumePausedMutations()
506 }
507β
508 executeMutation<
509 TData = unknown,
510 TError = unknown,
511 TVariables = void,
512 TContext = unknown
513 >(
514 options: MutationOptions<TData, TError, TVariables, TContext>
515 ): Promise<TData> {
516 return this.mutationCache.build(this, options).execute()
517 }
518β
519 getQueryCache(): QueryCache {
520 return this.queryCache
521 }
522β
523 getMutationCache(): MutationCache {
524 return this.mutationCache
525 }
526β
527 getDefaultOptions(): DefaultOptions {
528 return this.defaultOptions
529 }
530β
531 setDefaultOptions(options: DefaultOptions): void {
532 this.defaultOptions = options
533 }
534β
535 setQueryDefaults(
536 queryKey: QueryKey,
537 options: QueryObserverOptions<any, any, any, any>
538 ): void {
539 const result = this.queryDefaults.find(
540 x => hashQueryKey(queryKey) === hashQueryKey(x.queryKey)
541 )
542 if (result) {
543 result.defaultOptions = options
544 } else {
545 this.queryDefaults.push({ queryKey, defaultOptions: options })
546 }
547 }
548β
549 getQueryDefaults(
550 queryKey?: QueryKey
551 ): QueryObserverOptions<any, any, any, any, any> | undefined {
552 return queryKey
553 ? this.queryDefaults.find(x => partialMatchKey(queryKey, x.queryKey))
554 ?.defaultOptions
555 : undefined
556 }
557β
558 setMutationDefaults(
559 mutationKey: MutationKey,
560 options: MutationObserverOptions<any, any, any, any>
561 ): void {
562 const result = this.mutationDefaults.find(
563 x => hashQueryKey(mutationKey) === hashQueryKey(x.mutationKey)
564 )
565 if (result) {
566 result.defaultOptions = options
567 } else {
568 this.mutationDefaults.push({ mutationKey, defaultOptions: options })
569 }
570 }
571β
572 getMutationDefaults(
573 mutationKey?: MutationKey
574 ): MutationObserverOptions<any, any, any, any> | undefined {
575 return mutationKey
576 ? this.mutationDefaults.find(x =>
577 partialMatchKey(mutationKey, x.mutationKey)
578 )?.defaultOptions
579 : undefined
580 }
581β
582 defaultQueryOptions<
583 TQueryFnData,
584 TError,
585 TData,
586 TQueryData,
587 TQueryKey extends QueryKey
588 >(
589 options?: QueryObserverOptions<
590 TQueryFnData,
591 TError,
592 TData,
593 TQueryData,
594 TQueryKey
595 >
596 ): QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
597 if (options?._defaulted) {
598 return options
599 }
600β
601 const defaultedOptions = {
602 ...this.defaultOptions.queries,
603 ...this.getQueryDefaults(options?.queryKey),
604 ...options,
605 _defaulted: true,
606 } as QueryObserverOptions<
607 TQueryFnData,
608 TError,
609 TData,
610 TQueryData,
611 TQueryKey
612 >
613β
614 if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {
615 defaultedOptions.queryHash = hashQueryKeyByOptions(
616 defaultedOptions.queryKey,
617 defaultedOptions
618 )
619 }
620β
621 return defaultedOptions
622 }
623β
624 defaultQueryObserverOptions<
625 TQueryFnData,
626 TError,
627 TData,
628 TQueryData,
629 TQueryKey extends QueryKey
630 >(
631 options?: QueryObserverOptions<
632 TQueryFnData,
633 TError,
634 TData,
635 TQueryData,
636 TQueryKey
637 >
638 ): QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
639 return this.defaultQueryOptions(options)
640 }
641β
642 defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(
643 options?: T
644 ): T {
645 if (options?._defaulted) {
646 return options
647 }
648 return {
649 ...this.defaultOptions.mutations,
650 ...this.getMutationDefaults(options?.mutationKey),
651 ...options,
652 _defaulted: true,
653 } as T
654 }
655β
656 clear(): void {
657 this.queryCache.clear()
658 this.mutationCache.clear()
659 }
660}