@ventlio/tanstack-query 0.4.0 → 0.4.2

package/dist/index.mjs

@@ -123,7 +123,7 @@ const useKeyTrackerModel = (keyTracker) => {
     return { refetchQuery, getQueryKey };
 };
 
-const useQueryModel = (keyTracker) => {
+const useQueryModel = (keyTracker, exact = true) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
@@ -141,13 +141,13 @@ const useQueryModel = (keyTracker) => {
             queryClient.setQueryData(queryKey, records);
         }
         else {
-            const queryData = queryClient.getQueryData(queryKey) ?? {};
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
             queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
         }
         return data;
     };
     const findAll = (path) => {
-        const data = queryClient.getQueryData(queryKey);
+        const data = queryClient.getQueryData(queryKey, { exact });
         if (!data) {
             return [];
         }
@@ -169,7 +169,7 @@ const useQueryModel = (keyTracker) => {
         return data.find((record) => record[modelConfig.idColumn] === id);
     };
     const get = (path) => {
-        let data = queryClient.getQueryData(queryKey);
+        let data = queryClient.getQueryData(queryKey, { exact });
         if (path) {
             data = result(data, path);
         }
@@ -207,7 +207,7 @@ const useQueryModel = (keyTracker) => {
             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;
@@ -232,7 +232,7 @@ const useQueryModel = (keyTracker) => {
             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;
@@ -247,7 +247,7 @@ const useRefetchQuery = async (queryKey) => {
             queryKey: innerQueryKey ?? queryKey,
             exact: true,
         }, { throwOnError: true, cancelRefetch: true });
-        return queryClient.getQueriesData({ queryKey: innerQueryKey ?? queryKey });
+        return queryClient.getQueriesData(innerQueryKey ?? queryKey);
     };
     return { refetchQuery };
 };
@@ -347,35 +347,36 @@ async function makeRequest({ body = {}, method = HttpMethod.GET, path, isFormDat
     if (!isFormData) {
         headers['Content-Type'] = ContentType.APPLICATION_JSON;
     }
-    else {
-        if (isApp) {
-            headers['Content-Type'] = ContentType.MULTIPART_FORM_DATA;
-            // add the app files
-            for (const fileKey in appFiles) {
-                const currentFile = appFiles[fileKey];
-                if (Array.isArray(currentFile)) {
-                    for (const innerFile of currentFile) {
-                        body.append(fileKey, innerFile);
-                    }
-                }
-                else {
-                    body.append(fileKey, currentFile);
+    else if (isApp) {
+        headers['Content-Type'] = ContentType.MULTIPART_FORM_DATA;
+        // add the app files
+        for (const fileKey in appFiles) {
+            const currentFile = appFiles[fileKey];
+            if (Array.isArray(currentFile)) {
+                for (const innerFile of currentFile) {
+                    body.append(fileKey, innerFile);
                 }
             }
+            else {
+                body.append(fileKey, currentFile);
+            }
         }
-        else {
-            delete headers['Content-Type'];
-        }
+    }
+    else {
+        delete headers['Content-Type'];
     }
     try {
         const axiosRequest = axiosInstance({ baseURL, headers, timeout });
-        //   send request
-        const resp = await axiosRequest({
+        const axiosRequestConfig = {
             url: path,
             method,
-            data: body,
             onUploadProgress,
-        });
+        };
+        if (Object.keys(body).length > 0) {
+            axiosRequestConfig.data = body;
+        }
+        //   send request
+        const resp = await axiosRequest(axiosRequestConfig);
         // get response json
         const jsonResp = await resp.data;
         // get response code
@@ -450,12 +451,7 @@ const useDeleteRequest = (deleteOptions) => {
             rej(null);
         }
     };
-    const query = useQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
-        enabled: false,
-        ...options,
-    });
+    const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), { enabled: false, ...options });
     const updatedPathAsync = async (link) => {
         return setRequestPath(link);
     };
@@ -465,7 +461,8 @@ const useDeleteRequest = (deleteOptions) => {
     const destroy = async (link, internalDeleteOptions) => {
         if (!isFutureQueriesPaused) {
             // set enabled to be true for every delete
-            internalDeleteOptions = internalDeleteOptions ?? { queryKey: [] };
+            internalDeleteOptions = internalDeleteOptions ?? {};
+            internalDeleteOptions.enabled = true;
             await setOptionsAsync(internalDeleteOptions);
             await updatedPathAsync(link);
             return query.data;
@@ -537,9 +534,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         queryParams.set('page', String(lastPageItem));
         return pathname + '?' + queryParams.toString();
     };
-    const query = useInfiniteQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
+    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
         enabled: load && !isFutureQueriesPaused,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
@@ -577,6 +572,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         if (keyTracker) {
             // set expiration time for the tracker
             queryClient.setQueryDefaults([keyTracker], {
+                cacheTime: Infinity,
                 staleTime: Infinity,
             });
             queryClient.setQueryData([keyTracker], [requestPath, {}]);
@@ -632,9 +628,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,
     });
@@ -647,6 +641,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, {}]);
@@ -771,12 +766,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);
@@ -793,7 +785,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 };
 };
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
@@ -852,8 +844,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) => {
@@ -873,7 +864,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 { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useHeaderStore, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };

package/dist/index.mjs.map

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

package/dist/model/useKeyTrackerModel.d.ts

@@ -1,4 +1,4 @@
-export declare const useKeyTrackerModel: (keyTracker: string) => {
+export declare const useKeyTrackerModel: <T>(keyTracker: string) => {
     refetchQuery: (innerKeyTracker?: string) => Promise<void>;
     getQueryKey: (innerKeyTracker?: string) => any[] | undefined;
 };

package/dist/model/useQueryModel.d.ts

@@ -1,2 +1,2 @@
 import type { QueryModelBuilder } from './model.interface';
-export declare const useQueryModel: <T>(keyTracker: string) => QueryModelBuilder<T>;
+export declare const useQueryModel: <T>(keyTracker: string, exact?: boolean) => QueryModelBuilder<T>;

package/dist/model/useQueryModel.js

@@ -7,7 +7,7 @@ import '../stores/useHeaderStore.js';
 import '../stores/usePauseFutureRequests.js';
 import { useKeyTrackerModel } from './useKeyTrackerModel.js';
 
-const useQueryModel = (keyTracker) => {
+const useQueryModel = (keyTracker, exact = true) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
@@ -25,13 +25,13 @@ const useQueryModel = (keyTracker) => {
             queryClient.setQueryData(queryKey, records);
         }
         else {
-            const queryData = queryClient.getQueryData(queryKey) ?? {};
+            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
             queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
         }
         return data;
     };
     const findAll = (path) => {
-        const data = queryClient.getQueryData(queryKey);
+        const data = queryClient.getQueryData(queryKey, { exact });
         if (!data) {
             return [];
         }
@@ -53,7 +53,7 @@ const useQueryModel = (keyTracker) => {
         return data.find((record) => record[modelConfig.idColumn] === id);
     };
     const get = (path) => {
-        let data = queryClient.getQueryData(queryKey);
+        let data = queryClient.getQueryData(queryKey, { exact });
         if (path) {
             data = result(data, path);
         }
@@ -91,7 +91,7 @@ const useQueryModel = (keyTracker) => {
             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;
@@ -116,7 +116,7 @@ const useQueryModel = (keyTracker) => {
             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/dist/model/useRefetchQuery.d.ts

@@ -1,3 +1,3 @@
 export declare const useRefetchQuery: (queryKey: any[]) => Promise<{
-    refetchQuery: <T>(innerQueryKey?: any[]) => Promise<[import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").t, T | undefined][]>;
+    refetchQuery: <T>(innerQueryKey?: any[]) => Promise<[import("@tanstack/react-query").QueryKey, T | undefined][]>;
 }>;

package/dist/model/useRefetchQuery.js

@@ -7,7 +7,7 @@ const useRefetchQuery = async (queryKey) => {
             queryKey: innerQueryKey ?? queryKey,
             exact: true,
         }, { throwOnError: true, cancelRefetch: true });
-        return queryClient.getQueriesData({ queryKey: innerQueryKey ?? queryKey });
+        return queryClient.getQueriesData(innerQueryKey ?? queryKey);
     };
     return { refetchQuery };
 };

package/dist/queries/useDeleteRequest.d.ts

@@ -6,7 +6,6 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
-    isPending: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -22,10 +21,12 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     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;
     destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
@@ -34,7 +35,6 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
-    isPending: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
@@ -50,10 +50,70 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     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;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+} | {
+    isLoading: boolean;
+    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;
+    destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
+        cached?: boolean | undefined;
+    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+} | {
+    isLoading: boolean;
+    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;
     destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;

package/dist/queries/useDeleteRequest.js

@@ -45,12 +45,7 @@ const useDeleteRequest = (deleteOptions) => {
             rej(null);
         }
     };
-    const query = useQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
-        enabled: false,
-        ...options,
-    });
+    const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), { enabled: false, ...options });
     const updatedPathAsync = async (link) => {
         return setRequestPath(link);
     };
