@tanstack/query-core 5.21.2 → 5.21.7

package/src/queryClient.ts

@@ -41,7 +41,7 @@ import type { MutationFilters, QueryFilters, Updater } from './utils'
 
 interface QueryDefaults {
   queryKey: QueryKey
-  defaultOptions: QueryOptions<any, any, any>
+  defaultOptions: Omit<QueryOptions<any, any, any>, 'queryKey'>
 }
 
 interface MutationDefaults {
@@ -119,7 +119,8 @@ export class QueryClient {
       : TQueryFnData,
   >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined
   getQueryData(queryKey: QueryKey) {
-    return this.#queryCache.find({ queryKey })?.state.data
+    const options = this.defaultQueryOptions({ queryKey })
+    return this.#queryCache.get(options.queryHash)?.state.data
   }
 
   ensureQueryData<
@@ -165,14 +166,6 @@ export class QueryClient {
     >,
     options?: SetDataOptions,
   ): TInferredQueryFnData | undefined {
-    const query = this.#queryCache.find<TInferredQueryFnData>({ queryKey })
-    const prevData = query?.state.data
-    const data = functionalUpdate(updater, prevData)
-
-    if (typeof data === 'undefined') {
-      return undefined
-    }
-
     const defaultedOptions = this.defaultQueryOptions<
       any,
       any,
@@ -181,6 +174,16 @@ export class QueryClient {
       QueryKey
     >({ queryKey })
 
+    const query = this.#queryCache.get<TInferredQueryFnData>(
+      defaultedOptions.queryHash,
+    )
+    const prevData = query?.state.data
+    const data = functionalUpdate(updater, prevData)
+
+    if (typeof data === 'undefined') {
+      return undefined
+    }
+
     return this.#queryCache
       .build(this, defaultedOptions)
       .setData(data, { ...options, manual: true })
@@ -204,7 +207,8 @@ export class QueryClient {
   getQueryState<TQueryFnData = unknown, TError = DefaultError>(
     queryKey: QueryKey,
   ): QueryState<TQueryFnData, TError> | undefined {
-    return this.#queryCache.find<TQueryFnData, TError>({ queryKey })?.state
+    const options = this.defaultQueryOptions({ queryKey })
+    return this.#queryCache.get<TQueryFnData, TError>(options.queryHash)?.state
   }
 
   removeQueries(filters?: QueryFilters): void {
@@ -409,10 +413,13 @@ export class QueryClient {
 
   getQueryDefaults(
     queryKey: QueryKey,
-  ): QueryObserverOptions<any, any, any, any, any> {
+  ): Omit<QueryObserverOptions<any, any, any, any, any>, 'queryKey'> {
     const defaults = [...this.#queryDefaults.values()]
 
-    let result: QueryObserverOptions<any, any, any, any, any> = {}
+    let result: Omit<
+      QueryObserverOptions<any, any, any, any, any>,
+      'queryKey'
+    > = {}
 
     defaults.forEach((queryDefault) => {
       if (partialMatchKey(queryKey, queryDefault.queryKey)) {
@@ -456,7 +463,7 @@ export class QueryClient {
     TQueryKey extends QueryKey = QueryKey,
     TPageParam = never,
   >(
-    options?:
+    options:
       | QueryObserverOptions<
           TQueryFnData,
           TError,
@@ -479,7 +486,7 @@ export class QueryClient {
     TQueryData,
     TQueryKey
   > {
-    if (options?._defaulted) {
+    if (options._defaulted) {
       return options as DefaultedQueryObserverOptions<
         TQueryFnData,
         TError,
@@ -491,7 +498,7 @@ export class QueryClient {
 
     const defaultedOptions = {
       ...this.#defaultOptions.queries,
-      ...(options?.queryKey && this.getQueryDefaults(options.queryKey)),
+      ...this.getQueryDefaults(options.queryKey),
       ...options,
       _defaulted: true,
     }

package/src/queryObserver.ts

@@ -132,7 +132,7 @@ export class QueryObserver<
   }
 
   setOptions(
-    options?: QueryObserverOptions<
+    options: QueryObserverOptions<
       TQueryFnData,
       TError,
       TData,
@@ -146,7 +146,7 @@ export class QueryObserver<
 
     this.options = this.#client.defaultQueryOptions(options)
 
-    if (!shallowEqualObjects(prevOptions, this.options)) {
+    if (!shallowEqualObjects(this.options, prevOptions)) {
       this.#client.getQueryCache().notify({
         type: 'observerOptionsUpdated',
         query: this.#currentQuery,
@@ -161,11 +161,6 @@ export class QueryObserver<
       throw new Error('Expected enabled to be a boolean')
     }
 
-    // Keep previous query key if the user does not supply one
-    if (!this.options.queryKey) {
-      this.options.queryKey = prevOptions.queryKey
-    }
-
     this.#updateQuery()
 
     const mounted = this.hasListeners()

package/src/tests/queriesObserver.test.tsx

@@ -34,31 +34,6 @@ describe('queriesObserver', () => {
     expect(observerResult).toMatchObject([{ data: 1 }, { data: 2 }])
   })
 
-  test('should still return value for undefined query key', async () => {
-    const consoleMock = vi.spyOn(console, 'error')
-    consoleMock.mockImplementation(() => undefined)
-    const key1 = queryKey()
-    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 },
-    ])
-    let observerResult
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-    await sleep(1)
-    unsubscribe()
-    expect(observerResult).toMatchObject([{ data: 1 }, { data: 2 }])
-
-    expect(consoleMock).toHaveBeenCalledTimes(1)
-    expect(consoleMock).toHaveBeenCalledWith(
-      "As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']",
-    )
-    consoleMock.mockRestore()
-  })
-
   test('should update when a query updates', async () => {
     const key1 = queryKey()
     const key2 = queryKey()

package/src/tests/queryCache.test.tsx

@@ -53,10 +53,11 @@ describe('queryCache', () => {
       const unsubScribeObserver = observer.subscribe(vi.fn())
 
       await waitFor(() => {
-        expect(events.length).toBe(8)
+        expect(events.length).toBe(9)
       })
 
       expect(events).toEqual([
+        'observerOptionsUpdated',
         'added', // 1. Query added -> loading
         'observerResultsUpdated', // 2. Observer result updated -> loading
         'observerAdded', // 3. Observer added

package/src/tests/queryClient.test.tsx

@@ -356,6 +356,16 @@ describe('queryClient', () => {
         }),
       )
     })
+
+    test('should set 10k data in less than 500ms', () => {
+      const key = queryKey()
+      const start = performance.now()
+      for (let i = 0; i < 10000; i++) {
+        queryClient.setQueryData([key, i], i)
+      }
+      const end = performance.now()
+      expect(end - start).toBeLessThan(500)
+    })
   })
 
   describe('setQueriesData', () => {
@@ -419,6 +429,38 @@ describe('queryClient', () => {
       queryClient.setQueryData([key, 'id'], 'bar')
       expect(queryClient.getQueryData([key])).toBeUndefined()
     })
+
+    test('should get 10k queries in less than 500ms', () => {
+      const key = queryKey()
+      for (let i = 0; i < 10000; i++) {
+        queryClient.setQueryData([key, i], i)
+      }
+
+      const start = performance.now()
+      for (let i = 0; i < 10000; i++) {
+        queryClient.getQueryData([key, i])
+      }
+      const end = performance.now()
+
+      expect(end - start).toBeLessThan(500)
+    })
+  })
+
+  describe('getQueryState', () => {
+    test('should get 10k queries in less than 500ms', () => {
+      const key = queryKey()
+      for (let i = 0; i < 10000; i++) {
+        queryClient.setQueryData([key, i], i)
+      }
+
+      const start = performance.now()
+      for (let i = 0; i < 10000; i++) {
+        queryClient.getQueryState([key, i])
+      }
+      const end = performance.now()
+
+      expect(end - start).toBeLessThan(500)
+    })
   })
 
   describe('ensureQueryData', () => {

package/src/tests/queryObserver.test.tsx

@@ -459,7 +459,7 @@ describe('queryObserver', () => {
     const unsubscribe = observer.subscribe((x) => {
       results.push(x)
     })
-    observer.setOptions({ enabled: false, staleTime: 10 })
+    observer.setOptions({ queryKey: key, enabled: false, staleTime: 10 })
     await queryClient.fetchQuery({ queryKey: key, queryFn })
     await sleep(100)
     unsubscribe()
@@ -579,7 +579,7 @@ describe('queryObserver', () => {
 
     const firstData = observer.getCurrentResult().data
 
-    observer.setOptions({ placeholderData: {} })
+    observer.setOptions({ queryKey: key, placeholderData: {} })
 
     const secondData = observer.getCurrentResult().data
 
@@ -885,7 +885,7 @@ describe('queryObserver', () => {
 
     const spy = vi.fn()
     const unsubscribe = queryClient.getQueryCache().subscribe(spy)
-    observer.setOptions({ enabled: false })
+    observer.setOptions({ queryKey: key, enabled: false })
 
     expect(spy).toHaveBeenCalledTimes(1)
     expect(spy).toHaveBeenCalledWith(

package/src/tests/queryObserver.types.test.tsx

@@ -31,6 +31,7 @@ describe('placeholderData', () => {
         }
 
         new QueryObserver<boolean, CustomError>(createQueryClient(), {
+          queryKey: ['key'],
           placeholderData: (_, previousQuery) => {
             const error = previousQuery?.state.error
 
@@ -49,6 +50,7 @@ describe('placeholderData', () => {
         type QueryData = typeof queryData
 
         new QueryObserver(createQueryClient(), {
+          queryKey: ['key'],
           queryFn: () => queryData,
           select: (data) => data.foo,
           placeholderData: (previousData) => {

package/src/tests/utils.test.tsx

@@ -7,11 +7,29 @@ import {
   matchMutation,
   partialMatchKey,
   replaceEqualDeep,
+  shallowEqualObjects,
 } from '../utils'
 import { Mutation } from '../mutation'
 import { createQueryClient } from './utils'
 
 describe('core/utils', () => {
+  describe('shallowEqualObjects', () => {
+    it('should return `true` for shallow equal objects', () => {
+      expect(shallowEqualObjects({ a: 1 }, { a: 1 })).toEqual(true)
+    })
+
+    it('should return `false` for non shallow equal objects', () => {
+      expect(shallowEqualObjects({ a: 1 }, { a: 2 })).toEqual(false)
+    })
+
+    it('should return `false` if lengths are not equal', () => {
+      expect(shallowEqualObjects({ a: 1 }, { a: 1, b: 2 })).toEqual(false)
+    })
+
+    it('should return false if b is undefined', () => {
+      expect(shallowEqualObjects({ a: 1 }, undefined)).toEqual(false)
+    })
+  })
   describe('isPlainObject', () => {
     it('should return `true` for a plain object', () => {
       expect(isPlainObject({})).toEqual(true)

package/src/types.ts

@@ -218,12 +218,9 @@ export interface QueryObserverOptions<
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = never,
-> extends QueryOptions<
-    TQueryFnData,
-    TError,
-    TQueryData,
-    TQueryKey,
-    TPageParam
+> extends WithRequired<
+    QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>,
+    'queryKey'
   > {
   /**
    * Set this to `false` to disable automatic refetching when the query mounts or changes query keys.
@@ -340,6 +337,11 @@ export interface QueryObserverOptions<
 export type WithRequired<TTarget, TKey extends keyof TTarget> = TTarget & {
   [_ in TKey]: {}
 }
+export type Optional<TTarget, TKey extends keyof TTarget> = Pick<
+  Partial<TTarget>,
+  TKey
+> &
+  Omit<TTarget, TKey>
 
 export type DefaultedQueryObserverOptions<
   TQueryFnData = unknown,
@@ -871,7 +873,7 @@ export interface QueryClientConfig {
 }
 
 export interface DefaultOptions<TError = DefaultError> {
-  queries?: Omit<QueryObserverOptions<unknown, TError>, 'suspense'>
+  queries?: Omit<QueryObserverOptions<unknown, TError>, 'suspense' | 'queryKey'>
   mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>
 }
 

package/src/utils.ts

@@ -167,7 +167,7 @@ export function matchMutation(
 
 export function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(
   queryKey: TQueryKey,
-  options?: QueryOptions<any, any, any, TQueryKey>,
+  options?: Pick<QueryOptions<any, any, any, any>, 'queryKeyHashFn'>,
 ): string {
   const hashFn = options?.queryKeyHashFn || hashKey
   return hashFn(queryKey)
@@ -257,10 +257,13 @@ export function replaceEqualDeep(a: any, b: any): any {
 }
 
 /**
- * Shallow compare objects. Only works with objects that always have the same properties.
+ * Shallow compare objects.
  */
-export function shallowEqualObjects<T>(a: T, b: T): boolean {
-  if ((a && !b) || (b && !a)) {
+export function shallowEqualObjects<T extends Record<string, any>>(
+  a: T,
+  b: T | undefined,
+): boolean {
+  if (!b || Object.keys(a).length !== Object.keys(b).length) {
     return false
   }