@ventlio/tanstack-query 0.4.1 → 0.4.2

package/dist/queries/useGetRequest.d.ts

@@ -19,7 +19,6 @@ 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;
@@ -35,10 +34,12 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     isInitialLoading: boolean;
     isPaused: boolean;
     isPlaceholderData: boolean;
+    isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    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;
+    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>>;
@@ -51,7 +52,6 @@ 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,8 +67,76 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     isInitialLoading: boolean;
     isPaused: boolean;
     isPlaceholderData: boolean;
+    isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    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;
+    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;
 };

package/dist/queries/useGetRequest.js

@@ -52,9 +52,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
             res(null);
         }
     };
-    const query = useQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
+    const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), {
         enabled: load && !isFutureQueriesPaused,
         ...options,
     });
@@ -67,6 +65,7 @@ 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,81 +6,73 @@ 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/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").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: "pending";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    status: "loading";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").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/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").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/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     reset: () => void;
     context: unknown;
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    variables: void | undefined;
+    mutateAsync: import("@tanstack/react-query").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,12 +58,9 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         }
     };
     // register post mutation
-    const mutation = useMutation({
-        mutationFn: (dataData) => new Promise((res, rej) => {
-            return sendRequest(res, rej, dataData);
-        }),
-        mutationKey: [path, { type: 'mutation' }],
-    });
+    const mutation = useMutation((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);
@@ -80,7 +77,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [isFutureMutationsPaused]);
-    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
+    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || 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,14 +8,12 @@ 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/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -24,8 +22,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
+    } | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -43,17 +44,12 @@ 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: "pending";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    status: "loading";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -62,8 +58,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
+    } | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -82,16 +81,11 @@ 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/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -100,8 +94,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
+    } | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -120,16 +117,11 @@ 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/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;
@@ -138,8 +130,11 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
     failureCount: number;
     failureReason: IRequestError | null;
     isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
+    } | undefined;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
         data: any;
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     }, unknown>;

package/dist/queries/usePostRequest.js

@@ -68,8 +68,7 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         }
     };
     // register post mutation
-    const mutation = useMutation({
-        mutationFn: async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)),
+    const mutation = useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)), {
         mutationKey: [path, { type: 'mutation' }],
     });
     const post = async (data, options) => {
@@ -89,7 +88,7 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [isFutureMutationsPaused]);
-    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
+    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || 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.1",
+  "version": "0.4.2",
   "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": "^5.29.2",
+    "@tanstack/react-query": "^4.26.1",
     "@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 = (keyTracker: string) => {
