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