cleanup: move getUseApiQueries down in the file to reduce diff noise elsewhere

Author: david-crespo

app/api/hooks.ts

@@ -100,9 +100,6 @@ type FetchQueryOtherOptions<T, E = DefaultError> = Omit<
   'queryKey' | 'queryFn'
 >
 
-/** Result that includes both success and error so it can be cached by RQ */
-type ErrorsAllowed<T, E> = { type: 'success'; data: T } | { type: 'error'; data: E }
-
 export const getUseApiQuery =
   <A extends ApiClient>(api: A) =>
   <M extends string & keyof A>(
@@ -123,35 +120,6 @@ export const getUseApiQuery =
     })
   }
 
-/**
- * Our version of `useQueries`, but with the key difference that all queries in
- * a given call are using the same API method, and therefore all have the same
- * request and response (`Params` and `Result`) types. Otherwise the types would
- * be (perhaps literally) impossible.
- */
-export const getUseApiQueries =
-  <A extends ApiClient>(api: A) =>
-  <M extends string & keyof A>(
-    method: M,
-    paramsArray: Params<A[M]>[],
-    options: UseQueryOtherOptions<Result<A[M]>, ApiError> = {}
-  ) => {
-    return useQueries({
-      queries: paramsArray.map(
-        (params) =>
-          ({
-            queryKey: [method, params],
-            queryFn: ({ signal }) =>
-              api[method](params, { signal }).then(handleResult(method)),
-            throwOnError: (err: ApiError) => err.statusCode === 404,
-            ...options,
-            // Add params to the result for reassembly after the queries are returned
-            select: (data) => ({ ...data, params }),
-          }) satisfies UseQueryOptions<Result<A[M]> & { params: Params<A[M]> }, ApiError>
-      ),
-    })
-  }
-
 export const getUsePrefetchedApiQuery =
   <A extends ApiClient>(api: A) =>
   <M extends string & keyof A>(
@@ -189,6 +157,9 @@ Ensure the following:
 
 const ERRORS_ALLOWED = 'errors-allowed'
 
+/** Result that includes both success and error so it can be cached by RQ */
+type ErrorsAllowed<T, E> = { type: 'success'; data: T } | { type: 'error'; data: E }
+
 /**
  * Variant of `getUseApiQuery` that allows error responses as a valid result,
  * which importantly means they can be cached by RQ. This means we can prefetch
@@ -238,6 +209,35 @@ export const getUseApiMutation =
       ...options,
     })
 
+/**
+ * Our version of `useQueries`, but with the key difference that all queries in
+ * a given call are using the same API method, and therefore all have the same
+ * request and response (`Params` and `Result`) types. Otherwise the types would
+ * be (perhaps literally) impossible.
+ */
+export const getUseApiQueries =
+  <A extends ApiClient>(api: A) =>
+  <M extends string & keyof A>(
+    method: M,
+    paramsArray: Params<A[M]>[],
+    options: UseQueryOtherOptions<Result<A[M]>, ApiError> = {}
+  ) => {
+    return useQueries({
+      queries: paramsArray.map(
+        (params) =>
+          ({
+            queryKey: [method, params],
+            queryFn: ({ signal }) =>
+              api[method](params, { signal }).then(handleResult(method)),
+            throwOnError: (err: ApiError) => err.statusCode === 404,
+            ...options,
+            // Add params to the result for reassembly after the queries are returned
+            select: (data) => ({ ...data, params }),
+          }) satisfies UseQueryOptions<Result<A[M]> & { params: Params<A[M]> }, ApiError>
+      ),
+    })
+  }
+
 export const wrapQueryClient = <A extends ApiClient>(api: A, queryClient: QueryClient) => ({
   /**
    * Note that we only take a single argument, `method`, rather than allowing