fix(vue-query): useQueries type inference

packages/vue-query/src/__tests__/useQueries.test-d.ts

@@ -142,4 +142,81 @@ describe('UseQueries config object overload', () => {
       expectTypeOf(queriesState[0].data).toEqualTypeOf<string | undefined>()
     })
   })
+
+  // Fix #7270
+  it('should have proper type inference with different options provided', () => {
+    const numbers = [1, 2, 3]
+    const queryKey = (n: number) => [n]
+    const queryFn = (n: number) => () => Promise.resolve(n)
+    const select = (data: number) => data.toString()
+
+    const queries = numbers.map((n) => ({
+      queryKey: [n],
+      queryFn: () => Promise.resolve(n),
+      select: (data: number) => data.toString(),
+    }))
+
+    const queriesWithoutSelect = numbers.map((n) => ({
+      queryKey: queryKey(n),
+      queryFn: queryFn(n),
+    }))
+
+    const queriesWithQueryOptions = numbers.map((n) =>
+      queryOptions({
+        queryKey: queryKey(n),
+        queryFn: queryFn(n),
+        select,
+      }),
+    )
+
+    const queriesWithQueryOptionsWithoutSelect = numbers.map((n) =>
+      queryOptions({
+        queryKey: queryKey(n),
+        queryFn: queryFn(n),
+      }),
+    )
+
+    const query1 = useQueries({ queries: queries })
+    expectTypeOf(query1.value).toEqualTypeOf<
+      Array<QueryObserverResult<string, Error>>
+    >()
+
+    const query2 = useQueries({ queries: queriesWithoutSelect })
+    expectTypeOf(query2.value).toEqualTypeOf<
+      Array<QueryObserverResult<number, Error>>
+    >()
+
+    const query3 = useQueries({ queries: queriesWithQueryOptions })
+    expectTypeOf(query3.value).toEqualTypeOf<
+      Array<QueryObserverResult<string, Error>>
+    >()
+
+    const query4 = useQueries({ queries: queriesWithQueryOptionsWithoutSelect })
+    expectTypeOf(query4.value).toEqualTypeOf<
+      Array<QueryObserverResult<number, Error>>
+    >()
+
+    const queryCombine = useQueries({
+      queries: queries,
+      combine: (data) => {
+        return data.reduce((acc, i) => {
+          acc.push(i.data ?? '')
+          return acc
+        }, [] as Array<string>)
+      },
+    })
+    expectTypeOf(queryCombine.value).toEqualTypeOf<Array<string>>()
+
+    const queryCombineWithoutSelect = useQueries({
+      queries: queriesWithoutSelect,
+      combine: (data) => {
+        return data.reduce((acc, i) => {
+          acc.push(i.data ?? 0)
+          return acc
+        }, [] as Array<number>)
+      },
+    })
+
+    expectTypeOf(queryCombineWithoutSelect.value).toEqualTypeOf<Array<number>>()
+  })
 })

packages/vue-query/src/useQueries.ts

@@ -15,15 +15,14 @@ import type {
   DefaultError,
   DefinedQueryObserverResult,
   QueriesObserverOptions,
-  QueriesPlaceholderDataFunction,
   QueryFunction,
   QueryKey,
   QueryObserverResult,
   ThrowOnError,
 } from '@tanstack/query-core'
 import type { UseQueryOptions } from './useQuery'
 import type { QueryClient } from './queryClient'
-import type { DeepUnwrapRef, DistributiveOmit, MaybeRefDeep } from './types'
+import type { DeepUnwrapRef, MaybeRefDeep } from './types'
 
 // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
 // `placeholderData` function does not have a parameter
@@ -32,20 +31,15 @@ type UseQueryOptionsForUseQueries<
   TError = unknown,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> = DistributiveOmit<
-  UseQueryOptions<TQueryFnData, TError, TData, unknown, TQueryKey>,
-  'placeholderData'
-> & {
-  placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
-}
+> = UseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>
 
 // Avoid TS depth-limit error in case of large array literal
 type MAXIMUM_DEPTH = 20
 
 // Widen the type of the symbol to enable type inference even if skipToken is not immutable.
 type SkipTokenForUseQueries = symbol
 
