@ventlio/tanstack-query 0.3.9 → 0.4.1

package/dist/index.mjs

@@ -123,7 +123,7 @@ const useKeyTrackerModel = (keyTracker) => {
     return { refetchQuery, getQueryKey };
 };
 
-const useQueryModel = (keyTracker, exact = true) => {
+const useQueryModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
@@ -141,13 +141,13 @@ const useQueryModel = (keyTracker, exact = true) => {
             queryClient.setQueryData(queryKey, records);
         }
         else {
-            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            const queryData = queryClient.getQueryData(queryKey) ?? {};
             queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
         }
         return data;
     };
     const findAll = (path) => {
-        const data = queryClient.getQueryData(queryKey, { exact });
+        const data = queryClient.getQueryData(queryKey);
         if (!data) {
             return [];
         }
@@ -169,7 +169,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         return data.find((record) => record[modelConfig.idColumn] === id);
     };
     const get = (path) => {
-        let data = queryClient.getQueryData(queryKey, { exact });
+        let data = queryClient.getQueryData(queryKey);
         if (path) {
             data = result(data, path);
         }
@@ -207,7 +207,7 @@ const useQueryModel = (keyTracker, exact = true) => {
             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;
@@ -232,7 +232,7 @@ const useQueryModel = (keyTracker, exact = true) => {
             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;
@@ -247,7 +247,7 @@ const useRefetchQuery = async (queryKey) => {
             queryKey: innerQueryKey ?? queryKey,
             exact: true,
         }, { throwOnError: true, cancelRefetch: true });
-        return queryClient.getQueriesData(innerQueryKey ?? queryKey);
+        return queryClient.getQueriesData({ queryKey: 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,7 +451,12 @@ const useDeleteRequest = (deleteOptions) => {
             rej(null);
         }
     };
-    const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), { enabled: false, ...options });
+    const query = useQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
+        enabled: false,
+        ...options,
+    });
     const updatedPathAsync = async (link) => {
         return setRequestPath(link);
     };
@@ -460,8 +466,7 @@ const useDeleteRequest = (deleteOptions) => {
     const destroy = async (link, internalDeleteOptions) => {
         if (!isFutureQueriesPaused) {
             // set enabled to be true for every delete
-            internalDeleteOptions = internalDeleteOptions ?? {};
-            internalDeleteOptions.enabled = true;
+            internalDeleteOptions = internalDeleteOptions ?? { queryKey: [] };
             await setOptionsAsync(internalDeleteOptions);
             await updatedPathAsync(link);
             return query.data;
@@ -533,7 +538,9 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         queryParams.set('page', String(lastPageItem));
         return pathname + '?' + queryParams.toString();
     };
-    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
+    const query = useInfiniteQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ 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),
@@ -571,7 +578,6 @@ 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, {}]);
@@ -627,7 +633,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,
     });
