Open History to see the last commit
1import { QueryClient } from '@tanstack/query-core'
2import { createKey } from '@tanstack/query-test-utils'
3import { describe, expectTypeOf, it } from 'vitest'
4import { useInfiniteQuery } from '../useInfiniteQuery'
5import type { InfiniteData } from '@tanstack/query-core'
6import type { UseInfiniteQueryOptions } from '../types'
7β
8describe('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 getNextPageParam: () => undefined,
40 initialPageParam: 1,
41 })
42 })
43β
44 it('should define type of param passed to queryFunctionContext with initialPageParam for infiniteQuery', () => {
45 const queryClient = new QueryClient()
46 queryClient.infiniteQuery({
47 queryKey: ['key'],
48 queryFn: ({ pageParam }) => {
49 expectTypeOf(pageParam).toEqualTypeOf<number>()
50 return Promise.resolve(pageParam)
51 },
52 getNextPageParam: () => undefined,
53 initialPageParam: 1,
54 })
55 })
56β
57 it('should define type of param passed to queryFunctionContext with initialPageParam for prefetchInfiniteQuery', () => {
58 const queryClient = new QueryClient()
59 // oxlint-disable-next-line tanstack-query/no-restricted-syntax -- grandfathered direct test
60 queryClient.prefetchInfiniteQuery({
61 queryKey: createKey(),
62 queryFn: ({ pageParam }) => {
63 expectTypeOf(pageParam).toEqualTypeOf<number>()
64 },
65 getNextPageParam: () => undefined,
66 initialPageParam: 1,
67 })
68 })
69})
70β
71describe('select', () => {
72 it('should still return paginated data if no select result', () => {
73 const infiniteQuery = useInfiniteQuery({
74 queryKey: createKey(),
75 queryFn: ({ pageParam }) => {
76 return pageParam * 5
77 },
78 initialPageParam: 1,
79 getNextPageParam: () => undefined,
80 })
81β
82 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
83 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
84 InfiniteData<number, unknown> | undefined
85 >()
86 })
87β
88 it('should be able to transform data to arbitrary result', () => {
89 const infiniteQuery = useInfiniteQuery({
90 queryKey: createKey(),
91 queryFn: ({ pageParam }) => {
92 return pageParam * 5
93 },
94 initialPageParam: 1,
95 getNextPageParam: () => undefined,
96 select: (data) => {
97 expectTypeOf(data).toEqualTypeOf<InfiniteData<number, number>>()
98 return 'selected' as const
99 },
100 })
101β
102 expectTypeOf(infiniteQuery.data).toEqualTypeOf<'selected' | undefined>()
103 })
104})
105β
106describe('getNextPageParam / getPreviousPageParam', () => {
107 it('should get typed params', () => {
108 const infiniteQuery = useInfiniteQuery({
109 queryKey: createKey(),
110 queryFn: ({ pageParam }) => {
111 return String(pageParam)
112 },
113 initialPageParam: 1,
114 getNextPageParam: (lastPage, allPages, lastPageParam, allPageParams) => {
115 expectTypeOf(lastPage).toEqualTypeOf<string>()
116 expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
117 expectTypeOf(lastPageParam).toEqualTypeOf<number>()
118 expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
119 return undefined
120 },
121 getPreviousPageParam: (
122 firstPage,
123 allPages,
124 firstPageParam,
125 allPageParams,
126 ) => {
127 expectTypeOf(firstPage).toEqualTypeOf<string>()
128 expectTypeOf(allPages).toEqualTypeOf<Array<string>>()
129 expectTypeOf(firstPageParam).toEqualTypeOf<number>()
130 expectTypeOf(allPageParams).toEqualTypeOf<Array<number>>()
131 return undefined
132 },
133 })
134β
135 // TODO: Order of generics prevents pageParams to be typed correctly. Using `unknown` for now
136 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
137 InfiniteData<string, unknown> | undefined
138 >()
139 })
140})
141β
142describe('error booleans', () => {
143 it('should not be permanently `false`', () => {
144 const {
145 isFetchNextPageError,
146 isFetchPreviousPageError,
147 isLoadingError,
148 isRefetchError,
149 } = useInfiniteQuery({
150 queryKey: createKey(),
151 queryFn: ({ pageParam }) => {
152 return pageParam * 5
153 },
154 initialPageParam: 1,
155 getNextPageParam: () => undefined,
156 })
157β
158 expectTypeOf(isFetchNextPageError).toEqualTypeOf<boolean>()
159 expectTypeOf(isFetchPreviousPageError).toEqualTypeOf<boolean>()
160 expectTypeOf(isLoadingError).toEqualTypeOf<boolean>()
161 expectTypeOf(isRefetchError).toEqualTypeOf<boolean>()
162 })
163})
164β
165describe('UseInfiniteQueryOptions', () => {
166 it('should default TData to InfiniteData<TQueryFnData>', () => {
167 const options: UseInfiniteQueryOptions<number, Error> = {
168 queryKey: createKey(),
169 queryFn: () => 5,
170 initialPageParam: 1,
171 getNextPageParam: () => undefined,
172 }
173 const infiniteQuery = useInfiniteQuery(options)
174β
175 expectTypeOf(infiniteQuery.data).toEqualTypeOf<
176 InfiniteData<number, unknown> | undefined
177 >()
178 })
179})