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

useInfiniteQuery.test-d.tsx

207 lines6.7 KB

1import { describe, expectTypeOf, it } from 'vitest'
2import { createKey } from '@tanstack/query-test-utils'
3import { useInfiniteQuery } from '../useInfiniteQuery'
4import { QueryClient } from '../QueryClient'
5import type { InfiniteData } from '@tanstack/query-core'
6​
7describe('useInfiniteQuery', () => {
8 describe('pageParam', () => {
9 it('should define type of param passed to queryFunctionContext with initialPageParam', () => {
10 useInfiniteQuery(() => ({
11 queryKey: createKey(),
12 queryFn: ({ pageParam }) => {
13 expectTypeOf(pageParam).toEqualTypeOf<number>()
14 },
15 initialPageParam: 1,
16 getNextPageParam: () => undefined,
17 }))
18 })
19​
20 it('should pass direction to queryFn of useInfiniteQuery', () => {
21 useInfiniteQuery(() => ({
22 queryKey: createKey(),
23 queryFn: ({ direction }) => {
24 expectTypeOf(direction).toEqualTypeOf<'forward' | 'backward'>()
25 },
26 initialPageParam: 1,
27 getNextPageParam: () => undefined,
28 }))
29 })
30​
31 it('should define type of param passed to queryFunctionContext with initialPageParam for fetchInfiniteQuery', () => {
32 const queryClient = new QueryClient()
33 // oxlint-disable-next-line tanstack-query/no-restricted-syntax -- grandfathered direct test
34 queryClient.fetchInfiniteQuery({
35 queryKey: createKey(),
36 queryFn: ({ pageParam }) => {
37 expectTypeOf(pageParam).toEqualTypeOf<number>()
38 },
39 initialPageParam: 1,
40 })
41 })
42​
43 it('should define type of param passed to queryFunctionContext with initialPageParam for prefetchInfiniteQuery', () => {
44 const queryClient = new QueryClient()
45 // oxlint-disable-next-line tanstack-query/no-restricted-syntax -- grandfathered direct test
46 queryClient.prefetchInfiniteQuery({
47 queryKey: createKey(),
48 queryFn: ({ pageParam }) => {
49 expectTypeOf(pageParam).toEqualTypeOf<number>()
50 },
51 initialPageParam: 1,
52 })
53 })
54 })
55​
56 describe('initialData', () => {
57 it('should always define TData when initialData is provided', () => {
58 const infiniteQuery = useInfiniteQuery(() => ({
59 queryKey: createKey(),
60 queryFn: ({ pageParam }) => {
61 return pageParam * 5
62 },
63 initialPageParam: 1,
64 getNextPageParam: () => undefined,
65 initialData: { pages: [5], pageParams: [1] },
66 }))
67​
68 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
69 InfiniteData<number, unknown>
70 >()
71 })
72​
73 it('should have undefined in the TData union when initialData is NOT provided', () => {
74 const infiniteQuery = useInfiniteQuery(() => ({
75 queryKey: createKey(),
76 queryFn: ({ pageParam }) => {
77 return pageParam * 5
78 },
79 initialPageParam: 1,
80 getNextPageParam: () => undefined,
81 }))
82​
83 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
84 InfiniteData<number, unknown> | undefined
85 >()
86 })
87 })
88​
89 describe('select', () => {
90 it('should still return paginated data if no select result', () => {
91 const infiniteQuery = useInfiniteQuery(() => ({
92 queryKey: createKey(),
93 queryFn: ({ pageParam }) => {
94 return pageParam * 5
95 },
96 initialPageParam: 1,
97 getNextPageParam: () => undefined,
98 }))
99​
100 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
101 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
102 InfiniteData<number, unknown> | undefined
103 >()
104 })
105​
106 it('should be able to transform data to arbitrary result', () => {
107 const infiniteQuery = useInfiniteQuery(() => ({
108 queryKey: createKey(),
109 queryFn: ({ pageParam }) => {
110 return pageParam * 5
111 },
112 initialPageParam: 1,
113 getNextPageParam: () => undefined,
114 select: (data) => {
115 expectTypeOf(data).toEqualTypeOf<InfiniteData<number, number>>()
116 return 'selected' as const
117 },
118 }))
119​
120 expectTypeOf(infiniteQuery.data).toEqualTypeOf<'selected' | undefined>()
121 })
122 })
123​
124 describe('getNextPageParam / getPreviousPageParam', () => {
125 it('should get typed params', () => {
126 const infiniteQuery = useInfiniteQuery(() => ({
127 queryKey: createKey(),
128 queryFn: ({ pageParam }) => {
129 return String(pageParam)
130 },
131 initialPageParam: 1,
132 getNextPageParam: (
133 lastPage,
134 allPages,
135 lastPageParam,
136 allPageParams,
137 ) => {
138 expectTypeOf(lastPage).toEqualTypeOf<string>()
139 expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
140 expectTypeOf(lastPageParam).toEqualTypeOf<number>()
141 expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
142 return undefined
143 },
144 getPreviousPageParam: (
145 firstPage,
146 allPages,
147 firstPageParam,
148 allPageParams,
149 ) => {
150 expectTypeOf(firstPage).toEqualTypeOf<string>()
151 expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
152 expectTypeOf(firstPageParam).toEqualTypeOf<number>()
153 expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
154 return undefined
155 },
156 }))
157​
158 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
159 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
160 InfiniteData<string, unknown> | undefined
161 >()
162 })
163 })
164​
165 describe('error booleans', () => {
166 it('should not be permanently `false`', () => {
167 const infiniteQuery = useInfiniteQuery(() => ({
168 queryKey: createKey(),
169 queryFn: ({ pageParam }) => {
170 return pageParam * 5
171 },
172 initialPageParam: 1,
173 getNextPageParam: () => undefined,
174 }))
175​
176 expectTypeOf(infiniteQuery.isFetchNextPageError).toEqualTypeOf<boolean>()
177 expectTypeOf(
178 infiniteQuery.isFetchPreviousPageError,
179 ).toEqualTypeOf<boolean>()
180 expectTypeOf(infiniteQuery.isLoadingError).toEqualTypeOf<boolean>()
181 expectTypeOf(infiniteQuery.isRefetchError).toEqualTypeOf<boolean>()
182 })
183 })
184​
185 describe('queryClient', () => {
186 it('should accept queryClient as second argument', () => {
187 const queryClient = new QueryClient()
188​
189 const infiniteQuery = useInfiniteQuery(
190 () => ({
191 queryKey: createKey(),
192 queryFn: ({ pageParam }) => {
193 return pageParam * 5
194 },
195 initialPageParam: 1,
196 getNextPageParam: () => undefined,
197 }),
198 () => queryClient,
199 )
200​
201 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
202 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
203 InfiniteData<number, unknown> | undefined
204 >()
205 })
206 })
207})