@@ -640,7 +648,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, {}]);
@@ -765,9 +772,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);
@@ -784,7 +794,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 };
 };
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
@@ -843,7 +853,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) => {
@@ -863,7 +874,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 { 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: <T>(keyTracker: string) => {
+export declare const useKeyTrackerModel: (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, exact?: boolean) => QueryModelBuilder<T>;
+export declare const useQueryModel: <T>(keyTracker: string) => 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, exact = true) => {
+const useQueryModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const { getQueryKey } = useKeyTrackerModel(keyTracker);
     const queryKey = getQueryKey();
@@ -25,13 +25,13 @@ const useQueryModel = (keyTracker, exact = true) => {
             queryClient.setQueryData(queryKey, records);
         }
         else {
-            const queryData = queryClient.getQueryData(queryKey, { exact }) ?? {};
+            const queryData = queryClient.getQueryData(queryKey) ?? {};
             queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
         }
         return data;
     };
     const findAll = (path) => {
-        const data = queryClient.getQueryData(queryKey, { exact });
+        const data = queryClient.getQueryData(queryKey);
         if (!data) {
             return [];
         }
@@ -53,7 +53,7 @@ const useQueryModel = (keyTracker, exact = true) => {
         return data.find((record) => record[modelConfig.idColumn] === id);
     };
     const get = (path) => {
-        let data = queryClient.getQueryData(queryKey, { exact });
+        let data = queryClient.getQueryData(queryKey);
         if (path) {
             data = result(data, path);
         }
@@ -91,7 +91,7 @@ const useQueryModel = (keyTracker, exact = true) => {
             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;
@@ -116,7 +116,7 @@ const useQueryModel = (keyTracker, exact = true) => {
             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/dist/model/useRefetchQuery.d.ts

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

package/dist/queries/useDeleteRequest.d.ts

@@ -6,6 +6,7 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -21,12 +22,10 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     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;
     destroy: (link: string, internalDeleteOptions?: (UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> & {
         cached?: boolean | undefined;
     }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
@@ -35,6 +34,7 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
@@ -50,70 +50,10 @@ export declare const useDeleteRequest: <TResponse>(deleteOptions?: DefaultReques
     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: 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;
+    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;
     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,7 +45,12 @@ const useDeleteRequest = (deleteOptions) => {
             rej(null);
         }
     };
-    const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), { enabled: false, ...options });
+    const query = useQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
+        enabled: false,
+        ...options,
+    });
     const updatedPathAsync = async (link) => {
         return setRequestPath(link);
     };
@@ -55,8 +60,7 @@ const useDeleteRequest = (deleteOptions) => {
     const destroy = async (link, internalDeleteOptions) => {
         if (!isFutureQueriesPaused) {
             // set enabled to be true for every delete
-            internalDeleteOptions = internalDeleteOptions ?? {};
-            internalDeleteOptions.enabled = true;
+            internalDeleteOptions = internalDeleteOptions ?? { queryKey: [] };
             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 { InfiniteData, UseQueryOptions } from '@tanstack/react-query';
+import type { UseQueryOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
 import type { DefaultRequestOptions, TanstackInfiniteQueryOption } from './queries.interface';
 interface Pagination {
@@ -18,105 +18,24 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
     isLoading: boolean;
-    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 & {
+    data: 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/react-query").FetchNextPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
+    fetchNextPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a9 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
+    fetchPreviousPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").aa | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    hasNextPage?: boolean | undefined;
-    hasPreviousPage?: boolean | undefined;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
     isFetchingNextPage: boolean;
     isFetchingPreviousPage: boolean;
     dataUpdatedAt: number;
@@ -130,36 +49,35 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     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 & {
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a4 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ak<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 & {
+    }>, 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 & {
         pagination: Pagination;
-    }>> | undefined>;
+    }> | undefined>;
 } | {
     isLoading: boolean;
-    data: InfiniteData<IRequestSuccess<TResponse & {
+    data: IRequestSuccess<TResponse & {
         pagination: Pagination;
-    }>>;
+    }>;
     error: null;
     isError: false;
+    isPending: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
     status: "success";
-    fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
+    fetchNextPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a9 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions | undefined) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<IRequestSuccess<TResponse & {
+    fetchPreviousPage: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").aa | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").as<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>, any>>;
-    hasNextPage?: boolean | undefined;
-    hasPreviousPage?: boolean | undefined;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
     isFetchingNextPage: boolean;
     isFetchingPreviousPage: boolean;
     dataUpdatedAt: number;
@@ -173,16 +91,14 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     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 & {
+    refetch: (options?: import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").a4 | undefined) => Promise<import("@tanstack/query-core/build/legacy/queryClient-K0zFyarY").ak<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 & {
+    }>, 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 & {
         pagination: Pagination;
-    }>> | undefined>;
+    }> | undefined>;
 };
 export {};

package/dist/queries/useGetInfiniteRequest.js

@@ -61,7 +61,9 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         queryParams.set('page', String(lastPageItem));
         return pathname + '?' + queryParams.toString();
     };
-    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
+    const query = useInfiniteQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ 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),
@@ -99,7 +101,6 @@ 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, {}]);