@tanstack/query-core 5.27.4 → 5.28.0

package/src/tests/queryClient.test.tsx

@@ -450,6 +450,33 @@ describe('queryClient', () => {
         queryClient.ensureQueryData({ queryKey: [key], queryFn }),
       ).resolves.toEqual('data')
     })
+
+    test('should return the cached query data if the query is found and preFetchQuery in the background when revalidateIfStale is set', async () => {
+      const TIMEOUT = 10
+      const key = queryKey()
+      queryClient.setQueryData([key, 'id'], 'old')
+
+      const queryFn = () =>
+        new Promise((resolve) => {
+          setTimeout(() => resolve('new'), TIMEOUT)
+        })
+
+      await expect(
+        queryClient.ensureQueryData({
+          queryKey: [key, 'id'],
+          queryFn,
+          revalidateIfStale: true,
+        }),
+      ).resolves.toEqual('old')
+      await sleep(TIMEOUT + 10)
+      await expect(
+        queryClient.ensureQueryData({
+          queryKey: [key, 'id'],
+          queryFn,
+          revalidateIfStale: true,
+        }),
+      ).resolves.toEqual('new')
+    })
   })
 
   describe('getQueriesData', () => {
@@ -1389,6 +1416,10 @@ describe('queryClient', () => {
   })
 
   describe('focusManager and onlineManager', () => {
+    afterEach(() => {
+      onlineManager.setOnline(true)
+      focusManager.setFocused(undefined)
+    })
     test('should notify queryCache and mutationCache if focused', async () => {
       const testClient = createQueryClient()
       testClient.mount()
@@ -1411,7 +1442,7 @@ describe('queryClient', () => {
       expect(mutationCacheResumePausedMutationsSpy).not.toHaveBeenCalled()
 
       focusManager.setFocused(true)
-      expect(queryCacheOnFocusSpy).toHaveBeenCalledTimes(1)
+      await waitFor(() => expect(queryCacheOnFocusSpy).toHaveBeenCalledTimes(1))
       expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(1)
 
       expect(queryCacheOnOnlineSpy).not.toHaveBeenCalled()
@@ -1419,7 +1450,6 @@ describe('queryClient', () => {
       queryCacheOnFocusSpy.mockRestore()
       mutationCacheResumePausedMutationsSpy.mockRestore()
       queryCacheOnOnlineSpy.mockRestore()
-      focusManager.setFocused(undefined)
     })
 
     test('should notify queryCache and mutationCache if online', async () => {
@@ -1444,7 +1474,10 @@ describe('queryClient', () => {
       expect(mutationCacheResumePausedMutationsSpy).not.toHaveBeenCalled()
 
       onlineManager.setOnline(true)
-      expect(queryCacheOnOnlineSpy).toHaveBeenCalledTimes(1)
+      await waitFor(() =>
+        expect(queryCacheOnOnlineSpy).toHaveBeenCalledTimes(1),
+      )
+
       expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(1)
 
       expect(queryCacheOnFocusSpy).not.toHaveBeenCalled()
@@ -1452,7 +1485,6 @@ describe('queryClient', () => {
       queryCacheOnFocusSpy.mockRestore()
       queryCacheOnOnlineSpy.mockRestore()
       mutationCacheResumePausedMutationsSpy.mockRestore()
-      onlineManager.setOnline(true)
     })
 
     test('should resume paused mutations when coming online', async () => {
@@ -1481,8 +1513,6 @@ describe('queryClient', () => {
         expect(observer1.getCurrentResult().status).toBe('success')
         expect(observer1.getCurrentResult().status).toBe('success')
       })
-
-      onlineManager.setOnline(true)
     })
 
     test('should resume paused mutations one after the other when invoked manually at the same time', async () => {
@@ -1600,6 +1630,54 @@ describe('queryClient', () => {
       newQueryClient.unmount()
     })
 
+    test('should notify queryCache after resumePausedMutations has finished when coming online', async () => {
+      const key = queryKey()
+
+      let count = 0
+      const results: Array<string> = []
+
+      const queryObserver = new QueryObserver(queryClient, {
+        queryKey: key,
+        queryFn: async () => {
+          count++
+          results.push('data' + count)
+          await sleep(10)
+          return 'data' + count
+        },
+      })
+
+      const unsubscribe = queryObserver.subscribe(() => undefined)
+
+      await waitFor(() => {
+        expect(queryClient.getQueryData(key)).toBe('data1')
+      })
+
+      onlineManager.setOnline(false)
+
+      const observer = new MutationObserver(queryClient, {
+        mutationFn: async () => {
+          results.push('mutation')
+          await sleep(50)
+          return 1
+        },
+      })
+
+      void observer.mutate()
+
+      expect(observer.getCurrentResult().isPaused).toBeTruthy()
+
+      onlineManager.setOnline(true)
+
+      await waitFor(() => {
+        expect(queryClient.getQueryData(key)).toBe('data2')
+      })
+
+      // refetch from coming online should happen after mutations have finished
+      expect(results).toStrictEqual(['data1', 'mutation', 'data2'])
+
+      unsubscribe()
+    })
+
     test('should notify queryCache and mutationCache after multiple mounts and single unmount', async () => {
       const testClient = createQueryClient()
       testClient.mount()
@@ -1621,11 +1699,13 @@ describe('queryClient', () => {
 
       onlineManager.setOnline(false)
       onlineManager.setOnline(true)
-      expect(queryCacheOnOnlineSpy).toHaveBeenCalledTimes(1)
+      await waitFor(() =>
+        expect(queryCacheOnOnlineSpy).toHaveBeenCalledTimes(1),
+      )
       expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(1)
 
       focusManager.setFocused(true)
-      expect(queryCacheOnFocusSpy).toHaveBeenCalledTimes(1)
+      await waitFor(() => expect(queryCacheOnFocusSpy).toHaveBeenCalledTimes(1))
       expect(mutationCacheResumePausedMutationsSpy).toHaveBeenCalledTimes(2)
 
       queryCacheOnFocusSpy.mockRestore()

package/src/tests/utils.ts

@@ -1,7 +1,7 @@
 import { vi } from 'vitest'
 import { QueryClient, onlineManager } from '..'
 import * as utils from '../utils'
-import type { SpyInstance } from 'vitest'
+import type { MockInstance } from 'vitest'
 import type { MutationOptions, QueryClientConfig } from '..'
 
 export function createQueryClient(config?: QueryClientConfig): QueryClient {
@@ -10,13 +10,13 @@ export function createQueryClient(config?: QueryClientConfig): QueryClient {
 
 export function mockVisibilityState(
   value: DocumentVisibilityState,
-): SpyInstance<[], DocumentVisibilityState> {
+): MockInstance<[], DocumentVisibilityState> {
   return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value)
 }
 
 export function mockOnlineManagerIsOnline(
   value: boolean,
-): SpyInstance<[], boolean> {
+): MockInstance<[], boolean> {
   return vi.spyOn(onlineManager, 'isOnline').mockReturnValue(value)
 }
 

package/src/types.ts

@@ -407,6 +407,22 @@ export interface FetchQueryOptions<
   staleTime?: number
 }
 
+export interface EnsureQueryDataOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = never,
+> extends FetchQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  > {
+  revalidateIfStale?: boolean
+}
+
 type FetchInfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> =
   | { pages?: never }
   | {