@tanstack/query-core 5.28.0 → 5.28.4

package/src/queryObserver.ts

@@ -9,9 +9,9 @@ import {
 import { notifyManager } from './notifyManager'
 import { focusManager } from './focusManager'
 import { Subscribable } from './subscribable'
-import { canFetch } from './retryer'
-import type { QueryClient } from './queryClient'
+import { fetchState } from './query'
 import type { FetchOptions, Query, QueryState } from './query'
+import type { QueryClient } from './queryClient'
 import type {
   DefaultError,
   DefaultedQueryObserverOptions,
@@ -437,7 +437,7 @@ export class QueryObserver<
       : this.#currentQueryInitialState
 
     const { state } = query
-    let { error, errorUpdatedAt, fetchStatus, status } = state
+    let newState = { ...state }
     let isPlaceholderData = false
     let data: TData | undefined
 
@@ -451,31 +451,31 @@ export class QueryObserver<
         mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions)
 
       if (fetchOnMount || fetchOptionally) {
-        fetchStatus = canFetch(query.options.networkMode)
-          ? 'fetching'
-          : 'paused'
-        if (state.data === undefined) {
-          status = 'pending'
+        newState = {
+          ...newState,
+          ...fetchState(state.data, query.options),
         }
       }
       if (options._optimisticResults === 'isRestoring') {
-        fetchStatus = 'idle'
+        newState.fetchStatus = 'idle'
       }
     }
 
+    let { error, errorUpdatedAt, status } = newState
+
     // Select data if needed
-    if (options.select && state.data !== undefined) {
+    if (options.select && newState.data !== undefined) {
       // Memoize select result
       if (
         prevResult &&
-        state.data === prevResultState?.data &&
+        newState.data === prevResultState?.data &&
         options.select === this.#selectFn
       ) {
         data = this.#selectResult
       } else {
         try {
           this.#selectFn = options.select
-          data = options.select(state.data)
+          data = options.select(newState.data)
           data = replaceData(prevResult?.data, data, options)
           this.#selectResult = data
           this.#selectError = null
@@ -486,7 +486,7 @@ export class QueryObserver<
     }
     // Use query data
     else {
-      data = state.data as unknown as TData
+      data = newState.data as unknown as TData
     }
 
     // Show placeholder data if needed
@@ -541,36 +541,36 @@ export class QueryObserver<
       status = 'error'
     }
 
-    const isFetching = fetchStatus === 'fetching'
+    const isFetching = newState.fetchStatus === 'fetching'
     const isPending = status === 'pending'
     const isError = status === 'error'
 
     const isLoading = isPending && isFetching
-    const hasData = state.data !== undefined
+    const hasData = data !== undefined
 
     const result: QueryObserverBaseResult<TData, TError> = {
       status,
-      fetchStatus,
+      fetchStatus: newState.fetchStatus,
       isPending,
       isSuccess: status === 'success',
       isError,
       isInitialLoading: isLoading,
       isLoading,
       data,
-      dataUpdatedAt: state.dataUpdatedAt,
+      dataUpdatedAt: newState.dataUpdatedAt,
       error,
       errorUpdatedAt,
-      failureCount: state.fetchFailureCount,
-      failureReason: state.fetchFailureReason,
-      errorUpdateCount: state.errorUpdateCount,
-      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
+      failureCount: newState.fetchFailureCount,
+      failureReason: newState.fetchFailureReason,
+      errorUpdateCount: newState.errorUpdateCount,
+      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
       isFetchedAfterMount:
-        state.dataUpdateCount > queryInitialState.dataUpdateCount ||
-        state.errorUpdateCount > queryInitialState.errorUpdateCount,
+        newState.dataUpdateCount > queryInitialState.dataUpdateCount ||
+        newState.errorUpdateCount > queryInitialState.errorUpdateCount,
       isFetching,
       isRefetching: isFetching && !isPending,
       isLoadingError: isError && !hasData,
-      isPaused: fetchStatus === 'paused',
+      isPaused: newState.fetchStatus === 'paused',
       isPlaceholderData,
       isRefetchError: isError && hasData,
       isStale: isStale(query, options),

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()
+  })
 })