fix(useQueries): check for invalid types

src/reactjs/tests/useQueries.test.tsx

@@ -607,6 +607,50 @@ describe('useQueries', () => {
     // @ts-expect-error (Page component is not rendered)
     // eslint-disable-next-line
     function Page() {
+      // Rejects queryFn that returns/resolved to undefined
+      // @ts-expect-error (queryFn must not return undefined)
+      useQueries({ queries: [{ queryKey: key1, queryFn: () => undefined }] })
+      useQueries({
+        queries: [
+          // @ts-expect-error (queryFn must not return undefined)
+          { queryKey: key2, queryFn: () => Promise.resolve(undefined) },
+        ],
+      })
+      useQueries({
+        // @ts-expect-error (queryFn must not return undefined)
+        queries: Array(50).map((_, i) => ({
+          queryKey: ['key', i] as const,
+          queryFn: () => Promise.resolve(undefined),
+        })),
+      })
+
+      // Rejects queryFn that always throws
+      useQueries({
+        queries: [
+          // @ts-expect-error (queryFn must not return undefined)
+          {
+            queryKey: key3,
+            queryFn: async () => {
+              throw new Error('')
+            },
+          },
+        ],
+      })
+      // Accepts queryFn that *sometimes* throws
+      useQueries({
+        queries: [
+          {
+            queryKey: key3,
+            queryFn: async () => {
+              if (Math.random() > 0.1) {
+                throw new Error('')
+              }
+              return 'result'
+            },
+          },
+        ],
+      })
+
       // Array.map preserves TQueryFnData
       const result1 = useQueries({
         queries: Array(50).map((_, i) => ({

src/reactjs/useQueries.ts

@@ -17,6 +17,8 @@ type UseQueryOptionsForUseQueries<
   TQueryKey extends QueryKey = QueryKey
 > = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>
 
+type InvalidQueryFn = QueryFunction<undefined | Promise<undefined> | Promise<undefined> | void | Promise<void>>
+
 // Avoid TS depth-limit error in case of large array literal
 type MAXIMUM_DEPTH = 20
 
@@ -40,6 +42,9 @@ type GetOptions<T> =
     : T extends [infer TQueryFnData]
     ? UseQueryOptionsForUseQueries<TQueryFnData>
     : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
+    T extends { queryFn?: InvalidQueryFn }
+    ? never | 'queryFn must not return undefined'
+    :
     T extends {
         queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>
         select: (data: any) => infer TData
@@ -100,6 +105,8 @@ export type QueriesOptions<
   ? T
   : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
   // use this to infer the param types in the case of Array.map() argument
+  T extends { queryFn: InvalidQueryFn }[]
+  ? (never | 'queryFn must not return undefined')[] :
   T extends UseQueryOptionsForUseQueries<
       infer TQueryFnData,
       infer TError,