fix(streamedQuery): maintain error state on reset refetch with initialData defined (TanStack#10287)

* fix(streamedQuery): maintain error state on reset refetch with initialData defined

* ref: changeset

* fix: isRefetch computation

* test: add refetch behavior for reset mode after initial error

* test: add reset behavior for refetch after initial error with initialData

* ref: re-use isFetched in queryObserver.ts

* ref: function instead of getter

Author: TkDodo

.changeset/shaggy-ducks-cheer.md

@@ -0,0 +1,20 @@
+---
+'@tanstack/query-broadcast-client-experimental': patch
+'@tanstack/query-async-storage-persister': patch
+'@tanstack/angular-query-persist-client': patch
+'@tanstack/query-sync-storage-persister': patch
+'@tanstack/preact-query-persist-client': patch
+'@tanstack/svelte-query-persist-client': patch
+'@tanstack/angular-query-experimental': patch
+'@tanstack/react-query-persist-client': patch
+'@tanstack/solid-query-persist-client': patch
+'@tanstack/query-persist-client-core': patch
+'@tanstack/preact-query': patch
+'@tanstack/svelte-query': patch
+'@tanstack/react-query': patch
+'@tanstack/solid-query': patch
+'@tanstack/query-core': patch
+'@tanstack/vue-query': patch
+---
+
+fix(streamedQuery): maintain error state on reset refetch with initialData defined

packages/query-core/src/__tests__/streamedQuery.test.tsx

@@ -539,6 +539,171 @@ describe('streamedQuery', () => {
     unsubscribe()
   })
 
+  test('should keep error state on reset refetch when initialData is defined', async () => {
+    const key = queryKey()
+    let shouldError = false
+    const error = new Error('stream failed')
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      initialData: ['initial'],
+      retry: false,
+      queryFn: streamedQuery({
+        refetchMode: 'reset',
+        streamFn: async function* () {
+          if (shouldError) {
+            throw error
+          }
+
+          yield 0
+        },
+      }),
+    })
+
+    const unsubscribe = observer.subscribe(vi.fn())
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'success',
+      fetchStatus: 'idle',
+      data: ['initial', 0],
+    })
+
+    shouldError = true
+
+    const refetchPromise = observer.refetch()
+
+    await vi.advanceTimersByTimeAsync(0)
+    await expect(refetchPromise).resolves.toMatchObject({
+      status: 'error',
+      error,
+      data: ['initial'],
+    })
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'error',
+      fetchStatus: 'idle',
+      data: ['initial'],
+      error,
+    })
+
+    unsubscribe()
+  })
+
+  test('should treat a fetch after an initial error as a refetch for reset mode', async () => {
+    const key = queryKey()
+    let shouldError = true
+    const error = new Error('stream failed')
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      retry: false,
+      queryFn: streamedQuery({
+        refetchMode: 'reset',
+        streamFn: async function* () {
+          if (shouldError) {
+            throw error
+          }
+
+          yield* createAsyncNumberGenerator(1)
+        },
+      }),
+    })
+
+    const unsubscribe = observer.subscribe(vi.fn())
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'error',
+      fetchStatus: 'idle',
+      data: undefined,
+      error,
+    })
+
+    shouldError = false
+
+    void observer.refetch()
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'pending',
+      fetchStatus: 'fetching',
+      data: undefined,
+      error: null,
+    })
+
+    await vi.advanceTimersByTimeAsync(50)
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'success',
+      fetchStatus: 'idle',
+      data: [0],
+      error: null,
+    })
+
+    unsubscribe()
+  })
+
+  test('should reset to initialData on refetch after an initial error', async () => {
+    const key = queryKey()
+    let shouldError = true
+    const error = new Error('stream failed')
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      initialData: ['initial'],
+      retry: false,
+      queryFn: streamedQuery({
+        refetchMode: 'reset',
+        streamFn: async function* () {
+          if (shouldError) {
+            throw error
+          }
+
+          yield* createAsyncNumberGenerator(1)
+        },
+      }),
+    })
+
+    const unsubscribe = observer.subscribe(vi.fn())
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'error',
+      fetchStatus: 'idle',
+      data: ['initial'],
+      error,
+    })
+
+    shouldError = false
+
+    void observer.refetch()
+
+    await vi.advanceTimersByTimeAsync(0)
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'success',
+      fetchStatus: 'fetching',
+      data: ['initial'],
+      error: null,
+    })
+
+    await vi.advanceTimersByTimeAsync(50)
+
+    expect(observer.getCurrentResult()).toMatchObject({
+      status: 'success',
+      fetchStatus: 'idle',
+      data: ['initial', 0],
+      error: null,
+    })
+
+    unsubscribe()
+  })
+
   test('should not call reducer twice when refetchMode is replace', async () => {
     const key = queryKey()
     const arr: Array<number> = []

packages/query-core/src/query.ts

@@ -260,9 +260,13 @@ export class Query<
     this.cancel({ silent: true })
   }
 
+  get resetState(): QueryState<TData, TError> {
+    return this.#initialState
+  }
+
   reset(): void {
     this.destroy()
-    this.setState(this.#initialState)
+    this.setState(this.resetState)
   }
 
   isActive(): boolean {
@@ -276,10 +280,11 @@ export class Query<
       return !this.isActive()
     }
     // if a query has no observers, it should still be considered disabled if it never attempted a fetch
-    return (
-      this.options.queryFn === skipToken ||
-      this.state.dataUpdateCount + this.state.errorUpdateCount === 0
-    )
+    return this.options.queryFn === skipToken || !this.isFetched()
+  }
+
+  isFetched() {
+    return this.state.dataUpdateCount + this.state.errorUpdateCount > 0
   }
 
   isStatic(): boolean {

packages/query-core/src/queryObserver.ts

@@ -576,7 +576,7 @@ export class QueryObserver<
       failureCount: newState.fetchFailureCount,
       failureReason: newState.fetchFailureReason,
       errorUpdateCount: newState.errorUpdateCount,
-      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
+      isFetched: query.isFetched(),
       isFetchedAfterMount:
         newState.dataUpdateCount > queryInitialState.dataUpdateCount ||
         newState.errorUpdateCount > queryInitialState.errorUpdateCount,

packages/query-core/src/streamedQuery.ts

@@ -66,12 +66,10 @@ export function streamedQuery<
     const query = context.client
       .getQueryCache()
       .find({ queryKey: context.queryKey, exact: true })
-    const isRefetch = !!query && query.state.data !== undefined
+    const isRefetch = !!query && query.isFetched()
     if (isRefetch && refetchMode === 'reset') {
       query.setState({
-        status: 'pending',
-        data: undefined,
-        error: null,
+        ...query.resetState,
         fetchStatus: 'fetching',
       })
     }