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

createQueries.ts

203 lines7.1 KB

1import { createComputed, onCleanup, onMount } from 'solid-js'
2import { QueriesObserver } from '@tanstack/query-core'
3import { createStore, unwrap } from 'solid-js/store'
4import { useQueryClient } from './QueryClientProvider'
5import { scheduleMicrotask } from './utils'
6import type {
7 CreateQueryOptions,
8 CreateQueryResult,
9 SolidQueryKey,
10} from './types'
11import type { QueryFunction } from '@tanstack/query-core'
12​
13// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
14// - `context` is omitted as it is passed as a root-level option to `useQueries` instead.
15type CreateQueryOptionsForCreateQueries<
16 TQueryFnData = unknown,
17 TError = unknown,
18 TData = TQueryFnData,
19 TQueryKey extends SolidQueryKey = SolidQueryKey,
20> = Omit<CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>
21​
22// Avoid TS depth-limit error in case of large array literal
23type MAXIMUM_DEPTH = 20
24​
25type GetOptions<T> =
26 // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
27 T extends {
28 queryFnData: infer TQueryFnData
29 error?: infer TError
30 data: infer TData
31 }
32 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
33 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
34 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
35 : T extends { data: infer TData; error?: infer TError }
36 ? CreateQueryOptionsForCreateQueries<unknown, TError, TData>
37 : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
38 T extends [infer TQueryFnData, infer TError, infer TData]
39 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
40 : T extends [infer TQueryFnData, infer TError]
41 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
42 : T extends [infer TQueryFnData]
43 ? CreateQueryOptionsForCreateQueries<TQueryFnData>
44 : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
45 T extends {
46 queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
47 select: (data: any) => infer TData
48 }
49 ? CreateQueryOptionsForCreateQueries<
50 TQueryFnData,
51 unknown,
52 TData,
53 () => TQueryKey
54 >
55 : T extends { queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> }
56 ? CreateQueryOptionsForCreateQueries<
57 TQueryFnData,
58 unknown,
59 TQueryFnData,
60 () => TQueryKey
61 >
62 : // Fallback
63 CreateQueryOptionsForCreateQueries
64​
65type GetResults<T> =
66 // Part 1: responsible for mapping explicit type parameter to function result, if object
67 T extends { queryFnData: any; error?: infer TError; data: infer TData }
68 ? CreateQueryResult<TData, TError>
69 : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
70 ? CreateQueryResult<TQueryFnData, TError>
71 : T extends { data: infer TData; error?: infer TError }
72 ? CreateQueryResult<TData, TError>
73 : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
74 T extends [any, infer TError, infer TData]
75 ? CreateQueryResult<TData, TError>
76 : T extends [infer TQueryFnData, infer TError]
77 ? CreateQueryResult<TQueryFnData, TError>
78 : T extends [infer TQueryFnData]
79 ? CreateQueryResult<TQueryFnData>
80 : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
81 T extends {
82 queryFn?: QueryFunction<unknown, any>
83 select: (data: any) => infer TData
84 }
85 ? CreateQueryResult<TData>
86 : T extends { queryFn?: QueryFunction<infer TQueryFnData, any> }
87 ? CreateQueryResult<TQueryFnData>
88 : // Fallback
89 CreateQueryResult
90​
91/**
92 * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
93 */
94export type QueriesOptions<
95 T extends any[],
96 Result extends any[] = [],
97 Depth extends ReadonlyArray<number> = [],
98> = Depth['length'] extends MAXIMUM_DEPTH
99 ? CreateQueryOptionsForCreateQueries[]
100 : T extends []
101 ? []
102 : T extends [infer Head]
103 ? [...Result, GetOptions<Head>]
104 : T extends [infer Head, ...infer Tail]
105 ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]>
106 : unknown[] extends T
107 ? T
108 : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
109 // use this to infer the param types in the case of Array.map() argument
110 T extends CreateQueryOptionsForCreateQueries<
111 infer TQueryFnData,
112 infer TError,
113 infer TData,
114 infer TQueryKey
115 >[]
116 ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>[]
117 : // Fallback
118 CreateQueryOptionsForCreateQueries[]
119​
120/**
121 * QueriesResults reducer recursively maps type param to results
122 */
123export type QueriesResults<
124 T extends any[],
125 Result extends any[] = [],
126 Depth extends ReadonlyArray<number> = [],
127> = Depth['length'] extends MAXIMUM_DEPTH
128 ? CreateQueryResult[]
129 : T extends []
130 ? []
131 : T extends [infer Head]
132 ? [...Result, GetResults<Head>]
133 : T extends [infer Head, ...infer Tail]
134 ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]>
135 : T extends CreateQueryOptionsForCreateQueries<
136 infer TQueryFnData,
137 infer TError,
138 infer TData,
139 any
140 >[]
141 ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
142 CreateQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[]
143 : // Fallback
144 CreateQueryResult[]
145​
146type ArrType<T> = T extends (infer U)[] ? U : never
147​
148export function createQueries<T extends any[]>(queriesOptions: {
149 queries: readonly [...QueriesOptions<T>]
150 context?: CreateQueryOptions['context']
151}): QueriesResults<T> {
152 const queryClient = useQueryClient({ context: queriesOptions.context })
153​
154 const normalizeOptions = (
155 options: ArrType<typeof queriesOptions.queries>,
156 ) => {
157 const normalizedOptions = { ...options, queryKey: options.queryKey?.() }
158 const defaultedOptions = queryClient.defaultQueryOptions(normalizedOptions)
159 defaultedOptions._optimisticResults = 'optimistic'
160 return defaultedOptions
161 }
162​
163 const defaultedQueries = queriesOptions.queries.map((options) =>
164 normalizeOptions(options),
165 )
166​
167 const observer = new QueriesObserver(queryClient, defaultedQueries)
168​
169 const [state, setState] = createStore(
170 observer.getOptimisticResult(defaultedQueries),
171 )
172​
173 const taskQueue: Array<() => void> = []
174​
175 const unsubscribe = observer.subscribe((result) => {
176 taskQueue.push(() => {
177 setState(unwrap(result))
178 })
179​
180 scheduleMicrotask(() => {
181 const taskToRun = taskQueue.pop()
182 if (taskToRun) {
183 taskToRun()
184 taskQueue.splice(0, taskQueue.length)
185 }
186 })
187 })
188​
189 onCleanup(unsubscribe)
190​
191 onMount(() => {
192 observer.setQueries(defaultedQueries, { listeners: false })
193 })
194​
195 createComputed(() => {
196 const updateDefaultedQueries = queriesOptions.queries.map((options) =>
197 normalizeOptions(options),
198 )
199 observer.setQueries(updateDefaultedQueries)
200 })
201​
202 return state as QueriesResults<T>