@@ -60,7 +55,8 @@ const useDeleteRequest = (deleteOptions) => {
     const destroy = async (link, internalDeleteOptions) => {
         if (!isFutureQueriesPaused) {
             // set enabled to be true for every delete
-            internalDeleteOptions = internalDeleteOptions ?? { queryKey: [] };
+            internalDeleteOptions = internalDeleteOptions ?? {};
+            internalDeleteOptions.enabled = true;
             await setOptionsAsync(internalDeleteOptions);
             await updatedPathAsync(link);
             return query.data;

package/dist/queries/useDeleteRequest.js.map

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

package/dist/queries/useGetInfiniteRequest.d.ts

@@ -1,4 +1,4 @@
-import type { UseQueryOptions } from '@tanstack/react-query';
+import type { InfiniteData, UseQueryOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
 import type { DefaultRequestOptions, TanstackInfiniteQueryOption } from './queries.interface';
 interface Pagination {
@@ -18,24 +18,105 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
     isLoading: boolean;
-    data: IRequestSuccess<TResponse & {
+    data: undefined;
+    error: any;
+    isError: true;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "error";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, any>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, any>>;
+    hasNextPage?: boolean | undefined;
+    hasPreviousPage?: boolean | undefined;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    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<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>> | undefined>;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: "loading";
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
         pagination: Pagination;
-    }>;
+    }>, any>>;
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>, any>>;
+    hasNextPage?: boolean | undefined;
+    hasPreviousPage?: boolean | undefined;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+    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<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>> | undefined>;
+} | {
+    isLoading: boolean;
+    data: InfiniteData<IRequestSuccess<TResponse & {
+        pagination: Pagination;
+    }>>;
     error: any;
     isError: true;
-    isPending: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
     status: "error";
-    fetchNextPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a9 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").aa | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
+    hasNextPage?: boolean | undefined;
+    hasPreviousPage?: boolean | undefined;
     isFetchingNextPage: boolean;
     isFetchingPreviousPage: boolean;
     dataUpdatedAt: number;
@@ -49,35 +130,36 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     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 & {
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
-    }>, any>>;
-    fetchStatus: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ac;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse & {
+    }>>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
-    }> | undefined>;
+    }>> | undefined>;
 } | {
     isLoading: boolean;
-    data: IRequestSuccess<TResponse & {
+    data: InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
-    }>;
+    }>>;
     error: null;
     isError: false;
-    isPending: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
     status: "success";
-    fetchNextPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a9 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
+    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    fetchPreviousPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").aa | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
+    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    hasNextPage: boolean;
-    hasPreviousPage: boolean;
+    hasNextPage?: boolean | undefined;
+    hasPreviousPage?: boolean | undefined;
     isFetchingNextPage: boolean;
     isFetchingPreviousPage: boolean;
     dataUpdatedAt: number;
@@ -91,14 +173,16 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     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 & {
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
-    }>, any>>;
-    fetchStatus: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ac;
-    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse & {
+    }>>, any>>;
+    remove: () => void;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    get: (link: string, fetchOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
-    }> | undefined>;
+    }>> | undefined>;
 };
 export {};

package/dist/queries/useGetInfiniteRequest.js

@@ -61,9 +61,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         queryParams.set('page', String(lastPageItem));
         return pathname + '?' + queryParams.toString();
     };
-    const query = useInfiniteQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
+    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
         enabled: load && !isFutureQueriesPaused,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
@@ -101,6 +99,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         if (keyTracker) {
             // set expiration time for the tracker
             queryClient.setQueryDefaults([keyTracker], {
+                cacheTime: Infinity,
                 staleTime: Infinity,
             });
             queryClient.setQueryData([keyTracker], [requestPath, {}]);