@ventlio/tanstack-query 0.4.2 → 0.5.1

package/dist/queries/useGetRequest.d.ts

@@ -19,6 +19,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -34,12 +35,10 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     isInitialLoading: boolean;
     isPaused: boolean;
     isPlaceholderData: boolean;
-    isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
-    remove: () => void;
-    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a4 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ak<IRequestSuccess<TResponse>, any>>;
+    fetchStatus: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ac;
 } | {
     isLoading: boolean;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
@@ -52,6 +51,7 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
@@ -67,76 +67,8 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     isInitialLoading: boolean;
     isPaused: boolean;
     isPlaceholderData: boolean;
-    isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
-    remove: () => void;
-    fetchStatus: import("@tanstack/react-query").FetchStatus;
-} | {
-    isLoading: boolean;
-    setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    nextPage: () => void;
-    prevPage: () => void;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    gotoPage: (pageNumber: number) => void;
-    page: number;
-    queryKey: {}[];
-    data: undefined;
-    error: any;
-    isError: true;
-    isLoadingError: true;
-    isRefetchError: false;
-    isSuccess: false;
-    status: "error";
-    dataUpdatedAt: number;
-    errorUpdatedAt: number;
-    failureCount: number;
-    failureReason: any;
-    errorUpdateCount: number;
-    isFetched: boolean;
-    isFetchedAfterMount: boolean;
-    isFetching: boolean;
-    isInitialLoading: boolean;
-    isPaused: boolean;
-    isPlaceholderData: boolean;
-    isPreviousData: boolean;
-    isRefetching: boolean;
-    isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
-    remove: () => void;
-    fetchStatus: import("@tanstack/react-query").FetchStatus;
-} | {
-    isLoading: boolean;
-    setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    nextPage: () => void;
-    prevPage: () => void;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    gotoPage: (pageNumber: number) => void;
-    page: number;
-    queryKey: {}[];
-    data: undefined;
-    error: null;
-    isError: false;
-    isLoadingError: false;
-    isRefetchError: false;
-    isSuccess: false;
-    status: "loading";
-    dataUpdatedAt: number;
-    errorUpdatedAt: number;
-    failureCount: number;
-    failureReason: any;
-    errorUpdateCount: number;
-    isFetched: boolean;
-    isFetchedAfterMount: boolean;
-    isFetching: boolean;
-    isInitialLoading: boolean;
-    isPaused: boolean;
-    isPlaceholderData: boolean;
-    isPreviousData: boolean;
-    isRefetching: boolean;
-    isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
-    remove: () => void;
-    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a4 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ak<IRequestSuccess<TResponse>, any>>;
+    fetchStatus: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ac;
 };

package/dist/queries/useGetRequest.js

@@ -52,7 +52,9 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
             res(null);
         }
     };
-    const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), {
+    const query = useQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
         enabled: load && !isFutureQueriesPaused,
         ...options,
     });
@@ -65,7 +67,6 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         if (keyTracker) {
             // set expiration time for the tracker
             queryClient.setQueryDefaults([keyTracker], {
-                cacheTime: Infinity,
                 staleTime: Infinity,
             });
             queryClient.setQueryData([keyTracker], [requestPath, {}]);

package/dist/queries/useGetRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"useGetRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/usePatchRequest.d.ts

@@ -6,73 +6,81 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
 } & DefaultRequestOptions) => {
     isLoading: boolean;
     data: undefined;
+    variables: undefined;
     error: null;
     isError: false;
     isIdle: true;
+    isPending: false;
     isSuccess: false;
     status: "idle";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: void | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
     isLoading: boolean;
     data: undefined;
+    variables: void;
     error: null;
     isError: false;
     isIdle: false;
+    isPending: true;
     isSuccess: false;
-    status: "loading";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    status: "pending";
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: void | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
     isLoading: boolean;
     data: undefined;
     error: IRequestError;
+    variables: void;
     isError: true;
     isIdle: false;
+    isPending: false;
     isSuccess: false;
     status: "error";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: void | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
     isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
+    variables: void;
     isError: false;
     isIdle: false;
+    isPending: false;
     isSuccess: true;
     status: "success";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: void | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 };

package/dist/queries/usePatchRequest.js

@@ -58,9 +58,12 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         }
     };
     // register post mutation
-    const mutation = useMutation((dataData) => new Promise((res, rej) => {
-        return sendRequest(res, rej, dataData);
-    }), { mutationKey: [path, { type: 'mutation' }] });
+    const mutation = useMutation({
+        mutationFn: (dataData) => new Promise((res, rej) => {
+            return sendRequest(res, rej, dataData);
+        }),
+        mutationKey: [path, { type: 'mutation' }],
+    });
     const patch = async (data, options) => {
         if (!isFutureMutationsPaused) {
             return mutation.mutateAsync(data, options);
@@ -77,7 +80,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [isFutureMutationsPaused]);
-    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
+    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
 };
 
 export { usePatchRequest };

