@tanstack/query-core 5.0.0-alpha.2 → 5.0.0-alpha.21

package/src/tests/queryClient.test.tsx

@@ -11,6 +11,7 @@ import type {
 import { MutationObserver, QueryObserver } from '..'
 import { focusManager, onlineManager } from '..'
 import { noop } from '../utils'
+import { vi } from 'vitest'
 
 describe('queryClient', () => {
   let queryClient: QueryClient
@@ -223,7 +224,7 @@ describe('queryClient', () => {
     test('should accept an update function', () => {
       const key = queryKey()
 
-      const updater = jest.fn((oldData) => `new data + ${oldData}`)
+      const updater = vi.fn((oldData) => `new data + ${oldData}`)
 
       queryClient.setQueryData(key, 'test data')
       queryClient.setQueryData(key, updater)
@@ -802,7 +803,7 @@ describe('queryClient', () => {
   describe('refetchQueries', () => {
     test('should not refetch if all observers are disabled', async () => {
       const key = queryKey()
-      const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+      const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
       await queryClient.fetchQuery({ queryKey: key, queryFn })
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key,
@@ -816,7 +817,7 @@ describe('queryClient', () => {
     })
     test('should refetch if at least one observer is enabled', async () => {
       const key = queryKey()
-      const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+      const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
       await queryClient.fetchQuery({ queryKey: key, queryFn })
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key,
@@ -838,8 +839,8 @@ describe('queryClient', () => {
     test('should refetch all queries when no arguments are given', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer1 = new QueryObserver(queryClient, {
@@ -864,8 +865,8 @@ describe('queryClient', () => {
     test('should be able to refetch all fresh queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -883,8 +884,8 @@ describe('queryClient', () => {
     test('should be able to refetch all stale queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -903,8 +904,8 @@ describe('queryClient', () => {
     test('should be able to refetch all stale and active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       queryClient.invalidateQueries({ queryKey: key1 })
@@ -925,8 +926,8 @@ describe('queryClient', () => {
     test('should be able to refetch all active and inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -944,8 +945,8 @@ describe('queryClient', () => {
     test('should be able to refetch all active and inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -963,8 +964,8 @@ describe('queryClient', () => {
     test('should be able to refetch only active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -982,8 +983,8 @@ describe('queryClient', () => {
     test('should be able to refetch only inactive queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1025,8 +1026,8 @@ describe('queryClient', () => {
     test('should refetch active queries by default', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1044,8 +1045,8 @@ describe('queryClient', () => {
     test('should not refetch inactive queries by default', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1063,8 +1064,8 @@ describe('queryClient', () => {
     test('should not refetch active queries when "refetch" is "none"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1085,8 +1086,8 @@ describe('queryClient', () => {
     test('should refetch inactive queries when "refetch" is "inactive"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1109,8 +1110,8 @@ describe('queryClient', () => {
     test('should refetch active and inactive queries when "refetch" is "all"', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       await queryClient.fetchQuery({ queryKey: key1, queryFn: queryFn1 })
       await queryClient.fetchQuery({ queryKey: key2, queryFn: queryFn2 })
       const observer = new QueryObserver(queryClient, {
@@ -1129,7 +1130,7 @@ describe('queryClient', () => {
 
     test('should cancel ongoing fetches if cancelRefetch option is set (default value)', async () => {
       const key = queryKey()
-      const abortFn = jest.fn()
+      const abortFn = vi.fn()
       let fetchCount = 0
       const observer = new QueryObserver(queryClient, {
         queryKey: key,
@@ -1152,7 +1153,7 @@ describe('queryClient', () => {
 
     test('should not cancel ongoing fetches if cancelRefetch option is set to false', async () => {
       const key = queryKey()
-      const abortFn = jest.fn()
+      const abortFn = vi.fn()
       let fetchCount = 0
       const observer = new QueryObserver(queryClient, {
         queryKey: key,
@@ -1178,7 +1179,7 @@ describe('queryClient', () => {
     test('should notify listeners when a query is reset', async () => {
       const key = queryKey()
 
-      const callback = jest.fn()
+      const callback = vi.fn()
 
       await queryClient.prefetchQuery({ queryKey: key, queryFn: () => 'data' })
 
@@ -1231,8 +1232,8 @@ describe('queryClient', () => {
     test('should refetch all active queries', async () => {
       const key1 = queryKey()
       const key2 = queryKey()
-      const queryFn1 = jest.fn<string, unknown[]>().mockReturnValue('data1')
-      const queryFn2 = jest.fn<string, unknown[]>().mockReturnValue('data2')
+      const queryFn1 = vi.fn<unknown[], string>().mockReturnValue('data1')
+      const queryFn2 = vi.fn<unknown[], string>().mockReturnValue('data2')
       const observer1 = new QueryObserver(queryClient, {
         queryKey: key1,
         queryFn: queryFn1,
@@ -1258,15 +1259,15 @@ describe('queryClient', () => {
       const testClient = createQueryClient()
       testClient.mount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )
@@ -1291,15 +1292,15 @@ describe('queryClient', () => {
       const testClient = createQueryClient()
       testClient.mount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )
@@ -1321,7 +1322,7 @@ describe('queryClient', () => {
     })
 
     test('should resume paused mutations when coming online', async () => {
-      const consoleMock = jest.spyOn(console, 'error')
+      const consoleMock = vi.spyOn(console, 'error')
       consoleMock.mockImplementation(() => undefined)
       onlineManager.setOnline(false)
 
@@ -1351,7 +1352,7 @@ describe('queryClient', () => {
     })
 
     test('should resume paused mutations one after the other when invoked manually at the same time', async () => {
-      const consoleMock = jest.spyOn(console, 'error')
+      const consoleMock = vi.spyOn(console, 'error')
       consoleMock.mockImplementation(() => undefined)
       onlineManager.setOnline(false)
 
@@ -1401,15 +1402,15 @@ describe('queryClient', () => {
       testClient.mount()
       testClient.unmount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )
@@ -1436,15 +1437,15 @@ describe('queryClient', () => {
       testClient.unmount()
       testClient.unmount()
 
-      const queryCacheOnFocusSpy = jest.spyOn(
+      const queryCacheOnFocusSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onFocus',
       )
-      const queryCacheOnOnlineSpy = jest.spyOn(
+      const queryCacheOnOnlineSpy = vi.spyOn(
         testClient.getQueryCache(),
         'onOnline',
       )
-      const mutationCacheResumePausedMutationsSpy = jest.spyOn(
+      const mutationCacheResumePausedMutationsSpy = vi.spyOn(
         testClient.getMutationCache(),
         'resumePausedMutations',
       )

package/src/tests/queryObserver.test.tsx

@@ -1,6 +1,7 @@
 import { sleep, queryKey, expectType, createQueryClient } from './utils'
 import type { QueryClient, QueryObserverResult } from '..'
 import { QueryObserver, focusManager } from '..'
+import { vi } from 'vitest'
 
 describe('queryObserver', () => {
   let queryClient: QueryClient
@@ -16,7 +17,7 @@ describe('queryObserver', () => {
 
   test('should trigger a fetch when subscribed', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, { queryKey: key, queryFn })
     const unsubscribe = observer.subscribe(() => undefined)
     await sleep(1)
@@ -348,7 +349,7 @@ describe('queryObserver', () => {
 
   test('should not trigger a fetch when subscribed and disabled', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       queryFn,
@@ -362,7 +363,7 @@ describe('queryObserver', () => {
 
   test('should not trigger a fetch when not subscribed', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     new QueryObserver(queryClient, { queryKey: key, queryFn })
     await sleep(1)
     expect(queryFn).toHaveBeenCalledTimes(0)
@@ -370,8 +371,8 @@ describe('queryObserver', () => {
 
   test('should be able to watch a query without defining a query function', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
-    const callback = jest.fn()
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
+    const callback = vi.fn()
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       enabled: false,
@@ -385,7 +386,7 @@ describe('queryObserver', () => {
 
   test('should accept unresolved query config in update function', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       enabled: false,
@@ -407,7 +408,7 @@ describe('queryObserver', () => {
 
   test('should be able to handle multiple subscribers', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
     const observer = new QueryObserver<string>(queryClient, {
       queryKey: key,
       enabled: false,
@@ -567,7 +568,7 @@ describe('queryObserver', () => {
 
   test('should not refetch in background if refetchIntervalInBackground is false', async () => {
     const key = queryKey()
-    const queryFn = jest.fn<string, unknown[]>().mockReturnValue('data')
+    const queryFn = vi.fn<unknown[], string>().mockReturnValue('data')
 
     focusManager.setFocused(false)
     const observer = new QueryObserver(queryClient, {
@@ -690,6 +691,61 @@ describe('queryObserver', () => {
     expect(observer.getCurrentResult().isPlaceholderData).toBe(false)
   })
 
+  test('should pass the correct previous data to placeholderData function params when select function is used in conjunction', async () => {
+    const results: QueryObserverResult[] = []
+
+    const key1 = queryKey()
+    const key2 = queryKey()
+
+    const data1 = { value: 'data1' }
+    const data2 = { value: 'data2' }
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key1,
+      queryFn: () => data1,
+      placeholderData: (prev) => prev,
+      select: (data) => data.value,
+    })
+
+    const unsubscribe = observer.subscribe((result) => {
+      results.push(result)
+    })
+
+    await sleep(1)
+
+    observer.setOptions({
+      queryKey: key2,
+      queryFn: () => data2,
+      placeholderData: (prev) => prev,
+      select: (data) => data.value,
+    })
+
+    await sleep(1)
+    unsubscribe()
+
+    expect(results.length).toBe(4)
+    expect(results[0]).toMatchObject({
+      data: undefined,
+      status: 'pending',
+      fetchStatus: 'fetching',
+    }) // Initial fetch
+    expect(results[1]).toMatchObject({
+      data: 'data1',
+      status: 'success',
+      fetchStatus: 'idle',
+    }) // Successful fetch
+    expect(results[2]).toMatchObject({
+      data: 'data1',
+      status: 'success',
+      fetchStatus: 'fetching',
+    }) // Fetch for new key, but using previous data as placeholder
+    expect(results[3]).toMatchObject({
+      data: 'data2',
+      status: 'success',
+      fetchStatus: 'idle',
+    }) // Successful fetch for new key
+  })
+
   test('setOptions should notify cache listeners', async () => {
     const key = queryKey()
 
@@ -697,7 +753,7 @@ describe('queryObserver', () => {
       queryKey: key,
     })
 
-    const spy = jest.fn()
+    const spy = vi.fn()
     const unsubscribe = queryClient.getQueryCache().subscribe(spy)
     observer.setOptions({ enabled: false })
 

package/src/tests/utils.test.tsx

@@ -11,6 +11,7 @@ import {
 } from '../utils'
 import { Mutation } from '../mutation'
 import { createQueryClient } from './utils'
+import { vi } from 'vitest'
 
 describe('core/utils', () => {
   describe('isPlainObject', () => {
@@ -343,7 +344,7 @@ describe('core/utils', () => {
 
   describe('scheduleMicrotask', () => {
     it('should defer execution of callback', async () => {
-      const callback = jest.fn()
+      const callback = vi.fn()
 
       scheduleMicrotask(callback)
       expect(callback).not.toHaveBeenCalled()

package/src/tests/utils.ts

@@ -1,7 +1,8 @@
 import { act } from '@testing-library/react'
+import { vi } from 'vitest'
 
-import type { MutationOptions, QueryClientConfig } from '@tanstack/query-core'
-import { QueryClient } from '@tanstack/query-core'
+import type { MutationOptions, QueryClientConfig } from '..'
+import { QueryClient } from '..'
 import * as utils from '../utils'
 
 export function createQueryClient(config?: QueryClientConfig): QueryClient {
@@ -9,11 +10,11 @@ export function createQueryClient(config?: QueryClientConfig): QueryClient {
 }
 
 export function mockVisibilityState(value: DocumentVisibilityState) {
-  return jest.spyOn(document, 'visibilityState', 'get').mockReturnValue(value)
+  return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value)
 }
 
 export function mockNavigatorOnLine(value: boolean) {
-  return jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
+  return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
 }
 
 let queryKeyCount = 0

package/src/types.ts

@@ -6,6 +6,7 @@ import type { RetryValue, RetryDelayValue } from './retryer'
 import type { QueryFilters, QueryTypeFilter } from './utils'
 import type { QueryCache } from './queryCache'
 import type { MutationCache } from './mutationCache'
+import type { FetchDirection } from './query'
 
 export interface Register {
   // defaultError: Error
@@ -40,6 +41,7 @@ export type QueryFunctionContext<
       queryKey: TQueryKey
       signal: AbortSignal
       pageParam: TPageParam
+      direction: FetchDirection
       meta: QueryMeta | undefined
     }
 
@@ -62,11 +64,15 @@ export type QueryKeyHashFunction<TQueryKey extends QueryKey> = (
 export type GetPreviousPageParamFunction<TPageParam, TQueryFnData = unknown> = (
   firstPage: TQueryFnData,
   allPages: TQueryFnData[],
+  firstPageParam: TPageParam,
+  allPageParams: TPageParam[],
 ) => TPageParam | undefined
 
 export type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (
   lastPage: TQueryFnData,
   allPages: TQueryFnData[],
+  lastPageParam: TPageParam,
+  allPageParams: TPageParam[],
 ) => TPageParam | undefined
 
 export interface InfiniteData<TData> {
@@ -253,18 +259,6 @@ export interface QueryObserverOptions<
    * By default, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.
    */
   notifyOnChangeProps?: Array<keyof InfiniteQueryObserverResult> | 'all'
-  /**
-   * This callback will fire any time the query successfully fetches new data.
-   */
-  onSuccess?: (data: TData) => void
-  /**
-   * This callback will fire if the query encounters an error and will be passed the error.
-   */
-  onError?: (err: TError) => void
-  /**
-   * This callback will fire any time the query is either successfully fetched or errors and be passed either the data or error.
-   */
-  onSettled?: (data: TData | undefined, error: TError | null) => void
   /**
    * Whether errors should be thrown instead of setting the `error` property.
    * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
@@ -329,13 +323,15 @@ export type DefaultedInfiniteQueryObserverOptions<
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
 > = WithRequired<
   InfiniteQueryObserverOptions<
     TQueryFnData,
     TError,
     TData,
     TQueryData,
-    TQueryKey
+    TQueryKey,
+    TPageParam
   >,
   'throwErrors' | 'refetchOnReconnect'
 >