feat: add default options to query

README.md

@@ -114,6 +114,7 @@ function AnotherExampleComponent () {
   - returns a function that will return a queryToolkit instance
 
 ***
+<br>
 
 ### createQuery
 
@@ -137,13 +138,17 @@ function AnotherExampleComponent () {
     - Defaults to `'query'`
     - if set to `'query'`, `QueryToolkit` will have `useQuery`, `fetchQuery`, `prefetchQuery` methods.
     - if set to `'infiniteQuery'`, `QueryToolkit` will have `useInfiniteQuery`, `fetchInfiniteQuery`, `prefetchInfiniteQuery` methods.
+  - `defaultOptions: QueryOptions & UseQueryOptions & UseInfiniteQueryOptions`
+    - same option as react-query's query options [check out here](https://react-query.tanstack.com/reference/useQuery)
 
 #### returns
 
 - `QueryToolkit`
   - will Return a `QueryClient` instance
 
 ***
+<br>
+
 ### createMutationToolkit
 
 #### parameters
@@ -156,7 +161,12 @@ function AnotherExampleComponent () {
 - `createMutaion: (queryKey, queryFn, options) => QueryToolkit`
   - returns a function that will return a mutationToolkit instance
 
+
+***
+<br>
+
 ### createMutation
+
 #### parameters
 
 - `mutationKey: MutationKey`

src/createMutationToolkit.ts

@@ -8,7 +8,7 @@ import {
 } from "react-query";
 import { MutationFilters } from "react-query/types/core/utils";
 import { generateKey } from "./internal/generateKey";
-import { MutationToolkit } from "./types/mutation";
+import { MutationToolkit } from "./types/mutationToolkit";
 
 export function createMutationToolkit(queryClient: QueryClient) {
   function createMutation<TMutationFnArgs, TMutationFnReturn, TContext>(

src/createQueryToolkit.ts

@@ -8,36 +8,73 @@ import {
 import { generateKey } from "./internal/generateKey";
 import { returnByCondition } from "./internal/returnByCondition";
 import {
-  QueryToolkit,
-  QueryToolkitInfiniteQueryType,
-  QueryToolkitQueryType,
+  QueryDefaultOption,
   QueryType,
   TQueryFunction,
+  UseInfiniteQueryDefaultOption,
+  UseQueryDefaultOption,
 } from "./types/query";
+import {
+  QueryToolkit,
+  QueryToolkitInfiniteQueryType,
+  QueryToolkitQueryType,
+} from "./types/queryToolkit";
 
 export function createQueryToolkit(queryClient: QueryClient) {
-  function createQuery<TQueryFnArgs extends unknown[], TQueryFnReturn>(
+  function createQuery<
+    TQueryFnArgs extends unknown[],
+    TQueryFnReturn,
+    TData = TQueryFnReturn,
+  >(
     queryKey: QueryKey,
     queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
-    options?: { passArgsToQueryKey?: boolean; queryType?: "query" },
+    options?: {
+      passArgsToQueryKey?: boolean;
+      queryType?: "query";
+      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
+        UseQueryDefaultOption<TQueryFnReturn, TData>;
+    },
   ): Omit<
-    QueryToolkitQueryType<TQueryFnArgs, TQueryFnReturn, Error>,
+    QueryToolkitQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
     "useInfiniteQuery" | "fetchInfiniteQuery" | "prefetchInfiniteQuery"
   >;
-  function createQuery<TQueryFnArgs extends unknown[], TQueryFnReturn>(
+  function createQuery<
+    TQueryFnArgs extends unknown[],
+    TQueryFnReturn,
+    TData = TQueryFnReturn,
+  >(
     queryKey: QueryKey,
     queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
-    options?: { passArgsToQueryKey?: boolean; queryType?: "infiniteQuery" },
+    options?: {
+      passArgsToQueryKey?: boolean;
+      queryType?: "infiniteQuery";
+      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
+        UseInfiniteQueryDefaultOption<TQueryFnReturn, TData>;
+    },
   ): Omit<
-    QueryToolkitInfiniteQueryType<TQueryFnArgs, TQueryFnReturn, Error>,
+    QueryToolkitInfiniteQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
     "useQuery" | "fetchQuery" | "prefetchQuery"
   >;
-  function createQuery<TQueryFnArgs extends unknown[], TQueryFnReturn>(
+  function createQuery<
+    TQueryFnArgs extends unknown[],
+    TQueryFnReturn,
+    TData = TQueryFnReturn,
+  >(
     queryKey: QueryKey,
     queryFn: TQueryFunction<TQueryFnArgs, TQueryFnReturn>,
-    options: { passArgsToQueryKey?: boolean; queryType?: QueryType } = {},
+    options: {
+      passArgsToQueryKey?: boolean;
+      queryType?: QueryType;
+      defaultOptions?: QueryDefaultOption<TQueryFnReturn, TData> &
+        UseQueryDefaultOption<TQueryFnReturn, TData> &
+        UseInfiniteQueryDefaultOption<TQueryFnReturn, TData>;
+    } = {},
   ) {
-    const { passArgsToQueryKey = true, queryType = "query" } = options;
+    const {
+      passArgsToQueryKey = true,
+      queryType = "query",
+      defaultOptions,
+    } = options;
 
     const isInfiniteQuery = queryType === "infiniteQuery";
     const returnOnQuery = returnByCondition(!isInfiniteQuery);
@@ -55,7 +92,7 @@ export function createQueryToolkit(queryClient: QueryClient) {
         hook(
           getKey(queryOptions?.queryKey, args),
           queryFn(...((args || []) as TQueryFnArgs)),
-          queryOptions,
+          { ...defaultOptions, ...queryOptions },
         );
 
     const hooks: Partial<
@@ -78,7 +115,7 @@ export function createQueryToolkit(queryClient: QueryClient) {
         (queryClient as any)[path](
           getKey(options?.queryKey, args),
           queryFn(...args),
-          options,
+          { ...defaultOptions, ...options },
         ),
       );
 
@@ -110,12 +147,17 @@ export function createQueryToolkit(queryClient: QueryClient) {
 
     if (isInfiniteQuery)
       return handler as Omit<
-        QueryToolkitInfiniteQueryType<TQueryFnArgs, TQueryFnReturn, Error>,
+        QueryToolkitInfiniteQueryType<
+          TQueryFnArgs,
+          TQueryFnReturn,
+          Error,
+          TData
+        >,
         "useQuery" | "fetchQuery" | "prefetchQuery"
       >;
 
     return handler as Omit<
-      QueryToolkitQueryType<TQueryFnArgs, TQueryFnReturn, Error>,
+      QueryToolkitQueryType<TQueryFnArgs, TQueryFnReturn, Error, TData>,
       "useInfiniteQuery" | "fetchInfiniteQuery" | "prefetchInfiniteQuery"
     >;
   }

src/types/query.ts

@@ -1,128 +1,32 @@
 import {
-  CancelOptions,
-  FetchInfiniteQueryOptions,
-  FetchQueryOptions,
-  InfiniteData,
-  InvalidateOptions,
-  InvalidateQueryFilters,
   QueryFunction,
-  QueryKey,
-  RefetchOptions,
-  RefetchQueryFilters,
-  ResetOptions,
-  ResetQueryFilters,
-  SetDataOptions,
+  QueryOptions,
   UseInfiniteQueryOptions,
-  UseInfiniteQueryResult,
   UseQueryOptions,
-  UseQueryResult,
 } from "react-query";
-import { QueryState } from "react-query/types/core/query";
-import { QueryFilters, Updater } from "react-query/types/core/utils";
 
 export type QueryType = "query" | "infiniteQuery";
 export type TQueryFunction<TQueryFnArgs extends unknown[], TQueryFnReturn> = (
   ...args: TQueryFnArgs
 ) => QueryFunction<TQueryFnReturn>;
 
-interface QueryToolkitBase<
+export type QueryDefaultOption<
   TQueryFnData = unknown,
-  TError = unknown,
   TData = TQueryFnData,
-> {
-  getQueryData(queryKey?: QueryKey, filters?: QueryFilters): TData | undefined;
-  getQueryState(
-    queryKey?: QueryKey,
-    filters?: QueryFilters,
-  ): QueryState<TData, TError> | undefined;
-  setQueryData(
-    queryKey: QueryKey,
-    updater: Updater<TData | undefined, TData | undefined>,
-    options?: SetDataOptions,
-  ): TData;
-  getQueriesData(filters?: QueryFilters): [QueryKey, TData][];
-  setQueriesData(
-    filters: QueryFilters,
-    updater: Updater<TData | undefined, TData | undefined>,
-    options?: SetDataOptions,
-  ): [QueryKey, TData][];
-
-  invalidateQueries<TPageData = unknown>(
-    filters?: InvalidateQueryFilters<TPageData>,
-    options?: InvalidateOptions,
-  ): Promise<void>;
-  refetchQueries<TPageData = unknown>(
-    filters?: RefetchQueryFilters<TPageData>,
-    options?: RefetchOptions,
-  ): Promise<void>;
-  cancelQueries(filters?: QueryFilters, options?: CancelOptions): Promise<void>;
-  removeQueries(filters?: QueryFilters): void;
-  resetQueries<TPageData = unknown>(
-    filters?: ResetQueryFilters<TPageData>,
-    options?: ResetOptions,
-  ): Promise<void>;
-
-  isFetching(filters?: QueryFilters): number;
-  useIsFetching(filters?: QueryFilters): number;
-}
-
-export interface QueryToolkitQueryType<
-  TQueryFnArgs extends unknown[] = [],
-  TQueryFnData = unknown,
   TError = unknown,
-  TData = TQueryFnData,
-> extends QueryToolkitBase<TQueryFnData, TError, TData> {
-  fetchInfiniteQuery: undefined;
-  prefetchInfiniteQuery: undefined;
-  useInfiniteQuery: undefined;
-  fetchQuery<TReturn = TData>(
-    args: TQueryFnArgs,
-    options?: Omit<FetchQueryOptions<TQueryFnData, TError, TReturn>, "queryFn">,
-  ): Promise<TReturn>;
-  prefetchQuery(
-    args: TQueryFnArgs,
-    options?: Omit<FetchQueryOptions<TQueryFnData, TError>, "queryFn">,
-  ): Promise<void>;
-  useQuery<TReturn = TData>(
-    args: TQueryFnArgs,
-    options?: Omit<UseQueryOptions<TQueryFnData, TError, TReturn>, "queryFn">,
-  ): UseQueryResult<TReturn, TError>;
-}
+> = Omit<QueryOptions<TQueryFnData, TError, TData>, "queryKey" | "queryFn">;
 
-export interface QueryToolkitInfiniteQueryType<
-  TQueryFnArgs extends unknown[] = [],
+export type UseQueryDefaultOption<
   TQueryFnData = unknown,
-  TError = unknown,
   TData = TQueryFnData,
-> extends QueryToolkitBase<TQueryFnData, TError, TData> {
-  fetchQuery: undefined;
-  prefetchQuery: undefined;
-  useQuery: undefined;
-  fetchInfiniteQuery<TReturn = TData>(
-    args: TQueryFnArgs,
-    options?: Omit<
-      FetchInfiniteQueryOptions<TQueryFnData, TError, TReturn>,
-      "queryFn"
-    >,
-  ): Promise<InfiniteData<TReturn>>;
-  prefetchInfiniteQuery(
-    args: TQueryFnArgs,
-    options?: Omit<FetchQueryOptions<TQueryFnData, TError>, "queryFn">,
-  ): Promise<void>;
-  useInfiniteQuery<TReturn = TData>(
-    args: TQueryFnArgs,
-    options?: Omit<
-      UseInfiniteQueryOptions<TQueryFnData, TError, TReturn>,
-      "queryFn"
-    >,
-  ): UseInfiniteQueryResult<TReturn, TError>;
-}
+  TError = unknown,
+> = Omit<UseQueryOptions<TQueryFnData, TError, TData>, "queryKey" | "queryFn">;
 
-export type QueryToolkit<
-  TQueryFnArgs extends unknown[] = [],
+export type UseInfiniteQueryDefaultOption<
   TQueryFnData = unknown,
-  TError = unknown,
   TData = TQueryFnData,
-> =
-  | QueryToolkitQueryType<TQueryFnArgs, TQueryFnData, TError, TData>
-  | QueryToolkitInfiniteQueryType<TQueryFnArgs, TQueryFnData, TError, TData>;
+  TError = unknown,
+> = Omit<
+  UseInfiniteQueryOptions<TQueryFnData, TError, TData>,
+  "queryKey" | "queryFn"
+>;