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

createQueries.test.tsx

718 lines20.4 KB

1import { describe, expect, expectTypeOf, it, vi } from 'vitest'
2import { fireEvent, render, waitFor } from '@solidjs/testing-library'
3import * as QueryCore from '@tanstack/query-core'
4​
5import { createRenderEffect, createSignal } from 'solid-js'
6import {
7 QueriesObserver,
8 QueryCache,
9 QueryClientProvider,
10 createQueries,
11} from '..'
12import { createQueryClient, expectTypeNotAny, queryKey, sleep } from './utils'
13import type { QueryFunctionContext, QueryKey } from '@tanstack/query-core'
14import type {
15 CreateQueryResult,
16 QueryFunction,
17 QueryObserverResult,
18 SolidQueryOptions,
19} from '..'
20​
21describe('useQueries', () => {
22 const queryCache = new QueryCache()
23 const queryClient = createQueryClient({ queryCache })
24​
25 it('should return the correct states', async () => {
26 const key1 = queryKey()
27 const key2 = queryKey()
28 const results: Array<Array<CreateQueryResult>> = []
29​
30 function Page() {
31 const result = createQueries(() => ({
32 queries: [
33 {
34 queryKey: key1,
35 queryFn: async () => {
36 await sleep(10)
37 return 1
38 },
39 },
40 {
41 queryKey: key2,
42 queryFn: async () => {
43 await sleep(100)
44 return 2
45 },
46 },
47 ],
48 }))
49​
50 createRenderEffect(() => {
51 results.push([{ ...result[0] }, { ...result[1] }])
52 })
53​
54 return (
55 <div>
56 <div>
57 data1: {String(result[0].data ?? 'null')}, data2:{' '}
58 {String(result[1].data ?? 'null')}
59 </div>
60 </div>
61 )
62 }
63​
64 const rendered = render(() => (
65 <QueryClientProvider client={queryClient}>
66 <Page />
67 </QueryClientProvider>
68 ))
69​
70 await waitFor(() => rendered.getByText('data1: 1, data2: 2'))
71​
72 expect(results.length).toBe(3)
73 expect(results[0]).toMatchObject([{ data: undefined }, { data: undefined }])
74 expect(results[1]).toMatchObject([{ data: 1 }, { data: undefined }])
75 expect(results[2]).toMatchObject([{ data: 1 }, { data: 2 }])
76 })
77​
78 it('handles type parameter - tuple of tuples', async () => {
79 const key1 = queryKey()
80 const key2 = queryKey()
81 const key3 = queryKey()
82​
83 // @ts-expect-error (Page component is not rendered)
84 // eslint-disable-next-line
85 function Page() {
86 const result1 = createQueries<
87 [[number], [string], [Array<string>, boolean]]
88 >(() => ({
89 queries: [
90 {
91 queryKey: key1,
92 queryFn: () => 1,
93 },
94 {
95 queryKey: key2,
96 queryFn: () => 'string',
97 },
98 {
99 queryKey: key3,
100 queryFn: () => ['string[]'],
101 },
102 ],
103 }))
104 expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
105 expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
106 expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
107 expectTypeOf<number | undefined>(result1[0].data)
108 expectTypeOf<string | undefined>(result1[1].data)
109 expectTypeOf<Array<string> | undefined>(result1[2].data)
110 expectTypeOf<boolean | null>(result1[2].error)
111​
112 // TData (3rd element) takes precedence over TQueryFnData (1st element)
113 const result2 = createQueries<
114 [[string, unknown, string], [string, unknown, number]]
115 >(() => ({
116 queries: [
117 {
118 queryKey: key1,
119 queryFn: () => 'string',
120 select: (a) => {
121 expectTypeOf<string>(a)
122 expectTypeNotAny(a)
123 return a.toLowerCase()
124 },
125 },
126 {
127 queryKey: key2,
128 queryFn: () => 'string',
129 select: (a) => {
130 expectTypeOf<string>(a)
131 expectTypeNotAny(a)
132 return parseInt(a)
133 },
134 },
135 ],
136 }))
137 expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
138 expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
139 expectTypeOf<string | undefined>(result2[0].data)
140 expectTypeOf<number | undefined>(result2[1].data)
141​
142 // types should be enforced
143 createQueries<[[string, unknown, string], [string, boolean, number]]>(
144 () => ({
145 queries: [
146 {
147 queryKey: key1,
148 queryFn: () => 'string',
149 select: (a) => {
150 expectTypeOf<string>(a)
151 expectTypeNotAny(a)
152 return a.toLowerCase()
153 },
154 placeholderData: 'string',
155 // @ts-expect-error (initialData: string)
156 initialData: 123,
157 },
158 {
159 queryKey: key2,
160 queryFn: () => 'string',
161 select: (a) => {
162 expectTypeOf<string>(a)
163 expectTypeNotAny(a)
164 return parseInt(a)
165 },
166 placeholderData: 'string',
167 // @ts-expect-error (initialData: string)
168 initialData: 123,
169 },
170 ],
171 }),
172 )
173​
174 // field names should be enforced
175 createQueries<[[string]]>(() => ({
176 queries: [
177 {
178 queryKey: key1,
179 queryFn: () => 'string',
180 },
181 ],
182 }))
183 }
184 })
185​
186 it('handles type parameter - tuple of objects', async () => {
187 const key1 = queryKey()
188 const key2 = queryKey()
189 const key3 = queryKey()
190​
191 // @ts-expect-error (Page component is not rendered)
192 // eslint-disable-next-line
193 function Page() {
194 const result1 = createQueries<
195 [
196 { queryFnData: number },
197 { queryFnData: string },
198 { queryFnData: Array<string>; error: boolean },
199 ]
200 >(() => ({
201 queries: [
202 {
203 queryKey: key1,
204 queryFn: () => 1,
205 },
206 {
207 queryKey: key2,
208 queryFn: () => 'string',
209 },
210 {
211 queryKey: key3,
212 queryFn: () => ['string[]'],
213 },
214 ],
215 }))
216 expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
217 expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
218 expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
219 expectTypeOf<number | undefined>(result1[0].data)
220 expectTypeOf<string | undefined>(result1[1].data)
221 expectTypeOf<Array<string> | undefined>(result1[2].data)
222 expectTypeOf<boolean | null>(result1[2].error)
223​
224 // TData (data prop) takes precedence over TQueryFnData (queryFnData prop)
225 const result2 = createQueries<
226 [
227 { queryFnData: string; data: string },
228 { queryFnData: string; data: number },
229 ]
230 >(() => ({
231 queries: [
232 {
233 queryKey: key1,
234 queryFn: () => 'string',
235 select: (a) => {
236 expectTypeOf<string>(a)
237 expectTypeNotAny(a)
238 return a.toLowerCase()
239 },
240 },
241 {
242 queryKey: key2,
243 queryFn: () => 'string',
244 select: (a) => {
245 expectTypeOf<string>(a)
246 expectTypeNotAny(a)
247 return parseInt(a)
248 },
249 },
250 ],
251 }))
252 expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
253 expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
254 expectTypeOf<string | undefined>(result2[0].data)
255 expectTypeOf<number | undefined>(result2[1].data)
256​
257 // can pass only TData (data prop) although TQueryFnData will be left unknown
258 const result3 = createQueries<[{ data: string }, { data: number }]>(
259 () => ({
260 queries: [
261 {
262 queryKey: key1,
263 queryFn: () => 'string',
264 select: (a) => {
265 expectTypeOf<unknown>(a)
266 expectTypeNotAny(a)
267 return a as string
268 },
269 },
270 {
271 queryKey: key2,
272 queryFn: () => 'string',
273 select: (a) => {
274 expectTypeOf<unknown>(a)
275 expectTypeNotAny(a)
276 return a as number
277 },
278 },
279 ],
280 }),
281 )
282 expectTypeOf<QueryObserverResult<string, unknown>>(result3[0])
283 expectTypeOf<QueryObserverResult<number, unknown>>(result3[1])
284 expectTypeOf<string | undefined>(result3[0].data)
285 expectTypeOf<number | undefined>(result3[1].data)
286​
287 // types should be enforced
288 createQueries<
289 [
290 { queryFnData: string; data: string },
291 { queryFnData: string; data: number; error: boolean },
292 ]
293 >(() => ({
294 queries: [
295 {
296 queryKey: key1,
297 queryFn: () => 'string',
298 select: (a) => {
299 expectTypeOf<string>(a)
300 expectTypeNotAny(a)
301 return a.toLowerCase()
302 },
303 placeholderData: 'string',
304 // @ts-expect-error (initialData: string)
305 initialData: 123,
306 },
307 {
308 queryKey: key2,
309 queryFn: () => 'string',
310 select: (a) => {
311 expectTypeOf<string>(a)
312 expectTypeNotAny(a)
313 return parseInt(a)
314 },
315 placeholderData: 'string',
316 // @ts-expect-error (initialData: string)
317 initialData: 123,
318 },
319 ],
320 }))
321​
322 // field names should be enforced
323 createQueries<[{ queryFnData: string }]>(() => ({
324 queries: [
325 {
326 queryKey: key1,
327 queryFn: () => 'string',
328 },
329 ],
330 }))
331 }
332 })
333​
334 it('handles array literal without type parameter to infer result type', async () => {
335 const key1 = queryKey()
336 const key2 = queryKey()
337 const key3 = queryKey()
338 const key4 = queryKey()
339​
340 // @ts-expect-error (Page component is not rendered)
341 // eslint-disable-next-line
342 function Page() {
343 // Array.map preserves TQueryFnData
344 const result1 = createQueries(() => ({
345 queries: Array(50).map((_, i) => ({
346 queryKey: ['key', i] as const,
347 queryFn: () => i + 10,
348 })),
349 }))
350 expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1)
351 expectTypeOf<number | undefined>(result1[0]?.data)
352​
353 // Array.map preserves TData
354 const result2 = createQueries(() => ({
355 queries: Array(50).map((_, i) => ({
356 queryKey: ['key', i] as const,
357 queryFn: () => i + 10,
358 select: (data: number) => data.toString(),
359 })),
360 }))
361 expectTypeOf<Array<QueryObserverResult<string, unknown>>>(result2)
362​
363 const result3 = createQueries(() => ({
364 queries: [
365 {
366 queryKey: key1,
367 queryFn: () => 1,
368 },
369 {
370 queryKey: key2,
371 queryFn: () => 'string',
372 },
373 {
374 queryKey: key3,
375 queryFn: () => ['string[]'],
376 select: () => 123,
377 },
378 ],
379 }))
380 expectTypeOf<QueryObserverResult<number, unknown>>(result3[0])
381 expectTypeOf<QueryObserverResult<string, unknown>>(result3[1])
382 expectTypeOf<QueryObserverResult<number, unknown>>(result3[2])
383 expectTypeOf<number | undefined>(result3[0].data)
384 expectTypeOf<string | undefined>(result3[1].data)
385 // select takes precedence over queryFn
386 expectTypeOf<number | undefined>(result3[2].data)
387​
388 // initialData/placeholderData are enforced
389 createQueries(() => ({
390 queries: [
391 {
392 queryKey: key1,
393 queryFn: () => 'string',
394 placeholderData: 'string',
395 // @ts-expect-error (initialData: string)
396 initialData: 123,
397 },
398 {
399 queryKey: key2,
400 queryFn: () => 123,
401 // @ts-expect-error (placeholderData: number)
402 placeholderData: 'string',
403 initialData: 123,
404 },
405 ],
406 }))
407​
408 // select params are "indirectly" enforced
409 createQueries(() => ({
410 queries: [
411 // unfortunately TS will not suggest the type for you
412 {
413 queryKey: key1,
414 queryFn: () => 'string',
415 },
416 // however you can add a type to the callback
417 {
418 queryKey: key2,
419 queryFn: () => 'string',
420 },
421 // the type you do pass is enforced
422 {
423 queryKey: key3,
424 queryFn: () => 'string',
425 },
426 {
427 queryKey: key4,
428 queryFn: () => 'string',
429 select: (a: string) => parseInt(a),
430 },
431 ],
432 }))
433​
434 // callbacks are also indirectly enforced with Array.map
435 createQueries(() => ({
436 queries: Array(50).map((_, i) => ({
437 queryKey: ['key', i] as const,
438 queryFn: () => i + 10,
439 select: (data: number) => data.toString(),
440 })),
441 }))
442​
443 createQueries(() => ({
444 queries: Array(50).map((_, i) => ({
445 queryKey: ['key', i] as const,
446 queryFn: () => i + 10,
447 select: (data: number) => data.toString(),
448 })),
449 }))
450​
451 // results inference works when all the handlers are defined
452 const result4 = createQueries(() => ({
453 queries: [
454 {
455 queryKey: key1,
456 queryFn: () => 'string',
457 },
458 {
459 queryKey: key2,
460 queryFn: () => 'string',
461 },
462 {
463 queryKey: key4,
464 queryFn: () => 'string',
465 select: (a: string) => parseInt(a),
466 },
467 ],
468 }))
469 expectTypeOf<QueryObserverResult<string, unknown>>(result4[0])
470 expectTypeOf<QueryObserverResult<string, unknown>>(result4[1])
471 expectTypeOf<QueryObserverResult<number, unknown>>(result4[2])
472​
473 // handles when queryFn returns a Promise
474 const result5 = createQueries(() => ({
475 queries: [
476 {
477 queryKey: key1,
478 queryFn: () => Promise.resolve('string'),
479 },
480 ],
481 }))
482 expectTypeOf<QueryObserverResult<string, unknown>>(result5[0])
483​
484 // Array as const does not throw error
485 const result6 = createQueries(
486 () =>
487 ({
488 queries: [
489 {
490 queryKey: ['key1'],
491 queryFn: () => 'string',
492 },
493 {
494 queryKey: ['key1'],
495 queryFn: () => 123,
496 },
497 ],
498 }) as const,
499 )
500 expectTypeOf<QueryObserverResult<string, unknown>>(result6[0])
501 expectTypeOf<QueryObserverResult<number, unknown>>(result6[1])
502​
503 // field names should be enforced - array literal
504 createQueries(() => ({
505 queries: [
506 {
507 queryKey: key1,
508 queryFn: () => 'string',
509 },
510 ],
511 }))
512​
513 // field names should be enforced - Array.map() result
514 createQueries(() => ({
515 // @ts-expect-error (invalidField)
516 queries: Array(10).map(() => ({
517 someInvalidField: '',
518 })),
519 }))
520​
521 // field names should be enforced - array literal
522 createQueries(() => ({
523 queries: [
524 {
525 queryKey: key1,
526 queryFn: () => 'string',
527 },
528 ],
529 }))
530​
531 // supports queryFn using fetch() to return Promise<any> - Array.map() result
532 createQueries(() => ({
533 queries: Array(50).map((_, i) => ({
534 queryKey: ['key', i] as const,
535 queryFn: () =>
536 fetch('return Promise<any>').then((resp) => resp.json()),
537 })),
538 }))
539​
540 // supports queryFn using fetch() to return Promise<any> - array literal
541 createQueries(() => ({
542 queries: [
543 {
544 queryKey: key1,
545 queryFn: () =>
546 fetch('return Promise<any>').then((resp) => resp.json()),
547 },
548 ],
549 }))
550 }
551 })
552​
553 it('handles strongly typed queryFn factories and useQueries wrappers', () => {
554 // QueryKey + queryFn factory
555 type QueryKeyA = ['queryA']
556 const getQueryKeyA = (): QueryKeyA => ['queryA']
557 type GetQueryFunctionA = () => QueryFunction<number, QueryKeyA>
558 const getQueryFunctionA: GetQueryFunctionA = () => async () => {
559 return 1
560 }
561 type SelectorA = (data: number) => [number, string]
562 const getSelectorA = (): SelectorA => (data) => [data, data.toString()]
563​
564 type QueryKeyB = ['queryB', string]
565 const getQueryKeyB = (id: string): QueryKeyB => ['queryB', id]
566 type GetQueryFunctionB = () => QueryFunction<string, QueryKeyB>
567 const getQueryFunctionB: GetQueryFunctionB = () => async () => {
568 return '1'
569 }
570 type SelectorB = (data: string) => [string, number]
571 const getSelectorB = (): SelectorB => (data) => [data, +data]
572​
573 // Wrapper with strongly typed array-parameter
574 function useWrappedQueries<
575 TQueryFnData,
576 TError,
577 TData,
578 TQueryKey extends QueryKey,
579 >(
580 queries: Array<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>,
581 ) {
582 return createQueries(() => ({
583 queries: queries.map(
584 // no need to type the mapped query
585 (query) => {
586 const { queryFn: fn, queryKey: key } = query
587 expectTypeOf<QueryFunction<TQueryFnData, TQueryKey> | undefined>(fn)
588 return {
589 queryKey: key,
590 queryFn: fn
591 ? (ctx: QueryFunctionContext<TQueryKey>) => {
592 expectTypeOf<TQueryKey>(ctx.queryKey)
593 return fn.call({}, ctx)
594 }
595 : undefined,
596 }
597 },
598 ),
599 }))
600 }
601​
602 // @ts-expect-error (Page component is not rendered)
603 // eslint-disable-next-line
604 function Page() {
605 const result = createQueries(() => ({
606 queries: [
607 {
608 queryKey: getQueryKeyA(),
609 queryFn: getQueryFunctionA(),
610 },
611 {
612 queryKey: getQueryKeyB('id'),
613 queryFn: getQueryFunctionB(),
614 },
615 ],
616 }))
617 expectTypeOf<QueryObserverResult<number, unknown>>(result[0])
618 expectTypeOf<QueryObserverResult<string, unknown>>(result[1])
619​
620 const withSelector = createQueries(() => ({
621 queries: [
622 {
623 queryKey: getQueryKeyA(),
624 queryFn: getQueryFunctionA(),
625 select: getSelectorA(),
626 },
627 {
628 queryKey: getQueryKeyB('id'),
629 queryFn: getQueryFunctionB(),
630 select: getSelectorB(),
631 },
632 ],
633 }))
634 expectTypeOf<QueryObserverResult<[number, string], unknown>>(
635 withSelector[0],
636 )
637 expectTypeOf<QueryObserverResult<[string, number], unknown>>(
638 withSelector[1],
639 )
640​
641 const withWrappedQueries = useWrappedQueries(
642 Array(10).map(() => ({
643 queryKey: getQueryKeyA(),
644 queryFn: getQueryFunctionA(),
645 select: getSelectorA(),
646 })),
647 )
648​
649 expectTypeOf<Array<QueryObserverResult<number | undefined, unknown>>>(
650 withWrappedQueries,
651 )
652 }
653 })
654​
655 it('should not change state if unmounted', async () => {
656 const key1 = queryKey()
657​
658 // We have to mock the QueriesObserver to not unsubscribe
659 // the listener when the component is unmounted
660 class QueriesObserverMock extends QueriesObserver {
661 subscribe(listener: any) {
662 super.subscribe(listener)
663 return () => void 0
664 }
665 }
666​
667 const QueriesObserverSpy = vi
668 .spyOn(QueryCore, 'QueriesObserver')
669 .mockImplementation((fn) => {
670 return new QueriesObserverMock(fn, [])
671 })
672​
673 function Queries() {
674 createQueries(() => ({
675 queries: [
676 {
677 queryKey: key1,
678 queryFn: async () => {
679 await sleep(10)
680 return 1
681 },
682 },
683 ],
684 }))
685​
686 return (
687 <div>
688 <span>queries</span>
689 </div>
690 )
691 }
692​
693 function Page() {
694 const [mounted, setMounted] = createSignal(true)
695​
696 return (
697 <div>
698 <button onClick={() => setMounted(false)}>unmount</button>
699 {mounted() && <Queries />}
700 </div>
701 )
702 }
703​
704 const rendered = render(() => (
705 <QueryClientProvider client={queryClient}>
706 <Page />
707 </QueryClientProvider>
708 ))
709​
710 fireEvent.click(rendered.getByText('unmount'))
711​
712 // Should not display the console error
713 // "Warning: Can't perform a React state update on an unmounted component"
714​
715 await sleep(20)
716 QueriesObserverSpy.mockRestore()
717 })
718})