@tanstack/react-query 5.0.0-beta.8 → 5.0.0-rc.0

package/src/__tests__/useQueries.test.tsx

@@ -6,7 +6,6 @@ import { vi } from 'vitest'
 import { QueryCache, useQueries } from '..'
 import {
   createQueryClient,
-  expectType,
   expectTypeNotAny,
   queryKey,
   renderWithClient,
@@ -28,7 +27,7 @@ describe('useQueries', () => {
   it('should return the correct states', async () => {
     const key1 = queryKey()
     const key2 = queryKey()
-    const results: UseQueryResult[][] = []
+    const results: Array<Array<UseQueryResult>> = []
 
     function Page() {
       const result = useQueries({
@@ -73,7 +72,7 @@ describe('useQueries', () => {
 
   it('should track results', async () => {
     const key1 = queryKey()
-    const results: UseQueryResult[][] = []
+    const results: Array<Array<UseQueryResult>> = []
     let count = 0
 
     function Page() {
@@ -125,7 +124,9 @@ describe('useQueries', () => {
     // @ts-expect-error (Page component is not rendered)
     // eslint-disable-next-line
     function Page() {
-      const result1 = useQueries<[[number], [string], [string[], boolean]]>({
+      const result1 = useQueries<
+        [[number], [string], [Array<string>, boolean]]
+      >({
         queries: [
           {
             queryKey: key1,
@@ -141,13 +142,13 @@ describe('useQueries', () => {
           },
         ],
       })
-      expectType<QueryObserverResult<number, unknown>>(result1[0])
-      expectType<QueryObserverResult<string, unknown>>(result1[1])
-      expectType<QueryObserverResult<string[], boolean>>(result1[2])
-      expectType<number | undefined>(result1[0].data)
-      expectType<string | undefined>(result1[1].data)
-      expectType<string[] | undefined>(result1[2].data)
-      expectType<boolean | null>(result1[2].error)
+      expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
+      expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
+      expectTypeOf<number | undefined>(result1[0].data)
+      expectTypeOf<string | undefined>(result1[1].data)
+      expectTypeOf<Array<string> | undefined>(result1[2].data)
+      expectTypeOf<boolean | null>(result1[2].error)
 
       // TData (3rd element) takes precedence over TQueryFnData (1st element)
       const result2 = useQueries<
@@ -158,7 +159,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return a.toLowerCase()
             },
@@ -167,17 +168,17 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return parseInt(a)
             },
           },
         ],
       })
-      expectType<QueryObserverResult<string, unknown>>(result2[0])
-      expectType<QueryObserverResult<number, unknown>>(result2[1])
-      expectType<string | undefined>(result2[0].data)
-      expectType<number | undefined>(result2[1].data)
+      expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
+      expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
+      expectTypeOf<string | undefined>(result2[0].data)
+      expectTypeOf<number | undefined>(result2[1].data)
 
       // types should be enforced
       useQueries<[[string, unknown, string], [string, boolean, number]]>({
@@ -186,7 +187,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return a.toLowerCase()
             },
@@ -198,7 +199,7 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return parseInt(a)
             },
@@ -235,7 +236,7 @@ describe('useQueries', () => {
         [
           { queryFnData: number },
           { queryFnData: string },
-          { queryFnData: string[]; error: boolean },
+          { queryFnData: Array<string>; error: boolean },
         ]
       >({
         queries: [
@@ -253,13 +254,13 @@ describe('useQueries', () => {
           },
         ],
       })
-      expectType<QueryObserverResult<number, unknown>>(result1[0])
-      expectType<QueryObserverResult<string, unknown>>(result1[1])
-      expectType<QueryObserverResult<string[], boolean>>(result1[2])
-      expectType<number | undefined>(result1[0].data)
-      expectType<string | undefined>(result1[1].data)
-      expectType<string[] | undefined>(result1[2].data)
-      expectType<boolean | null>(result1[2].error)
+      expectTypeOf<QueryObserverResult<number, unknown>>(result1[0])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result1[1])
+      expectTypeOf<QueryObserverResult<Array<string>, boolean>>(result1[2])
+      expectTypeOf<number | undefined>(result1[0].data)
+      expectTypeOf<string | undefined>(result1[1].data)
+      expectTypeOf<Array<string> | undefined>(result1[2].data)
+      expectTypeOf<boolean | null>(result1[2].error)
 
       // TData (data prop) takes precedence over TQueryFnData (queryFnData prop)
       const result2 = useQueries<
@@ -273,7 +274,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return a.toLowerCase()
             },
@@ -282,17 +283,17 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return parseInt(a)
             },
           },
         ],
       })
-      expectType<QueryObserverResult<string, unknown>>(result2[0])
-      expectType<QueryObserverResult<number, unknown>>(result2[1])
-      expectType<string | undefined>(result2[0].data)
-      expectType<number | undefined>(result2[1].data)
+      expectTypeOf<QueryObserverResult<string, unknown>>(result2[0])
+      expectTypeOf<QueryObserverResult<number, unknown>>(result2[1])
+      expectTypeOf<string | undefined>(result2[0].data)
+      expectTypeOf<number | undefined>(result2[1].data)
 
       // can pass only TData (data prop) although TQueryFnData will be left unknown
       const result3 = useQueries<[{ data: string }, { data: number }]>({
@@ -301,7 +302,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<unknown>(a)
+              expectTypeOf<unknown>(a)
               expectTypeNotAny(a)
               return a as string
             },
@@ -310,17 +311,17 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<unknown>(a)
+              expectTypeOf<unknown>(a)
               expectTypeNotAny(a)
               return a as number
             },
           },
         ],
       })
-      expectType<QueryObserverResult<string, unknown>>(result3[0])
-      expectType<QueryObserverResult<number, unknown>>(result3[1])
-      expectType<string | undefined>(result3[0].data)
-      expectType<number | undefined>(result3[1].data)
+      expectTypeOf<QueryObserverResult<string, unknown>>(result3[0])
+      expectTypeOf<QueryObserverResult<number, unknown>>(result3[1])
+      expectTypeOf<string | undefined>(result3[0].data)
+      expectTypeOf<number | undefined>(result3[1].data)
 
       // types should be enforced
       useQueries<
@@ -334,7 +335,7 @@ describe('useQueries', () => {
             queryKey: key1,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return a.toLowerCase()
             },
@@ -346,7 +347,7 @@ describe('useQueries', () => {
             queryKey: key2,
             queryFn: () => 'string',
             select: (a) => {
-              expectType<string>(a)
+              expectTypeOf<string>(a)
               expectTypeNotAny(a)
               return parseInt(a)
             },
@@ -387,8 +388,8 @@ describe('useQueries', () => {
           queryFn: () => i + 10,
         })),
       })
-      expectType<QueryObserverResult<number, unknown>[]>(result1)
-      expectType<number | undefined>(result1[0]?.data)
+      expectTypeOf<Array<QueryObserverResult<number, unknown>>>(result1)
+      expectTypeOf<number | undefined>(result1[0]?.data)
 
       // Array.map preserves TData
       const result2 = useQueries({
@@ -398,7 +399,7 @@ describe('useQueries', () => {
           select: (data: number) => data.toString(),
         })),
       })
-      expectType<QueryObserverResult<string, unknown>[]>(result2)
+      expectTypeOf<Array<QueryObserverResult<string, unknown>>>(result2)
 
       const result3 = useQueries({
         queries: [
@@ -417,13 +418,13 @@ describe('useQueries', () => {
           },
         ],
       })
-      expectType<QueryObserverResult<number, unknown>>(result3[0])
-      expectType<QueryObserverResult<string, unknown>>(result3[1])
-      expectType<QueryObserverResult<number, unknown>>(result3[2])
-      expectType<number | undefined>(result3[0].data)
-      expectType<string | undefined>(result3[1].data)
+      expectTypeOf<QueryObserverResult<number, unknown>>(result3[0])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result3[1])
+      expectTypeOf<QueryObserverResult<number, unknown>>(result3[2])
+      expectTypeOf<number | undefined>(result3[0].data)
+      expectTypeOf<string | undefined>(result3[1].data)
       // select takes precedence over queryFn
-      expectType<number | undefined>(result3[2].data)
+      expectTypeOf<number | undefined>(result3[2].data)
 
       // initialData/placeholderData are enforced
       useQueries({
@@ -505,9 +506,9 @@ describe('useQueries', () => {
           },
         ],
       })
-      expectType<QueryObserverResult<string, unknown>>(result4[0])
-      expectType<QueryObserverResult<string, unknown>>(result4[1])
-      expectType<QueryObserverResult<number, unknown>>(result4[2])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result4[0])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result4[1])
+      expectTypeOf<QueryObserverResult<number, unknown>>(result4[2])
 
       // handles when queryFn returns a Promise
       const result5 = useQueries({
@@ -518,7 +519,7 @@ describe('useQueries', () => {
           },
         ],
       })
-      expectType<QueryObserverResult<string, unknown>>(result5[0])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result5[0])
 
       // Array as const does not throw error
       const result6 = useQueries({
@@ -533,8 +534,8 @@ describe('useQueries', () => {
           },
         ],
       } as const)
-      expectType<QueryObserverResult<string, unknown>>(result6[0])
-      expectType<QueryObserverResult<number, unknown>>(result6[1])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result6[0])
+      expectTypeOf<QueryObserverResult<number, unknown>>(result6[1])
 
       // field names should be enforced - array literal
       useQueries({
@@ -616,18 +617,18 @@ describe('useQueries', () => {
       TError,
       TData,
       TQueryKey extends QueryKey,
-    >(queries: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>[]) {
+    >(queries: Array<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>>) {
       return useQueries({
         queries: queries.map(
           // no need to type the mapped query
           (query) => {
             const { queryFn: fn, queryKey: key } = query
-            expectType<QueryFunction<TQueryFnData, TQueryKey> | undefined>(fn)
+            expectTypeOf<QueryFunction<TQueryFnData, TQueryKey> | undefined>(fn)
             return {
               queryKey: key,
               queryFn: fn
                 ? (ctx: QueryFunctionContext<TQueryKey>) => {
-                    expectType<TQueryKey>(ctx.queryKey)
+                    expectTypeOf<TQueryKey>(ctx.queryKey)
                     return fn.call({}, ctx)
                   }
                 : undefined,
@@ -652,8 +653,8 @@ describe('useQueries', () => {
           },
         ],
       })
-      expectType<QueryObserverResult<number, unknown>>(result[0])
-      expectType<QueryObserverResult<string, unknown>>(result[1])
+      expectTypeOf<QueryObserverResult<number, unknown>>(result[0])
+      expectTypeOf<QueryObserverResult<string, unknown>>(result[1])
 
       const withSelector = useQueries({
         queries: [
@@ -669,10 +670,10 @@ describe('useQueries', () => {
           },
         ],
       })
-      expectType<QueryObserverResult<[number, string], unknown>>(
+      expectTypeOf<QueryObserverResult<[number, string], unknown>>(
         withSelector[0],
       )
-      expectType<QueryObserverResult<[string, number], unknown>>(
+      expectTypeOf<QueryObserverResult<[string, number], unknown>>(
         withSelector[1],
       )
 
@@ -684,7 +685,7 @@ describe('useQueries', () => {
         })),
       )
 
-      expectType<QueryObserverResult<number | undefined, unknown>[]>(
+      expectTypeOf<Array<QueryObserverResult<number | undefined, unknown>>>(
         withWrappedQueries,
       )
     }