package/dist/queries/usePatchRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePatchRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"usePatchRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/queries/usePostRequest.d.ts

@@ -8,12 +8,14 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
 } & DefaultRequestOptions) => {
     isLoading: boolean;
     data: undefined;
+    variables: undefined;
     error: null;
     isError: false;
     isIdle: true;
+    isPending: false;
     isSuccess: false;
     status: "idle";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -22,11 +24,8 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -44,12 +43,17 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
 } | {
     isLoading: boolean;
     data: undefined;
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
+    };
     error: null;
     isError: false;
     isIdle: false;
+    isPending: true;
     isSuccess: false;
-    status: "loading";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    status: "pending";
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -58,11 +62,8 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -81,11 +82,16 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     isLoading: boolean;
     data: undefined;
     error: IRequestError;
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
+    };
     isError: true;
     isIdle: false;
+    isPending: false;
     isSuccess: false;
     status: "error";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -94,11 +100,8 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -117,11 +120,16 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     isLoading: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
+    };
     isError: false;
     isIdle: false;
+    isPending: false;
     isSuccess: true;
     status: "success";
-    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -130,11 +138,8 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    variables: {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } | undefined;
-    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;

package/dist/queries/usePostRequest.js

@@ -68,7 +68,8 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         }
     };
     // register post mutation
-    const mutation = useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)), {
+    const mutation = useMutation({
+        mutationFn: async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)),
         mutationKey: [path, { type: 'mutation' }],
     });
     const post = async (data, options) => {
@@ -88,7 +89,7 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [isFutureMutationsPaused]);
-    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
+    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
 };
 
 export { usePostRequest };

package/dist/queries/usePostRequest.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePostRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"usePostRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [
@@ -47,7 +47,7 @@
     "@rollup/plugin-json": "^6.0.0",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-typescript": "^11.0.0",
-    "@tanstack/react-query": "^4.26.1",
+    "@tanstack/react-query": "^5.29.2",
     "@testing-library/react": "^13.1",
     "@testing-library/react-hooks": "^8.0.1",
     "@types/axios": "^0.14.0",

package/src/model/useKeyTrackerModel.ts

@@ -1,6 +1,6 @@
 import { useQueryClient } from '@tanstack/react-query';
 