-type GetOptions<T> =
+type GetUseQueryOptionsForUseQueries<T> =
   // Part 1: if UseQueryOptions are already being sent through, then just return T
   T extends UseQueryOptions
     ? DeepUnwrapRef<T>
@@ -81,8 +75,20 @@ type GetOptions<T> =
                       unknown extends TData ? TQueryFnData : TData,
                       TQueryKey
                     >
-                  : // Fallback
-                    UseQueryOptionsForUseQueries
+                  : T extends {
+                        queryFn?:
+                          | QueryFunction<infer TQueryFnData, infer TQueryKey>
+                          | SkipTokenForUseQueries
+                        throwOnError?: ThrowOnError<any, infer TError, any, any>
+                      }
+                    ? UseQueryOptionsForUseQueries<
+                        TQueryFnData,
+                        TError,
+                        TQueryFnData,
+                        TQueryKey
+                      >
+                    : // Fallback
+                      UseQueryOptionsForUseQueries
 
 // A defined initialData setting should return a DefinedQueryObserverResult rather than QueryObserverResult
 type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
@@ -101,7 +107,7 @@ type GetDefinedOrUndefinedQueryResult<T, TData, TError = unknown> = T extends {
         : QueryObserverResult<TData, TError>
   : QueryObserverResult<TData, TError>
 
-type GetResults<T> =
+type GetUseQueryResult<T> =
   // Part 1: if using UseQueryOptions then the types are already set
   T extends UseQueryOptions<
     infer TQueryFnData,
@@ -142,26 +148,37 @@ type GetResults<T> =
                       unknown extends TData ? TQueryFnData : TData,
                       unknown extends TError ? DefaultError : TError
                     >
-                  : // Fallback
-                    QueryObserverResult
+                  : T extends {
+                        queryFn?:
+                          | QueryFunction<infer TQueryFnData, any>
+                          | SkipTokenForUseQueries
+                        throwOnError?: ThrowOnError<any, infer TError, any, any>
+                      }
+                    ? GetDefinedOrUndefinedQueryResult<
+                        T,
+                        TQueryFnData,
+                        unknown extends TError ? DefaultError : TError
+                      >
+                    : // Fallback
+                      QueryObserverResult
 
 /**
  * UseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
  */
 export type UseQueriesOptions<
   T extends Array<any>,
-  TResult extends Array<any> = [],
+  TResults extends Array<any> = [],
   TDepth extends ReadonlyArray<number> = [],
 > = TDepth['length'] extends MAXIMUM_DEPTH
   ? Array<UseQueryOptionsForUseQueries>
   : T extends []
     ? []
     : T extends [infer Head]
-      ? [...TResult, GetOptions<Head>]
-      : T extends [infer Head, ...infer Tail]
+      ? [...TResults, GetUseQueryOptionsForUseQueries<Head>]
+      : T extends [infer Head, ...infer Tails]
         ? UseQueriesOptions<
-            [...Tail],
-            [...TResult, GetOptions<Head>],
+            [...Tails],
+            [...TResults, GetUseQueryOptionsForUseQueries<Head>],
             [...TDepth, 1]
           >
         : ReadonlyArray<unknown> extends T
@@ -192,18 +209,18 @@ export type UseQueriesOptions<
  */
 export type UseQueriesResults<
   T extends Array<any>,
-  TResult extends Array<any> = [],
+  TResults extends Array<any> = [],
   TDepth extends ReadonlyArray<number> = [],
 > = TDepth['length'] extends MAXIMUM_DEPTH
   ? Array<QueryObserverResult>
   : T extends []
     ? []
     : T extends [infer Head]
-      ? [...TResult, GetResults<Head>]
-      : T extends [infer Head, ...infer Tail]
+      ? [...TResults, GetUseQueryResult<Head>]
+      : T extends [infer Head, ...infer Tails]
         ? UseQueriesResults<
-            [...Tail],
-            [...TResult, GetResults<Head>],
+            [...Tails],
+            [...TResults, GetUseQueryResult<Head>],
             [...TDepth, 1]
           >
         : T extends Array<