Open History to see the last commit
1import { waitFor, fireEvent } from '@testing-library/react'
2import React from 'react'
3β
4import * as QueriesObserverModule from '../../core/queriesObserver'
5β
6import {
7 expectType,
8 expectTypeNotAny,
9 queryKey,
10 renderWithClient,
11 setActTimeout,
12 sleep,
13} from './utils'
14import {
15 useQueries,
16 QueryClient,
17 UseQueryResult,
18 QueryCache,
19 QueryObserverResult,
20 QueriesObserver,
21 QueryFunction,
22 UseQueryOptions,
23 QueryKey,
24} from '../..'
25import { EnsuredQueryKey, QueryFunctionContext } from '../../core'
26β
27describe('useQueries', () => {
28 const queryCache = new QueryCache()
29 const queryClient = new QueryClient({ queryCache })
30β
31 it('should return the correct states', async () => {
32 const key1 = queryKey()
33 const key2 = queryKey()
34 const results: UseQueryResult[][] = []
35β
36 function Page() {
37 const result = useQueries([
38 {
39 queryKey: key1,
40 queryFn: async () => {
41 await sleep(5)
42 return 1
43 },
44 },
45 {
46 queryKey: key2,
47 queryFn: async () => {
48 await sleep(10)
49 return 2
50 },
51 },
52 ])
53 results.push(result)
54 return null
55 }
56β
57 renderWithClient(queryClient, <Page />)
58β
59 await sleep(30)
60β
61 expect(results.length).toBe(3)
62 expect(results[0]).toMatchObject([{ data: undefined }, { data: undefined }])
63 expect(results[1]).toMatchObject([{ data: 1 }, { data: undefined }])
64 expect(results[2]).toMatchObject([{ data: 1 }, { data: 2 }])
65 })
66β
67 it('should keep previous data if amount of queries is the same', async () => {
68 const key1 = queryKey()
69 const key2 = queryKey()
70 const states: UseQueryResult[][] = []
71β
72 function Page() {
73 const [count, setCount] = React.useState(1)
74 const result = useQueries([
75 {
76 queryKey: [key1, count],
77 keepPreviousData: true,
78 queryFn: async () => {
79 await sleep(5)
80 return count * 2
81 },
82 },
83 {
84 queryKey: [key2, count],
85 keepPreviousData: true,
86 queryFn: async () => {
87 await sleep(10)
88 return count * 5
89 },
90 },
91 ])
92 states.push(result)
93β
94 React.useEffect(() => {
95 setActTimeout(() => {
96 setCount(prev => prev + 1)
97 }, 20)
98 }, [])
99β
100 return null
101 }
102β
103 renderWithClient(queryClient, <Page />)
104β
105 await waitFor(() => expect(states.length).toBe(7))
106β
107 expect(states[0]).toMatchObject([
108 {
109 status: 'loading',
110 data: undefined,
111 isPreviousData: false,
112 isFetching: true,
113 },
114 {
115 status: 'loading',
116 data: undefined,
117 isPreviousData: false,
118 isFetching: true,
119 },
120 ])
121 expect(states[1]).toMatchObject([
122 { status: 'success', data: 2, isPreviousData: false, isFetching: false },
123 {
124 status: 'loading',
125 data: undefined,
126 isPreviousData: false,
127 isFetching: true,
128 },
129 ])
130 expect(states[2]).toMatchObject([
131 { status: 'success', data: 2, isPreviousData: false, isFetching: false },
132 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
133 ])
134 expect(states[3]).toMatchObject([
135 { status: 'success', data: 2, isPreviousData: true, isFetching: true },
136 { status: 'success', data: 5, isPreviousData: true, isFetching: true },
137 ])
138 expect(states[4]).toMatchObject([
139 { status: 'success', data: 2, isPreviousData: true, isFetching: true },
140 { status: 'success', data: 5, isPreviousData: true, isFetching: true },
141 ])
142 expect(states[5]).toMatchObject([
143 { status: 'success', data: 4, isPreviousData: false, isFetching: false },
144 { status: 'success', data: 5, isPreviousData: true, isFetching: true },
145 ])
146 expect(states[6]).toMatchObject([
147 { status: 'success', data: 4, isPreviousData: false, isFetching: false },
148 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
149 ])
150 })
151β
152 it('should keep previous data for variable amounts of useQueries', async () => {
153 const key = queryKey()
154 const states: UseQueryResult[][] = []
155β
156 function Page() {
157 const [count, setCount] = React.useState(2)
158 const result = useQueries(
159 Array.from({ length: count }, (_, i) => ({
160 queryKey: [key, count, i + 1],
161 keepPreviousData: true,
162 queryFn: async () => {
163 await sleep(5 * (i + 1))
164 return (i + 1) * count * 2
165 },
166 }))
167 )
168β
169 states.push(result)
170β
171 React.useEffect(() => {
172 setActTimeout(() => {
173 setCount(prev => prev + 1)
174 }, 20)
175 }, [])
176β
177 return null
178 }
179β
180 renderWithClient(queryClient, <Page />)
181β
182 await waitFor(() => expect(states.length).toBe(8))
183β
184 expect(states[0]).toMatchObject([
185 {
186 status: 'loading',
187 data: undefined,
188 isPreviousData: false,
189 isFetching: true,
190 },
191 {
192 status: 'loading',
193 data: undefined,
194 isPreviousData: false,
195 isFetching: true,
196 },
197 ])
198 expect(states[1]).toMatchObject([
199 { status: 'success', data: 4, isPreviousData: false, isFetching: false },
200 {
201 status: 'loading',
202 data: undefined,
203 isPreviousData: false,
204 isFetching: true,
205 },
206 ])
207 expect(states[2]).toMatchObject([
208 { status: 'success', data: 4, isPreviousData: false, isFetching: false },
209 { status: 'success', data: 8, isPreviousData: false, isFetching: false },
210 ])
211β
212 expect(states[3]).toMatchObject([
213 { status: 'success', data: 4, isPreviousData: true, isFetching: true },
214 { status: 'success', data: 8, isPreviousData: true, isFetching: true },
215 {
216 status: 'loading',
217 data: undefined,
218 isPreviousData: false,
219 isFetching: true,
220 },
221 ])
222 expect(states[4]).toMatchObject([
223 { status: 'success', data: 4, isPreviousData: true, isFetching: true },
224 { status: 'success', data: 8, isPreviousData: true, isFetching: true },
225 {
226 status: 'loading',
227 data: undefined,
228 isPreviousData: false,
229 isFetching: true,
230 },
231 ])
232 expect(states[5]).toMatchObject([
233 { status: 'success', data: 6, isPreviousData: false, isFetching: false },
234 { status: 'success', data: 8, isPreviousData: true, isFetching: true },
235 {
236 status: 'loading',
237 data: undefined,
238 isPreviousData: false,
239 isFetching: true,
240 },
241 ])
242 expect(states[6]).toMatchObject([
243 { status: 'success', data: 6, isPreviousData: false, isFetching: false },
244 { status: 'success', data: 12, isPreviousData: false, isFetching: false },
245 {
246 status: 'loading',
247 data: undefined,
248 isPreviousData: false,
249 isFetching: true,
250 },
251 ])
252 expect(states[7]).toMatchObject([
253 { status: 'success', data: 6, isPreviousData: false, isFetching: false },
254 { status: 'success', data: 12, isPreviousData: false, isFetching: false },
255 { status: 'success', data: 18, isPreviousData: false, isFetching: false },
256 ])
257 })
258β
259 it('should keep previous data when switching between queries', async () => {
260 const key = queryKey()
261 const states: UseQueryResult[][] = []
262β
263 function Page() {
264 const [series1, setSeries1] = React.useState(1)
265 const [series2, setSeries2] = React.useState(2)
266 const ids = [series1, series2]
267β
268 const result = useQueries(
269 ids.map(id => {
270 return {
271 queryKey: [key, id],
272 queryFn: async () => {
273 await sleep(5)
274 return id * 5
275 },
276 keepPreviousData: true,
277 }
278 })
279 )
280β
281 states.push(result)
282β
283 React.useEffect(() => {
284 setActTimeout(() => {
285 setSeries2(3)
286 }, 20)
287 }, [])
288β
289 React.useEffect(() => {
290 setActTimeout(() => {
291 setSeries1(2)
292 }, 50)
293 }, [])
294β
295 return null
296 }
297β
298 renderWithClient(queryClient, <Page />)
299β
300 await waitFor(() => expect(states.length).toBe(9))
301β
302 expect(states[0]).toMatchObject([
303 {
304 status: 'loading',
305 data: undefined,
306 isPreviousData: false,
307 isFetching: true,
308 },
309 {
310 status: 'loading',
311 data: undefined,
312 isPreviousData: false,
313 isFetching: true,
314 },
315 ])
316 expect(states[1]).toMatchObject([
317 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
318 {
319 status: 'loading',
320 data: undefined,
321 isPreviousData: false,
322 isFetching: true,
323 },
324 ])
325 expect(states[2]).toMatchObject([
326 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
327 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
328 ])
329 expect(states[3]).toMatchObject([
330 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
331 { status: 'success', data: 10, isPreviousData: true, isFetching: true },
332 ])
333 expect(states[4]).toMatchObject([
334 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
335 { status: 'success', data: 10, isPreviousData: true, isFetching: true },
336 ])
337 expect(states[5]).toMatchObject([
338 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
339 { status: 'success', data: 15, isPreviousData: false, isFetching: false },
340 ])
341 expect(states[6]).toMatchObject([
342 { status: 'success', data: 10, isPreviousData: false, isFetching: true },
343 { status: 'success', data: 15, isPreviousData: false, isFetching: false },
344 ])
345 expect(states[7]).toMatchObject([
346 { status: 'success', data: 10, isPreviousData: false, isFetching: true },
347 { status: 'success', data: 15, isPreviousData: false, isFetching: false },
348 ])
349 expect(states[8]).toMatchObject([
350 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
351 { status: 'success', data: 15, isPreviousData: false, isFetching: false },
352 ])
353 })
354β
355 it('should not go to infinite render loop with previous data when toggling queries', async () => {
356 const key = queryKey()
357 const states: UseQueryResult[][] = []
358β
359 function Page() {
360 const [enableId1, setEnableId1] = React.useState(true)
361 const ids = enableId1 ? [1, 2] : [2]
362β
363 const result = useQueries(
364 ids.map(id => {
365 return {
366 queryKey: [key, id],
367 queryFn: async () => {
368 await sleep(5)
369 return id * 5
370 },
371 keepPreviousData: true,
372 }
373 })
374 )
375β
376 states.push(result)
377β
378 React.useEffect(() => {
379 setActTimeout(() => {
380 setEnableId1(false)
381 }, 20)
382β
383 setActTimeout(() => {
384 setEnableId1(true)
385 }, 30)
386 }, [])
387β
388 return null
389 }
390β
391 renderWithClient(queryClient, <Page />)
392β
393 await waitFor(() => expect(states.length).toBe(8))
394β
395 expect(states[0]).toMatchObject([
396 {
397 status: 'loading',
398 data: undefined,
399 isPreviousData: false,
400 isFetching: true,
401 },
402 {
403 status: 'loading',
404 data: undefined,
405 isPreviousData: false,
406 isFetching: true,
407 },
408 ])
409 expect(states[1]).toMatchObject([
410 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
411 {
412 status: 'loading',
413 data: undefined,
414 isPreviousData: false,
415 isFetching: true,
416 },
417 ])
418 expect(states[2]).toMatchObject([
419 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
420 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
421 ])
422 expect(states[3]).toMatchObject([
423 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
424 ])
425 expect(states[4]).toMatchObject([
426 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
427 ])
428 expect(states[5]).toMatchObject([
429 { status: 'success', data: 5, isPreviousData: false, isFetching: true },
430 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
431 ])
432 expect(states[6]).toMatchObject([
433 { status: 'success', data: 5, isPreviousData: false, isFetching: true },
434 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
435 ])
436 expect(states[7]).toMatchObject([
437 { status: 'success', data: 5, isPreviousData: false, isFetching: false },
438 { status: 'success', data: 10, isPreviousData: false, isFetching: false },
439 ])
440 })
441β
442 it('handles type parameter - tuple of tuples', async () => {
443 const key1 = queryKey()
444 const key2 = queryKey()
445 const key3 = queryKey()
446β
447 // @ts-expect-error (Page component is not rendered)
448 // eslint-disable-next-line
449 function Page() {
450 const result1 = useQueries<[[number], [string], [string[], boolean]]>([
451 {
452 queryKey: key1,
453 queryFn: () => 1,
454 },
455 {
456 queryKey: key2,
457 queryFn: () => 'string',
458 },
459 {
460 queryKey: key3,
461 queryFn: () => ['string[]'],
462 },
463 ])
464 expectType<QueryObserverResult<number, unknown>>(result1[0])
465 expectType<QueryObserverResult<string, unknown>>(result1[1])
466 expectType<QueryObserverResult<string[], boolean>>(result1[2])
467 expectType<number | undefined>(result1[0].data)
468 expectType<string | undefined>(result1[1].data)
469 expectType<string[] | undefined>(result1[2].data)
470 expectType<boolean | null>(result1[2].error)
471β
472 // TData (3rd element) takes precedence over TQueryFnData (1st element)
473 const result2 = useQueries<
474 [[string, unknown, string], [string, unknown, number]]
475 >([
476 {
477 queryKey: key1,
478 queryFn: () => 'string',
479 select: a => {
480 expectType<string>(a)
481 expectTypeNotAny(a)
482 return a.toLowerCase()
483 },
484 },
485 {
486 queryKey: key2,
487 queryFn: () => 'string',
488 select: a => {
489 expectType<string>(a)
490 expectTypeNotAny(a)
491 return parseInt(a)
492 },
493 },
494 ])
495 expectType<QueryObserverResult<string, unknown>>(result2[0])
496 expectType<QueryObserverResult<number, unknown>>(result2[1])
497 expectType<string | undefined>(result2[0].data)
498 expectType<number | undefined>(result2[1].data)
499β
500 // types should be enforced
501 useQueries<[[string, unknown, string], [string, boolean, number]]>([
502 {
503 queryKey: key1,
504 queryFn: () => 'string',
505 select: a => {
506 expectType<string>(a)
507 expectTypeNotAny(a)
508 return a.toLowerCase()
509 },
510 onSuccess: a => {
511 expectType<string>(a)
512 expectTypeNotAny(a)
513 },
514 placeholderData: 'string',
515 // @ts-expect-error (initialData: string)
516 initialData: 123,
517 },
518 {
519 queryKey: key2,
520 queryFn: () => 'string',
521 select: a => {
522 expectType<string>(a)
523 expectTypeNotAny(a)
524 return parseInt(a)
525 },
526 onSuccess: a => {
527 expectType<number>(a)
528 expectTypeNotAny(a)
529 },
530 onError: e => {
531 expectType<boolean>(e)
532 expectTypeNotAny(e)
533 },
534 placeholderData: 'string',
535 // @ts-expect-error (initialData: string)
536 initialData: 123,
537 },
538 ])
539β
540 // field names should be enforced
541 useQueries<[[string]]>([
542 {
543 queryKey: key1,
544 queryFn: () => 'string',
545 // @ts-expect-error (invalidField)
546 someInvalidField: [],
547 },
548 ])
549 }
550 })
551β
552 it('handles type parameter - tuple of objects', async () => {
553 const key1 = queryKey()
554 const key2 = queryKey()
555 const key3 = queryKey()
556β
557 // @ts-expect-error (Page component is not rendered)
558 // eslint-disable-next-line
559 function Page() {
560 const result1 = useQueries<
561 [
562 { queryFnData: number },
563 { queryFnData: string },
564 { queryFnData: string[]; error: boolean }
565 ]
566 >([
567 {
568 queryKey: key1,
569 queryFn: () => 1,
570 },
571 {
572 queryKey: key2,
573 queryFn: () => 'string',
574 },
575 {
576 queryKey: key3,
577 queryFn: () => ['string[]'],
578 },
579 ])
580 expectType<QueryObserverResult<number, unknown>>(result1[0])
581 expectType<QueryObserverResult<string, unknown>>(result1[1])
582 expectType<QueryObserverResult<string[], boolean>>(result1[2])
583 expectType<number | undefined>(result1[0].data)
584 expectType<string | undefined>(result1[1].data)
585 expectType<string[] | undefined>(result1[2].data)
586 expectType<boolean | null>(result1[2].error)
587β
588 // TData (data prop) takes precedence over TQueryFnData (queryFnData prop)
589 const result2 = useQueries<
590 [
591 { queryFnData: string; data: string },
592 { queryFnData: string; data: number }
593 ]
594 >([
595 {
596 queryKey: key1,
597 queryFn: () => 'string',
598 select: a => {
599 expectType<string>(a)
600 expectTypeNotAny(a)
601 return a.toLowerCase()
602 },
603 },
604 {
605 queryKey: key2,
606 queryFn: () => 'string',
607 select: a => {
608 expectType<string>(a)
609 expectTypeNotAny(a)
610 return parseInt(a)
611 },
612 },
613 ])
614 expectType<QueryObserverResult<string, unknown>>(result2[0])
615 expectType<QueryObserverResult<number, unknown>>(result2[1])
616 expectType<string | undefined>(result2[0].data)
617 expectType<number | undefined>(result2[1].data)
618β
619 // can pass only TData (data prop) although TQueryFnData will be left unknown
620 const result3 = useQueries<[{ data: string }, { data: number }]>([
621 {
622 queryKey: key1,
623 queryFn: () => 'string',
624 select: a => {
625 expectType<unknown>(a)
626 expectTypeNotAny(a)
627 return a as string
628 },
629 },
630 {
631 queryKey: key2,
632 queryFn: () => 'string',
633 select: a => {
634 expectType<unknown>(a)
635 expectTypeNotAny(a)
636 return a as number
637 },
638 },
639 ])
640 expectType<QueryObserverResult<string, unknown>>(result3[0])
641 expectType<QueryObserverResult<number, unknown>>(result3[1])
642 expectType<string | undefined>(result3[0].data)
643 expectType<number | undefined>(result3[1].data)
644β
645 // types should be enforced
646 useQueries<
647 [
648 { queryFnData: string; data: string },
649 { queryFnData: string; data: number; error: boolean }
650 ]
651 >([
652 {
653 queryKey: key1,
654 queryFn: () => 'string',
655 select: a => {
656 expectType<string>(a)
657 expectTypeNotAny(a)
658 return a.toLowerCase()
659 },
660 onSuccess: a => {
661 expectType<string>(a)
662 expectTypeNotAny(a)
663 },
664 placeholderData: 'string',
665 // @ts-expect-error (initialData: string)
666 initialData: 123,
667 },
668 {
669 queryKey: key2,
670 queryFn: () => 'string',
671 select: a => {
672 expectType<string>(a)
673 expectTypeNotAny(a)
674 return parseInt(a)
675 },
676 onSuccess: a => {
677 expectType<number>(a)
678 expectTypeNotAny(a)
679 },
680 onError: e => {
681 expectType<boolean>(e)
682 expectTypeNotAny(e)
683 },
684 placeholderData: 'string',
685 // @ts-expect-error (initialData: string)
686 initialData: 123,
687 },
688 ])
689β
690 // field names should be enforced
691 useQueries<[{ queryFnData: string }]>([
692 {
693 queryKey: key1,
694 queryFn: () => 'string',
695 // @ts-expect-error (invalidField)
696 someInvalidField: [],
697 },
698 ])
699 }
700 })
701β
702 it('handles array literal without type parameter to infer result type', async () => {
703 const key1 = queryKey()
704 const key2 = queryKey()
705 const key3 = queryKey()
706 const key4 = queryKey()
707β
708 // @ts-expect-error (Page component is not rendered)
709 // eslint-disable-next-line
710 function Page() {
711 // Array.map preserves TQueryFnData
712 const result1 = useQueries(
713 Array(50).map((_, i) => ({
714 queryKey: ['key', i] as const,
715 queryFn: () => i + 10,
716 }))
717 )
718 expectType<QueryObserverResult<number, unknown>[]>(result1)
719 expectType<number | undefined>(result1[0]?.data)
720β
721 // Array.map preserves TData
722 const result2 = useQueries(
723 Array(50).map((_, i) => ({
724 queryKey: ['key', i] as const,
725 queryFn: () => i + 10,
726 select: (data: number) => data.toString(),
727 }))
728 )
729 expectType<QueryObserverResult<string, unknown>[]>(result2)
730β
731 const result3 = useQueries([
732 {
733 queryKey: key1,
734 queryFn: () => 1,
735 },
736 {
737 queryKey: key2,
738 queryFn: () => 'string',
739 },
740 {
741 queryKey: key3,
742 queryFn: () => ['string[]'],
743 select: () => 123,
744 },
745 ])
746 expectType<QueryObserverResult<number, unknown>>(result3[0])
747 expectType<QueryObserverResult<string, unknown>>(result3[1])
748 expectType<QueryObserverResult<number, unknown>>(result3[2])
749 expectType<number | undefined>(result3[0].data)
750 expectType<string | undefined>(result3[1].data)
751 // select takes precedence over queryFn
752 expectType<number | undefined>(result3[2].data)
753β
754 // initialData/placeholderData are enforced
755 useQueries([
756 {
757 queryKey: key1,
758 queryFn: () => 'string',
759 placeholderData: 'string',
760 // @ts-expect-error (initialData: string)
761 initialData: 123,
762 },
763 {
764 queryKey: key2,
765 queryFn: () => 123,
766 // @ts-expect-error (placeholderData: number)
767 placeholderData: 'string',
768 initialData: 123,
769 },
770 ])
771β
772 // select / onSuccess / onSettled params are "indirectly" enforced
773 useQueries([
774 // unfortunately TS will not suggest the type for you
775 {
776 queryKey: key1,
777 queryFn: () => 'string',
778 // @ts-expect-error (noImplicitAny)
779 onSuccess: a => null,
780 // @ts-expect-error (noImplicitAny)
781 onSettled: a => null,
782 },
783 // however you can add a type to the callback
784 {
785 queryKey: key2,
786 queryFn: () => 'string',
787 onSuccess: (a: string) => {
788 expectType<string>(a)
789 expectTypeNotAny(a)
790 },
791 onSettled: (a: string | undefined) => {
792 expectType<string | undefined>(a)
793 expectTypeNotAny(a)
794 },
795 },
796 // the type you do pass is enforced
797 {
798 queryKey: key3,
799 queryFn: () => 'string',
800 // @ts-expect-error (only accepts string)
801 onSuccess: (a: number) => null,
802 },
803 {
804 queryKey: key4,
805 queryFn: () => 'string',
806 select: (a: string) => parseInt(a),
807 // @ts-expect-error (select is defined => only accepts number)
808 onSuccess: (a: string) => null,
809 onSettled: (a: number | undefined) => {
810 expectType<number | undefined>(a)
811 expectTypeNotAny(a)
812 },
813 },
814 ])
815β
816 // callbacks are also indirectly enforced with Array.map
817 useQueries(
818 // @ts-expect-error (onSuccess only accepts string)
819 Array(50).map((_, i) => ({
820 queryKey: ['key', i] as const,
821 queryFn: () => i + 10,
822 select: (data: number) => data.toString(),
823 onSuccess: (_data: number) => null,
824 }))
825 )
826 useQueries(
827 Array(50).map((_, i) => ({
828 queryKey: ['key', i] as const,
829 queryFn: () => i + 10,
830 select: (data: number) => data.toString(),
831 onSuccess: (_data: string) => null,
832 }))
833 )
834β
835 // results inference works when all the handlers are defined
836 const result4 = useQueries([
837 {
838 queryKey: key1,
839 queryFn: () => 'string',
840 // @ts-expect-error (noImplicitAny)
841 onSuccess: a => null,
842 // @ts-expect-error (noImplicitAny)
843 onSettled: a => null,
844 },
845 {
846 queryKey: key2,
847 queryFn: () => 'string',
848 onSuccess: (a: string) => {
849 expectType<string>(a)
850 expectTypeNotAny(a)
851 },
852 onSettled: (a: string | undefined) => {
853 expectType<string | undefined>(a)
854 expectTypeNotAny(a)
855 },
856 },
857 {
858 queryKey: key4,
859 queryFn: () => 'string',
860 select: (a: string) => parseInt(a),
861 onSuccess: (_a: number) => null,
862 onSettled: (a: number | undefined) => {
863 expectType<number | undefined>(a)
864 expectTypeNotAny(a)
865 },
866 },
867 ])
868 expectType<QueryObserverResult<string, unknown>>(result4[0])
869 expectType<QueryObserverResult<string, unknown>>(result4[1])
870 expectType<QueryObserverResult<number, unknown>>(result4[2])
871β
872 // Array as const does not throw error
873 const result5 = useQueries([
874 {
875 queryKey: 'key1',
876 queryFn: () => 'string',
877 },
878 {
879 queryKey: 'key1',
880 queryFn: () => 123,
881 },
882 ] as const)
883 expectType<QueryObserverResult<string, unknown>>(result5[0])
884 expectType<QueryObserverResult<number, unknown>>(result5[1])
885β
886 // field names should be enforced - array literal
887 useQueries([
888 {
889 queryKey: key1,
890 queryFn: () => 'string',
891 // @ts-expect-error (invalidField)
892 someInvalidField: [],
893 },
894 ])
895β
896 // field names should be enforced - Array.map() result
897 useQueries(
898 // @ts-expect-error (invalidField)
899 Array(10).map(() => ({
900 someInvalidField: '',
901 }))
902 )
903 }
904 })
905β
906 it('handles strongly typed queryFn factories and useQueries wrappers', () => {
907 // QueryKey + queryFn factory
908 type QueryKeyA = ['queryA']
909 const getQueryKeyA = (): QueryKeyA => ['queryA']
910 type GetQueryFunctionA = () => QueryFunction<number, QueryKeyA>
911 const getQueryFunctionA: GetQueryFunctionA = () => async () => {
912 return 1
913 }
914 type SelectorA = (data: number) => [number, string]
915 const getSelectorA = (): SelectorA => data => [data, data.toString()]
916β
917 type QueryKeyB = ['queryB', string]
918 const getQueryKeyB = (id: string): QueryKeyB => ['queryB', id]
919 type GetQueryFunctionB = () => QueryFunction<string, QueryKeyB>
920 const getQueryFunctionB: GetQueryFunctionB = () => async () => {
921 return '1'
922 }
923 type SelectorB = (data: string) => [string, number]
924 const getSelectorB = (): SelectorB => data => [data, +data]
925β
926 // Wrapper with strongly typed array-parameter
927 function useWrappedQueries<
928 TQueryFnData,
929 TError,
930 TData,
931 TQueryKey extends QueryKey
932 >(queries: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>[]) {
933 return useQueries(
934 queries.map(
935 // no need to type the mapped query
936 query => {
937 const { queryFn: fn, queryKey: key, onError: err } = query
938 expectType<QueryFunction<TQueryFnData, TQueryKey> | undefined>(fn)
939 return {
940 queryKey: key,
941 onError: err,
942 queryFn: (ctx: QueryFunctionContext<TQueryKey>) => {
943 expectType<EnsuredQueryKey<TQueryKey>>(ctx.queryKey)
944 return fn?.call({}, ctx)
945 },
946 }
947 }
948 )
949 )
950 }
951β
952 // @ts-expect-error (Page component is not rendered)
953 // eslint-disable-next-line
954 function Page() {
955 const result = useQueries([
956 {
957 queryKey: getQueryKeyA(),
958 queryFn: getQueryFunctionA(),
959 },
960 {
961 queryKey: getQueryKeyB('id'),
962 queryFn: getQueryFunctionB(),
963 },
964 ])
965 expectType<QueryObserverResult<number, unknown>>(result[0])
966 expectType<QueryObserverResult<string, unknown>>(result[1])
967β
968 const withSelector = useQueries([
969 {
970 queryKey: getQueryKeyA(),
971 queryFn: getQueryFunctionA(),
972 select: getSelectorA(),
973 },
974 {
975 queryKey: getQueryKeyB('id'),
976 queryFn: getQueryFunctionB(),
977 select: getSelectorB(),
978 },
979 ])
980 expectType<QueryObserverResult<[number, string], unknown>>(
981 withSelector[0]
982 )
983 expectType<QueryObserverResult<[string, number], unknown>>(
984 withSelector[1]
985 )
986β
987 const withWrappedQueries = useWrappedQueries(
988 Array(10).map(() => ({
989 queryKey: getQueryKeyA(),
990 queryFn: getQueryFunctionA(),
991 select: getSelectorA(),
992 }))
993 )
994β
995 expectType<QueryObserverResult<number | undefined, unknown>[]>(
996 withWrappedQueries
997 )
998 }
999 })
1000β
1001 it('should not change state if unmounted', async () => {
1002 const key1 = queryKey()
1003β
1004 // We have to mock the QueriesObserver to not unsubscribe
1005 // the listener when the component is unmounted
1006 class QueriesObserverMock extends QueriesObserver {
1007 subscribe(listener: any) {
1008 super.subscribe(listener)
1009 return () => void 0
1010 }
1011 }
1012β
1013 const QueriesObserverSpy = jest
1014 .spyOn(QueriesObserverModule, 'QueriesObserver')
1015 .mockImplementation(fn => {
1016 return new QueriesObserverMock(fn)
1017 })
1018β
1019 function Queries() {
1020 useQueries([
1021 {
1022 queryKey: key1,
1023 queryFn: async () => {
1024 await sleep(10)
1025 return 1
1026 },
1027 },
1028 ])
1029β
1030 return (
1031 <div>
1032 <span>queries</span>
1033 </div>
1034 )
1035 }
1036β
1037 function Page() {
1038 const [mounted, setMounted] = React.useState(true)
1039β
1040 return (
1041 <div>
1042 <button onClick={() => setMounted(false)}>unmount</button>
1043 {mounted && <Queries />}
1044 </div>
1045 )
1046 }
1047β
1048 const { getByText } = renderWithClient(queryClient, <Page />)
1049 fireEvent.click(getByText('unmount'))
1050β
1051 // Should not display the console error
1052 // "Warning: Can't perform a React state update on an unmounted component"
1053β
1054 await sleep(20)
1055 QueriesObserverSpy.mockRestore()
1056 })
1057})