TanStack · TkDodo · Feb 21, 2025 · Feb 8, 2025 · Feb 9, 2025 · Feb 9, 2025
diff --git a/packages/react-query/src/__tests__/useQueries.test-d.tsx b/packages/react-query/src/__tests__/useQueries.test-d.tsx
@@ -1,4 +1,5 @@
 import { describe, expectTypeOf, it } from 'vitest'
+import { queryKey, sleep } from 'src/__tests__/utils'
 import { skipToken } from '..'
 import { useQueries } from '../useQueries'
 import { queryOptions } from '../queryOptions'
@@ -141,4 +142,42 @@ describe('UseQueries config object overload', () => {
     expectTypeOf(firstResult).toEqualTypeOf<UseQueryResult<number, Error>>()
     expectTypeOf(firstResult.data).toEqualTypeOf<number | undefined>()
   })
+
+  it('should return correct data for dynamic queries with mixed result types', () => {
+    const key1 = queryKey()
+    const key2 = queryKey()
+    const Queries1 = {
+      get: () =>
+        queryOptions({
+          queryKey: key1,
+          queryFn: async () => {
+            await sleep(10)
+            return 1
+          },
+        }),
+    }
+    const Queries2 = {
+      get: () =>
+        queryOptions({
+          queryKey: key2,
+          queryFn: async () => {
+            await sleep(10)
+            return true
+          },
+        }),
+    }
+
+    const queries1List = [1, 2, 3].map(() => ({ ...Queries1.get() }))
+    const result = useQueries({
+      queries: [...queries1List, { ...Queries2.get() }],
+    })
+
+    expectTypeOf(result).toEqualTypeOf<
+      [...Array<UseQueryResult<number, Error>>, UseQueryResult<boolean, Error>]
+    >()
+
+    if (result[0]) {
+      expectTypeOf(result[0].data).toEqualTypeOf<number | boolean | undefined>()
+    }
+  })
 })
diff --git a/packages/react-query/src/__tests__/useSuspenseQueries.test-d.tsx b/packages/react-query/src/__tests__/useSuspenseQueries.test-d.tsx
@@ -1,4 +1,5 @@
 import { describe, expectTypeOf, it } from 'vitest'
+import { queryKey, sleep } from 'src/__tests__/utils'
 import { skipToken, useSuspenseQueries } from '..'
 import { queryOptions } from '../queryOptions'
 import type { OmitKeyof } from '..'
@@ -154,4 +155,46 @@ describe('UseSuspenseQueries config object overload', () => {
       expectTypeOf(data).toEqualTypeOf<Data>()
     })
   })
+
+  it('should return correct data for dynamic queries with mixed result types', () => {
+    const key1 = queryKey()
+    const key2 = queryKey()
+
+    const Queries1 = {
+      get: () =>
+        queryOptions({
+          queryKey: key1,
+          queryFn: async () => {
+            await sleep(10)
+            return 1
+          },
+        }),
+    }
+    const Queries2 = {
+      get: () =>
+        queryOptions({
+          queryKey: key2,
+          queryFn: async () => {
+            await sleep(10)
+            return true
+          },
+        }),
+    }
+
+    const queries1List = [1, 2, 3].map(() => ({ ...Queries1.get() }))
+    const result = useSuspenseQueries({
+      queries: [...queries1List, { ...Queries2.get() }],
+    })
+
+    expectTypeOf(result).toEqualTypeOf<
+      [
+        ...Array<UseSuspenseQueryResult<number, Error>>,
+        UseSuspenseQueryResult<boolean, Error>,
+      ]
+    >()
+
+    if (result[0]) {
+      expectTypeOf(result[0].data).toEqualTypeOf<number | boolean>()
+    }
+  })
 })
diff --git a/packages/react-query/src/useQueries.ts b/packages/react-query/src/useQueries.ts
@@ -203,23 +203,19 @@ export type QueriesResults<
             [...TResults, GetUseQueryResult<Head>],
             [...TDepth, 1]
           >
-        : T extends Array<
-              UseQueryOptionsForUseQueries<
-                infer TQueryFnData,
-                infer TError,
-                infer TData,
-                any
-              >
-            >
-          ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
-            Array<
-              UseQueryResult<
-                unknown extends TData ? TQueryFnData : TData,
-                unknown extends TError ? DefaultError : TError
-              >
+        : {
+            [K in keyof T]: T[K] extends UseQueryOptionsForUseQueries<
+              infer TQueryFnData,
+              infer TError,
+              infer TData,
+              any
             >
-          : // Fallback
-            Array<UseQueryResult>
+              ? UseQueryResult<
+                  unknown extends TData ? TQueryFnData : TData,
+                  unknown extends TError ? DefaultError : TError
+                >
+              : GetUseQueryResult<T[number]>
+          }
 
 export function useQueries<
   T extends Array<any>,
@@ -229,7 +225,9 @@ export function useQueries<
     queries,
     ...options
   }: {
-    queries: readonly [...QueriesOptions<T>]
+    queries:
+      | readonly [...QueriesOptions<T>]
+      | readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> }]
     combine?: (result: QueriesResults<T>) => TCombinedResult
     subscribed?: boolean
   },

