@tanstack/query-core 5.100.0 → 5.100.2

package/src/hydration.ts

@@ -48,6 +48,7 @@ interface DehydratedQuery {
   state: QueryState
   promise?: Promise<unknown>
   meta?: QueryMeta
+  queryType?: 'infinite'
   // This is only optional because older versions of Query might have dehydrated
   // without it which we need to handle for backwards compatibility.
   // This should be changed to required in the future.
@@ -117,6 +118,7 @@ function dehydrateQuery(
       promise: dehydratePromise(),
     }),
     ...(query.meta && { meta: query.meta }),
+    ...(query.queryType && { queryType: query.queryType }),
   }
 }
 
@@ -209,7 +211,15 @@ export function hydrate(
   })
 
   queries.forEach(
-    ({ queryKey, state, queryHash, meta, promise, dehydratedAt }) => {
+    ({
+      queryKey,
+      state,
+      queryHash,
+      meta,
+      promise,
+      dehydratedAt,
+      queryType,
+    }) => {
       const syncData = promise ? tryResolveSync(promise) : undefined
       const rawData = state.data === undefined ? syncData?.data : state.data
       const data = rawData === undefined ? rawData : deserializeData(rawData)
@@ -230,12 +240,24 @@ export function hydrate(
           state.dataUpdatedAt > query.state.dataUpdatedAt ||
           hasNewerSyncData
         ) {
-          // omit fetchStatus from dehydrated state
-          // so that query stays in its current fetchStatus
+          // Omit fetchStatus from dehydrated state so that query stays in its current fetchStatus
           const { fetchStatus: _ignored, ...serializedState } = state
           query.setState({
             ...serializedState,
             data,
+            // If the query was pending at the moment of dehydration, but resolved to have data
+            // before hydration, we can assume the query should be hydrated as successful.
+            //
+            // Since you can opt into dehydrating failed queries, and those can have data from
+            // previous successful fetches, we make sure we only do this for pending queries.
+            ...(state.status === 'pending' &&
+              data !== undefined && {
+                status: 'success' as const,
+                // Preserve existing fetchStatus if the existing query is actively fetching.
+                ...(!existingQueryIsFetching && {
+                  fetchStatus: 'idle' as const,
+                }),
+              }),
           })
         }
       } else {
@@ -248,6 +270,7 @@ export function hydrate(
             queryKey,
             queryHash,
             meta,
+            _type: queryType,
           },
           // Reset fetch status to idle to avoid
           // query being stuck in fetching state upon hydration
@@ -255,13 +278,21 @@ export function hydrate(
             ...state,
             data,
             fetchStatus: 'idle',
-            status: data !== undefined ? 'success' : state.status,
+            // Like above, if the query was pending at the moment of dehydration but has data,
+            // we can assume it should be hydrated as successful.
+            status:
+              state.status === 'pending' && data !== undefined
+                ? 'success'
+                : state.status,
           },
         )
       }
 
       if (
         promise &&
+        // If the data was synchronously available, there is no need to set up
+        // a retryer and thus no reason to call fetch
+        !syncData &&
         !existingQueryIsPending &&
         !existingQueryIsFetching &&
         // Only hydrate if dehydration is newer than any existing data,
@@ -270,8 +301,6 @@ export function hydrate(
       ) {
         // This doesn't actually fetch - it just creates a retryer
         // which will re-use the passed `initialPromise`
-        // Note that we need to call these even when data was synchronously
-        // available, as we still need to set up the retryer
         query
           .fetch(undefined, {
             // RSC transformed promises are not thenable

package/src/infiniteQueryObserver.ts

@@ -1,9 +1,5 @@
 import { QueryObserver } from './queryObserver'
-import {
-  hasNextPage,
-  hasPreviousPage,
-  infiniteQueryBehavior,
-} from './infiniteQueryBehavior'
+import { hasNextPage, hasPreviousPage } from './infiniteQueryBehavior'
 import type { Subscribable } from './subscribable'
 import type {
   DefaultError,
@@ -93,10 +89,8 @@ export class InfiniteQueryObserver<
       TPageParam
     >,
   ): void {
-    super.setOptions({
-      ...options,
-      behavior: infiniteQueryBehavior(),
-    })
+    options._type = 'infinite'
+    super.setOptions(options)
   }
 
   getOptimisticResult(
@@ -108,7 +102,7 @@ export class InfiniteQueryObserver<
       TPageParam
     >,
   ): InfiniteQueryObserverResult<TData, TError> {
-    options.behavior = infiniteQueryBehavior()
+    options._type = 'infinite'
     return super.getOptimisticResult(options) as InfiniteQueryObserverResult<
       TData,
       TError

package/src/query.ts

@@ -10,6 +10,7 @@ import {
 import { notifyManager } from './notifyManager'
 import { CancelledError, canFetch, createRetryer } from './retryer'
 import { Removable } from './removable'
+import { infiniteQueryBehavior } from './infiniteQueryBehavior'
 import type { QueryCache } from './queryCache'
 import type { QueryClient } from './queryClient'
 import type {
@@ -137,7 +138,6 @@ interface ContinueAction {
 interface SetStateAction<TData, TError> {
   type: 'setState'
   state: Partial<QueryState<TData, TError>>
-  setStateOptions?: SetStateOptions
 }
 
 export type Action<TData, TError> =
@@ -150,10 +150,6 @@ export type Action<TData, TError> =
   | SetStateAction<TData, TError>
   | SuccessAction<TData>
 
-export interface SetStateOptions {
-  meta?: any
-}
-
 // CLASS
 
 export class Query<
@@ -166,6 +162,7 @@ export class Query<
   queryHash: string
   options!: QueryOptions<TQueryFnData, TError, TData, TQueryKey>
   state: QueryState<TData, TError>
+  #queryType?: 'infinite'
 
   #initialState: QueryState<TData, TError>
   #revertState?: QueryState<TData, TError>
@@ -195,6 +192,10 @@ export class Query<
     return this.options.meta
   }
 
+  get queryType() {
+    return this.#queryType
+  }
+
   get promise(): Promise<TData> | undefined {
     return this.#retryer?.promise
   }
@@ -204,6 +205,10 @@ export class Query<
   ): void {
     this.options = { ...this.#defaultOptions, ...options }
 
+    if (options?._type) {
+      this.#queryType = options._type
+    }
+
     this.updateGcTime(this.options.gcTime)
 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -241,11 +246,8 @@ export class Query<
     return data
   }
 
-  setState(
-    state: Partial<QueryState<TData, TError>>,
-    setStateOptions?: SetStateOptions,
-  ): void {
-    this.#dispatch({ type: 'setState', state, setStateOptions })
+  setState(state: Partial<QueryState<TData, TError>>): void {
+    this.#dispatch({ type: 'setState', state })
   }
 
   cancel(options?: CancelOptions): Promise<void> {
@@ -511,7 +513,13 @@ export class Query<
 
     const context = createFetchContext()
 
-    this.options.behavior?.onFetch(context, this as unknown as Query)
+    const behavior =
+      this.#queryType === 'infinite'
+        ? (infiniteQueryBehavior(
+            (this.options as { pages?: number }).pages,
+          ) as QueryBehavior<TQueryFnData, TError, TData, TQueryKey>)
+        : this.options.behavior
+    behavior?.onFetch(context, this as unknown as Query)
 
     // Store state in case the current fetch needs to be reverted
     this.#revertState = this.state

package/src/queryClient.ts

@@ -12,7 +12,6 @@ import { MutationCache } from './mutationCache'
 import { focusManager } from './focusManager'
 import { onlineManager } from './onlineManager'
 import { notifyManager } from './notifyManager'
-import { infiniteQueryBehavior } from './infiniteQueryBehavior'
 import type {
   CancelOptions,
   DefaultError,
@@ -395,12 +394,7 @@ export class QueryClient {
       TPageParam
     >,
   ): Promise<InfiniteData<TData, TPageParam>> {
-    options.behavior = infiniteQueryBehavior<
-      TQueryFnData,
-      TError,
-      TData,
-      TPageParam
-    >(options.pages)
+    options._type = 'infinite'
     return this.fetchQuery(options as any)
   }
 
@@ -437,12 +431,7 @@ export class QueryClient {
       TPageParam
     >,
   ): Promise<InfiniteData<TData, TPageParam>> {
-    options.behavior = infiniteQueryBehavior<
-      TQueryFnData,
-      TError,
-      TData,
-      TPageParam
-    >(options.pages)
+    options._type = 'infinite'
 
     return this.ensureQueryData(options as any)
   }

package/src/types.ts

@@ -246,11 +246,7 @@ export interface QueryOptions<
    */
   gcTime?: number
   queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken
-  persister?: QueryPersister<
-    NoInfer<TQueryFnData>,
-    NoInfer<TQueryKey>,
-    NoInfer<TPageParam>
-  >
+  persister?: QueryPersister<TQueryFnData, TQueryKey, TPageParam>
   queryHash?: string
   queryKey?: TQueryKey
   queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>
@@ -266,6 +262,7 @@ export interface QueryOptions<
     | boolean
     | ((oldData: unknown | undefined, newData: unknown) => unknown)
   _defaulted?: boolean
+  _type?: 'infinite'
   /**
    * Additional payload to be stored on each query.
    * Use this property to pass information that can be used in other places.