revert

packages/query-core/src/query.ts

@@ -1,16 +1,13 @@
-import { notifyManager } from './notifyManager'
-import { Removable } from './removable'
-import { canFetch, createRetryer, isCancelledError } from './retryer'
 import {
   ensureQueryFn,
   noop,
   replaceData,
   resolveEnabled,
   timeUntilStale,
 } from './utils'
-import type { QueryCache } from './queryCache'
-import type { QueryObserver } from './queryObserver'
-import type { Retryer } from './retryer'
+import { notifyManager } from './notifyManager'
+import { canFetch, createRetryer, isCancelledError } from './retryer'
+import { Removable } from './removable'
 import type {
   CancelOptions,
   DefaultError,
@@ -25,6 +22,9 @@ import type {
   QueryStatus,
   SetDataOptions,
 } from './types'
+import type { QueryCache } from './queryCache'
+import type { QueryObserver } from './queryObserver'
+import type { Retryer } from './retryer'
 
 // TYPES
 
@@ -300,7 +300,7 @@ export class Query<
   }
 
   addObserver(observer: QueryObserver<any, any, any, any, any>): void {
-    if (!this.hasObserver(observer)) {
+    if (!this.observers.includes(observer)) {
       this.observers.push(observer)
 
       // Stop the query from being garbage collected
@@ -310,12 +310,8 @@ export class Query<
     }
   }
 
-  hasObserver(observer: QueryObserver<any, any, any, any, any>): boolean {
-    return this.observers.includes(observer)
-  }
-
   removeObserver(observer: QueryObserver<any, any, any, any, any>): void {
-    if (this.hasObserver(observer)) {
+    if (this.observers.includes(observer)) {
       this.observers = this.observers.filter((x) => x !== observer)
 
       if (!this.observers.length) {

packages/query-core/src/queryObserver.ts

@@ -89,22 +89,6 @@ export class QueryObserver<
 
     this.bindMethods()
     this.setOptions(options)
-
-    const query = this.#client.getQueryCache().find(this.options)
-
-    if (query?.promise) {
-      // If there is an existing promise, we tap into it to resolve the currentThenable
-      // This is because `use()` actually unmounts `useQuery()` immediately where the observer is never subscribing
-      query.promise
-        .catch(() => {
-          // if this throws, we don't care
-        })
-        .finally(() => {
-          if (!this.#currentQuery.hasObserver(this)) {
-            this.onQueryUpdate()
-          }
-        })
-    }
   }
 
   protected bindMethods(): void {
@@ -755,6 +739,10 @@ export class QueryObserver<
       })
     })
   }
+
+  isObserved(): boolean {
+    return this.#currentQuery.hasObserver(this)
+  }
 }
 
 function shouldLoadOnMount(

packages/react-query/src/useBaseQuery.ts

@@ -67,13 +67,6 @@ export function useBaseQuery<
 
   useClearResetErrorBoundary(errorResetBoundary)
 
-  if (
-    !client.getQueryState(options.queryKey) &&
-    defaultedOptions.enabled !== false
-  ) {
-    client.prefetchQuery(defaultedOptions)
-  }
-
   const [observer] = React.useState(
     () =>
       new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(
@@ -82,6 +75,18 @@ export function useBaseQuery<
       ),
   )
 
+  if (
+    client.getQueryState(options.queryKey)?.data === undefined &&
+    defaultedOptions.enabled !== false
+  ) {
+    client.prefetchQuery(defaultedOptions).finally(() => {
+      if (!observer.hasListeners()) {
+        // This allows `.use(query.promise)` to work without having to be subscribed to the query
+        // This is because `use()` actually unmounts `useQuery()` so the observer is never starts subscribing
+        observer.onQueryUpdate()
+      }
+    })
+  }
   const result = observer.getOptimisticResult(defaultedOptions)
 
   React.useSyncExternalStore(