diff --git a/packages/react-query/src/useSuspenseQueries.ts b/packages/react-query/src/useSuspenseQueries.ts
@@ -160,30 +160,28 @@ export type SuspenseQueriesResults<
             [...TResults, GetUseSuspenseQueryResult<Head>],
             [...TDepth, 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
-              >
+        : {
+            [K in keyof T]: T[K] extends UseSuspenseQueryOptions<
+              infer TQueryFnData,
+              infer TError,
+              infer TData,
+              any
             >
-          : // Fallback
-            Array<UseSuspenseQueryResult>
+              ? UseSuspenseQueryResult<
+                  unknown extends TData ? TQueryFnData : TData,
+                  unknown extends TError ? DefaultError : TError
+                >
+              : GetUseSuspenseQueryResult<T[number]>
+          }
 
 export function useSuspenseQueries<
   T extends Array<any>,
   TCombinedResult = SuspenseQueriesResults<T>,
 >(
   options: {
-    queries: readonly [...SuspenseQueriesOptions<T>]
+    queries:
+      | readonly [...SuspenseQueriesOptions<T>]
+      | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions<T[K]> }]
     combine?: (result: SuspenseQueriesResults<T>) => TCombinedResult
   },
   queryClient?: QueryClient,

diff --git a/packages/vue-query/src/__tests__/useQueries.test-d.ts b/packages/vue-query/src/__tests__/useQueries.test-d.ts
@@ -1,5 +1,6 @@
 import { describe, expectTypeOf, it } from 'vitest'
 import { reactive } from 'vue'
+import { sleep } from 'node_modules/@tanstack/query-core/src/utils'
 import { skipToken, useQueries } from '..'
 import { queryOptions } from '../queryOptions'
 import type { OmitKeyof, QueryObserverResult } from '..'
@@ -219,4 +220,43 @@ describe('UseQueries config object overload', () => {
 
     expectTypeOf(queryCombineWithoutSelect.value).toEqualTypeOf<Array<number>>()
   })
+
+  it('should return correct data for dynamic queries with mixed result types', () => {
+    const Queries1 = {
+      get: () =>
+        queryOptions({
+          queryKey: ['key1'],
+          queryFn: async () => {
+            await sleep(10)
+            return 1
+          },
+        }),
+    }
+    const Queries2 = {
+      get: () =>
+        queryOptions({
+          queryKey: ['key2'],
+          queryFn: async () => {
+            await sleep(10)
+            return true
+          },
+        }),
+    }
+
+    const queries1List = [1, 2, 3].map(() => ({ ...Queries1.get() }))
+    const { value: queriesState } = useQueries({
+      queries: [...queries1List, { ...Queries2.get() }],
+    })
+
+    expectTypeOf(queriesState).toEqualTypeOf<
+      [
+        ...Array<QueryObserverResult<number, Error>>,
+        QueryObserverResult<boolean, Error>,
+      ]
+    >()
+
+    expectTypeOf(queriesState[0].data).toEqualTypeOf<
+      number | boolean | undefined
+    >()
+  })
 })
diff --git a/packages/vue-query/src/useQueries.ts b/packages/vue-query/src/useQueries.ts
@@ -225,23 +225,19 @@ export type UseQueriesResults<
             [...TResults, GetUseQueryResult<Head>],
             [...TDepth, 1]
           >
-        : T extends Array<
-              UseQueryOptionsForUseQueries<
-                infer TQueryFnData,
-                infer TError,
-                infer TData,
-                any
-              >
-            >
-          ? // Dynamic-size (homogenous) UseQueryOptions array: map directly to array of results
-            Array<
-              QueryObserverResult<
-                unknown extends TData ? TQueryFnData : TData,
-                unknown extends TError ? DefaultError : TError
-              >
+        : {
+            [K in keyof T]: T[K] extends UseQueryOptionsForUseQueries<
+              infer TQueryFnData,
+              infer TError,
+              infer TData,
+              any
             >
-          : // Fallback
-            Array<QueryObserverResult>
+              ? QueryObserverResult<
+                  unknown extends TData ? TQueryFnData : TData,
+                  unknown extends TError ? DefaultError : TError
+                >
+              : GetUseQueryResult<T[number]>
+          }
 
 type UseQueriesOptionsArg<T extends Array<any>> = readonly [
   ...UseQueriesOptions<T>,
@@ -255,7 +251,13 @@ export function useQueries<
     queries,
     ...options
   }: {
-    queries: MaybeRefDeep<UseQueriesOptionsArg<T>>
+    queries:
+      | MaybeRefDeep<UseQueriesOptionsArg<T>>
+      | MaybeRefDeep<
+          readonly [
+            ...{ [K in keyof T]: GetUseQueryOptionsForUseQueries<T[K]> },
+          ]
+        >
     combine?: (result: UseQueriesResults<T>) => TCombinedResult
     shallow?: boolean
   },