@tanstack/react-query 5.0.0-beta.9 → 5.0.0-rc.1

package/src/__tests__/useQuery.types.test.tsx

@@ -111,6 +111,26 @@ describe('initialData', () => {
         return result
       })
     })
+
+    it('TData should be narrowed after an isSuccess check when initialData is provided as a function which can return undefined', () => {
+      doNotExecute(() => {
+        const { data, isSuccess } = useQuery({
+          queryKey: ['key'],
+          queryFn: () => {
+            return {
+              wow: true,
+            }
+          },
+          initialData: () => undefined as { wow: boolean } | undefined,
+        })
+
+        if (isSuccess) {
+          const result: Expect<Equal<{ wow: boolean }, typeof data>> = true
+          return result
+        }
+        return false
+      })
+    })
   })
 
   describe('custom hook', () => {
@@ -135,4 +155,18 @@ describe('initialData', () => {
       })
     })
   })
+
+  describe('structuralSharing', () => {
+    it('should restrict to same types', () => {
+      doNotExecute(() => {
+        useQuery({
+          queryKey: ['key'],
+          queryFn: () => 5,
+          structuralSharing: (_oldData, newData) => {
+            return newData
+          },
+        })
+      })
+    })
+  })
 })

package/src/__tests__/utils.tsx

@@ -79,13 +79,6 @@ export function setActTimeout(fn: () => void, ms?: number) {
   }, ms)
 }
 
-/**
- * Assert the parameter is of a specific type.
- */
-export function expectType<T>(_: T): void {
-  return undefined
-}
-
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
   T,
 >() => T extends Y ? 1 : 2

package/src/index.ts

@@ -10,6 +10,11 @@ export type { QueriesResults, QueriesOptions } from './useQueries'
 export { useQuery } from './useQuery'
 export { useSuspenseQuery } from './useSuspenseQuery'
 export { useSuspenseInfiniteQuery } from './useSuspenseInfiniteQuery'
+export { useSuspenseQueries } from './useSuspenseQueries'
+export type {
+  SuspenseQueriesResults,
+  SuspenseQueriesOptions,
+} from './useSuspenseQueries'
 export { queryOptions } from './queryOptions'
 export type {
   DefinedInitialDataOptions,

package/src/queryOptions.ts

@@ -10,13 +10,21 @@ export type UndefinedInitialDataOptions<
   initialData?: undefined
 }
 
+type NonUndefinedGuard<T> = T extends undefined ? never : T
+
 export type DefinedInitialDataOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > = UseQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
-  initialData: TQueryFnData | (() => TQueryFnData)
+  initialData:
+    | NonUndefinedGuard<TQueryFnData>
+    | (() => NonUndefinedGuard<TQueryFnData>)
+}
+
+type ValidateQueryOptions<T> = {
+  [K in keyof T]: K extends keyof UseQueryOptions ? T[K] : never
 }
 
 export function queryOptions<
@@ -30,7 +38,7 @@ export function queryOptions<
     TData,
     TQueryKey
   > = UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
->(options: TOptions): TOptions
+>(options: ValidateQueryOptions<TOptions>): TOptions
 
 export function queryOptions<
   TQueryFnData = unknown,
@@ -43,7 +51,7 @@ export function queryOptions<
     TData,
     TQueryKey
   > = DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
->(options: TOptions): TOptions
+>(options: ValidateQueryOptions<TOptions>): TOptions
 
 export function queryOptions(options: unknown) {
   return options

package/src/suspense.ts

@@ -1,11 +1,23 @@
+import type { DefaultError } from '@tanstack/query-core/src'
 import type {
   DefaultedQueryObserverOptions,
+  Query,
   QueryKey,
   QueryObserver,
   QueryObserverResult,
 } from '@tanstack/query-core'
 import type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'
 
+export const defaultThrowOnError = <
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  _error: TError,
+  query: Query<TQueryFnData, TError, TData, TQueryKey>,
+) => typeof query.state.data === 'undefined'
+
 export const ensureStaleTime = (
   defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,
 ) => {

package/src/types.ts

@@ -33,9 +33,12 @@ export interface UseQueryOptions<
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends WithRequired<
-    UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
-    'queryKey'
+> extends Omit<
+    WithRequired<
+      UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>,
+      'queryKey'
+    >,
+    'suspense'
   > {}
 
 export interface UseSuspenseQueryOptions<
@@ -45,7 +48,7 @@ export interface UseSuspenseQueryOptions<
   TQueryKey extends QueryKey = QueryKey,
 > extends Omit<
     UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'enabled' | 'suspense' | 'throwOnError' | 'placeholderData'
+    'enabled' | 'throwOnError' | 'placeholderData'
   > {}
 
 export interface UseInfiniteQueryOptions<
@@ -56,13 +59,16 @@ export interface UseInfiniteQueryOptions<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 > extends WithRequired<
-    InfiniteQueryObserverOptions<
-      TQueryFnData,
-      TError,
-      TData,
-      TQueryData,
-      TQueryKey,
-      TPageParam
+    Omit<
+      InfiniteQueryObserverOptions<
+        TQueryFnData,
+        TError,
+        TData,
+        TQueryData,
+        TQueryKey,
+        TPageParam
+      >,
+      'suspense'
     >,
     'queryKey'
   > {}
@@ -83,7 +89,7 @@ export interface UseSuspenseInfiniteQueryOptions<
       TQueryKey,
       TPageParam
     >,
-    'enabled' | 'suspense' | 'throwOnError' | 'placeholderData'
+    'enabled' | 'throwOnError' | 'placeholderData'
   > {}
 
 export type UseBaseQueryResult<

package/src/useQueries.ts

@@ -35,7 +35,7 @@ type UseQueryOptionsForUseQueries<
   TQueryKey extends QueryKey = QueryKey,
 > = Omit<
   UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  'placeholderData'
+  'placeholderData' | 'suspense'
 > & {
   placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
 }
@@ -103,62 +103,68 @@ type GetResults<T> =
  * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
  */
 export type QueriesOptions<
-  T extends any[],
-  Result extends any[] = [],
+  T extends Array<any>,
+  Result extends Array<any> = [],
   Depth extends ReadonlyArray<number> = [],
 > = Depth['length'] extends MAXIMUM_DEPTH
-  ? UseQueryOptionsForUseQueries[]
+  ? Array<UseQueryOptionsForUseQueries>
   : T extends []
   ? []
   : T extends [infer Head]
   ? [...Result, GetOptions<Head>]
   : T extends [infer Head, ...infer Tail]
   ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]>
