Open History to see the last commit
1import { describe, expectTypeOf, it } from 'vitest'
2import { queryKey } 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: queryKey(),
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: queryKey(),
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: queryKey(),
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: queryKey(),
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 { data } = useInfiniteQuery(() => ({
59 queryKey: queryKey(),
60 queryFn: ({ pageParam }) => {
61 return pageParam * 5
62 },
63 initialPageParam: 1,
64 getNextPageParam: () => undefined,
65 initialData: { pages: [5], pageParams: [1] },
66 }))
67β
68 expectTypeOf(data).toEqualTypeOf<InfiniteData<number, unknown>>()
69 })
70β
71 it('should have undefined in the TData union when initialData is NOT provided', () => {
72 const { data } = useInfiniteQuery(() => ({
73 queryKey: queryKey(),
74 queryFn: ({ pageParam }) => {
75 return pageParam * 5
76 },
77 initialPageParam: 1,
78 getNextPageParam: () => undefined,
79 }))
80β
81 expectTypeOf(data).toEqualTypeOf<
82 InfiniteData<number, unknown> | undefined
83 >()
84 })
85 })
86β
87 describe('select', () => {
88 it('should still return paginated data if no select result', () => {
89 const infiniteQuery = useInfiniteQuery(() => ({
90 queryKey: queryKey(),
91 queryFn: ({ pageParam }) => {
92 return pageParam * 5
93 },
94 initialPageParam: 1,
95 getNextPageParam: () => undefined,
96 }))
97β
98 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
99 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
100 InfiniteData<number, unknown> | undefined
101 >()
102 })
103β
104 it('should be able to transform data to arbitrary result', () => {
105 const infiniteQuery = useInfiniteQuery(() => ({
106 queryKey: queryKey(),
107 queryFn: ({ pageParam }) => {
108 return pageParam * 5
109 },
110 initialPageParam: 1,
111 getNextPageParam: () => undefined,
112 select: (data) => {
113 expectTypeOf(data).toEqualTypeOf<InfiniteData<number, number>>()
114 return 'selected' as const
115 },
116 }))
117β
118 expectTypeOf(infiniteQuery.data).toEqualTypeOf<'selected' | undefined>()
119 })
120 })
121β
122 describe('getNextPageParam / getPreviousPageParam', () => {
123 it('should get typed params', () => {
124 const infiniteQuery = useInfiniteQuery(() => ({
125 queryKey: queryKey(),
126 queryFn: ({ pageParam }) => {
127 return String(pageParam)
128 },
129 initialPageParam: 1,
130 getNextPageParam: (
131 lastPage,
132 allPages,
133 lastPageParam,
134 allPageParams,
135 ) => {
136 expectTypeOf(lastPage).toEqualTypeOf<string>()
137 expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
138 expectTypeOf(lastPageParam).toEqualTypeOf<number>()
139 expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
140 return undefined
141 },
142 getPreviousPageParam: (
143 firstPage,
144 allPages,
145 firstPageParam,
146 allPageParams,
147 ) => {
148 expectTypeOf(firstPage).toEqualTypeOf<string>()
149 expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
150 expectTypeOf(firstPageParam).toEqualTypeOf<number>()
151 expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
152 return undefined
153 },
154 }))
155β
156 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
157 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
158 InfiniteData<string, unknown> | undefined
159 >()
160 })
161 })
162β
163 describe('error booleans', () => {
164 it('should not be permanently `false`', () => {
165 const {
166 isFetchNextPageError,
167 isFetchPreviousPageError,
168 isLoadingError,
169 isRefetchError,
170 } = useInfiniteQuery(() => ({
171 queryKey: queryKey(),
172 queryFn: ({ pageParam }) => {
173 return pageParam * 5
174 },
175 initialPageParam: 1,
176 getNextPageParam: () => undefined,
177 }))
178β
179 expectTypeOf(isFetchNextPageError).toEqualTypeOf<boolean>()
180 expectTypeOf(isFetchPreviousPageError).toEqualTypeOf<boolean>()
181 expectTypeOf(isLoadingError).toEqualTypeOf<boolean>()
182 expectTypeOf(isRefetchError).toEqualTypeOf<boolean>()
183 })
184 })
185β
186 describe('queryClient', () => {
187 it('should accept queryClient as second argument', () => {
188 const queryClient = new QueryClient()
189β
190 const infiniteQuery = useInfiniteQuery(
191 () => ({
192 queryKey: queryKey(),
193 queryFn: ({ pageParam }) => {
194 return pageParam * 5
195 },
196 initialPageParam: 1,
197 getNextPageParam: () => undefined,
198 }),
199 () => queryClient,
200 )
201β
202 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
203 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
204 InfiniteData<number, unknown> | undefined
205 >()
206 })
207 })
208})