Open History to see the last commit
1import { QueriesObserver } 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 { CreateQueryResult, SolidQueryOptions } 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 CreateQueryOptionsForCreateQueries<
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 createQueries 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 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
66 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
67 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
68 : T extends { data: infer TData; error?: infer TError }
69 ? CreateQueryOptionsForCreateQueries<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 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
73 : T extends [infer TQueryFnData, infer TError]
74 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
75 : T extends [infer TQueryFnData]
76 ? CreateQueryOptionsForCreateQueries<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 ? CreateQueryOptionsForCreateQueries<
86 TQueryFnData,
87 unknown extends TError ? DefaultError : TError,
88 unknown extends TData ? TQueryFnData : TData,
89 TQueryKey
90 >
91 : // Fallback
92 CreateQueryOptionsForCreateQueries
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 ? CreateQueryResult<TData, TError>
98 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
99 ? CreateQueryResult<TQueryFnData, TError>
100 : T extends { data: infer TData; error?: infer TError }
101 ? CreateQueryResult<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 ? CreateQueryResult<TData, TError>
105 : T extends [infer TQueryFnData, infer TError]
106 ? CreateQueryResult<TQueryFnData, TError>
107 : T extends [infer TQueryFnData]
108 ? CreateQueryResult<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 ? CreateQueryResult<
118 unknown extends TData ? TQueryFnData : TData,
119 unknown extends TError ? DefaultError : TError
120 >
121 : // Fallback
122 CreateQueryResult
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<CreateQueryOptionsForCreateQueries>
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 CreateQueryOptionsForCreateQueries<
149 infer TQueryFnData,
150 infer TError,
151 infer TData,
152 infer TQueryKey
153 >
154 >
155 ? Array<
156 CreateQueryOptionsForCreateQueries<
157 TQueryFnData,
158 TError,
159 TData,
160 TQueryKey
161 >
162 >
163 : // Fallback
164 Array<CreateQueryOptionsForCreateQueries>
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<CreateQueryResult>
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 : T extends Array<
186 CreateQueryOptionsForCreateQueries<
187 infer TQueryFnData,
188 infer TError,
189 infer TData,
190 any
191 >
192 >
193 ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
194 Array<
195 CreateQueryResult<
196 unknown extends TData ? TQueryFnData : TData,
197 unknown extends TError ? DefaultError : TError
198 >
199 >
200 : // Fallback
201 Array<CreateQueryResult>
202β
203export function createQueries<
204 T extends Array<any>,
205 TCombinedResult extends QueriesResults<T> = QueriesResults<T>,
206>(
207 queriesOptions: Accessor<{
208 queries: readonly [...QueriesOptions<T>]
209 combine?: (result: QueriesResults<T>) => TCombinedResult
210 }>,
211 queryClient?: Accessor<QueryClient>,
212): TCombinedResult {
213 const client = createMemo(() => useQueryClient(queryClient?.()))
214 const isRestoring = useIsRestoring()
215β
216 const defaultedQueries = createMemo(() =>
217 queriesOptions().queries.map((options) =>
218 mergeProps(
219 client().defaultQueryOptions(options as QueryObserverOptions),
220 {
221 get _optimisticResults() {
222 return isRestoring() ? 'isRestoring' : 'optimistic'
223 },
224 },
225 ),
226 ),
227 )
228β
229 const observer = new QueriesObserver(
230 client(),
231 defaultedQueries(),
232 queriesOptions().combine
233 ? ({
234 combine: queriesOptions().combine,
235 } as QueriesObserverOptions<TCombinedResult>)
236 : undefined,
237 )
238β
239 const [state, setState] = createStore<TCombinedResult>(
240 observer.getOptimisticResult(
241 defaultedQueries(),
242 (queriesOptions() as QueriesObserverOptions<TCombinedResult>).combine,
243 )[1](),
244 )
245β
246 createRenderEffect(
247 on(
248 () => queriesOptions().queries.length,
249 () =>
250 setState(
251 observer.getOptimisticResult(
252 defaultedQueries(),
253 (queriesOptions() as QueriesObserverOptions<TCombinedResult>)
254 .combine,
255 )[1](),
256 ),
257 ),
258 )
259β
260 const dataResources = createMemo(
261 on(
262 () => state.length,
263 () =>
264 state.map((queryRes) => {
265 const dataPromise = () =>
266 new Promise((resolve) => {
267 if (queryRes.isFetching && queryRes.isLoading) return
268 resolve(unwrap(queryRes.data))
269 })
270 return createResource(dataPromise)
271 }),
272 ),
273 )
274β
275 batch(() => {
276 const dataResources_ = dataResources()
277 for (let index = 0; index < dataResources_.length; index++) {
278 const dataResource = dataResources_[index]!
279 dataResource[1].mutate(() => unwrap(state[index]!.data))
280 dataResource[1].refetch()
281 }
282 })
283β
284 let taskQueue: Array<() => void> = []
285 const subscribeToObserver = () =>
286 observer.subscribe((result) => {
287 taskQueue.push(() => {
288 batch(() => {
289 const dataResources_ = dataResources()
290 for (let index = 0; index < dataResources_.length; index++) {
291 const dataResource = dataResources_[index]!
292 const unwrappedResult = { ...unwrap(result[index]) }
293 // @ts-expect-error typescript pedantry regarding the possible range of index
294 setState(index, unwrap(unwrappedResult))
295 dataResource[1].mutate(() => unwrap(state[index]!.data))
296 dataResource[1].refetch()
297 }
298 })
299 })
300β
301 queueMicrotask(() => {
302 const taskToRun = taskQueue.pop()
303 if (taskToRun) taskToRun()
304 taskQueue = []
305 })
306 })
307β
308 let unsubscribe: () => void = () => undefined
309 createComputed<() => void>((cleanup) => {
310 cleanup?.()
311 unsubscribe = isRestoring() ? () => undefined : subscribeToObserver()
312 // cleanup needs to be scheduled after synchronous effects take place
313 return () => queueMicrotask(unsubscribe)
314 })
315 onCleanup(unsubscribe)
316β
317 onMount(() => {
318 observer.setQueries(
319 defaultedQueries(),
320 queriesOptions().combine
321 ? ({
322 combine: queriesOptions().combine,
323 } as QueriesObserverOptions<TCombinedResult>)
324 : undefined,
325 { listeners: false },
326 )
327 })
328β
329 createComputed(() => {
330 observer.setQueries(
331 defaultedQueries(),
332 queriesOptions().combine
333 ? ({
334 combine: queriesOptions().combine,
335 } as QueriesObserverOptions<TCombinedResult>)
336 : undefined,
337 { listeners: false },
338 )
339 })
340β
341 const handler = (index: number) => ({
342 get(target: QueryObserverResult, prop: keyof QueryObserverResult): any {
343 if (prop === 'data') {
344 return dataResources()[index]![0]()
345 }
346 return Reflect.get(target, prop)
347 },
348 })
349β
350 const getProxies = () =>
351 state.map((s, index) => {
352 return new Proxy(s, handler(index))
353 })
354β
355 const [proxyState, setProxyState] = createStore(getProxies())
356 createRenderEffect(() => setProxyState(getProxies()))
357β
358 return proxyState as TCombinedResult
359}