Open History to see the last commit
1'use client'
2import * as React from 'react'
3β
4import { QueriesObserver, notifyManager } from '@tanstack/query-core'
5import { useSyncExternalStore } from './useSyncExternalStore'
6import { useQueryClient } from './QueryClientProvider'
7import { useIsRestoring } from './isRestoring'
8import { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'
9import {
10 ensurePreventErrorBoundaryRetry,
11 getHasError,
12 useClearResetErrorBoundary,
13} from './errorBoundaryUtils'
14import {
15 ensureStaleTime,
16 fetchOptimistic,
17 shouldSuspend,
18 willFetch,
19} from './suspense'
20import type { OmitKeyof, QueryFunction, QueryKey } from '@tanstack/query-core'
21import type {
22 DefinedUseQueryResult,
23 UseQueryOptions,
24 UseQueryResult,
25} from './types'
26β
27// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
28// - `context` is omitted as it is passed as a root-level option to `useQueries` instead.
29type UseQueryOptionsForUseQueries<
30 TQueryFnData = unknown,
31 TError = unknown,
32 TData = TQueryFnData,
33 TQueryKey extends QueryKey = QueryKey,
34> = OmitKeyof<
35 UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
36 'context'
37>
38β
39// Avoid TS depth-limit error in case of large array literal
40type MAXIMUM_DEPTH = 20
41β
42type GetOptions<T> =
43 // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
44 T extends {
45 queryFnData: infer TQueryFnData
46 error?: infer TError
47 data: infer TData
48 }
49 ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
50 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
51 ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
52 : T extends { data: infer TData; error?: infer TError }
53 ? UseQueryOptionsForUseQueries<unknown, TError, TData>
54 : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
55 T extends [infer TQueryFnData, infer TError, infer TData]
56 ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
57 : T extends [infer TQueryFnData, infer TError]
58 ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
59 : T extends [infer TQueryFnData]
60 ? UseQueryOptionsForUseQueries<TQueryFnData>
61 : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
62 T extends {
63 queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
64 select: (data: any) => infer TData
65 }
66 ? UseQueryOptionsForUseQueries<TQueryFnData, unknown, TData, TQueryKey>
67 : T extends { queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> }
68 ? UseQueryOptionsForUseQueries<
69 TQueryFnData,
70 unknown,
71 TQueryFnData,
72 TQueryKey
73 >
74 : // Fallback
75 UseQueryOptionsForUseQueries
76β
77// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult
78type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
79 initialData?: infer TInitialData
80}
81 ? unknown extends TInitialData
82 ? UseQueryResult<TData, TError>
83 : TInitialData extends TData
84 ? DefinedUseQueryResult<TData, TError>
85 : TInitialData extends () => infer TInitialDataResult
86 ? unknown extends TInitialDataResult
87 ? UseQueryResult<TData, TError>
88 : TInitialDataResult extends TData
89 ? DefinedUseQueryResult<TData, TError>
90 : UseQueryResult<TData, TError>
91 : UseQueryResult<TData, TError>
92 : UseQueryResult<TData, TError>
93β
94type GetUseQueryResult<T> =
95 // Part 1: responsible for mapping explicit type parameter to function result, if object
96 T extends { queryFnData: any; error?: infer TError; data: infer TData }
97 ? GetDefinedOrUndefinedQueryResult<T, TData, TError>
98 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
99 ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>
100 : T extends { data: infer TData; error?: infer TError }
101 ? GetDefinedOrUndefinedQueryResult<T, TData, TError>
102 : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
103 T extends [any, infer TError, infer TData]
104 ? GetDefinedOrUndefinedQueryResult<T, TData, TError>
105 : T extends [infer TQueryFnData, infer TError]
106 ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData, TError>
107 : T extends [infer TQueryFnData]
108 ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>
109 : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
110 T extends {
111 queryFn?: QueryFunction<unknown, any>
112 select: (data: any) => infer TData
113 }
114 ? GetDefinedOrUndefinedQueryResult<T, TData>
115 : T extends { queryFn?: QueryFunction<infer TQueryFnData, any> }
116 ? GetDefinedOrUndefinedQueryResult<T, TQueryFnData>
117 : // Fallback
118 UseQueryResult
119β
120/**
121 * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
122 */
123export type QueriesOptions<
124 T extends any[],
125 TResult extends any[] = [],
126 TDepth extends ReadonlyArray<number> = [],
127> = TDepth['length'] extends MAXIMUM_DEPTH
128 ? UseQueryOptionsForUseQueries[]
129 : T extends []
130 ? []
131 : T extends [infer Head]
132 ? [...TResult, GetOptions<Head>]
133 : T extends [infer Head, ...infer Tail]
134 ? QueriesOptions<[...Tail], [...TResult, GetOptions<Head>], [...TDepth, 1]>
135 : unknown[] extends T
136 ? T
137 : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
138 // use this to infer the param types in the case of Array.map() argument
139 T extends UseQueryOptionsForUseQueries<
140 infer TQueryFnData,
141 infer TError,
142 infer TData,
143 infer TQueryKey
144 >[]
145 ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>[]
146 : // Fallback
147 UseQueryOptionsForUseQueries[]
148β
149/**
150 * QueriesResults reducer recursively maps type param to results
151 */
152export type QueriesResults<
153 T extends any[],
154 TResults extends any[] = [],
155 TDepth extends ReadonlyArray<number> = [],
156> = TDepth['length'] extends MAXIMUM_DEPTH
157 ? UseQueryResult[]
158 : T extends []
159 ? []
160 : T extends [infer Head]
161 ? [...TResults, GetUseQueryResult<Head>]
162 : T extends [infer Head, ...infer Tail]
163 ? QueriesResults<
164 [...Tail],
165 [...TResults, GetUseQueryResult<Head>],
166 [...TDepth, 1]
167 >
168 : T extends UseQueryOptionsForUseQueries<
169 infer TQueryFnData,
170 infer TError,
171 infer TData,
172 any
173 >[]
174 ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
175 UseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[]
176 : // Fallback
177 UseQueryResult[]
178β
179export function useQueries<T extends any[]>({
180 queries,
181 context,
182}: {
183 queries: readonly [...QueriesOptions<T>]
184 context?: UseQueryOptions['context']
185}): QueriesResults<T> {
186 const queryClient = useQueryClient({ context })
187 const isRestoring = useIsRestoring()
188 const errorResetBoundary = useQueryErrorResetBoundary()
189β
190 const defaultedQueries = React.useMemo(
191 () =>
192 queries.map((options) => {
193 const defaultedOptions = queryClient.defaultQueryOptions(options)
194β
195 // Make sure the results are already in fetching state before subscribing or updating options
196 defaultedOptions._optimisticResults = isRestoring
197 ? 'isRestoring'
198 : 'optimistic'
199β
200 return defaultedOptions
201 }),
202 [queries, queryClient, isRestoring],
203 )
204β
205 defaultedQueries.forEach((query) => {
206 ensureStaleTime(query)
207 ensurePreventErrorBoundaryRetry(query, errorResetBoundary)
208 })
209β
210 useClearResetErrorBoundary(errorResetBoundary)
211β
212 const [observer] = React.useState(
213 () => new QueriesObserver(queryClient, defaultedQueries),
214 )
215β
216 const optimisticResult = observer.getOptimisticResult(defaultedQueries)
217β
218 useSyncExternalStore(
219 React.useCallback(
220 (onStoreChange) =>
221 isRestoring
222 ? () => undefined
223 : observer.subscribe(notifyManager.batchCalls(onStoreChange)),
224 [observer, isRestoring],
225 ),
226 () => observer.getCurrentResult(),
227 () => observer.getCurrentResult(),
228 )
229β
230 React.useEffect(() => {
231 // Do not notify on updates because of changes in the options because
232 // these changes should already be reflected in the optimistic result.
233 observer.setQueries(defaultedQueries, { listeners: false })
234 }, [defaultedQueries, observer])
235β
236 const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>
237 shouldSuspend(defaultedQueries[index], result, isRestoring),
238 )
239β
240 const suspensePromises = shouldAtLeastOneSuspend
241 ? optimisticResult.flatMap((result, index) => {
242 const options = defaultedQueries[index]
243 const queryObserver = observer.getObservers()[index]
244β
245 if (options && queryObserver) {
246 if (shouldSuspend(options, result, isRestoring)) {
247 return fetchOptimistic(options, queryObserver, errorResetBoundary)
248 } else if (willFetch(result, isRestoring)) {
249 void fetchOptimistic(options, queryObserver, errorResetBoundary)
250 }
251 }
252 return []
253 })
254 : []
255β
256 if (suspensePromises.length > 0) {
257 throw Promise.all(suspensePromises)
258 }
259 const observerQueries = observer.getQueries()
260 const firstSingleResultWhichShouldThrow = optimisticResult.find(
261 (result, index) =>
262 getHasError({
263 result,
264 errorResetBoundary,
265 useErrorBoundary: defaultedQueries[index]?.useErrorBoundary ?? false,
266 query: observerQueries[index]!,
267 }),
268 )
269β
270 if (firstSingleResultWhichShouldThrow?.error) {
271 throw firstSingleResultWhichShouldThrow.error
272 }
273β
274 return optimisticResult as QueriesResults<T>
275}