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

package/src/tests/queryObserver.test.tsx

@@ -1,10 +1,4 @@
-import {
-  sleep,
-  queryKey,
-  expectType,
-  mockLogger,
-  createQueryClient,
-} from './utils'
+import { sleep, queryKey, expectType, createQueryClient } from './utils'
 import type { QueryClient, QueryObserverResult } from '..'
 import { QueryObserver, focusManager } from '..'
 
@@ -46,9 +40,9 @@ describe('queryObserver', () => {
     await sleep(1)
     unsubscribe()
     expect(results.length).toBe(4)
-    expect(results[0]).toMatchObject({ data: undefined, status: 'loading' })
+    expect(results[0]).toMatchObject({ data: undefined, status: 'pending' })
     expect(results[1]).toMatchObject({ data: 1, status: 'success' })
-    expect(results[2]).toMatchObject({ data: undefined, status: 'loading' })
+    expect(results[2]).toMatchObject({ data: undefined, status: 'pending' })
     expect(results[3]).toMatchObject({ data: 2, status: 'success' })
   })
 
@@ -148,7 +142,7 @@ describe('queryObserver', () => {
     expect(count).toBe(2)
     expect(results.length).toBe(5)
     expect(results[0]).toMatchObject({
-      status: 'loading',
+      status: 'pending',
       isFetching: true,
       data: undefined,
     })
@@ -203,7 +197,7 @@ describe('queryObserver', () => {
     expect(count).toBe(1)
     expect(results.length).toBe(4)
     expect(results[0]).toMatchObject({
-      status: 'loading',
+      status: 'pending',
       isFetching: true,
       data: undefined,
     })
@@ -263,7 +257,7 @@ describe('queryObserver', () => {
     await observer.refetch()
     unsubscribe()
     expect(results[0]).toMatchObject({
-      status: 'loading',
+      status: 'pending',
       isFetching: true,
       data: undefined,
     })
@@ -313,7 +307,7 @@ describe('queryObserver', () => {
     unsubscribe()
 
     expect(results[0]).toMatchObject({
-      status: 'loading',
+      status: 'pending',
       isFetching: true,
       data: undefined,
       error: null,
@@ -383,7 +377,7 @@ describe('queryObserver', () => {
       enabled: false,
     })
     const unsubscribe = observer.subscribe(callback)
-    await queryClient.fetchQuery(key, queryFn)
+    await queryClient.fetchQuery({ queryKey: key, queryFn })
     unsubscribe()
     expect(queryFn).toHaveBeenCalledTimes(1)
     expect(callback).toHaveBeenCalledTimes(2)
@@ -401,7 +395,7 @@ describe('queryObserver', () => {
       results.push(x)
     })
     observer.setOptions({ enabled: false, staleTime: 10 })
-    await queryClient.fetchQuery(key, queryFn)
+    await queryClient.fetchQuery({ queryKey: key, queryFn })
     await sleep(100)
     unsubscribe()
     expect(queryFn).toHaveBeenCalledTimes(1)
@@ -426,7 +420,7 @@ describe('queryObserver', () => {
     const unsubscribe2 = observer.subscribe((x) => {
       results2.push(x)
     })
-    await queryClient.fetchQuery(key, queryFn)
+    await queryClient.fetchQuery({ queryKey: key, queryFn })
     await sleep(50)
     unsubscribe1()
     unsubscribe2()
@@ -460,25 +454,29 @@ describe('queryObserver', () => {
 
   test('should clear interval when unsubscribing to a refetchInterval query', async () => {
     const key = queryKey()
+    let count = 0
 
-    const fetchData = () => Promise.resolve('data')
+    const fetchData = () => {
+      count++
+      return Promise.resolve('data')
+    }
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
       queryFn: fetchData,
-      cacheTime: 0,
-      refetchInterval: 1,
+      gcTime: 0,
+      refetchInterval: 10,
     })
     const unsubscribe = observer.subscribe(() => undefined)
-    // @ts-expect-error
-    expect(observer.refetchIntervalId).not.toBeUndefined()
+    expect(count).toBe(1)
+    await sleep(15)
+    expect(count).toBe(2)
     unsubscribe()
-    // @ts-expect-error
-    expect(observer.refetchIntervalId).toBeUndefined()
     await sleep(10)
-    expect(queryClient.getQueryCache().find(key)).toBeUndefined()
+    expect(queryClient.getQueryCache().find({ queryKey: key })).toBeUndefined()
+    expect(count).toBe(2)
   })
 
-  test('uses placeholderData as non-cache data when loading a query with no data', async () => {
+  test('uses placeholderData as non-cache data when pending a query with no data', async () => {
     const key = queryKey()
     const observer = new QueryObserver(queryClient, {
       queryKey: key,
@@ -523,36 +521,6 @@ describe('queryObserver', () => {
     expect(firstData).toBe(secondData)
   })
 
-  test('the retrier should not throw an error when reject if the retrier is already resolved', async () => {
-    const key = queryKey()
-    let count = 0
-
-    const observer = new QueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: () => {
-        count++
-        return Promise.reject<unknown>(`reject ${count}`)
-      },
-      retry: 1,
-      retryDelay: 20,
-    })
-
-    const unsubscribe = observer.subscribe(() => undefined)
-
-    // Simulate a race condition when an unsubscribe and a retry occur.
-    await sleep(20)
-    unsubscribe()
-
-    // A second reject is triggered for the retry
-    // but the retryer has already set isResolved to true
-    // so it does nothing and no error is thrown
-
-    // Should not log an error
-    queryClient.clear()
-    await sleep(40)
-    expect(mockLogger.error).not.toHaveBeenNthCalledWith(1, 'reject 1')
-  })
-
   test('should throw an error if enabled option type is not valid', async () => {
     const key = queryKey()
 
@@ -649,50 +617,6 @@ describe('queryObserver', () => {
     unsubscribe()
   })
 
-  test('should prefer isDataEqual to structuralSharing', async () => {
-    const key = queryKey()
-
-    const data = { value: 'data' }
-    const newData = { value: 'data' }
-
-    const observer = new QueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: () => data,
-    })
-
-    const unsubscribe = observer.subscribe(() => undefined)
-
-    await sleep(10)
-    expect(observer.getCurrentResult().data).toBe(data)
-
-    observer.setOptions({
-      queryKey: key,
-      queryFn: () => newData,
-      isDataEqual: () => true,
-      structuralSharing: false,
-    })
-
-    await observer.refetch()
-    expect(observer.getCurrentResult().data).toBe(data)
-
-    unsubscribe()
-  })
-
-  test('select function error using placeholderdata should log an error', () => {
-    const key = queryKey()
-
-    new QueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: () => 'data',
-      placeholderData: 'placeholderdata',
-      select: () => {
-        throw new Error('error')
-      },
-    })
-
-    expect(mockLogger.error).toHaveBeenNthCalledWith(2, new Error('error'))
-  })
-
   test('should not use replaceEqualDeep for select value when structuralSharing option is true and placeholderdata is defined', () => {
     const key = queryKey()
 
@@ -766,54 +690,6 @@ describe('queryObserver', () => {
     expect(observer.getCurrentResult().isPlaceholderData).toBe(false)
   })
 
-  test('updateResult should not notify cache listeners if cache option is false', async () => {
-    const key = queryKey()
-
-    const data1 = { value: 'data 1' }
-    const data2 = { value: 'data 2' }
-
-    await queryClient.prefetchQuery(key, () => data1)
-    const observer = new QueryObserver(queryClient, {
-      queryKey: key,
-    })
-    await queryClient.prefetchQuery(key, () => data2)
-
-    const spy = jest.fn()
-    const unsubscribe = queryClient.getQueryCache().subscribe(spy)
-    observer.updateResult({ cache: false })
-
-    expect(spy).toHaveBeenCalledTimes(0)
-
-    unsubscribe()
-  })
-
-  test('should not notify observer when the stale timeout expires and the current result is stale', async () => {
-    const key = queryKey()
-    const queryFn = () => 'data'
-
-    await queryClient.prefetchQuery(key, queryFn)
-    const observer = new QueryObserver(queryClient, {
-      queryKey: key,
-      queryFn,
-      staleTime: 20,
-    })
-
-    const spy = jest.fn()
-    const unsubscribe = observer.subscribe(spy)
-    await queryClient.refetchQueries(key)
-    await sleep(10)
-
-    // Force isStale to true
-    // because no use case has been found to reproduce this condition
-    // @ts-ignore
-    observer['currentResult'].isStale = true
-    spy.mockReset()
-    await sleep(30)
-    expect(spy).not.toHaveBeenCalled()
-
-    unsubscribe()
-  })
-
   test('setOptions should notify cache listeners', async () => {
     const key = queryKey()
 

package/src/tests/utils.test.tsx

@@ -1,12 +1,13 @@
 import {
   replaceEqualDeep,
-  partialDeepEqual,
+  partialMatchKey,
   isPlainObject,
-  parseMutationArgs,
   matchMutation,
   scheduleMicrotask,
   sleep,
   isPlainArray,
+  addToEnd,
+  addToStart,
 } from '../utils'
 import { Mutation } from '../mutation'
 import { createQueryClient } from './utils'
@@ -67,47 +68,47 @@ describe('core/utils', () => {
     })
   })
 
-  describe('partialDeepEqual', () => {
+  describe('partialMatchKey', () => {
     it('should return `true` if a includes b', () => {
-      const a = { a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }
-      const b = { a: { b: 'b' }, c: 'c', d: [] }
-      expect(partialDeepEqual(a, b)).toEqual(true)
+      const a = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
+      const b = [{ a: { b: 'b' }, c: 'c', d: [] }]
+      expect(partialMatchKey(a, b)).toEqual(true)
     })
 
     it('should return `false` if a does not include b', () => {
-      const a = { a: { b: 'b' }, c: 'c', d: [] }
-      const b = { a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }
-      expect(partialDeepEqual(a, b)).toEqual(false)
+      const a = [{ a: { b: 'b' }, c: 'c', d: [] }]
+      const b = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
+      expect(partialMatchKey(a, b)).toEqual(false)
     })
 
     it('should return `true` if array a includes array b', () => {
       const a = [1, 2, 3]
       const b = [1, 2]
-      expect(partialDeepEqual(a, b)).toEqual(true)
+      expect(partialMatchKey(a, b)).toEqual(true)
     })
 
     it('should return `false` if a is null and b is not', () => {
-      const a = null
-      const b = { a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }
-      expect(partialDeepEqual(a, b)).toEqual(false)
+      const a = [null]
+      const b = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
+      expect(partialMatchKey(a, b)).toEqual(false)
     })
 
     it('should return `false` if a contains null and b is not', () => {
-      const a = { a: null, c: 'c', d: [] }
-      const b = { a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }
-      expect(partialDeepEqual(a, b)).toEqual(false)
+      const a = [{ a: null, c: 'c', d: [] }]
+      const b = [{ a: { b: 'b' }, c: 'c', d: [{ d: 'd ' }] }]
+      expect(partialMatchKey(a, b)).toEqual(false)
     })
 
     it('should return `false` if b is null and a is not', () => {
-      const a = { a: { b: 'b' }, c: 'c', d: [] }
-      const b = null
-      expect(partialDeepEqual(a, b)).toEqual(false)
+      const a = [{ a: { b: 'b' }, c: 'c', d: [] }]
+      const b = [null]
+      expect(partialMatchKey(a, b)).toEqual(false)
     })
 
     it('should return `false` if b contains null and a is not', () => {
-      const a = { a: { b: 'b' }, c: 'c', d: [] }
-      const b = { a: null, c: 'c', d: [{ d: 'd ' }] }
-      expect(partialDeepEqual(a, b)).toEqual(false)
+      const a = [{ a: { b: 'b' }, c: 'c', d: [] }]
+      const b = [{ a: null, c: 'c', d: [{ d: 'd ' }] }]
+      expect(partialMatchKey(a, b)).toEqual(false)
     })
   })
 
@@ -327,13 +328,6 @@ describe('core/utils', () => {
     })
   })
 
-  describe('parseMutationArgs', () => {
-    it('should return mutation options', () => {
-      const options = { mutationKey: ['key'] }
-      expect(parseMutationArgs(options)).toMatchObject(options)
-    })
-  })
-
   describe('matchMutation', () => {
     it('should return false if mutationKey options is undefined', () => {
       const filters = { mutationKey: ['key1'] }
@@ -357,4 +351,65 @@ describe('core/utils', () => {
       expect(callback).toHaveBeenCalledTimes(1)
     })
   })
+
+  describe('addToEnd', () => {
+    it('should add item to the end of the array', () => {
+      const items = [1, 2, 3]
+      const newItems = addToEnd(items, 4)
+      expect(newItems).toEqual([1, 2, 3, 4])
+    })
+
+    it('should not exceed max if provided', () => {
+      const items = [1, 2, 3]
+      const newItems = addToEnd(items, 4, 3)
+      expect(newItems).toEqual([2, 3, 4])
+    })
+
+    it('should add item to the end of the array when max = 0', () => {
+      const items = [1, 2, 3]
+      const item = 4
+      const max = 0
+      expect(addToEnd(items, item, max)).toEqual([1, 2, 3, 4])
+    })
+
+    it('should add item to the end of the array when max is undefined', () => {
+      const items = [1, 2, 3]
+      const item = 4
+      const max = undefined
+      expect(addToEnd(items, item, max)).toEqual([1, 2, 3, 4])
+    })
+  })
+
+  describe('addToStart', () => {
+    it('should add an item to the start of the array', () => {
+      const items = [1, 2, 3]
+      const item = 4
+      const newItems = addToStart(items, item)
+      expect(newItems).toEqual([4, 1, 2, 3])
+    })
+
+    it('should respect the max argument', () => {
+      const items = [1, 2, 3]
+      const item = 4
+      const max = 2
+      const newItems = addToStart(items, item, max)
+      expect(newItems).toEqual([4, 1, 2])
+    })
+
+    it('should not remove any items if max = 0', () => {
+      const items = [1, 2, 3]
+      const item = 4
+      const max = 0
+      const newItems = addToStart(items, item, max)
+      expect(newItems).toEqual([4, 1, 2, 3])
+    })
+
+    it('should not remove any items if max is undefined', () => {
+      const items = [1, 2, 3]
+      const item = 4
+      const max = 0
+      const newItems = addToStart(items, item, max)
+      expect(newItems).toEqual([4, 1, 2, 3])
+    })
+  })
 })

package/src/tests/utils.ts

@@ -5,8 +5,7 @@ import { QueryClient } from '@tanstack/query-core'
 import * as utils from '../utils'
 
 export function createQueryClient(config?: QueryClientConfig): QueryClient {
-  jest.spyOn(console, 'error').mockImplementation(() => undefined)
-  return new QueryClient({ logger: mockLogger, ...config })
+  return new QueryClient(config)
 }
 
 export function mockVisibilityState(value: DocumentVisibilityState) {
@@ -17,12 +16,6 @@ export function mockNavigatorOnLine(value: boolean) {
   return jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
 }
 
-export const mockLogger = {
-  log: jest.fn(),
-  warn: jest.fn(),
-  error: jest.fn(),
-}
-
 let queryKeyCount = 0
 export function queryKey(): Array<string> {
   queryKeyCount++
@@ -48,17 +41,15 @@ export function setActTimeout(fn: () => void, ms?: number) {
  */
 export const expectType = <T>(_: T): void => undefined
 
-/**
- * Assert the parameter is not typed as `any`
- */
-export const expectTypeNotAny = <T>(_: 0 extends 1 & T ? never : T): void =>
-  undefined
-
-export const executeMutation = (
+export const executeMutation = <TVariables>(
   queryClient: QueryClient,
-  options: MutationOptions<any, any, any, any>,
-): Promise<unknown> => {
-  return queryClient.getMutationCache().build(queryClient, options).execute()
+  options: MutationOptions<any, any, TVariables, any>,
+  variables: TVariables,
+) => {
+  return queryClient
+    .getMutationCache()
+    .build(queryClient, options)
+    .execute(variables)
 }
 
 // This monkey-patches the isServer-value from utils,