@tanstack/query-core 4.24.10 → 5.0.0-alpha.0

package/src/removable.ts

@@ -1,8 +1,8 @@
 import { isServer, isValidTimeout } from './utils'
 
 export abstract class Removable {
-  cacheTime!: number
-  private gcTimeout?: ReturnType<typeof setTimeout>
+  gcTime!: number
+  #gcTimeout?: ReturnType<typeof setTimeout>
 
   destroy(): void {
     this.clearGcTimeout()
@@ -11,25 +11,25 @@ export abstract class Removable {
   protected scheduleGc(): void {
     this.clearGcTimeout()
 
-    if (isValidTimeout(this.cacheTime)) {
-      this.gcTimeout = setTimeout(() => {
+    if (isValidTimeout(this.gcTime)) {
+      this.#gcTimeout = setTimeout(() => {
         this.optionalRemove()
-      }, this.cacheTime)
+      }, this.gcTime)
     }
   }
 
-  protected updateCacheTime(newCacheTime: number | undefined): void {
-    // Default to 5 minutes (Infinity for server-side) if no cache time is set
-    this.cacheTime = Math.max(
-      this.cacheTime || 0,
-      newCacheTime ?? (isServer ? Infinity : 5 * 60 * 1000),
+  protected updateGcTime(newGcTime: number | undefined): void {
+    // Default to 5 minutes (Infinity for server-side) if no gcTime is set
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      newGcTime ?? (isServer ? Infinity : 5 * 60 * 1000),
     )
   }
 
   protected clearGcTimeout() {
-    if (this.gcTimeout) {
-      clearTimeout(this.gcTimeout)
-      this.gcTimeout = undefined
+    if (this.#gcTimeout) {
+      clearTimeout(this.#gcTimeout)
+      this.#gcTimeout = undefined
     }
   }
 

package/src/retryer.ts

@@ -1,11 +1,11 @@
 import { focusManager } from './focusManager'
 import { onlineManager } from './onlineManager'
 import { sleep } from './utils'
-import type { CancelOptions, NetworkMode } from './types'
+import type { CancelOptions, NetworkMode, RegisteredError } from './types'
 
 // TYPES
 
-interface RetryerConfig<TData = unknown, TError = unknown> {
+interface RetryerConfig<TData = unknown, TError = RegisteredError> {
   fn: () => TData | Promise<TData>
   abort?: () => void
   onError?: (error: TError) => void
@@ -28,14 +28,14 @@ export interface Retryer<TData = unknown> {
 
 export type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>
 
-type ShouldRetryFunction<TError> = (
+type ShouldRetryFunction<TError = RegisteredError> = (
   failureCount: number,
   error: TError,
 ) => boolean
 
 export type RetryDelayValue<TError> = number | RetryDelayFunction<TError>
 
-type RetryDelayFunction<TError = unknown> = (
+type RetryDelayFunction<TError = RegisteredError> = (
   failureCount: number,
   error: TError,
 ) => number
@@ -63,7 +63,7 @@ export function isCancelledError(value: any): value is CancelledError {
   return value instanceof CancelledError
 }
 
-export function createRetryer<TData = unknown, TError = unknown>(
+export function createRetryer<TData = unknown, TError = RegisteredError>(
   config: RetryerConfig<TData, TError>,
 ): Retryer<TData> {
   let isRetryCancelled = false

package/src/tests/focusManager.test.tsx

@@ -63,55 +63,55 @@ describe('focusManager', () => {
     globalThis.document = document
   })
 
-  test('cleanup should still be undefined if window is not defined', async () => {
+  test('cleanup (removeEventListener) should not be called if window is not defined', async () => {
     const restoreIsServer = setIsServer(true)
 
+    const removeEventListenerSpy = jest.spyOn(globalThis, 'removeEventListener')
+
     const unsubscribe = focusManager.subscribe(() => undefined)
-    expect(focusManager['cleanup']).toBeUndefined()
 
     unsubscribe()
+
+    expect(removeEventListenerSpy).not.toHaveBeenCalled()
+
     restoreIsServer()
   })
 
-  test('cleanup should still be undefined if window.addEventListener is not defined', async () => {
+  test('cleanup (removeEventListener) should not be called if window.addEventListener is not defined', async () => {
     const { addEventListener } = globalThis.window
 
     // @ts-expect-error
     globalThis.window.addEventListener = undefined
 
+    const removeEventListenerSpy = jest.spyOn(globalThis, 'removeEventListener')
+
     const unsubscribe = focusManager.subscribe(() => undefined)
-    expect(focusManager['cleanup']).toBeUndefined()
 
     unsubscribe()
+
+    expect(removeEventListenerSpy).not.toHaveBeenCalled()
+
     globalThis.window.addEventListener = addEventListener
   })
 
   it('should replace default window listener when a new event listener is set', async () => {
-    const addEventListenerSpy = jest.spyOn(
-      globalThis.window,
-      'addEventListener',
-    )
+    const unsubscribeSpy = jest.fn().mockImplementation(() => undefined)
+    const handlerSpy = jest.fn().mockImplementation(() => unsubscribeSpy)
 
-    const removeEventListenerSpy = jest.spyOn(
-      globalThis.window,
-      'removeEventListener',
-    )
+    focusManager.setEventListener(() => handlerSpy())
 
-    // Should set the default event listener with window event listeners
     const unsubscribe = focusManager.subscribe(() => undefined)
-    expect(addEventListenerSpy).toHaveBeenCalledTimes(2)
 
-    // Should replace the window default event listener by a new one
-    // and it should call window.removeEventListener twice
-    focusManager.setEventListener(() => {
-      return () => void 0
-    })
-
-    expect(removeEventListenerSpy).toHaveBeenCalledTimes(2)
+    // Should call the custom event once
+    expect(handlerSpy).toHaveBeenCalledTimes(1)
 
     unsubscribe()
-    addEventListenerSpy.mockRestore()
-    removeEventListenerSpy.mockRestore()
+
+    // Should unsubscribe our event event
+    expect(unsubscribeSpy).toHaveBeenCalledTimes(1)
+
+    handlerSpy.mockRestore()
+    unsubscribeSpy.mockRestore()
   })
 
   test('should call removeEventListener when last listener unsubscribes', () => {
@@ -127,12 +127,12 @@ describe('focusManager', () => {
 
     const unsubscribe1 = focusManager.subscribe(() => undefined)
     const unsubscribe2 = focusManager.subscribe(() => undefined)
-    expect(addEventListenerSpy).toHaveBeenCalledTimes(2) // visibilitychange + focus
+    expect(addEventListenerSpy).toHaveBeenCalledTimes(1) // visibilitychange event
 
     unsubscribe1()
     expect(removeEventListenerSpy).toHaveBeenCalledTimes(0)
     unsubscribe2()
-    expect(removeEventListenerSpy).toHaveBeenCalledTimes(2) // visibilitychange + focus
+    expect(removeEventListenerSpy).toHaveBeenCalledTimes(1) // visibilitychange event
   })
 
   test('should keep setup function even if last listener unsubscribes', () => {

package/src/tests/hydration.test.tsx

@@ -16,14 +16,30 @@ describe('dehydration and rehydration', () => {
   test('should work with serializeable values', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['string'], () => fetchData('string'))
-    await queryClient.prefetchQuery(['number'], () => fetchData(1))
-    await queryClient.prefetchQuery(['boolean'], () => fetchData(true))
-    await queryClient.prefetchQuery(['null'], () => fetchData(null))
-    await queryClient.prefetchQuery(['array'], () => fetchData(['string', 0]))
-    await queryClient.prefetchQuery(['nested'], () =>
-      fetchData({ key: [{ nestedKey: 1 }] }),
-    )
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string'),
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['number'],
+      queryFn: () => fetchData(1),
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['boolean'],
+      queryFn: () => fetchData(true),
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['null'],
+      queryFn: () => fetchData(null),
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['array'],
+      queryFn: () => fetchData(['string', 0]),
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['nested'],
+      queryFn: () => fetchData({ key: [{ nestedKey: 1 }] }),
+    })
     const dehydrated = dehydrate(queryClient)
     const stringified = JSON.stringify(dehydrated)
 
@@ -35,32 +51,51 @@ describe('dehydration and rehydration', () => {
       queryCache: hydrationCache,
     })
     hydrate(hydrationClient, parsed)
-    expect(hydrationCache.find(['string'])?.state.data).toBe('string')
-    expect(hydrationCache.find(['number'])?.state.data).toBe(1)
-    expect(hydrationCache.find(['boolean'])?.state.data).toBe(true)
-    expect(hydrationCache.find(['null'])?.state.data).toBe(null)
-    expect(hydrationCache.find(['array'])?.state.data).toEqual(['string', 0])
-    expect(hydrationCache.find(['nested'])?.state.data).toEqual({
+    expect(hydrationCache.find({ queryKey: ['string'] })?.state.data).toBe(
+      'string',
+    )
+    expect(hydrationCache.find({ queryKey: ['number'] })?.state.data).toBe(1)
+    expect(hydrationCache.find({ queryKey: ['boolean'] })?.state.data).toBe(
+      true,
+    )
+    expect(hydrationCache.find({ queryKey: ['null'] })?.state.data).toBe(null)
+    expect(hydrationCache.find({ queryKey: ['array'] })?.state.data).toEqual([
+      'string',
+      0,
+    ])
+    expect(hydrationCache.find({ queryKey: ['nested'] })?.state.data).toEqual({
       key: [{ nestedKey: 1 }],
     })
 
     const fetchDataAfterHydration = jest.fn<unknown, unknown[]>()
-    await hydrationClient.prefetchQuery(['string'], fetchDataAfterHydration, {
+    await hydrationClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: fetchDataAfterHydration,
       staleTime: 1000,
     })
-    await hydrationClient.prefetchQuery(['number'], fetchDataAfterHydration, {
+    await hydrationClient.prefetchQuery({
+      queryKey: ['number'],
+      queryFn: fetchDataAfterHydration,
       staleTime: 1000,
     })
-    await hydrationClient.prefetchQuery(['boolean'], fetchDataAfterHydration, {
+    await hydrationClient.prefetchQuery({
+      queryKey: ['boolean'],
+      queryFn: fetchDataAfterHydration,
       staleTime: 1000,
     })
-    await hydrationClient.prefetchQuery(['null'], fetchDataAfterHydration, {
+    await hydrationClient.prefetchQuery({
+      queryKey: ['null'],
+      queryFn: fetchDataAfterHydration,
       staleTime: 1000,
     })
-    await hydrationClient.prefetchQuery(['array'], fetchDataAfterHydration, {
+    await hydrationClient.prefetchQuery({
+      queryKey: ['array'],
+      queryFn: fetchDataAfterHydration,
       staleTime: 1000,
     })
-    await hydrationClient.prefetchQuery(['nested'], fetchDataAfterHydration, {
+    await hydrationClient.prefetchQuery({
+      queryKey: ['nested'],
+      queryFn: fetchDataAfterHydration,
       staleTime: 1000,
     })
     expect(fetchDataAfterHydration).toHaveBeenCalledTimes(0)
@@ -72,7 +107,10 @@ describe('dehydration and rehydration', () => {
   test('should not dehydrate queries if dehydrateQueries is set to false', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['string'], () => fetchData('string'))
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string'),
+    })
 
     const dehydrated = dehydrate(queryClient, { dehydrateQueries: false })
 
@@ -81,11 +119,13 @@ describe('dehydration and rehydration', () => {
     queryClient.clear()
   })
 
-  test('should use the cache time from the client', async () => {
+  test('should use the garbage collection time from the client', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['string'], () => fetchData('string'), {
-      cacheTime: 50,
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string'),
+      gcTime: 50,
     })
     const dehydrated = dehydrate(queryClient)
     const stringified = JSON.stringify(dehydrated)
@@ -98,9 +138,11 @@ describe('dehydration and rehydration', () => {
     const hydrationCache = new QueryCache()
     const hydrationClient = createQueryClient({ queryCache: hydrationCache })
     hydrate(hydrationClient, parsed)
-    expect(hydrationCache.find(['string'])?.state.data).toBe('string')
+    expect(hydrationCache.find({ queryKey: ['string'] })?.state.data).toBe(
+      'string',
+    )
     await sleep(100)
-    expect(hydrationCache.find(['string'])).toBeTruthy()
+    expect(hydrationCache.find({ queryKey: ['string'] })).toBeTruthy()
 
     queryClient.clear()
     hydrationClient.clear()
@@ -109,7 +151,10 @@ describe('dehydration and rehydration', () => {
   test('should be able to provide default options for the hydrated queries', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['string'], () => fetchData('string'))
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string'),
+    })
     const dehydrated = dehydrate(queryClient)
     const stringified = JSON.stringify(dehydrated)
     const parsed = JSON.parse(stringified)
@@ -118,7 +163,9 @@ describe('dehydration and rehydration', () => {
     hydrate(hydrationClient, parsed, {
       defaultOptions: { queries: { retry: 10 } },
     })
-    expect(hydrationCache.find(['string'])?.options.retry).toBe(10)
+    expect(hydrationCache.find({ queryKey: ['string'] })?.options.retry).toBe(
+      10,
+    )
     queryClient.clear()
     hydrationClient.clear()
   })
@@ -126,10 +173,10 @@ describe('dehydration and rehydration', () => {
   test('should work with complex keys', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(
-      ['string', { key: ['string'], key2: 0 }],
-      () => fetchData('string'),
-    )
+    await queryClient.prefetchQuery({
+      queryKey: ['string', { key: ['string'], key2: 0 }],
+      queryFn: () => fetchData('string'),
+    })
     const dehydrated = dehydrate(queryClient)
     const stringified = JSON.stringify(dehydrated)
 
@@ -140,15 +187,17 @@ describe('dehydration and rehydration', () => {
     const hydrationClient = createQueryClient({ queryCache: hydrationCache })
     hydrate(hydrationClient, parsed)
     expect(
-      hydrationCache.find(['string', { key: ['string'], key2: 0 }])?.state.data,
+      hydrationCache.find({
+        queryKey: ['string', { key: ['string'], key2: 0 }],
+      })?.state.data,
     ).toBe('string')
 
     const fetchDataAfterHydration = jest.fn<unknown, unknown[]>()
-    await hydrationClient.prefetchQuery(
-      ['string', { key: ['string'], key2: 0 }],
-      fetchDataAfterHydration,
-      { staleTime: 100 },
-    )
+    await hydrationClient.prefetchQuery({
+      queryKey: ['string', { key: ['string'], key2: 0 }],
+      queryFn: fetchDataAfterHydration,
+      staleTime: 100,
+    })
     expect(fetchDataAfterHydration).toHaveBeenCalledTimes(0)
 
     queryClient.clear()
@@ -161,10 +210,19 @@ describe('dehydration and rehydration', () => {
 
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['success'], () => fetchData('success'))
-    queryClient.prefetchQuery(['loading'], () => fetchData('loading', 10000))
-    await queryClient.prefetchQuery(['error'], () => {
-      throw new Error()
+    await queryClient.prefetchQuery({
+      queryKey: ['success'],
+      queryFn: () => fetchData('success'),
+    })
+    queryClient.prefetchQuery({
+      queryKey: ['loading'],
+      queryFn: () => fetchData('loading', 10000),
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['error'],
+      queryFn: () => {
+        throw new Error()
+      },
     })
     const dehydrated = dehydrate(queryClient)
     const stringified = JSON.stringify(dehydrated)
@@ -176,9 +234,9 @@ describe('dehydration and rehydration', () => {
     const hydrationClient = createQueryClient({ queryCache: hydrationCache })
     hydrate(hydrationClient, parsed)
 
-    expect(hydrationCache.find(['success'])).toBeTruthy()
-    expect(hydrationCache.find(['loading'])).toBeFalsy()
-    expect(hydrationCache.find(['error'])).toBeFalsy()
+    expect(hydrationCache.find({ queryKey: ['success'] })).toBeTruthy()
+    expect(hydrationCache.find({ queryKey: ['loading'] })).toBeFalsy()
+    expect(hydrationCache.find({ queryKey: ['error'] })).toBeFalsy()
 
     queryClient.clear()
     hydrationClient.clear()
@@ -188,8 +246,14 @@ describe('dehydration and rehydration', () => {
   test('should filter queries via shouldDehydrateQuery', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['string'], () => fetchData('string'))
-    await queryClient.prefetchQuery(['number'], () => fetchData(1))
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string'),
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['number'],
+      queryFn: () => fetchData(1),
+    })
     const dehydrated = dehydrate(queryClient, {
       shouldDehydrateQuery: (query) => query.queryKey[0] !== 'string',
     })
@@ -209,8 +273,8 @@ describe('dehydration and rehydration', () => {
     const hydrationCache = new QueryCache()
     const hydrationClient = createQueryClient({ queryCache: hydrationCache })
     hydrate(hydrationClient, parsed)
-    expect(hydrationCache.find(['string'])).toBeUndefined()
-    expect(hydrationCache.find(['number'])?.state.data).toBe(1)
+    expect(hydrationCache.find({ queryKey: ['string'] })).toBeUndefined()
+    expect(hydrationCache.find({ queryKey: ['number'] })?.state.data).toBe(1)
 
     queryClient.clear()
     hydrationClient.clear()
@@ -219,9 +283,10 @@ describe('dehydration and rehydration', () => {
   test('should not overwrite query in cache if hydrated query is older', async () => {
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['string'], () =>
-      fetchData('string-older', 5),
-    )
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string-older', 5),
+    })
     const dehydrated = dehydrate(queryClient)
     const stringified = JSON.stringify(dehydrated)
 
@@ -230,12 +295,15 @@ describe('dehydration and rehydration', () => {
     const parsed = JSON.parse(stringified)
     const hydrationCache = new QueryCache()
     const hydrationClient = createQueryClient({ queryCache: hydrationCache })
-    await hydrationClient.prefetchQuery(['string'], () =>
-      fetchData('string-newer', 5),
-    )
+    await hydrationClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string-newer', 5),
+    })
 
     hydrate(hydrationClient, parsed)
-    expect(hydrationCache.find(['string'])?.state.data).toBe('string-newer')
+    expect(hydrationCache.find({ queryKey: ['string'] })?.state.data).toBe(
+      'string-newer',
+    )
 
     queryClient.clear()
     hydrationClient.clear()
@@ -244,17 +312,19 @@ describe('dehydration and rehydration', () => {
   test('should overwrite query in cache if hydrated query is newer', async () => {
     const hydrationCache = new QueryCache()
     const hydrationClient = createQueryClient({ queryCache: hydrationCache })
-    await hydrationClient.prefetchQuery(['string'], () =>
-      fetchData('string-older', 5),
-    )
+    await hydrationClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string-older', 5),
+    })
 
     // ---
 
     const queryCache = new QueryCache()
     const queryClient = createQueryClient({ queryCache })
-    await queryClient.prefetchQuery(['string'], () =>
-      fetchData('string-newer', 5),
-    )
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => fetchData('string-newer', 5),
+    })
     const dehydrated = dehydrate(queryClient)
     const stringified = JSON.stringify(dehydrated)
 
@@ -262,7 +332,9 @@ describe('dehydration and rehydration', () => {
 
     const parsed = JSON.parse(stringified)
     hydrate(hydrationClient, parsed)
-    expect(hydrationCache.find(['string'])?.state.data).toBe('string-newer')
+    expect(hydrationCache.find({ queryKey: ['string'] })?.state.data).toBe(
+      'string-newer',
+    )
 
     queryClient.clear()
     hydrationClient.clear()
@@ -275,7 +347,7 @@ describe('dehydration and rehydration', () => {
 
     const serverAddTodo = jest
       .fn()
-      .mockImplementation(() => Promise.reject('offline'))
+      .mockImplementation(() => Promise.reject(new Error('offline')))
     const serverOnMutate = jest.fn().mockImplementation((variables) => {
       const optimisticTodo = { id: 1, text: variables.text }
       return { optimisticTodo }
@@ -292,10 +364,13 @@ describe('dehydration and rehydration', () => {
       retryDelay: 10,
     })
 
-    executeMutation(serverClient, {
-      mutationKey: ['addTodo'],
-      variables: { text: 'text' },
-    }).catch(() => undefined)
+    executeMutation(
+      serverClient,
+      {
+        mutationKey: ['addTodo'],
+      },
+      { text: 'text' },
+    ).catch(() => undefined)
 
     await sleep(50)
 
@@ -352,7 +427,7 @@ describe('dehydration and rehydration', () => {
 
     const serverAddTodo = jest
       .fn()
-      .mockImplementation(() => Promise.reject('offline'))
+      .mockImplementation(() => Promise.reject(new Error('offline')))
 
     const queryClient = createQueryClient()
 
@@ -361,10 +436,13 @@ describe('dehydration and rehydration', () => {
       retry: false,
     })
 
-    executeMutation(queryClient, {
-      mutationKey: ['addTodo'],
-      variables: { text: 'text' },
-    }).catch(() => undefined)
+    executeMutation(
+      queryClient,
+      {
+        mutationKey: ['addTodo'],
+      },
+      { text: 'text' },
+    ).catch(() => undefined)
 
     await sleep(1)
     const dehydrated = dehydrate(queryClient, { dehydrateMutations: false })
@@ -381,7 +459,7 @@ describe('dehydration and rehydration', () => {
 
     const serverAddTodo = jest
       .fn()
-      .mockImplementation(() => Promise.reject('offline'))
+      .mockImplementation(() => Promise.reject(new Error('offline')))
 
     const queryClient = createQueryClient()
 
@@ -391,10 +469,13 @@ describe('dehydration and rehydration', () => {
       retryDelay: 20,
     })
 
-    executeMutation(queryClient, {
-      mutationKey: ['addTodo'],
-      variables: { text: 'text' },
-    }).catch(() => undefined)
+    executeMutation(
+      queryClient,
+      {
+        mutationKey: ['addTodo'],
+      },
+      { text: 'text' },
+    ).catch(() => undefined)
 
     // Dehydrate mutation between retries
     await sleep(1)
@@ -447,9 +528,12 @@ describe('dehydration and rehydration', () => {
       return promise
     }
 
-    await queryClient.prefetchQuery(['string'], () => customFetchData())
+    await queryClient.prefetchQuery({
+      queryKey: ['string'],
+      queryFn: () => customFetchData(),
+    })
 
-    queryClient.refetchQueries(['string'])
+    queryClient.refetchQueries({ queryKey: ['string'] })
 
     const dehydrated = dehydrate(queryClient)
     resolvePromise('string')
@@ -464,6 +548,8 @@ describe('dehydration and rehydration', () => {
     const hydrationCache = new QueryCache()
     const hydrationClient = createQueryClient({ queryCache: hydrationCache })
     hydrate(hydrationClient, parsed)
-    expect(hydrationCache.find(['string'])?.state.fetchStatus).toBe('idle')
+    expect(
+      hydrationCache.find({ queryKey: ['string'] })?.state.fetchStatus,
+    ).toBe('idle')
   })
 })