@tanstack/query-core 5.27.5 → 5.28.2

package/src/mutationObserver.ts

@@ -73,8 +73,8 @@ export class MutationObserver<
       hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)
     ) {
       this.reset()
-    } else {
-      this.#currentMutation?.setOptions(this.options)
+    } else if (this.#currentMutation?.state.status === 'pending') {
+      this.#currentMutation.setOptions(this.options)
     }
   }
 

package/src/queryClient.ts

@@ -19,6 +19,7 @@ import type {
   DefaultError,
   DefaultOptions,
   DefaultedQueryObserverOptions,
+  EnsureQueryDataOptions,
   FetchInfiniteQueryOptions,
   FetchQueryOptions,
   InfiniteData,
@@ -130,13 +131,24 @@ export class QueryClient {
     TData = TQueryFnData,
     TQueryKey extends QueryKey = QueryKey,
   >(
-    options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+    options: EnsureQueryDataOptions<TQueryFnData, TError, TData, TQueryKey>,
   ): Promise<TData> {
     const cachedData = this.getQueryData<TData>(options.queryKey)
 
-    return cachedData !== undefined
-      ? Promise.resolve(cachedData)
-      : this.fetchQuery(options)
+    if (cachedData === undefined) return this.fetchQuery(options)
+    else {
+      const defaultedOptions = this.defaultQueryOptions(options)
+      const query = this.#queryCache.build(this, defaultedOptions)
+
+      if (
+        options.revalidateIfStale &&
+        query.isStaleByTime(defaultedOptions.staleTime)
+      ) {
+        void this.prefetchQuery(defaultedOptions)
+      }
+
+      return Promise.resolve(cachedData)
+    }
   }
 
   getQueriesData<TQueryFnData = unknown>(

package/src/tests/mutationObserver.test.tsx

@@ -169,4 +169,158 @@ describe('mutationObserver', () => {
 
     unsubscribe()
   })
+
+  test('changing mutation meta should not affect successful mutations', async () => {
+    const mutationObserver = new MutationObserver(queryClient, {
+      meta: { a: 1 },
+      mutationFn: async (text: string) => {
+        await sleep(5)
+        return text
+      },
+    })
+
+    const subscriptionHandler = vi.fn()
+
+    const unsubscribe = mutationObserver.subscribe(subscriptionHandler)
+
+    await mutationObserver.mutate('input')
+
+    expect(queryClient.getMutationCache().find({})).toMatchObject({
+      options: { meta: { a: 1 } },
+      state: {
+        status: 'success',
+        data: 'input',
+      },
+    })
+
+    mutationObserver.setOptions({
+      meta: { a: 2 },
+    })
+
+    expect(queryClient.getMutationCache().find({})).toMatchObject({
+      options: { meta: { a: 1 } },
+      state: {
+        status: 'success',
+        data: 'input',
+      },
+    })
+
+    unsubscribe()
+  })
+
+  test('mutation cache should have different meta when updated between mutations', async () => {
+    const mutationFn = async (text: string) => {
+      await sleep(5)
+      return text
+    }
+    const mutationObserver = new MutationObserver(queryClient, {
+      meta: { a: 1 },
+      mutationFn,
+    })
+
+    const subscriptionHandler = vi.fn()
+
+    const unsubscribe = mutationObserver.subscribe(subscriptionHandler)
+
+    await mutationObserver.mutate('input')
+
+    mutationObserver.setOptions({
+      meta: { a: 2 },
+      mutationFn,
+    })
+
+    await mutationObserver.mutate('input')
+
+    const mutations = queryClient.getMutationCache().findAll()
+    expect(mutations[0]).toMatchObject({
+      options: { meta: { a: 1 } },
+      state: {
+        status: 'success',
+        data: 'input',
+      },
+    })
+    expect(mutations[1]).toMatchObject({
+      options: { meta: { a: 2 } },
+      state: {
+        status: 'success',
+        data: 'input',
+      },
+    })
+
+    unsubscribe()
+  })
+
+  test('changing mutation meta should not affect rejected mutations', async () => {
+    const mutationObserver = new MutationObserver(queryClient, {
+      meta: { a: 1 },
+      mutationFn: async (_: string) => {
+        await sleep(5)
+        return Promise.reject(new Error('err'))
+      },
+    })
+
+    const subscriptionHandler = vi.fn()
+
+    const unsubscribe = mutationObserver.subscribe(subscriptionHandler)
+
+    await mutationObserver.mutate('input').catch(() => undefined)
+
+    expect(queryClient.getMutationCache().find({})).toMatchObject({
+      options: { meta: { a: 1 } },
+      state: {
+        status: 'error',
+      },
+    })
+
+    mutationObserver.setOptions({
+      meta: { a: 2 },
+    })
+
+    expect(queryClient.getMutationCache().find({})).toMatchObject({
+      options: { meta: { a: 1 } },
+      state: {
+        status: 'error',
+      },
+    })
+
+    unsubscribe()
+  })
+
+  test('changing mutation meta should affect pending mutations', async () => {
+    const mutationObserver = new MutationObserver(queryClient, {
+      meta: { a: 1 },
+      mutationFn: async (text: string) => {
+        await sleep(20)
+        return text
+      },
+    })
+
+    const subscriptionHandler = vi.fn()
+
+    const unsubscribe = mutationObserver.subscribe(subscriptionHandler)
+
+    mutationObserver.mutate('input')
+
+    await sleep(0)
+
+    expect(queryClient.getMutationCache().find({})).toMatchObject({
+      options: { meta: { a: 1 } },
+      state: {
+        status: 'pending',
+      },
+    })
+
+    mutationObserver.setOptions({
+      meta: { a: 2 },
+    })
+
+    expect(queryClient.getMutationCache().find({})).toMatchObject({
+      options: { meta: { a: 2 } },
+      state: {
+        status: 'pending',
+      },
+    })
+
+    unsubscribe()
+  })
 })

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', () => {

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 }
   | {