+export const useKeyTrackerModel = <T>(keyTracker: string) => {
   const queryClient = useQueryClient();
 
   const getQueryKey = (innerKeyTracker?: string) => {
@@ -12,7 +12,7 @@ export const useKeyTrackerModel = (keyTracker: string) => {
   const refetchQuery = async (innerKeyTracker?: string) => {
     const queryKey: any = getQueryKey(innerKeyTracker ?? keyTracker);
 
-    await queryClient.refetchQueries({
+    await queryClient.refetchQueries<T>({
       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): QueryModelBuilder<T> => {
+export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): QueryModelBuilder<T> => {
   const queryClient = useQueryClient();
   const { getQueryKey } = useKeyTrackerModel(keyTracker);
   const queryKey = getQueryKey() as any[];
@@ -24,7 +24,7 @@ export const useQueryModel = <T>(keyTracker: string): QueryModelBuilder<T> => {
     if (!path) {
       queryClient.setQueryData(queryKey, records);
     } else {
-      const queryData = queryClient.getQueryData(queryKey) ?? {};
+      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
       queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
     }
 
@@ -32,7 +32,7 @@ export const useQueryModel = <T>(keyTracker: string): QueryModelBuilder<T> => {
   };
 
   const findAll = (path?: string): T[] | T | undefined => {
-    const data = queryClient.getQueryData(queryKey);
+    const data = queryClient.getQueryData(queryKey, { exact });
 
     if (!data) {
       return [];
@@ -62,7 +62,7 @@ export const useQueryModel = <T>(keyTracker: string): QueryModelBuilder<T> => {
   };
 
   const get = (path?: string): T | undefined => {
-    let data = queryClient.getQueryData(queryKey);
+    let data = queryClient.getQueryData(queryKey, { exact });
     if (path) {
       data = result<T>(data, path);
     }
@@ -75,7 +75,7 @@ export const useQueryModel = <T>(keyTracker: string): QueryModelBuilder<T> => {
       newData = lodashSet(data, path, newData);
     }
 
-    return queryClient.setQueryData(queryKey, newData as DataType) as DataType;
+    return queryClient.setQueryData(queryKey, newData) as DataType;
   };
 
   const getModelConfig = () => {
@@ -108,7 +108,7 @@ export const useQueryModel = <T>(keyTracker: string): QueryModelBuilder<T> => {
     if (!path) {
       queryClient.setQueryData(queryKey, newData);
     } else {
-      const queryData = queryClient.getQueryData(queryKey) ?? {};
+      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
       queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
     }
     return updatedRecord;
@@ -135,7 +135,7 @@ export const useQueryModel = <T>(keyTracker: string): QueryModelBuilder<T> => {
     if (!path) {
       queryClient.setQueryData(queryKey, newData);
     } else {
-      const queryData = queryClient.getQueryData(queryKey) ?? {};
+      const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
       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>({ queryKey: innerQueryKey ?? queryKey });
+    return queryClient.getQueriesData<T>(innerQueryKey ?? queryKey);
   };
 
   return { refetchQuery };

package/src/queries/useDeleteRequest.ts

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

package/src/queries/useGetInfiniteRequest.ts

@@ -1,4 +1,4 @@
-import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
+import type { InfiniteData, 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,17 +110,19 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
     return pathname + '?' + queryParams.toString();
   };
 
-  const query = useInfiniteQuery<any, any, IRequestSuccess<TResponse & { pagination: Pagination }>>({
-    queryKey: [requestPath, {}],
-    queryFn: ({ pageParam = requestPath, queryKey }) =>
+  const query = useInfiniteQuery<any, any, IRequestSuccess<TResponse & { pagination: Pagination }>>(
+    [requestPath, {}],
+    ({ pageParam = requestPath, queryKey }) =>
       new Promise<IRequestSuccess<TResponse & { pagination: Pagination }> | IRequestError>((res, rej) =>
-        sendRequest(res, rej, queryKey, pageParam as string)
+        sendRequest(res, rej, queryKey, pageParam)
       ),
-    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(() => {
@@ -137,10 +139,12 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
       Array<any>
     >
   ): Promise<
-    | IRequestSuccess<
-        TResponse & {
-          pagination: Pagination;
-        }
+    | InfiniteData<
+        IRequestSuccess<
+          TResponse & {
+            pagination: Pagination;
+          }
+        >
       >
     | undefined
   > => {
@@ -173,6 +177,7 @@ 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,13 +78,15 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     }
   };
 
-  const query = useQuery<any, any, IRequestSuccess<TResponse>>({
-    queryKey: [requestPath, {}],
-    queryFn: ({ queryKey }) =>
+  const query = useQuery<any, any, IRequestSuccess<TResponse>>(
+    [requestPath, {}],
+    ({ queryKey }) =>
       new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => sendRequest(res, rej, queryKey)),
-    enabled: load && !isFutureQueriesPaused,
-    ...options,
-  });
+    {
+      enabled: load && !isFutureQueriesPaused,
+      ...options,
+    }
+  );
 
   useEffect(() => {
     if (path) {
@@ -96,6 +98,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     if (keyTracker) {
       // set expiration time for the tracker
       queryClient.setQueryDefaults([keyTracker], {
+        cacheTime: Infinity,
         staleTime: Infinity,
       });