-  : unknown[] extends T
+  : Array<unknown> extends T
   ? T
   : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
   // use this to infer the param types in the case of Array.map() argument
-  T extends UseQueryOptionsForUseQueries<
-      infer TQueryFnData,
-      infer TError,
-      infer TData,
-      infer TQueryKey
-    >[]
-  ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>[]
+  T extends Array<
+      UseQueryOptionsForUseQueries<
+        infer TQueryFnData,
+        infer TError,
+        infer TData,
+        infer TQueryKey
+      >
+    >
+  ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>>
   : // Fallback
-    UseQueryOptionsForUseQueries[]
+    Array<UseQueryOptionsForUseQueries>
 
 /**
  * QueriesResults reducer recursively maps type param to results
  */
 export type QueriesResults<
-  T extends any[],
-  Result extends any[] = [],
+  T extends Array<any>,
+  Result extends Array<any> = [],
   Depth extends ReadonlyArray<number> = [],
 > = Depth['length'] extends MAXIMUM_DEPTH
-  ? UseQueryResult[]
+  ? Array<UseQueryResult>
   : T extends []
   ? []
   : T extends [infer Head]
   ? [...Result, GetResults<Head>]
   : T extends [infer Head, ...infer Tail]
   ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]>
-  : T extends UseQueryOptionsForUseQueries<
-      infer TQueryFnData,
-      infer TError,
-      infer TData,
-      any
-    >[]
+  : T extends Array<
+      UseQueryOptionsForUseQueries<
+        infer TQueryFnData,
+        infer TError,
+        infer TData,
+        any
+      >
+    >
   ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
-    UseQueryResult<
-      unknown extends TData ? TQueryFnData : TData,
-      unknown extends TError ? DefaultError : TError
-    >[]
+    Array<
+      UseQueryResult<
+        unknown extends TData ? TQueryFnData : TData,
+        unknown extends TError ? DefaultError : TError
+      >
+    >
   : // Fallback
-    UseQueryResult[]
+    Array<UseQueryResult>
 
 export function useQueries<
