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

index.js

488 lines12.0 KB

1import React from 'react'
2import JSONStableStringify from 'fast-json-stable-stringify'
3​
4const context = React.createContext()
5​
6export function ReactQueryProvider({ children, config = {} }) {
7 const metaRef = React.useRef({})
8​
9 const [state, setState] = React.useState({})
10​
11 const configRef = React.useRef({})
12 configRef.current = {
13 retry: 3,
14 retryDelay: attemptIndex => Math.min(1000 * 2 ** attemptIndex, 30000),
15 cacheTime: 60 * 1000,
16 ...config,
17 }
18​
19 const contextValue = React.useMemo(
20 () => [state, setState, metaRef, configRef],
21 [state]
22 )
23 return <context.Provider value={contextValue}>{children}</context.Provider>
25​
26let uid = 0
27const queryIDsByQuery = new Map()
28​
29function getQueryID(query) {
30 // Get a query ID for this query function
31 let queryID = queryIDsByQuery.get(query)
32 // Make the queryID if necessary
33 if (!queryID) {
34 queryIDsByQuery.set(query, uid++)
35 queryID = queryIDsByQuery.get(query)
36 }
37​
38 return queryID
40​
41function getQueryInfo({ query, variables: variablesObj, cacheBuster = '' }) {
42 const queryID = getQueryID(query)
43 const variablesHash = JSONStableStringify(variablesObj)
44 return [
45 [queryID, variablesHash, cacheBuster].join(''),
46 queryID,
47 variablesHash,
48 ]
50​
51function useVariables(variablesObj) {
52 const stringified = JSONStableStringify(variablesObj)
53 // eslint-disable-next-line
54 return React.useMemo(() => variablesObj, [stringified])
56​
57function useSharedQuery({
58 query,
59 variables: variablesObj,
60 cache,
61 instanceID,
62 refetchRef,
63 retry: queryRetry,
64 retryDelay: queryRetryDelay,
65 cacheTime: queryCacheTime,
66}) {
67 const [
68 providerState,
69 setProviderState,
70 providerMetaRef,
71 configRef,
72 ] = React.useContext(context)
73​
74 // Use this cacheBusterRef ID to avoid cache usage
75 const cacheBusterRef = React.useRef()
76 if (!cacheBusterRef) {
77 cacheBusterRef.current = uid++
78 }
79​
80 // Create the final query hash
81 const [queryHash, queryID, variablesHash] = getQueryInfo({
82 query,
83 variables: variablesObj,
84 cacheBuster: !cache ? cacheBusterRef.current : '',
85 })
86​
87 const variables = useVariables(variablesObj)
88​
89 const defaultQueryState = React.useMemo(
90 () => ({
91 data: null,
92 error: null,
93 isFetching: false,
94 fetchCount: 0,
95 successCount: 0,
96 failureCount: 0,
97 }),
98 []
99 )
100​
101 const queryState = providerState[queryHash] || defaultQueryState
102​
103 const setQueryState = React.useCallback(
104 updater => {
105 return setProviderState(old => {
106 const newValue =
107 typeof updater === 'function'
108 ? updater(old[queryHash] || defaultQueryState)
109 : updater
110​
111 if (typeof newValue === 'undefined') {
112 const copy = { ...old }
113 delete copy[queryHash]
114 return copy
115 }
116​
117 return {
118 ...old,
119 [queryHash]: newValue,
120 }
121 })
122 },
123 [setProviderState, queryHash, defaultQueryState]
124 )
125​
126 providerMetaRef.current[queryHash] = providerMetaRef.current[queryHash] || {
127 queryID,
128 variablesHash,
129 promise: null,
130 previousDelay: 0,
131 instancesByID: {},
132 }
133​
134 providerMetaRef.current[queryHash].instancesByID[instanceID] = {
135 refetchRef,
136 }
137​
138 if (providerMetaRef.current[queryHash].cleanupTimeout) {
139 clearTimeout(providerMetaRef.current[queryHash].cleanupTimeout)
140 }
141​
142 const metaRef = React.useRef()
143 metaRef.current = providerMetaRef.current[queryHash]
144​
145 const queryConfigRef = React.useRef()
146 queryConfigRef.current = {
147 ...configRef.current,
148 retry:
149 typeof queryRetry !== 'undefined' ? queryRetry : configRef.current.retry,
150 retryDelay:
151 typeof queryRetryDelay !== 'undefined'
152 ? queryRetryDelay
153 : configRef.current.retryDelay,
154 cacheTime:
155 typeof queryCacheTime !== 'undefined'
156 ? queryCacheTime
157 : configRef.current.cacheTime,
158 }
159​
160 // Manage query active-ness and garbage collection
161 React.useEffect(() => {
162 const providerMetaCopy = providerMetaRef.current
163​
164 return () => {
165 // Do some cleanup between hash changes
166 delete providerMetaCopy[queryHash].instancesByID[instanceID]
167​
168 // If no more instances are tied to this query, GC it
169 if (!Object.keys(providerMetaCopy[queryHash].instancesByID).length) {
170 providerMetaCopy[queryHash].cleanupTimeout = setTimeout(() => {
171 delete providerMetaCopy[queryHash]
172 setQueryState(undefined)
173 }, queryConfigRef.current.cacheTime)
174 }
175 }
176 }, [instanceID, providerMetaRef, queryHash, setQueryState])
177​
178 return {
179 queryState,
180 setQueryState,
181 metaRef,
182 variables,
183 queryHash,
184 configRef,
185 }
187​
188export function useQuery(
189 query,
190 {
191 variables: userVariables,
192 tags = [],
193 manual = false,
194 cache = true,
195 cacheTime,
196 retry: queryRetry,
197 retryDelay: queryRetryDelay,
198 }
199) {
200 const instanceIDRef = React.useRef(uid++)
201 const instanceID = instanceIDRef.current
202 const refetchRef = React.useRef()
203​
204 const {
205 queryState: {
206 data,
207 error,
208 fetchCount,
209 isFetching,
210 successCount,
211 failureCount,
212 },
213 setQueryState,
214 metaRef,
215 variables: defaultVariables,
216 configRef,
217 } = useSharedQuery({
218 query,
219 tags,
220 variables: userVariables,
221 cache,
222 instanceID,
223 refetchRef,
224 retry: queryRetry,
225 retryDelay: queryRetryDelay,
226 cacheTime,
227 })
228​
229 const isCached = successCount && !error
230​
231 const [isLoading, setIsLoading] = React.useState(!cache || !isCached)
232​
233 const latestRef = React.useRef({})
234 latestRef.current = {
235 successCount,
236 error,
237 failureCount,
238 isFetching,
239 }
240​
241 refetchRef.current = React.useCallback(
242 async ({ variables = defaultVariables, merge } = {}) => {
243 const fetch = async () => {
244 try {
245 return await query(variables)
246 } catch (error) {
247 setQueryState(old => {
248 return {
249 ...old,
250 error,
251 failureCount: old.failureCount + 1,
252 }
253 })
254​
255 if (
256 configRef.current.retry === true ||
257 latestRef.current.failureCount < configRef.current.retry
258 ) {
259 const delay =
260 typeof configRef.current.retryDelay === 'function'
261 ? configRef.current.retryDelay(latestRef.current.failureCount)
262 : configRef.current.retryDelay
263​
264 return new Promise(resolve =>
265 setTimeout(() => {
266 resolve(fetch())
267 }, delay)
268 )
269 }
270​
271 throw error
272 }
273 }
274​
275 // Create a new promise for the query cache if necessary
276 if (!metaRef.current.promise) {
277 metaRef.current.promise = new Promise(async (resolve, reject) => {
278 const fetchID = uid++
279 metaRef.current.fetchID = fetchID
280 const isLatest = () => metaRef.current.fetchID === fetchID
281 if (!latestRef.current.successCount || latestRef.current.error) {
282 setIsLoading(true)
283 }
284 try {
285 setQueryState(old => {
286 return {
287 ...old,
288 error: null,
289 isFetching: true,
290 fetchCount: old.fetchCount + 1,
291 failureCount: 0,
292 }
293 })
294 const data = await fetch()
295 if (isLatest()) {
296 setQueryState(old => {
297 return {
298 ...old,
299 data: merge ? merge(old.data, data) : data,
300 successCount: old.successCount + 1,
301 }
302 })
303 resolve(data)
304 return data
305 }
306 return new Promise((resolve, reject) => {
307 // Never resolve this promise
308 })
309 } catch (err) {
310 console.error(err)
311 if (isLatest()) {
312 reject(err)
313 }
314 } finally {
315 if (isLatest()) {
316 delete metaRef.current.promise
317 setIsLoading(false)
318 setQueryState(old => {
319 return {
320 ...old,
321 isFetching: false,
322 }
323 })
324 }
325 }
326 })
327 }
328​
329 return metaRef.current.promise
330 },
331 [defaultVariables, metaRef, query, setQueryState, configRef]
332 )
333​
334 const refetch = refetchRef.current
335​
336 React.useEffect(() => {
337 if (manual) {
338 return
339 }
340 refetch()
341 }, [manual, refetch])
342​
343 return {
344 data,
345 error,
346 isLoading,
347 isFetching,
348 fetchCount,
349 successCount,
350 failureCount,
351 refetch,
352 }
354​
355export function useRefetchQueries() {
356 const [, , providerMetaRef] = React.useContext(context)
357​
358 return React.useCallback(
359 async (refetchQueries, { waitForRefetchQueries }) => {
360 const refetchQueryPromises = refetchQueries.map(async refetchQuery => {
361 const { query, variables } =
362 typeof refetchQuery === 'function'
363 ? { query: refetchQuery }
364 : refetchQuery
365​
366 const [, queryID, variablesHash] = getQueryInfo({
367 query,
368 variables,
369 })
370​
371 const matchingQueriesPromises = Object.keys(
372 providerMetaRef.current
373 ).map(async key => {
374 const query = providerMetaRef.current[key]
375 if (!query.queryID === queryID) {
376 return
377 }
378 if (variablesHash && query.variablesHash !== variablesHash) {
379 return
380 }
381​
382 const queryInstancesPromises = Object.keys(query.instancesByID).map(
383 id => query.instancesByID[id].refetchRef.current()
384 )
385​
386 await Promise.all(queryInstancesPromises)
387 })
388​
389 await Promise.all(matchingQueriesPromises)
390 })
391​
392 if (waitForRefetchQueries) {
393 await Promise.all(refetchQueryPromises)
394 }
395 },
396 [providerMetaRef]
397 )
399​
400export function useUpdateQueries() {
401 const [, setState] = React.useContext(context)
402​
403 return React.useCallback(
404 (updaters, data) => {
405 updaters.forEach(updater => {
406 const { query, variables } =
407 typeof updater === 'function' ? { query: updater } : updater
408​
409 const [queryHash] = getQueryInfo({
410 query,
411 variables:
412 typeof variables === 'function' ? variables(data) : variables,
413 })
414​
415 setState(old => ({
416 ...old,
417 [queryHash]: {
418 ...old[queryHash],
419 data,
420 },
421 }))
422 })
423 },
424 [setState]
425 )
427​
428export function useMutation(
429 mutation,
430 { refetchQueries: defaultRefetchQueries } = {}
431) {
432 const [data, setData] = React.useState(null)
433 const [error, setError] = React.useState(null)
434 const [isLoading, setIsLoading] = React.useState(false)
435 const refetchQueries = useRefetchQueries()
436 const updateQueries = useUpdateQueries()
437​
438 const mutate = React.useCallback(
439 async (
440 variables,
441 {
442 refetchQueries: userRefetchQueries = defaultRefetchQueries,
443 updateQueries: userUpdateQueries,
444 waitForRefetchQueries,
445 } = {}
446 ) => {
447 setIsLoading(true)
448 try {
449 const res = await mutation(variables)
450 setData(res)
451 if (userRefetchQueries) {
452 await refetchQueries(userRefetchQueries, {
453 waitForRefetchQueries,
454 })
455 }
456 if (userUpdateQueries) {
457 updateQueries(userUpdateQueries, res)
458 }
459 } catch (err) {
460 console.error(err)
461 setError(err)
462 } finally {
463 setIsLoading(false)
464 }
465 },
466 [defaultRefetchQueries, mutation, refetchQueries, updateQueries]
467 )
468​
469 return [mutate, { data, isLoading, error }]
471​
472export function useIsFetching() {
473 const [state] = React.useContext(context)
474 return React.useMemo(() => {
475 return Object.keys(state).some(key => state[key].isFetching)
476 }, [state])
478​
479export function useRefetchAll() {
480 const [, , metaRef] = React.useContext(context)
481 return React.useCallback(() => {
482 Object.keys(metaRef.current).forEach(key => {
483 Object.keys(metaRef.current[key].instancesByID).forEach(key2 => {
484 metaRef.current[key].instancesByID[key2].refetchRef.current()
485 })
486 })
487 }, [metaRef])