@tanstack/react-query 5.0.0-rc.7 → 5.0.5

package/src/__tests__/useQueries.test.tsx

@@ -1,8 +1,7 @@
+import { describe, expect, expectTypeOf, it, vi } from 'vitest'
 import { fireEvent, render, waitFor } from '@testing-library/react'
 import * as React from 'react'
 import { ErrorBoundary } from 'react-error-boundary'
-
-import { vi } from 'vitest'
 import { QueryCache, useQueries } from '..'
 import {
   createQueryClient,
@@ -377,6 +376,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 +394,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 +416,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 +441,11 @@ describe('useQueries', () => {
             queryFn: () => ['string[]'],
             select: () => 123,
           },
+          {
+            queryKey: key5,
+            queryFn: () => 'string',
+            throwOnError,
+          },
         ],
       })
       expectTypeOf<QueryObserverResult<number, unknown>>(result3[0])
@@ -423,8 +453,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 +479,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 +502,11 @@ describe('useQueries', () => {
             queryFn: () => 'string',
             select: (a: string) => parseInt(a),
           },
+          {
+            queryKey: key5,
+            queryFn: () => 'string',
+            throwOnError,
+          },
         ],
       })
 
@@ -504,11 +542,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 +577,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

@@ -1,8 +1,7 @@
+import { describe, expect, expectTypeOf, it, test, vi } from 'vitest'
 import { act, fireEvent, render, waitFor } from '@testing-library/react'
-import '@testing-library/jest-dom'
 import * as React from 'react'
 import { ErrorBoundary } from 'react-error-boundary'
-import { vi } from 'vitest'
 import { QueryCache, keepPreviousData, useQuery } from '..'
 import {
   Blink,
@@ -154,8 +153,8 @@ describe('useQuery', () => {
           queryFn: () => fetcher(qk[1], 'token'),
           ...options,
         })
-      const test = useWrappedQuery([''], async () => '1')
-      expectTypeOf<string | undefined>(test.data)
+      const testQuery = useWrappedQuery([''], async () => '1')
+      expectTypeOf<string | undefined>(testQuery.data)
 
       // handles wrapped queries with custom fetcher passed directly to useQuery
       const useWrappedFuncStyleQuery = <
@@ -4146,7 +4145,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)

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

@@ -1,3 +1,4 @@
+import { describe, it } from 'vitest'
 import { useQuery } from '../useQuery'
 import { queryOptions } from '../queryOptions'
 import { doNotExecute } from './utils'
@@ -47,13 +48,15 @@ describe('initialData', () => {
 
     it('it should be possible to define a different TData than TQueryFnData using select with queryOptions spread into useQuery', () => {
       doNotExecute(() => {
-        const options = <TData = number,>(select?: (data: number) => TData) =>
-          queryOptions({
-            queryKey: ['key'],
-            queryFn: () => Promise.resolve(1),
-            select,
-          })
-        const query = useQuery(options((data) => data > 1))
+        const options = queryOptions({
+          queryKey: ['key'],
+          queryFn: () => Promise.resolve(1),
+        })
+
+        const query = useQuery({
+          ...options,
+          select: (data) => data > 1,
+        })
 
         const result: Expect<
           Equal<boolean | undefined, (typeof query)['data']>

package/src/__tests__/utils.tsx

@@ -1,8 +1,7 @@
+import { vi } from 'vitest'
 import * as React from 'react'
 import { act, render } from '@testing-library/react'
-
 import * as utils from '@tanstack/query-core'
-import { vi } from 'vitest'
 import { QueryClient, QueryClientProvider, onlineManager } from '..'
 import type { QueryClientConfig } from '..'
 import type { SpyInstance } from 'vitest'

package/src/suspense.ts

@@ -1,4 +1,4 @@
-import type { DefaultError } from '@tanstack/query-core/src'
+import type { DefaultError } from '@tanstack/query-core'
 import type {
   DefaultedQueryObserverOptions,
   Query,

package/src/useQueries.ts

@@ -24,6 +24,7 @@ import type {
   QueryClient,
   QueryFunction,
   QueryKey,
+  ThrowOnError,
 } from '@tanstack/query-core'
 
 // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
@@ -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/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