@tanstack/react-query 5.0.0-rc.1 → 5.0.0-rc.16

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

@@ -0,0 +1,146 @@
+import { useSuspenseQuery } from '../useSuspenseQuery'
+import { useSuspenseInfiniteQuery } from '../useSuspenseInfiniteQuery'
+import { doNotExecute } from './utils'
+import type { InfiniteData } from '@tanstack/query-core'
+import type { Equal, Expect } from './utils'
+
+describe('useSuspenseQuery', () => {
+  it('should always have data defined', () => {
+    doNotExecute(() => {
+      const { data } = useSuspenseQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+      })
+
+      const result: Expect<Equal<typeof data, number>> = true
+      return result
+    })
+  })
+
+  it('should not have pending status', () => {
+    doNotExecute(() => {
+      const { status } = useSuspenseQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+      })
+
+      const result: Expect<Equal<typeof status, 'error' | 'success'>> = true
+      return result
+    })
+  })
+
+  it('should not allow placeholderData, enabled or throwOnError props', () => {
+    doNotExecute(() => {
+      useSuspenseQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        // @ts-expect-error TS2345
+        placeholderData: 5,
+        enabled: true,
+      })
+
+      useSuspenseQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        // @ts-expect-error TS2345
+        enabled: true,
+      })
+
+      useSuspenseQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        // @ts-expect-error TS2345
+        throwOnError: true,
+      })
+    })
+  })
+
+  it('should not return isPlaceholderData', () => {
+    doNotExecute(() => {
+      const query = useSuspenseQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+      })
+
+      // @ts-expect-error TS2339
+      void query.isPlaceholderData
+    })
+  })
+})
+
+describe('useSuspenseInfiniteQuery', () => {
+  it('should always have data defined', () => {
+    doNotExecute(() => {
+      const { data } = useSuspenseInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        initialPageParam: 1,
+        getNextPageParam: () => 1,
+      })
+
+      const result: Expect<Equal<typeof data, InfiniteData<number, unknown>>> =
+        true
+      return result
+    })
+  })
+
+  it('should not have pending status', () => {
+    doNotExecute(() => {
+      const { status } = useSuspenseInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        initialPageParam: 1,
+        getNextPageParam: () => 1,
+      })
+
+      const result: Expect<Equal<typeof status, 'error' | 'success'>> = true
+      return result
+    })
+  })
+
+  it('should not allow placeholderData, enabled or throwOnError props', () => {
+    doNotExecute(() => {
+      useSuspenseInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        initialPageParam: 1,
+        getNextPageParam: () => 1,
+        // @ts-expect-error TS2345
+        placeholderData: 5,
+        enabled: true,
+      })
+
+      useSuspenseInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        initialPageParam: 1,
+        getNextPageParam: () => 1,
+        // @ts-expect-error TS2345
+        enabled: true,
+      })
+
+      useSuspenseInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        initialPageParam: 1,
+        getNextPageParam: () => 1,
+        // @ts-expect-error TS2345
+        throwOnError: true,
+      })
+    })
+  })
+
+  it('should not return isPlaceholderData', () => {
+    doNotExecute(() => {
+      const query = useSuspenseInfiniteQuery({
+        queryKey: ['key'],
+        queryFn: () => Promise.resolve(5),
+        initialPageParam: 1,
+        getNextPageParam: () => 1,
+      })
+
+      // @ts-expect-error TS2339
+      void query.isPlaceholderData
+    })
+  })
+})

package/src/__tests__/useQueries.test.tsx