-  T extends any[],
+  T extends Array<any>,
   TCombinedResult = QueriesResults<T>,
 >(
   {

package/src/useSuspenseQueries.ts

@@ -0,0 +1,164 @@
+'use client'
+import { useQueries } from './useQueries'
+import { defaultThrowOnError } from './suspense'
+import type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'
+import type {
+  DefaultError,
+  QueryClient,
+  QueryFunction,
+} from '@tanstack/query-core'
+
+// Avoid TS depth-limit error in case of large array literal
+type MAXIMUM_DEPTH = 20
+
+type GetSuspenseOptions<T> =
+  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
+  T extends {
+    queryFnData: infer TQueryFnData
+    error?: infer TError
+    data: infer TData
+  }
+    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>
+    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
+    ? UseSuspenseQueryOptions<TQueryFnData, TError>
+    : T extends { data: infer TData; error?: infer TError }
+    ? UseSuspenseQueryOptions<unknown, TError, TData>
+    : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
+    T extends [infer TQueryFnData, infer TError, infer TData]
+    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData>
+    : T extends [infer TQueryFnData, infer TError]
+    ? UseSuspenseQueryOptions<TQueryFnData, TError>
+    : T extends [infer TQueryFnData]
+    ? UseSuspenseQueryOptions<TQueryFnData>
+    : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
+    T extends {
+        queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
+        select: (data: any) => infer TData
+      }
+    ? UseSuspenseQueryOptions<TQueryFnData, Error, TData, TQueryKey>
+    : T extends { queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> }
+    ? UseSuspenseQueryOptions<TQueryFnData, Error, TQueryFnData, TQueryKey>
+    : // Fallback
+      UseSuspenseQueryOptions
+
+type GetSuspenseResults<T> =
+  // Part 1: responsible for mapping explicit type parameter to function result, if object
+  T extends { queryFnData: any; error?: infer TError; data: infer TData }
+    ? UseSuspenseQueryResult<TData, TError>
+    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
+    ? UseSuspenseQueryResult<TQueryFnData, TError>
+    : T extends { data: infer TData; error?: infer TError }
+    ? UseSuspenseQueryResult<TData, TError>
+    : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
+    T extends [any, infer TError, infer TData]
+    ? UseSuspenseQueryResult<TData, TError>
+    : T extends [infer TQueryFnData, infer TError]
+    ? UseSuspenseQueryResult<TQueryFnData, TError>
+    : T extends [infer TQueryFnData]
+    ? UseSuspenseQueryResult<TQueryFnData>
+    : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
+    T extends {
+        queryFn?: QueryFunction<unknown, any>
+        select: (data: any) => infer TData
+      }
+    ? UseSuspenseQueryResult<TData>
+    : T extends { queryFn?: QueryFunction<infer TQueryFnData, any> }
+    ? UseSuspenseQueryResult<TQueryFnData>
+    : // Fallback
+      UseSuspenseQueryResult
+
+/**
+ * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+export type SuspenseQueriesOptions<
+  T extends Array<any>,
+  Result extends Array<any> = [],
+  Depth extends ReadonlyArray<number> = [],
+> = Depth['length'] extends MAXIMUM_DEPTH
+  ? Array<UseSuspenseQueryOptions>
+  : T extends []
+  ? []
+  : T extends [infer Head]
+  ? [...Result, GetSuspenseOptions<Head>]
+  : T extends [infer Head, ...infer Tail]
+  ? SuspenseQueriesOptions<
+      [...Tail],
+      [...Result, GetSuspenseOptions<Head>],
+      [...Depth, 1]
+    >
+  : Array<unknown> extends T
+  ? T
+  : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
+  // use this to infer the param types in the case of Array.map() argument
+  T extends Array<
+      UseSuspenseQueryOptions<
+        infer TQueryFnData,
+        infer TError,
+        infer TData,
+        infer TQueryKey
+      >
+    >
+  ? Array<UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>>
+  : // Fallback
+    Array<UseSuspenseQueryOptions>
+
+/**
+ * SuspenseQueriesResults reducer recursively maps type param to results
+ */
+export type SuspenseQueriesResults<
+  T extends Array<any>,
+  Result extends Array<any> = [],
+  Depth extends ReadonlyArray<number> = [],
+> = Depth['length'] extends MAXIMUM_DEPTH
+  ? Array<UseSuspenseQueryResult>
+  : T extends []
+  ? []
+  : T extends [infer Head]
+  ? [...Result, GetSuspenseResults<Head>]
+  : T extends [infer Head, ...infer Tail]
+  ? SuspenseQueriesResults<
+      [...Tail],
+      [...Result, GetSuspenseResults<Head>],
+      [...Depth, 1]
+    >
+  : T extends Array<
+      UseSuspenseQueryOptions<
+        infer TQueryFnData,
+        infer TError,
+        infer TData,
+        any
+      >
+    >
+  ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
+    Array<
+      UseSuspenseQueryResult<
+        unknown extends TData ? TQueryFnData : TData,
+        unknown extends TError ? DefaultError : TError
+      >
+    >
+  : // Fallback
+    Array<UseSuspenseQueryResult>
+
+export function useSuspenseQueries<
+  T extends Array<any>,
+  TCombinedResult = SuspenseQueriesResults<T>,
+>(
+  options: {
+    queries: readonly [...SuspenseQueriesOptions<T>]
+    combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult
+  },
+  queryClient?: QueryClient,
+): TCombinedResult {
+  return useQueries(
+    {
+      ...options,
+      queries: options.queries.map((query) => ({
+        ...query,
+        suspense: true,
+        throwOnError: defaultThrowOnError,
+        enabled: true,
+      })),
+    } as any,
+    queryClient,
+  )
+}

package/src/useSuspenseQuery.ts

@@ -1,6 +1,7 @@
 'use client'
 import { QueryObserver } from '@tanstack/query-core'
 import { useBaseQuery } from './useBaseQuery'
+import { defaultThrowOnError } from './suspense'
 import type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'
 import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'
 
@@ -18,7 +19,7 @@ export function useSuspenseQuery<
       ...options,
       enabled: true,
       suspense: true,
-      throwOnError: true,
+      throwOnError: defaultThrowOnError,
     },
     QueryObserver,
     queryClient,

package/src/utils.ts

@@ -1,4 +1,4 @@
-export function shouldThrowError<T extends (...args: any[]) => boolean>(
+export function shouldThrowError<T extends (...args: Array<any>) => boolean>(
   throwError: boolean | T | undefined,
   params: Parameters<T>,
 ): boolean {