@tanstack/query-core 5.0.0-alpha.1 → 5.0.0-alpha.18

package/src/tests/infiniteQueryObserver.test.tsx

@@ -1,6 +1,7 @@
 import { createQueryClient, queryKey, sleep } from './utils'
 import type { QueryClient } from '..'
 import { InfiniteQueryObserver } from '..'
+import { vi } from 'vitest'
 
 describe('InfiniteQueryObserver', () => {
   let queryClient: QueryClient
@@ -43,7 +44,7 @@ describe('InfiniteQueryObserver', () => {
     }
 
     const key = queryKey()
-    const queryFn = jest.fn(() => 1)
+    const queryFn = vi.fn(() => 1)
     const observer = new InfiniteQueryObserver(queryClient, {
       meta,
       queryKey: key,
@@ -66,4 +67,64 @@ describe('InfiniteQueryObserver', () => {
     })
     expect(queryFn).toBeCalledWith(expect.objectContaining({ meta }))
   })
+
+  test('getNextPagParam and getPreviousPageParam should receive current pageParams', async () => {
+    const key = queryKey()
+    let single: string[] = []
+    let all: string[] = []
+    const observer = new InfiniteQueryObserver(queryClient, {
+      queryKey: key,
+      queryFn: ({ pageParam }) => String(pageParam),
+      defaultPageParam: 1,
+      getNextPageParam: (_, __, lastPageParam, allPageParams) => {
+        single.push('next' + lastPageParam)
+        all.push('next' + allPageParams.join(','))
+        return lastPageParam + 1
+      },
+      getPreviousPageParam: (_, __, firstPageParam, allPageParams) => {
+        single.push('prev' + firstPageParam)
+        all.push('prev' + allPageParams.join(','))
+        return firstPageParam - 1
+      },
+    })
+
+    await observer.fetchNextPage()
+    await observer.fetchPreviousPage()
+
+    expect(single).toEqual(['next1', 'prev1', 'prev1', 'next1', 'prev0'])
+    expect(all).toEqual(['next1', 'prev1', 'prev1', 'next0,1', 'prev0,1'])
+
+    single = []
+    all = []
+
+    await observer.refetch()
+
+    expect(single).toEqual(['next0', 'next1', 'prev0'])
+    expect(all).toEqual(['next0', 'next0,1', 'prev0,1'])
+  })
+
+  test('should stop refetching if undefined is returned from getNextPageParam', async () => {
+    const key = queryKey()
+    let next: number | undefined = 2
+    const queryFn = vi.fn<any, any>(({ pageParam }) => String(pageParam))
+    const observer = new InfiniteQueryObserver(queryClient, {
+      queryKey: key,
+      queryFn,
+      defaultPageParam: 1,
+      getNextPageParam: () => next,
+    })
+
+    await observer.fetchNextPage()
+    await observer.fetchNextPage()
+
+    expect(observer.getCurrentResult().data?.pages).toEqual(['1', '2'])
+    expect(queryFn).toBeCalledTimes(2)
+
+    next = undefined
+
+    await observer.refetch()
+
+    expect(observer.getCurrentResult().data?.pages).toEqual(['1'])
+    expect(queryFn).toBeCalledTimes(3)
+  })
 })

package/src/tests/mutationCache.test.tsx

@@ -1,13 +1,16 @@
 import { waitFor } from '@testing-library/react'
 import { queryKey, sleep, executeMutation, createQueryClient } from './utils'
 import { MutationCache, MutationObserver } from '..'
+import { vi } from 'vitest'
 
 describe('mutationCache', () => {
-  describe('MutationCacheConfig.onError', () => {
-    test('should be called when a mutation errors', async () => {
+  describe('MutationCacheConfig error callbacks', () => {
+    test('should call onError and onSettled when a mutation errors', async () => {
       const key = queryKey()
-      const onError = jest.fn()
-      const testCache = new MutationCache({ onError })
+      const onError = vi.fn()
+      const onSuccess = vi.fn()
+      const onSettled = vi.fn()
+      const testCache = new MutationCache({ onError, onSuccess, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       try {
@@ -23,12 +26,22 @@ describe('mutationCache', () => {
       } catch {}
 
       const mutation = testCache.getAll()[0]
+      expect(onError).toHaveBeenCalledTimes(1)
       expect(onError).toHaveBeenCalledWith(
         new Error('error'),
         'vars',
         'context',
         mutation,
       )
+      expect(onSuccess).not.toHaveBeenCalled()
+      expect(onSettled).toHaveBeenCalledTimes(1)
+      expect(onSettled).toHaveBeenCalledWith(
+        undefined,
+        new Error('error'),
+        'vars',
+        'context',
+        mutation,
+      )
     })
 
     test('should be awaited', async () => {
@@ -39,7 +52,12 @@ describe('mutationCache', () => {
         await sleep(1)
         states.push(2)
       }
-      const testCache = new MutationCache({ onError })
+      const onSettled = async () => {
+        states.push(5)
+        await sleep(1)
+        states.push(6)
+      }
+      const testCache = new MutationCache({ onError, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       try {
@@ -53,19 +71,26 @@ describe('mutationCache', () => {
               await sleep(1)
               states.push(4)
             },
+            onSettled: async () => {
+              states.push(7)
+              await sleep(1)
+              states.push(8)
+            },
           },
           'vars',
         )
       } catch {}
 
-      expect(states).toEqual([1, 2, 3, 4])
+      expect(states).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
     })
   })
-  describe('MutationCacheConfig.onSuccess', () => {
-    test('should be called when a mutation is successful', async () => {
+  describe('MutationCacheConfig success callbacks', () => {
+    test('should call onSuccess and onSettled when a mutation is successful', async () => {
       const key = queryKey()
-      const onSuccess = jest.fn()
-      const testCache = new MutationCache({ onSuccess })
+      const onError = vi.fn()
+      const onSuccess = vi.fn()
+      const onSettled = vi.fn()
+      const testCache = new MutationCache({ onError, onSuccess, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       try {
@@ -81,12 +106,22 @@ describe('mutationCache', () => {
       } catch {}
 
       const mutation = testCache.getAll()[0]
+      expect(onSuccess).toHaveBeenCalledTimes(1)
       expect(onSuccess).toHaveBeenCalledWith(
         { data: 5 },
         'vars',
         'context',
         mutation,
       )
+      expect(onError).not.toHaveBeenCalled()
+      expect(onSettled).toHaveBeenCalledTimes(1)
+      expect(onSettled).toHaveBeenCalledWith(
+        { data: 5 },
+        null,
+        'vars',
+        'context',
+        mutation,
+      )
     })
     test('should be awaited', async () => {
       const key = queryKey()
@@ -96,7 +131,12 @@ describe('mutationCache', () => {
         await sleep(1)
         states.push(2)
       }
-      const testCache = new MutationCache({ onSuccess })
+      const onSettled = async () => {
+        states.push(5)
+        await sleep(1)
+        states.push(6)
+      }
+      const testCache = new MutationCache({ onSuccess, onSettled })
       const testClient = createQueryClient({ mutationCache: testCache })
 
       await executeMutation(
@@ -109,17 +149,22 @@ describe('mutationCache', () => {
             await sleep(1)
             states.push(4)
           },
+          onSettled: async () => {
+            states.push(7)
+            await sleep(1)
+            states.push(8)
+          },
         },
         'vars',
       )
 
-      expect(states).toEqual([1, 2, 3, 4])
+      expect(states).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
     })
   })
   describe('MutationCacheConfig.onMutate', () => {
     test('should be called before a mutation executes', async () => {
       const key = queryKey()
-      const onMutate = jest.fn()
+      const onMutate = vi.fn()
       const testCache = new MutationCache({ onMutate })
       const testClient = createQueryClient({ mutationCache: testCache })
 
@@ -242,7 +287,7 @@ describe('mutationCache', () => {
     test('should remove unused mutations after gcTime has elapsed', async () => {
       const testCache = new MutationCache()
       const testClient = createQueryClient({ mutationCache: testCache })
-      const onSuccess = jest.fn()
+      const onSuccess = vi.fn()
       await executeMutation(
         testClient,
         {
@@ -285,7 +330,7 @@ describe('mutationCache', () => {
 
     test('should be garbage collected later when unsubscribed and mutation is pending', async () => {
       const queryClient = createQueryClient()
-      const onSuccess = jest.fn()
+      const onSuccess = vi.fn()
       const observer = new MutationObserver(queryClient, {
         gcTime: 10,
         mutationFn: async () => {
@@ -311,7 +356,7 @@ describe('mutationCache', () => {
 
     test('should call callbacks even with gcTime 0 and mutation still pending', async () => {
       const queryClient = createQueryClient()
-      const onSuccess = jest.fn()
+      const onSuccess = vi.fn()
       const observer = new MutationObserver(queryClient, {
         gcTime: 0,
         mutationFn: async () => {

package/src/tests/mutationObserver.test.tsx

@@ -2,6 +2,7 @@ import { waitFor } from '@testing-library/react'
 import { createQueryClient, sleep } from './utils'
 import type { QueryClient } from '..'
 import { MutationObserver } from '..'
+import { vi } from 'vitest'
 
 describe('mutationObserver', () => {
   let queryClient: QueryClient
@@ -23,8 +24,8 @@ describe('mutationObserver', () => {
       },
     })
 
-    const subscription1Handler = jest.fn()
-    const subscription2Handler = jest.fn()
+    const subscription1Handler = vi.fn()
+    const subscription2Handler = vi.fn()
 
     const unsubscribe1 = mutation.subscribe(subscription1Handler)
     const unsubscribe2 = mutation.subscribe(subscription2Handler)

package/src/tests/mutations.test.tsx

@@ -2,6 +2,8 @@ import type { QueryClient } from '..'
 import { createQueryClient, executeMutation, queryKey, sleep } from './utils'
 import type { MutationState } from '../mutation'
 import { MutationObserver } from '../mutationObserver'
+import { vi } from 'vitest'
+import { waitFor } from '@testing-library/react'
 
 describe('mutations', () => {
   let queryClient: QueryClient
@@ -32,7 +34,7 @@ describe('mutations', () => {
 
   test('setMutationDefaults should be able to set defaults', async () => {
     const key = queryKey()
-    const fn = jest.fn()
+    const fn = vi.fn()
 
     queryClient.setMutationDefaults(key, {
       mutationFn: fn,
@@ -249,9 +251,9 @@ describe('mutations', () => {
   test('should be able to restore a mutation', async () => {
     const key = queryKey()
 
-    const onMutate = jest.fn()
-    const onSuccess = jest.fn()
-    const onSettled = jest.fn()
+    const onMutate = vi.fn()
+    const onSuccess = vi.fn()
+    const onSettled = vi.fn()
 
     queryClient.setMutationDefaults(key, {
       mutationFn: async (text: string) => text,
@@ -316,7 +318,7 @@ describe('mutations', () => {
     const observer = new MutationObserver(queryClient, {})
     const currentMutation = mutationCache.build(queryClient, {})
 
-    const fn = jest.fn()
+    const fn = vi.fn()
 
     const unsubscribe = mutationCache.subscribe((event) => {
       fn(event.type)
@@ -347,8 +349,8 @@ describe('mutations', () => {
   })
 
   test('mutate update the mutation state even without an active subscription', async () => {
-    const onSuccess = jest.fn()
-    const onSettled = jest.fn()
+    const onSuccess = vi.fn()
+    const onSettled = vi.fn()
 
     const mutation = new MutationObserver(queryClient, {
       mutationFn: async () => {
@@ -363,8 +365,8 @@ describe('mutations', () => {
   })
 
   test('mutate update the mutation state even without an active subscription', async () => {
-    const onSuccess = jest.fn()
-    const onSettled = jest.fn()
+    const onSuccess = vi.fn()
+    const onSettled = vi.fn()
 
     const mutation = new MutationObserver(queryClient, {
       mutationFn: async () => {
@@ -377,4 +379,34 @@ describe('mutations', () => {
     expect(onSuccess).not.toHaveBeenCalled()
     expect(onSettled).not.toHaveBeenCalled()
   })
+
+  test('mutation callbacks should see updated options', async () => {
+    const onSuccess = vi.fn()
+
+    const mutation = new MutationObserver(queryClient, {
+      mutationFn: async () => {
+        sleep(100)
+        return 'update'
+      },
+      onSuccess: () => {
+        onSuccess(1)
+      },
+    })
+
+    void mutation.mutate()
+
+    mutation.setOptions({
+      mutationFn: async () => {
+        sleep(100)
+        return 'update'
+      },
+      onSuccess: () => {
+        onSuccess(2)
+      },
+    })
+
+    await waitFor(() => expect(onSuccess).toHaveBeenCalledTimes(1))
+
+    expect(onSuccess).toHaveBeenCalledWith(2)
+  })
 })

package/src/tests/notifyManager.test.tsx

@@ -1,10 +1,11 @@
 import { createNotifyManager } from '../notifyManager'
 import { sleep } from './utils'
+import { vi } from 'vitest'
 
 describe('notifyManager', () => {
   it('should use default notifyFn', async () => {
     const notifyManagerTest = createNotifyManager()
-    const callbackSpy = jest.fn()
+    const callbackSpy = vi.fn()
     notifyManagerTest.schedule(callbackSpy)
     await sleep(1)
     expect(callbackSpy).toHaveBeenCalled()
@@ -12,13 +13,13 @@ describe('notifyManager', () => {
 
   it('should use default batchNotifyFn', async () => {
     const notifyManagerTest = createNotifyManager()
-    const callbackScheduleSpy = jest
+    const callbackScheduleSpy = vi
       .fn()
       .mockImplementation(async () => await sleep(20))
-    const callbackBatchLevel2Spy = jest.fn().mockImplementation(async () => {
+    const callbackBatchLevel2Spy = vi.fn().mockImplementation(async () => {
       notifyManagerTest.schedule(callbackScheduleSpy)
     })
-    const callbackBatchLevel1Spy = jest.fn().mockImplementation(async () => {
+    const callbackBatchLevel1Spy = vi.fn().mockImplementation(async () => {
       notifyManagerTest.batch(callbackBatchLevel2Spy)
     })
 
@@ -32,13 +33,13 @@ describe('notifyManager', () => {
 
   it('should notify if error is thrown', async () => {
     const notifyManagerTest = createNotifyManager()
-    const notifySpy = jest.fn()
+    const notifySpy = vi.fn()
 
     notifyManagerTest.setNotifyFunction(notifySpy)
 
     try {
       notifyManagerTest.batch(() => {
-        notifyManagerTest.schedule(jest.fn)
+        notifyManagerTest.schedule(vi.fn)
         throw new Error('Foo')
       })
     } catch {}

package/src/tests/onlineManager.test.tsx

@@ -1,5 +1,6 @@
 import { OnlineManager } from '../onlineManager'
 import { setIsServer, sleep } from './utils'
+import { vi } from 'vitest'
 
 describe('onlineManager', () => {
   let onlineManager: OnlineManager
@@ -8,7 +9,7 @@ describe('onlineManager', () => {
   })
 
   test('isOnline should return true if navigator is undefined', () => {
-    const navigatorSpy = jest.spyOn(globalThis, 'navigator', 'get')
+    const navigatorSpy = vi.spyOn(globalThis, 'navigator', 'get')
 
     // Force navigator to be undefined
     //@ts-expect-error
@@ -19,7 +20,7 @@ describe('onlineManager', () => {
   })
 
   test('isOnline should return true if navigator.onLine is true', () => {
-    const navigatorSpy = jest.spyOn(navigator, 'onLine', 'get')
+    const navigatorSpy = vi.spyOn(navigator, 'onLine', 'get')
     navigatorSpy.mockImplementation(() => true)
 
     expect(onlineManager.isOnline()).toBeTruthy()
@@ -46,8 +47,8 @@ describe('onlineManager', () => {
   })
 
   test('setEventListener should call previous remove handler when replacing an event listener', () => {
-    const remove1Spy = jest.fn()
-    const remove2Spy = jest.fn()
+    const remove1Spy = vi.fn()
+    const remove2Spy = vi.fn()
 
     onlineManager.setEventListener(() => remove1Spy)
     onlineManager.setEventListener(() => remove2Spy)
@@ -59,7 +60,7 @@ describe('onlineManager', () => {
   test('cleanup (removeEventListener) should not be called if window is not defined', async () => {
     const restoreIsServer = setIsServer(true)
 
-    const removeEventListenerSpy = jest.spyOn(globalThis, 'removeEventListener')
+    const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')
 
     const unsubscribe = onlineManager.subscribe(() => undefined)
 
@@ -76,7 +77,7 @@ describe('onlineManager', () => {
     // @ts-expect-error
     globalThis.window.addEventListener = undefined
 
-    const removeEventListenerSpy = jest.spyOn(globalThis, 'removeEventListener')
+    const removeEventListenerSpy = vi.spyOn(globalThis, 'removeEventListener')
 
     const unsubscribe = onlineManager.subscribe(() => undefined)
 
@@ -88,12 +89,9 @@ describe('onlineManager', () => {
   })
 
   test('it should replace default window listener when a new event listener is set', async () => {
-    const addEventListenerSpy = jest.spyOn(
-      globalThis.window,
-      'addEventListener',
-    )
+    const addEventListenerSpy = vi.spyOn(globalThis.window, 'addEventListener')
 
-    const removeEventListenerSpy = jest.spyOn(
+    const removeEventListenerSpy = vi.spyOn(
       globalThis.window,
       'removeEventListener',
     )
@@ -116,12 +114,9 @@ describe('onlineManager', () => {
   })
 
   test('should call removeEventListener when last listener unsubscribes', () => {
-    const addEventListenerSpy = jest.spyOn(
-      globalThis.window,
-      'addEventListener',
-    )
+    const addEventListenerSpy = vi.spyOn(globalThis.window, 'addEventListener')
 
-    const removeEventListenerSpy = jest.spyOn(
+    const removeEventListenerSpy = vi.spyOn(
       globalThis.window,
       'removeEventListener',
     )
@@ -137,7 +132,7 @@ describe('onlineManager', () => {
   })
 
   test('should keep setup function even if last listener unsubscribes', () => {
-    const setupSpy = jest.fn().mockImplementation(() => () => undefined)
+    const setupSpy = vi.fn().mockImplementation(() => () => undefined)
 
     onlineManager.setEventListener(setupSpy)
 

package/src/tests/queriesObserver.test.tsx

@@ -2,6 +2,7 @@ import { waitFor } from '@testing-library/react'
 import { sleep, queryKey, createQueryClient } from './utils'
 import type { QueryClient, QueryObserverResult } from '..'
 import { QueriesObserver } from '..'
+import { vi } from 'vitest'
 
 describe('queriesObserver', () => {
   let queryClient: QueryClient
@@ -18,8 +19,8 @@ describe('queriesObserver', () => {
   test('should return an array with all query results', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -34,11 +35,11 @@ describe('queriesObserver', () => {
   })
 
   test('should still return value for undefined query key', async () => {
-    const consoleMock = jest.spyOn(console, 'error')
+    const consoleMock = vi.spyOn(console, 'error')
     consoleMock.mockImplementation(() => undefined)
     const key1 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: undefined, queryFn: queryFn2 },
@@ -61,8 +62,8 @@ describe('queriesObserver', () => {
   test('should update when a query updates', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -106,8 +107,8 @@ describe('queriesObserver', () => {
   test('should update when a query is removed', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -153,8 +154,8 @@ describe('queriesObserver', () => {
   test('should update when a query changed position', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -201,8 +202,8 @@ describe('queriesObserver', () => {
   test('should not update when nothing has changed', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -245,8 +246,8 @@ describe('queriesObserver', () => {
   test('should trigger all fetches when subscribed', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const queryFn1 = jest.fn().mockReturnValue(1)
-    const queryFn2 = jest.fn().mockReturnValue(2)
+    const queryFn1 = vi.fn().mockReturnValue(1)
+    const queryFn2 = vi.fn().mockReturnValue(2)
     const observer = new QueriesObserver(queryClient, [
       { queryKey: key1, queryFn: queryFn1 },
       { queryKey: key2, queryFn: queryFn2 },
@@ -270,8 +271,8 @@ describe('queriesObserver', () => {
       },
     ])
 
-    const subscription1Handler = jest.fn()
-    const subscription2Handler = jest.fn()
+    const subscription1Handler = vi.fn()
+    const subscription2Handler = vi.fn()
 
     const unsubscribe1 = observer.subscribe(subscription1Handler)
     const unsubscribe2 = observer.subscribe(subscription2Handler)