@@ -377,6 +377,10 @@ describe('useQueries', () => {
     const key2 = queryKey()
     const key3 = queryKey()
     const key4 = queryKey()
+    const key5 = queryKey()
+
+    type BizError = { code: number }
+    const throwOnError = (_error: BizError) => true
 
     // @ts-expect-error (Page component is not rendered)
     // eslint-disable-next-line
@@ -391,6 +395,18 @@ describe('useQueries', () => {
       expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1)
       expectTypeOf<number | undefined>(result1[0]?.data)
 
+      // Array.map preserves TError
+      const result1_err = useQueries({
+        queries: Array(50).map((_, i) => ({
+          queryKey: ['key', i] as const,
+          queryFn: () => i + 10,
+          throwOnError,
+        })),
+      })
+      expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1_err)
+      expectTypeOf<number | undefined>(result1_err[0]?.data)
+      expectTypeOf<BizError | null | undefined>(result1_err[0]?.error)
+
       // Array.map preserves TData
       const result2 = useQueries({
         queries: Array(50).map((_, i) => ({
@@ -401,6 +417,16 @@ describe('useQueries', () => {
       })
       expectTypeOf<Array<QueryObserverResult<string, unknown>>>(result2)
 
+      const result2_err = useQueries({
+        queries: Array(50).map((_, i) => ({
+          queryKey: ['key', i] as const,
+          queryFn: () => i + 10,
+          select: (data: number) => data.toString(),
+          throwOnError,
+        })),
+      })
+      expectTypeOf<Array<QueryObserverResult<string, BizError>>>(result2_err)
+
       const result3 = useQueries({
         queries: [
           {
@@ -416,6 +442,11 @@ describe('useQueries', () => {
             queryFn: () => ['string[]'],
             select: () => 123,
           },
+          {
+            queryKey: key5,
+            queryFn: () => 'string',
+            throwOnError,
+          },
         ],
       })
       expectTypeOf<QueryObserverResult<number, unknown>>(result3[0])
@@ -423,8 +454,11 @@ describe('useQueries', () => {
       expectTypeOf<QueryObserverResult<number, unknown>>(result3[2])
       expectTypeOf<number | undefined>(result3[0].data)
       expectTypeOf<string | undefined>(result3[1].data)
+      expectTypeOf<string | undefined>(result3[3].data)
       // select takes precedence over queryFn
       expectTypeOf<number | undefined>(result3[2].data)
+      // infer TError from throwOnError
+      expectTypeOf<BizError | null | undefined>(result3[3].error)
 
       // initialData/placeholderData are enforced
       useQueries({
@@ -446,7 +480,7 @@ describe('useQueries', () => {
         ],
       })
 
-      // select params are "indirectly" enforced
+      // select and throwOnError params are "indirectly" enforced
       useQueries({
         queries: [
           // unfortunately TS will not suggest the type for you
@@ -469,6 +503,11 @@ describe('useQueries', () => {
             queryFn: () => 'string',
             select: (a: string) => parseInt(a),
           },
+          {
+            queryKey: key5,
+            queryFn: () => 'string',
+            throwOnError,
+          },
         ],
       })
 
@@ -504,11 +543,18 @@ describe('useQueries', () => {
             queryFn: () => 'string',
             select: (a: string) => parseInt(a),
           },
+          {
+            queryKey: key5,
+            queryFn: () => 'string',
+            select: (a: string) => parseInt(a),
+            throwOnError,
+          },
         ],
       })
       expectTypeOf<QueryObserverResult<string, unknown>>(result4[0])
       expectTypeOf<QueryObserverResult<string, unknown>>(result4[1])
       expectTypeOf<QueryObserverResult<number, unknown>>(result4[2])
+      expectTypeOf<QueryObserverResult<number, BizError>>(result4[3])
 
       // handles when queryFn returns a Promise
       const result5 = useQueries({
@@ -532,10 +578,16 @@ describe('useQueries', () => {
             queryKey: ['key1'],
             queryFn: () => 123,
           },
+          {
+            queryKey: key5,
+            queryFn: () => 'string',
+            throwOnError,
+          },
         ],
       } as const)
       expectTypeOf<QueryObserverResult<string, unknown>>(result6[0])
       expectTypeOf<QueryObserverResult<number, unknown>>(result6[1])
+      expectTypeOf<QueryObserverResult<string, BizError>>(result6[2])
 
       // field names should be enforced - array literal
       useQueries({

package/src/__tests__/useQuery.test.tsx

@@ -4146,7 +4146,7 @@ describe('useQuery', () => {
           await sleep(10)
           return count++
         },
-        refetchInterval: (data = 0) => (data < 2 ? 10 : false),
+        refetchInterval: ({ state: { data = 0 } }) => (data < 2 ? 10 : false),
       })
 
       states.push(queryInfo)
@@ -5975,11 +5975,11 @@ describe('useQuery', () => {
           <div>data: {state.data}</div>
           <div>dataUpdatedAt: {state.dataUpdatedAt}</div>
           <button
-            onClick={() =>
+            onClick={() => {
               queryClient.setQueryData(key, 'newData', {
                 updatedAt: 100,
               })
-            }
+            }}
           >
             setQueryData
           </button>

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

@@ -51,10 +51,16 @@ describe('initialData', () => {
           queryKey: ['key'],
           queryFn: () => Promise.resolve(1),
         })
-        useQuery({
+
+        const query = useQuery({
           ...options,
           select: (data) => data > 1,
         })
+
+        const result: Expect<
+          Equal<boolean | undefined, (typeof query)['data']>
+        > = true
+        return result
       })
     })
 

package/src/infiniteQueryOptions.ts

@@ -1,50 +1,50 @@
+import type { DataTag } from '@tanstack/query-core'
 import type { InfiniteData } from '@tanstack/query-core'
 import type { UseInfiniteQueryOptions } from './types'
 import type { DefaultError, QueryKey } from '@tanstack/query-core'
 
 export type UndefinedInitialDataInfiniteOptions<
-  TQueryFnData = unknown,
+  TQueryFnData,
   TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryData = TQueryFnData,
+  TData = InfiniteData<TQueryFnData>,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 > = UseInfiniteQueryOptions<
   TQueryFnData,
   TError,
   TData,
-  TQueryData,
+  TQueryFnData,
   TQueryKey,
   TPageParam
 > & {
   initialData?: undefined
 }
 
+type NonUndefinedGuard<T> = T extends undefined ? never : T
+
 export type DefinedInitialDataInfiniteOptions<
-  TQueryFnData = unknown,
+  TQueryFnData,
   TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryData = TQueryFnData,
+  TData = InfiniteData<TQueryFnData>,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 > = UseInfiniteQueryOptions<
   TQueryFnData,
   TError,
   TData,
-  TQueryData,
+  TQueryFnData,
   TQueryKey,
   TPageParam
 > & {
   initialData:
-    | InfiniteData<TQueryData, TPageParam>
-    | (() => InfiniteData<TQueryData, TPageParam>)
+    | NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>
+    | (() => NonUndefinedGuard<InfiniteData<TQueryFnData, TPageParam>>)
 }
 
 export function infiniteQueryOptions<
-  TQueryFnData = unknown,
+  TQueryFnData,
   TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryData = TQueryFnData,
+  TData = InfiniteData<TQueryFnData>,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 >(
@@ -52,7 +52,6 @@ export function infiniteQueryOptions<
     TQueryFnData,
     TError,
     TData,
-    TQueryFnData,
     TQueryKey,
     TPageParam
   >,
@@ -60,16 +59,16 @@ export function infiniteQueryOptions<
   TQueryFnData,
   TError,
   TData,
-  TQueryFnData,
   TQueryKey,
   TPageParam
->
+> & {
+  queryKey: DataTag<TQueryKey, TData>
+}
 
 export function infiniteQueryOptions<
-  TQueryFnData = unknown,
+  TQueryFnData,
   TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryData = TQueryFnData,
+  TData = InfiniteData<TQueryFnData>,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 >(
@@ -77,7 +76,6 @@ export function infiniteQueryOptions<
     TQueryFnData,
     TError,
     TData,
-    TQueryFnData,
     TQueryKey,
     TPageParam
   >,
@@ -85,10 +83,11 @@ export function infiniteQueryOptions<
   TQueryFnData,
   TError,
   TData,
-  TQueryFnData,
   TQueryKey,
   TPageParam
->
+> & {
+  queryKey: DataTag<TQueryKey, TData>
+}
 
 export function infiniteQueryOptions(options: unknown) {
   return options

package/src/queryOptions.ts

@@ -1,4 +1,4 @@
-import type { DefaultError, QueryKey } from '@tanstack/query-core'
+import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core'
 import type { UseQueryOptions } from './types'
 
 export type UndefinedInitialDataOptions<
@@ -23,35 +23,27 @@ export type DefinedInitialDataOptions<
     | (() => NonUndefinedGuard<TQueryFnData>)
 }
 
-type ValidateQueryOptions<T> = {
-  [K in keyof T]: K extends keyof UseQueryOptions ? T[K] : never
-}
-
 export function queryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-  TOptions extends UndefinedInitialDataOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey
-  > = UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
->(options: ValidateQueryOptions<TOptions>): TOptions
+>(
+  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+): UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  queryKey: DataTag<TQueryKey, TData>
+}
 
 export function queryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-  TOptions extends DefinedInitialDataOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey
-  > = DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
->(options: ValidateQueryOptions<TOptions>): TOptions
+>(
+  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+): DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  queryKey: DataTag<TQueryKey, TData>
+}
 
 export function queryOptions(options: unknown) {
   return options

package/src/types.ts

@@ -6,14 +6,12 @@ import type {
   DefinedQueryObserverResult,
   InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
-  InfiniteQueryObserverSuccessResult,
   MutateFunction,
   MutationObserverOptions,
   MutationObserverResult,
   QueryKey,
   QueryObserverOptions,
   QueryObserverResult,
-  QueryObserverSuccessResult,
   WithRequired,
 } from '@tanstack/query-core'
 
@@ -105,7 +103,7 @@ export type UseQueryResult<
 export type UseSuspenseQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = Omit<QueryObserverSuccessResult<TData, TError>, 'isPlaceholderData'>
+> = Omit<DefinedQueryObserverResult<TData, TError>, 'isPlaceholderData'>
 
 export type DefinedUseQueryResult<
   TData = unknown,
@@ -125,7 +123,7 @@ export type DefinedUseInfiniteQueryResult<
 export type UseSuspenseInfiniteQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = Omit<InfiniteQueryObserverSuccessResult<TData, TError>, 'isPlaceholderData'>
+> = Omit<DefinedInfiniteQueryObserverResult<TData, TError>, 'isPlaceholderData'>
 
 export interface UseMutationOptions<
   TData = unknown,

package/src/useInfiniteQuery.ts

@@ -29,7 +29,6 @@ export function useInfiniteQuery<
     TQueryFnData,
     TError,
     TData,
-    TQueryFnData,
     TQueryKey,
     TPageParam
   >,
@@ -47,7 +46,6 @@ export function useInfiniteQuery<
     TQueryFnData,
     TError,
     TData,
-    TQueryFnData,
     TQueryKey,
     TPageParam
   >,

package/src/useQueries.ts

@@ -24,10 +24,11 @@ import type {
   QueryClient,
   QueryFunction,
   QueryKey,
+  ThrowOnError,
 } from '@tanstack/query-core'
 
 // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
-// `placeholderData` function does not have a parameter
+// `placeholderData` function always gets undefined passed
 type UseQueryOptionsForUseQueries<
   TQueryFnData = unknown,
   TError = DefaultError,
@@ -66,10 +67,19 @@ type GetOptions<T> =
     T extends {
         queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
         select: (data: any) => infer TData
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
       }
-    ? UseQueryOptionsForUseQueries<TQueryFnData, Error, TData, TQueryKey>
-    : T extends { queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> }
-    ? UseQueryOptionsForUseQueries<TQueryFnData, Error, TQueryFnData, TQueryKey>
+    ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>
+    : T extends {
+        queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
+      }
+    ? UseQueryOptionsForUseQueries<
+        TQueryFnData,
+        TError,
+        TQueryFnData,
+        TQueryKey
+      >
     : // Fallback
       UseQueryOptionsForUseQueries
 
@@ -92,10 +102,17 @@ type GetResults<T> =
     T extends {
         queryFn?: QueryFunction<unknown, any>
         select: (data: any) => infer TData
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
       }
-    ? UseQueryResult<TData>
-    : T extends { queryFn?: QueryFunction<infer TQueryFnData, any> }
-    ? UseQueryResult<TQueryFnData>
+    ? UseQueryResult<TData, unknown extends TError ? DefaultError : TError>
+    : T extends {
+        queryFn?: QueryFunction<infer TQueryFnData, any>
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
+      }
+    ? UseQueryResult<
+        TQueryFnData,
+        unknown extends TError ? DefaultError : TError
+      >
     : // Fallback
       UseQueryResult
 

package/src/useSuspenseInfiniteQuery.ts

@@ -1,6 +1,7 @@
 'use client'
 import { InfiniteQueryObserver } from '@tanstack/query-core'
 import { useBaseQuery } from './useBaseQuery'
+import { defaultThrowOnError } from './suspense'
 import type {
   InfiniteQueryObserverSuccessResult,
   QueryObserver,
@@ -38,7 +39,7 @@ export function useSuspenseInfiniteQuery<
       ...options,
       enabled: true,
       suspense: true,
-      throwOnError: true,
+      throwOnError: defaultThrowOnError,
     },
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     InfiniteQueryObserver as typeof QueryObserver,

package/src/useSuspenseQueries.ts

@@ -6,6 +6,7 @@ import type {
   DefaultError,
   QueryClient,
   QueryFunction,
+  ThrowOnError,
 } from '@tanstack/query-core'
 
 // Avoid TS depth-limit error in case of large array literal
@@ -34,10 +35,14 @@ type GetSuspenseOptions<T> =
     T extends {
         queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
         select: (data: any) => infer TData
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
       }
-    ? UseSuspenseQueryOptions<TQueryFnData, Error, TData, TQueryKey>
-    : T extends { queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> }
-    ? UseSuspenseQueryOptions<TQueryFnData, Error, TQueryFnData, TQueryKey>
+    ? UseSuspenseQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    : T extends {
+        queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
+      }
+    ? UseSuspenseQueryOptions<TQueryFnData, TError, TQueryFnData, TQueryKey>
     : // Fallback
       UseSuspenseQueryOptions
 
@@ -60,10 +65,20 @@ type GetSuspenseResults<T> =
     T extends {
         queryFn?: QueryFunction<unknown, any>
         select: (data: any) => infer TData
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
       }
-    ? UseSuspenseQueryResult<TData>
-    : T extends { queryFn?: QueryFunction<infer TQueryFnData, any> }
-    ? UseSuspenseQueryResult<TQueryFnData>
+    ? UseSuspenseQueryResult<
+        TData,
+        unknown extends TError ? DefaultError : TError
+      >
+    : T extends {
+        queryFn?: QueryFunction<infer TQueryFnData, any>
+        throwOnError?: ThrowOnError<any, infer TError, any, any>
+      }
+    ? UseSuspenseQueryResult<
+        TQueryFnData,
+        unknown extends TError ? DefaultError : TError
+      >
     : // Fallback
       UseSuspenseQueryResult