Skip to content
Source
Sign inSign up
TanStack/query
Open History to see the last commit

createQueries.ts

344 lines11.5 KB

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