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