From d670b2aed121a6319858b9dca94d1890922bd3a9 Mon Sep 17 00:00:00 2001
From: Jake Son <sonjeabin@gmail.com>
Date: Sat, 30 Apr 2022 12:03:42 +0900
Subject: [PATCH] ref: move type definition of createQueryToolkit

---
 src/createQueryToolkit.ts | 104 ++++----------------------------------
 src/types/queryToolkit.ts |  35 +++++++++++++
 2 files changed, 46 insertions(+), 93 deletions(-)

diff --git a/src/createQueryToolkit.ts b/src/createQueryToolkit.ts
index 94350a0..59ff7b4 100644
--- a/src/createQueryToolkit.ts
+++ b/src/createQueryToolkit.ts
@@ -7,69 +7,10 @@ import {
 } from "react-query";
 import { generateKey } from "./internal/generateKey";
 import { returnByCondition } from "./internal/returnByCondition";
-import {
-  QueryDefaultOption,
-  QueryType,
-  TQueryFunction,
-  UseInfiniteQueryDefaultOption,
-  UseQueryDefaultOption,
-} from "./types/query";
-import {
-  QueryToolkit,
-  QueryToolkitInfiniteQueryType,
-  QueryToolkitQueryType,
-} from "./types/queryToolkit";
+import { QueryCreator, QueryToolkit } from "./types/queryToolkit";
 
-export function createQueryToolkit(queryClient: QueryClient) {
-  function createQuery<
-    TQueryFnArgs extends unknown[],
-    TQueryFnReturn,
-    TData = TQueryFnReturn,
-  >(
-    queryKey: QueryKey,
-    queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
-    options?: {
-      passArgsToQueryKey?: boolean;
-      queryType?: "query";
-      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
-        UseQueryDefaultOption<TQueryFnReturn, TData>;
-    },
-  ): Omit<
-    QueryToolkitQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
-    "useInfiniteQuery" | "fetchInfiniteQuery" | "prefetchInfiniteQuery"
-  >;
-  function createQuery<
-    TQueryFnArgs extends unknown[],
-    TQueryFnReturn,
-    TData = TQueryFnReturn,
-  >(
-    queryKey: QueryKey,
-    queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
-    options?: {
-      passArgsToQueryKey?: boolean;
-      queryType?: "infiniteQuery";
-      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
-        UseInfiniteQueryDefaultOption<TQueryFnReturn, TData>;
-    },
-  ): Omit<
-    QueryToolkitInfiniteQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
-    "useQuery" | "fetchQuery" | "prefetchQuery"
-  >;
-  function createQuery<
-    TQueryFnArgs extends unknown[],
-    TQueryFnReturn,
-    TData = TQueryFnReturn,
-  >(
-    queryKey: QueryKey,
-    queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
-    options: {
-      passArgsToQueryKey?: boolean;
-      queryType?: QueryType;
-      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
-        UseQueryDefaultOption<TQueryFnReturn, TData> &
-        UseInfiniteQueryDefaultOption<TQueryFnReturn, TData>;
-    } = {},
-  ) {
+export function createQueryToolkit(queryClient: QueryClient): QueryCreator {
+  return (queryKey, queryFn, options = {}) => {
     const {
       passArgsToQueryKey = true,
       queryType = "query",
@@ -87,19 +28,14 @@ export function createQueryToolkit(queryClient: QueryClient) {
         ...(passArgsToQueryKey && args ? args : []),
       ]);
 
-    const handleHooks =
-      (hook: any) => (args?: TQueryFnArgs, queryOptions?: any) =>
-        hook(
-          getKey(queryOptions?.queryKey, args),
-          queryFn(...((args || []) as TQueryFnArgs)),
-          { ...defaultOptions, ...queryOptions },
-        );
+    const handleHooks = (hook: any) => (args?: any, queryOptions?: any) =>
+      hook(getKey(queryOptions?.queryKey, args), queryFn(...(args || [])), {
+        ...defaultOptions,
+        ...queryOptions,
+      });
 
     const hooks: Partial<
-      Pick<
-        QueryToolkit<TQueryFnArgs>,
-        "useQuery" | "useInfiniteQuery" | "useIsFetching"
-      >
+      Pick<QueryToolkit, "useQuery" | "useInfiniteQuery" | "useIsFetching">
     > = {
       useQuery: returnOnQuery(handleHooks(useQuery)),
       useInfiniteQuery: returnOnInfiniteQuery(handleHooks(useInfiniteQuery)),
@@ -119,7 +55,7 @@ export function createQueryToolkit(queryClient: QueryClient) {
         ),
       );
 
-    const handler = new Proxy(hooks, {
+    return new Proxy(hooks, {
       get(target: any, path: keyof QueryToolkit) {
         if (target[path]) return target[path];
         switch (path) {
@@ -144,23 +80,5 @@ export function createQueryToolkit(queryClient: QueryClient) {
         }
       },
     });
-
-    if (isInfiniteQuery)
-      return handler as Omit<
-        QueryToolkitInfiniteQueryType<
-          TQueryFnArgs,
-          TQueryFnReturn,
-          Error,
-          TData
-        >,
-        "useQuery" | "fetchQuery" | "prefetchQuery"
-      >;
-
-    return handler as Omit<
-      QueryToolkitQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
-      "useInfiniteQuery" | "fetchInfiniteQuery" | "prefetchInfiniteQuery"
-    >;
-  }
-
-  return createQuery;
+  };
 }
diff --git a/src/types/queryToolkit.ts b/src/types/queryToolkit.ts
index 85c5beb..4e2bde9 100644
--- a/src/types/queryToolkit.ts
+++ b/src/types/queryToolkit.ts
@@ -18,6 +18,12 @@ import {
 } from "react-query";
 import { QueryState } from "react-query/types/core/query";
 import { QueryFilters, Updater } from "react-query/types/core/utils";
+import {
+  QueryDefaultOption,
+  TQueryFunction,
+  UseInfiniteQueryDefaultOption,
+  UseQueryDefaultOption,
+} from "./query";
 
 interface QueryToolkitBase<
   TQueryFnData = unknown,
@@ -120,3 +126,32 @@ export type QueryToolkit<
 > =
   | QueryToolkitQueryType<TQueryFnArgs, TQueryFnData, TError, TData>
   | QueryToolkitInfiniteQueryType<TQueryFnArgs, TQueryFnData, TError, TData>;
+
+export interface QueryCreator {
+  <TQueryFnArgs extends unknown[], TQueryFnReturn, TData = TQueryFnReturn>(
+    queryKey: QueryKey,
+    queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
+    options?: {
+      passArgsToQueryKey?: boolean;
+      queryType?: "query";
+      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
+        UseQueryDefaultOption<TQueryFnReturn, TData>;
+    },
+  ): Omit<
+    QueryToolkitQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
+    "useInfiniteQuery" | "fetchInfiniteQuery" | "prefetchInfiniteQuery"
+  >;
+  <TQueryFnArgs extends unknown[], TQueryFnReturn, TData = TQueryFnReturn>(
+    queryKey: QueryKey,
+    queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
+    options?: {
+      passArgsToQueryKey?: boolean;
+      queryType?: "infiniteQuery";
+      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
+        UseInfiniteQueryDefaultOption<TQueryFnReturn, TData>;
+    },
+  ): Omit<
+    QueryToolkitInfiniteQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
+    "useQuery" | "fetchQuery" | "prefetchQuery"
+  >;
+}