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

infiniteQueryBehavior.ts

215 lines6.2 KB

1import type { QueryBehavior } from './query'
2import { isCancelable } from './retryer'
3import type {
4 InfiniteData,
5 QueryFunctionContext,
6 QueryOptions,
7 RefetchQueryFilters,
8} from './types'
9import { getAbortController } from './utils'
10​
11export function infiniteQueryBehavior<
12 TQueryFnData,
13 TError,
14 TData
15>(): QueryBehavior<TQueryFnData, TError, InfiniteData<TData>> {
16 return {
17 onFetch: context => {
18 context.fetchFn = () => {
19 const refetchPage: RefetchQueryFilters['refetchPage'] | undefined =
20 context.fetchOptions?.meta?.refetchPage
21 const fetchMore = context.fetchOptions?.meta?.fetchMore
22 const pageParam = fetchMore?.pageParam
23 const isFetchingNextPage = fetchMore?.direction === 'forward'
24 const isFetchingPreviousPage = fetchMore?.direction === 'backward'
25 const oldPages = context.state.data?.pages || []
26 const oldPageParams = context.state.data?.pageParams || []
27 const abortController = getAbortController()
28 const abortSignal = abortController?.signal
29 let newPageParams = oldPageParams
30 let cancelled = false
31​
32 // Get query function
33 const queryFn =
34 context.options.queryFn || (() => Promise.reject('Missing queryFn'))
35​
36 const buildNewPages = (
37 pages: unknown[],
38 param: unknown,
39 page: unknown,
40 previous?: boolean
41 ) => {
42 newPageParams = previous
43 ? [param, ...newPageParams]
44 : [...newPageParams, param]
45 return previous ? [page, ...pages] : [...pages, page]
46 }
47​
48 // Create function to fetch a page
49 const fetchPage = (
50 pages: unknown[],
51 manual?: boolean,
52 param?: unknown,
53 previous?: boolean
54 ): Promise<unknown[]> => {
55 if (cancelled) {
56 return Promise.reject('Cancelled')
57 }
58​
59 if (typeof param === 'undefined' && !manual && pages.length) {
60 return Promise.resolve(pages)
61 }
62​
63 const queryFnContext: QueryFunctionContext = {
64 queryKey: context.queryKey,
65 signal: abortSignal,
66 pageParam: param,
67 meta: context.meta,
68 }
69​
70 const queryFnResult = queryFn(queryFnContext)
71​
72 const promise = Promise.resolve(queryFnResult).then(page =>
73 buildNewPages(pages, param, page, previous)
74 )
75​
76 if (isCancelable(queryFnResult)) {
77 const promiseAsAny = promise as any
78 promiseAsAny.cancel = queryFnResult.cancel
79 }
80​
81 return promise
82 }
83​
84 let promise: Promise<unknown[]>
85​
86 // Fetch first page?
87 if (!oldPages.length) {
88 promise = fetchPage([])
89 }
90​
91 // Fetch next page?
92 else if (isFetchingNextPage) {
93 const manual = typeof pageParam !== 'undefined'
94 const param = manual
95 ? pageParam
96 : getNextPageParam(context.options, oldPages)
97 promise = fetchPage(oldPages, manual, param)
98 }
99​
100 // Fetch previous page?
101 else if (isFetchingPreviousPage) {
102 const manual = typeof pageParam !== 'undefined'
103 const param = manual
104 ? pageParam
105 : getPreviousPageParam(context.options, oldPages)
106 promise = fetchPage(oldPages, manual, param, true)
107 }
108​
109 // Refetch pages
110 else {
111 newPageParams = []
112​
113 const manual = typeof context.options.getNextPageParam === 'undefined'
114​
115 const shouldFetchFirstPage =
116 refetchPage && oldPages[0]
117 ? refetchPage(oldPages[0], 0, oldPages)
118 : true
119​
120 // Fetch first page
121 promise = shouldFetchFirstPage
122 ? fetchPage([], manual, oldPageParams[0])
123 : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0]))
124​
125 // Fetch remaining pages
126 for (let i = 1; i < oldPages.length; i++) {
127 promise = promise.then(pages => {
128 const shouldFetchNextPage =
129 refetchPage && oldPages[i]
130 ? refetchPage(oldPages[i], i, oldPages)
131 : true
132​
133 if (shouldFetchNextPage) {
134 const param = manual
135 ? oldPageParams[i]
136 : getNextPageParam(context.options, pages)
137 return fetchPage(pages, manual, param)
138 }
139 return Promise.resolve(
140 buildNewPages(pages, oldPageParams[i], oldPages[i])
141 )
142 })
143 }
144 }
145​
146 const finalPromise = promise.then(pages => ({
147 pages,
148 pageParams: newPageParams,
149 }))
150​
151 const finalPromiseAsAny = finalPromise as any
152​
153 finalPromiseAsAny.cancel = () => {
154 cancelled = true
155 abortController?.abort()
156 if (isCancelable(promise)) {
157 promise.cancel()
158 }
159 }
160​
161 return finalPromise
162 }
163 },
164 }
166​
167export function getNextPageParam(
168 options: QueryOptions<any, any>,
169 pages: unknown[]
170): unknown | undefined {
171 return options.getNextPageParam?.(pages[pages.length - 1], pages)
173​
174export function getPreviousPageParam(
175 options: QueryOptions<any, any>,
176 pages: unknown[]
177): unknown | undefined {
178 return options.getPreviousPageParam?.(pages[0], pages)
180​
181/**
182 * Checks if there is a next page.
183 * Returns `undefined` if it cannot be determined.
184 */
185export function hasNextPage(
186 options: QueryOptions<any, any>,
187 pages?: unknown
188): boolean | undefined {
189 if (options.getNextPageParam && Array.isArray(pages)) {
190 const nextPageParam = getNextPageParam(options, pages)
191 return (
192 typeof nextPageParam !== 'undefined' &&
193 nextPageParam !== null &&
194 nextPageParam !== false
195 )
196 }
198​
199/**
200 * Checks if there is a previous page.
201 * Returns `undefined` if it cannot be determined.
202 */
203export function hasPreviousPage(
204 options: QueryOptions<any, any>,
205 pages?: unknown
206): boolean | undefined {
207 if (options.getPreviousPageParam && Array.isArray(pages)) {
208 const previousPageParam = getPreviousPageParam(options, pages)
209 return (
210 typeof previousPageParam !== 'undefined' &&
211 previousPageParam !== null &&
212 previousPageParam !== false
213 )
214 }