forked from TanStack/query
-
Notifications
You must be signed in to change notification settings - Fork 0
/
useQueries.ts
160 lines (142 loc) · 5.74 KB
/
useQueries.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
import React from 'react'
import { QueryFunction } from '../core/types'
import { notifyManager } from '../core/notifyManager'
import { QueriesObserver } from '../core/queriesObserver'
import { useQueryClient } from './QueryClientProvider'
import { UseQueryOptions, UseQueryResult } from './types'
// Avoid TS depth-limit error in case of large array literal
type MAXIMUM_DEPTH = 20
type GetOptions<T extends any> =
// Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
T extends {
queryFnData: infer TQueryFnData
error?: infer TError
data: infer TData
}
? UseQueryOptions<TQueryFnData, TError, TData>
: T extends { queryFnData: infer TQueryFnData; error?: infer TError }
? UseQueryOptions<TQueryFnData, TError>
: T extends { data: infer TData; error?: infer TError }
? UseQueryOptions<unknown, TError, TData>
: // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
T extends [infer TQueryFnData, infer TError, infer TData]
? UseQueryOptions<TQueryFnData, TError, TData>
: T extends [infer TQueryFnData, infer TError]
? UseQueryOptions<TQueryFnData, TError>
: T extends [infer TQueryFnData]
? UseQueryOptions<TQueryFnData>
: // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
T extends {
queryFn?: QueryFunction<infer TQueryFnData>
select: (data: any) => infer TData
}
? UseQueryOptions<TQueryFnData, unknown, TData>
: T extends { queryFn?: QueryFunction<infer TQueryFnData> }
? UseQueryOptions<TQueryFnData>
: // Fallback
UseQueryOptions
type GetResults<T> =
// Part 1: responsible for mapping explicit type parameter to function result, if object
T extends { queryFnData: any; error?: infer TError; data: infer TData }
? UseQueryResult<TData, TError>
: T extends { queryFnData: infer TQueryFnData; error?: infer TError }
? UseQueryResult<TQueryFnData, TError>
: T extends { data: infer TData; error?: infer TError }
? UseQueryResult<TData, TError>
: // Part 2: responsible for mapping explicit type parameter to function result, if tuple
T extends [any, infer TError, infer TData]
? UseQueryResult<TData, TError>
: T extends [infer TQueryFnData, infer TError]
? UseQueryResult<TQueryFnData, TError>
: T extends [infer TQueryFnData]
? UseQueryResult<TQueryFnData>
: // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
T extends {
queryFn?: QueryFunction<any>
select: (data: any) => infer TData
}
? UseQueryResult<TData>
: T extends { queryFn?: QueryFunction<infer TQueryFnData> }
? UseQueryResult<TQueryFnData>
: // Fallback
UseQueryResult
/**
* QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
*/
type QueriesOptions<
T extends any[],
Result extends any[] = [],
Depth extends ReadonlyArray<number> = []
> = Depth['length'] extends MAXIMUM_DEPTH
? UseQueryOptions[]
: T extends []
? []
: T extends [infer Head]
? [...Result, GetOptions<Head>]
: T extends [infer Head, ...infer Tail]
? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]>
: unknown[] extends T
? T
: // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
// use this to infer the param types in the case of Array.map() argument
T extends UseQueryOptions<infer TQueryFnData, infer TError, infer TData>[]
? UseQueryOptions<TQueryFnData, TError, TData>[]
: // Fallback
UseQueryOptions[]
/**
* QueriesResults reducer recursively maps type param to results
*/
type QueriesResults<
T extends any[],
Result extends any[] = [],
Depth extends ReadonlyArray<number> = []
> = Depth['length'] extends MAXIMUM_DEPTH
? UseQueryResult[]
: T extends []
? []
: T extends [infer Head]
? [...Result, GetResults<Head>]
: T extends [infer Head, ...infer Tail]
? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]>
: T extends UseQueryOptions<infer TQueryFnData, infer TError, infer TData>[]
? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
UseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[]
: // Fallback
UseQueryResult[]
export function useQueries<T extends any[]>(
queries: readonly [...QueriesOptions<T>]
): QueriesResults<T> {
const mountedRef = React.useRef(false)
const [, forceUpdate] = React.useState(0)
const queryClient = useQueryClient()
const defaultedQueries = queries.map(options => {
const defaultedOptions = queryClient.defaultQueryObserverOptions(options)
// Make sure the results are already in fetching state before subscribing or updating options
defaultedOptions.optimisticResults = true
return defaultedOptions
})
const [observer] = React.useState(
() => new QueriesObserver(queryClient, defaultedQueries)
)
const result = observer.getOptimisticResult(defaultedQueries)
React.useEffect(() => {
mountedRef.current = true
const unsubscribe = observer.subscribe(
notifyManager.batchCalls(() => {
if (mountedRef.current) {
forceUpdate(x => x + 1)
}
})
)
return () => {
mountedRef.current = false
unsubscribe()
}
}, [observer])
React.useEffect(() => {
// Do not notify on updates because of changes in the options because
// these changes should already be reflected in the optimistic result.
observer.setQueries(defaultedQueries, { listeners: false })
}, [defaultedQueries, observer])
return result as QueriesResults<T>
}