Open History to see the last commit
1import { QueriesObserver, noop } from '@tanstack/query-core'
2import { createStore, unwrap } from 'solid-js/store'
3import {
4 batch,
5 createComputed,
6 createMemo,
7 createRenderEffect,
8 createResource,
9 mergeProps,
10 on,
11 onCleanup,
12 onMount,
13} from 'solid-js'
14import { useQueryClient } from './QueryClientProvider'
15import { useIsRestoring } from './isRestoring'
16import type { SolidQueryOptions, UseQueryResult } from './types'
17import type { Accessor } from 'solid-js'
18import type { QueryClient } from './QueryClient'
19import type {
20 DefaultError,
21 OmitKeyof,
22 QueriesObserverOptions,
23 QueriesPlaceholderDataFunction,
24 QueryFunction,
25 QueryKey,
26 QueryObserverOptions,
27 QueryObserverResult,
28 ThrowOnError,
29} from '@tanstack/query-core'
30β
31// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
32// `placeholderData` function does not have a parameter
33type UseQueryOptionsForUseQueries<
34 TQueryFnData = unknown,
35 TError = DefaultError,
36 TData = TQueryFnData,
37 TQueryKey extends QueryKey = QueryKey,
38> = OmitKeyof<
39 SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
40 'placeholderData' | 'suspense'
41> & {
42 placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
43 /**
44 * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
45 * The `data` property on useQueries is a plain object and not a SolidJS Resource.
46 * It will not suspend when the data is loading.
47 * Setting `suspense` to `true` will be a no-op.
48 */
49 suspense?: boolean
50}
51β
52// Avoid TS depth-limit error in case of large array literal
53type MAXIMUM_DEPTH = 20
54β
55// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
56type SkipTokenForUseQueries = symbol
57β
58type GetOptions<T> =
59 // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
60 T extends {
61 queryFnData: infer TQueryFnData
62 error?: infer TError
63 data: infer TData
64 }
65 ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
66 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
67 ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
68 : T extends { data: infer TData; error?: infer TError }
69 ? UseQueryOptionsForUseQueries<unknown, TError, TData>
70 : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
71 T extends [infer TQueryFnData, infer TError, infer TData]
72 ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
73 : T extends [infer TQueryFnData, infer TError]
74 ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
75 : T extends [infer TQueryFnData]
76 ? UseQueryOptionsForUseQueries<TQueryFnData>
77 : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
78 T extends {
79 queryFn?:
80 | QueryFunction<infer TQueryFnData, infer TQueryKey>
81 | SkipTokenForUseQueries
82 select?: (data: any) => infer TData
83 throwOnError?: ThrowOnError<any, infer TError, any, any>
84 }
85 ? UseQueryOptionsForUseQueries<
86 TQueryFnData,
87 unknown extends TError ? DefaultError : TError,
88 unknown extends TData ? TQueryFnData : TData,
89 TQueryKey
90 >
91 : // Fallback
92 UseQueryOptionsForUseQueries
93β
94type GetResults<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 ? UseQueryResult<TData, TError>
98 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
99 ? UseQueryResult<TQueryFnData, TError>
100 : T extends { data: infer TData; error?: infer TError }
101 ? UseQueryResult<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 ? UseQueryResult<TData, TError>
105 : T extends [infer TQueryFnData, infer TError]
106 ? UseQueryResult<TQueryFnData, TError>
107 : T extends [infer TQueryFnData]
108 ? UseQueryResult<TQueryFnData>
109 : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
110 T extends {
111 queryFn?:
112 | QueryFunction<infer TQueryFnData, any>
113 | SkipTokenForUseQueries
114 select?: (data: any) => infer TData
115 throwOnError?: ThrowOnError<any, infer TError, any, any>
116 }
117 ? UseQueryResult<
118 unknown extends TData ? TQueryFnData : TData,
119 unknown extends TError ? DefaultError : TError
120 >
121 : // Fallback
122 UseQueryResult
123β
124/**
125 * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
126 */
127type QueriesOptions<
128 T extends Array<any>,
129 TResult extends Array<any> = [],
130 TDepth extends ReadonlyArray<number> = [],
131> = TDepth['length'] extends MAXIMUM_DEPTH
132 ? Array<UseQueryOptionsForUseQueries>
133 : T extends []
134 ? []
135 : T extends [infer Head]
136 ? [...TResult, GetOptions<Head>]
137 : T extends [infer Head, ...infer Tail]
138 ? QueriesOptions<
139 [...Tail],
140 [...TResult, GetOptions<Head>],
141 [...TDepth, 1]
142 >
143 : ReadonlyArray<unknown> extends T
144 ? T
145 : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
146 // use this to infer the param types in the case of Array.map() argument
147 T extends Array<
148 UseQueryOptionsForUseQueries<
149 infer TQueryFnData,
150 infer TError,
151 infer TData,
152 infer TQueryKey
153 >
154 >
155 ? Array<
156 UseQueryOptionsForUseQueries<
157 TQueryFnData,
158 TError,
159 TData,
160 TQueryKey
161 >
162 >
163 : // Fallback
164 Array<UseQueryOptionsForUseQueries>
165β
166/**
167 * QueriesResults reducer recursively maps type param to results
168 */
169type QueriesResults<
170 T extends Array<any>,
171 TResult extends Array<any> = [],
172 TDepth extends ReadonlyArray<number> = [],
173> = TDepth['length'] extends MAXIMUM_DEPTH
174 ? Array<UseQueryResult>
175 : T extends []
176 ? []
177 : T extends [infer Head]
178 ? [...TResult, GetResults<Head>]
179 : T extends [infer Head, ...infer Tail]
180 ? QueriesResults<
181 [...Tail],
182 [...TResult, GetResults<Head>],
183 [...TDepth, 1]
184 >
185 : { [K in keyof T]: GetResults<T[K]> }
186β
187export function useQueries<
188 T extends Array<any>,
189 TCombinedResult extends QueriesResults<T> = QueriesResults<T>,
190>(
191 queriesOptions: Accessor<{
192 queries:
193 | readonly [...QueriesOptions<T>]
194 | readonly [...{ [K in keyof T]: GetOptions<T[K]> }]
195 combine?: (result: QueriesResults<T>) => TCombinedResult
196 }>,
197 queryClient?: Accessor<QueryClient>,
198): TCombinedResult {
199 const client = createMemo(() => useQueryClient(queryClient?.()))
200 const isRestoring = useIsRestoring()
201β
202 const defaultedQueries = createMemo(() =>
203 queriesOptions().queries.map((options) =>
204 mergeProps(
205 client().defaultQueryOptions(options as QueryObserverOptions),
206 {
207 get _optimisticResults() {
208 return isRestoring() ? 'isRestoring' : 'optimistic'
209 },
210 },
211 ),
212 ),
213 )
214β
215 const observer = new QueriesObserver(
216 client(),
217 defaultedQueries(),
218 queriesOptions().combine
219 ? ({
220 combine: queriesOptions().combine,
221 } as QueriesObserverOptions<TCombinedResult>)
222 : undefined,
223 )
224β
225 const [state, setState] = createStore<TCombinedResult>(
226 observer.getOptimisticResult(
227 defaultedQueries(),
228 (queriesOptions() as QueriesObserverOptions<TCombinedResult>).combine,
229 )[1](),
230 )
231β
232 createRenderEffect(
233 on(
234 () => queriesOptions().queries.length,
235 () =>
236 setState(
237 observer.getOptimisticResult(
238 defaultedQueries(),
239 (queriesOptions() as QueriesObserverOptions<TCombinedResult>)
240 .combine,
241 )[1](),
242 ),
243 ),
244 )
245β
246 const dataResources = createMemo(
247 on(
248 () => state.length,
249 () =>
250 state.map((queryRes) => {
251 const dataPromise = () =>
252 new Promise((resolve) => {
253 if (queryRes.isFetching && queryRes.isLoading) return
254 resolve(unwrap(queryRes.data))
255 })
256 return createResource(dataPromise)
257 }),
258 ),
259 )
260β
261 batch(() => {
262 const dataResources_ = dataResources()
263 for (let index = 0; index < dataResources_.length; index++) {
264 const dataResource = dataResources_[index]!
265 dataResource[1].mutate(() => unwrap(state[index]!.data))
266 dataResource[1].refetch()
267 }
268 })
269β
270 let taskQueue: Array<() => void> = []
271 const subscribeToObserver = () =>
272 observer.subscribe((result) => {
273 taskQueue.push(() => {
274 batch(() => {
275 const dataResources_ = dataResources()
276 for (let index = 0; index < dataResources_.length; index++) {
277 const dataResource = dataResources_[index]!
278 const unwrappedResult = { ...unwrap(result[index]) }
279 // @ts-expect-error typescript pedantry regarding the possible range of index
280 setState(index, unwrap(unwrappedResult))
281 dataResource[1].mutate(() => unwrap(state[index]!.data))
282 dataResource[1].refetch()
283 }
284 })
285 })
286β
287 queueMicrotask(() => {
288 const taskToRun = taskQueue.pop()
289 if (taskToRun) taskToRun()
290 taskQueue = []
291 })
292 })
293β
294 let unsubscribe: () => void = noop
295 createComputed<() => void>((cleanup) => {
296 cleanup?.()
297 unsubscribe = isRestoring() ? noop : subscribeToObserver()
298 // cleanup needs to be scheduled after synchronous effects take place
299 return () => queueMicrotask(unsubscribe)
300 })
301 onCleanup(unsubscribe)
302β
303 onMount(() => {
304 observer.setQueries(
305 defaultedQueries(),
306 queriesOptions().combine
307 ? ({
308 combine: queriesOptions().combine,
309 } as QueriesObserverOptions<TCombinedResult>)
310 : undefined,
311 )
312 })
313β
314 createComputed(() => {
315 observer.setQueries(
316 defaultedQueries(),
317 queriesOptions().combine
318 ? ({
319 combine: queriesOptions().combine,
320 } as QueriesObserverOptions<TCombinedResult>)
321 : undefined,
322 )
323 })
324β
325 const handler = (index: number) => ({
326 get(target: QueryObserverResult, prop: keyof QueryObserverResult): any {
327 if (prop === 'data') {
328 return dataResources()[index]![0]()
329 }
330 return Reflect.get(target, prop)
331 },
332 })
333β
334 const getProxies = () =>
335 state.map((s, index) => {
336 return new Proxy(s, handler(index))
337 })
338β
339 const [proxyState, setProxyState] = createStore(getProxies())
340 createRenderEffect(() => setProxyState(getProxies()))
341β
342 return proxyState as TCombinedResult
343}