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