-export const useKeyTrackerModel = <T>(keyTracker: string) => {
+export const useKeyTrackerModel = (keyTracker: string) => {
   const queryClient = useQueryClient();
 
   const getQueryKey = (innerKeyTracker?: string) => {
@@ -12,7 +12,7 @@ export const useKeyTrackerModel = <T>(keyTracker: string) => {
   const refetchQuery = async (innerKeyTracker?: string) => {
     const queryKey: any = getQueryKey(innerKeyTracker ?? keyTracker);
 
-    await queryClient.refetchQueries<T>({
+    await queryClient.refetchQueries({
       queryKey,
       exact: true,
     });

package/src/model/useQueryModel.ts

@@ -5,7 +5,7 @@ import { useQueryConfig } from '../config';
 import type { QueryModelAddPosition, QueryModelBuilder } from './model.interface';
 import { useKeyTrackerModel } from './useKeyTrackerModel';
 
-export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): QueryModelBuilder<T> => {
+export const useQueryModel = <T>(keyTracker: string): QueryModelBuilder<T> => {
   const queryClient = useQueryClient();
   const { getQueryKey } = useKeyTrackerModel(keyTracker);
   const queryKey = getQueryKey() as any[];
@@ -24,7 +24,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
     if (!path) {
       queryClient.setQueryData(queryKey, records);
     } else {
-      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+      const queryData = queryClient.getQueryData(queryKey) ?? {};
       queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
     }
 
@@ -32,7 +32,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
   };
 
   const findAll = (path?: string): T[] | T | undefined => {
-    const data = queryClient.getQueryData(queryKey, { exact });
+    const data = queryClient.getQueryData(queryKey);
 
     if (!data) {
       return [];
@@ -62,7 +62,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
   };
 
   const get = (path?: string): T | undefined => {
-    let data = queryClient.getQueryData(queryKey, { exact });
+    let data = queryClient.getQueryData(queryKey);
     if (path) {
       data = result<T>(data, path);
     }
@@ -75,7 +75,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
       newData = lodashSet(data, path, newData);
     }
 
-    return queryClient.setQueryData(queryKey, newData) as DataType;
+    return queryClient.setQueryData(queryKey, newData as DataType) as DataType;
   };
 
   const getModelConfig = () => {
@@ -108,7 +108,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
     if (!path) {
       queryClient.setQueryData(queryKey, newData);
     } else {
-      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+      const queryData = queryClient.getQueryData(queryKey) ?? {};
       queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
     }
     return updatedRecord;
@@ -135,7 +135,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
     if (!path) {
       queryClient.setQueryData(queryKey, newData);
     } else {
-      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+      const queryData = queryClient.getQueryData(queryKey) ?? {};
       queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
     }
     return updated;

package/src/model/useRefetchQuery.ts

@@ -12,7 +12,7 @@ export const useRefetchQuery = async (queryKey: any[]) => {
       { throwOnError: true, cancelRefetch: true }
     );
 
-    return queryClient.getQueriesData<T>(innerQueryKey ?? queryKey);
+    return queryClient.getQueriesData<T>({ queryKey: innerQueryKey ?? queryKey });
   };
 
   return { refetchQuery };

package/src/queries/useDeleteRequest.ts

@@ -52,12 +52,13 @@ export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOption
     }
   };
 
-  const query = useQuery<any, any, IRequestSuccess<TResponse>>(
-    [requestPath, {}],
-    ({ queryKey }) =>
+  const query = useQuery<any, any, IRequestSuccess<TResponse>>({
+    queryKey: [requestPath, {}],
+    queryFn: ({ queryKey }) =>
       new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => sendRequest(res, rej, queryKey)),
-    { enabled: false, ...options }
-  );
+    enabled: false,
+    ...options,
+  });
 
   const updatedPathAsync = async (link: string) => {
     return setRequestPath(link);
@@ -78,8 +79,7 @@ export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOption
   ): Promise<IRequestSuccess<TResponse> | undefined> => {
     if (!isFutureQueriesPaused) {
       // set enabled to be true for every delete
-      internalDeleteOptions = internalDeleteOptions ?? {};
-      internalDeleteOptions.enabled = true;
+      internalDeleteOptions = internalDeleteOptions ?? { queryKey: [] };
 
       await setOptionsAsync(internalDeleteOptions);
       await updatedPathAsync(link);

package/src/queries/useGetInfiniteRequest.ts

@@ -1,4 +1,4 @@
-import type { InfiniteData, QueryKey, UseQueryOptions } from '@tanstack/react-query';
+import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { useInfiniteQuery, useQueryClient } from '@tanstack/react-query';
 import { startTransition, useEffect, useMemo, useState } from 'react';
 import { useEnvironmentVariables, useQueryConfig } from '../config';
@@ -110,19 +110,17 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
     return pathname + '?' + queryParams.toString();
   };
 
-  const query = useInfiniteQuery<any, any, IRequestSuccess<TResponse & { pagination: Pagination }>>(
-    [requestPath, {}],
-    ({ pageParam = requestPath, queryKey }) =>
+  const query = useInfiniteQuery<any, any, IRequestSuccess<TResponse & { pagination: Pagination }>>({
+    queryKey: [requestPath, {}],
+    queryFn: ({ pageParam = requestPath, queryKey }) =>
       new Promise<IRequestSuccess<TResponse & { pagination: Pagination }> | IRequestError>((res, rej) =>
-        sendRequest(res, rej, queryKey, pageParam)
+        sendRequest(res, rej, queryKey, pageParam as string)
       ),
-    {
-      enabled: load && !isFutureQueriesPaused,
-      getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
-      getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
-      ...options,
-    }
-  );
+    enabled: load && !isFutureQueriesPaused,
+    getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
+    getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
+    ...options,
+  });
 
   const setOptionsAsync = async (fetchOptions: any) => {
     startTransition(() => {
@@ -139,12 +137,10 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
       Array<any>
     >
   ): Promise<
-    | InfiniteData<
-        IRequestSuccess<
-          TResponse & {
-            pagination: Pagination;
-          }
-        >
+    | IRequestSuccess<
+        TResponse & {
+          pagination: Pagination;
+        }
       >
     | undefined
   > => {
@@ -177,7 +173,6 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
     if (keyTracker) {
       // set expiration time for the tracker
       queryClient.setQueryDefaults([keyTracker], {
-        cacheTime: Infinity,
         staleTime: Infinity,
       });
 

package/src/queries/useGetRequest.ts

@@ -78,15 +78,13 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     }
   };
 
-  const query = useQuery<any, any, IRequestSuccess<TResponse>>(
-    [requestPath, {}],
-    ({ queryKey }) =>
+  const query = useQuery<any, any, IRequestSuccess<TResponse>>({
+    queryKey: [requestPath, {}],
+    queryFn: ({ queryKey }) =>
       new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => sendRequest(res, rej, queryKey)),
-    {
-      enabled: load && !isFutureQueriesPaused,
-      ...options,
-    }
-  );
+    enabled: load && !isFutureQueriesPaused,
+    ...options,
+  });
 
   useEffect(() => {
     if (path) {
@@ -98,7 +96,6 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     if (keyTracker) {
       // set expiration time for the tracker
       queryClient.setQueryDefaults([keyTracker], {
-        cacheTime: Infinity,
         staleTime: Infinity,
       });