@ventlio/tanstack-query 0.2.86 → 0.2.89

package/dist/queries/useDeleteRequest.js

@@ -1,52 +1,79 @@
 import { useQuery } from '@tanstack/react-query';
-import { useState } from 'react';
+import { useState, useEffect } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryConfig } from '../config/useQueryConfig.js';
 import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
-import { HttpMethod } from '../request/request.enum.js';
+import '../request/request.enum.js';
 
 const useDeleteRequest = (deleteOptions) => {
     const { baseUrl, headers } = deleteOptions ?? {};
-    const [requestPath, updateDeletePath] = useState('');
+    const [requestPath, setRequestPath] = useState('');
     const [options, setOptions] = useState();
+    const [destroyConfig, setDestroyConfig] = useState();
+    const { options: queryConfigOptions } = useQueryConfig();
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, queryKey) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const [url] = (queryKey ?? []);
-        const postResponse = await makeRequest({
-            path: url ?? requestPath,
+        const [url] = queryKey;
+        const requestUrl = (url ?? requestPath);
+        const requestOptions = {
+            path: requestUrl,
             headers: { ...globalHeaders, ...headers },
-            method: HttpMethod.DELETE,
             baseURL: baseUrl ?? API_URL,
             timeout: TIMEOUT,
-        });
-        if (postResponse.status) {
-            res(postResponse);
+        };
+        let shouldContinue = true;
+        if (queryConfigOptions.queryMiddleware) {
+            shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+        }
+        if (shouldContinue) {
+            const postResponse = await makeRequest(requestOptions);
+            if (postResponse.status) {
+                res(postResponse);
+            }
+            else {
+                rej(postResponse);
+            }
         }
         else {
-            rej(postResponse);
+            rej(null);
         }
     };
     const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), { enabled: false, ...options });
     const updatedPathAsync = async (link) => {
-        return updateDeletePath(link);
+        return setRequestPath(link);
     };
     const setOptionsAsync = async (fetchOptions) => {
         return setOptions(fetchOptions);
     };
     const destroy = async (link, internalDeleteOptions) => {
-        // set enabled to be true for every delete
-        internalDeleteOptions = internalDeleteOptions ?? {};
-        internalDeleteOptions.enabled = true;
-        await setOptionsAsync(internalDeleteOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        if (!queryConfigOptions.pauseFutureQueries) {
+            // set enabled to be true for every delete
+            internalDeleteOptions = internalDeleteOptions ?? {};
+            internalDeleteOptions.enabled = true;
+            await setOptionsAsync(internalDeleteOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            // save delete config
+            setDestroyConfig({ link, internalDeleteOptions });
+            return undefined;
+        }
     };
-    return { destroy, ...query };
+    useEffect(() => {
+        if (!queryConfigOptions.pauseFutureQueries && destroyConfig) {
+            destroy(destroyConfig.link, destroyConfig.internalDeleteOptions);
+            setDestroyConfig(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [queryConfigOptions.pauseFutureQueries]);
+    return { destroy, ...query, isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries };
 };
 
 export { useDeleteRequest };

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

@@ -17,10 +17,10 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
     }> | undefined;
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
+    isLoading: boolean | undefined;
     data: undefined;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: true;
     isRefetchError: false;
     isSuccess: false;
@@ -58,10 +58,10 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
+    isLoading: boolean | undefined;
     data: undefined;
     error: null;
     isError: false;
-    isLoading: true;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: false;
@@ -99,12 +99,12 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
+    isLoading: boolean | undefined;
     data: InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>>;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -142,12 +142,12 @@ export declare const useGetInfiniteRequest: <TResponse extends Record<string, an
         pagination: Pagination;
     }>> | undefined>;
 } | {
+    isLoading: boolean | undefined;
     data: InfiniteData<IRequestSuccess<TResponse & {
         pagination: Pagination;
     }>>;
     error: null;
     isError: false;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;

package/dist/queries/useGetInfiniteRequest.js

@@ -2,6 +2,7 @@ import { useQueryClient, useInfiniteQuery } from '@tanstack/react-query';
 import { useState, useMemo, useEffect, startTransition } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryConfig } from '../config/useQueryConfig.js';
 import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
@@ -10,26 +11,38 @@ import '../request/request.enum.js';
 const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
-    const [requestPath, updatePath] = useState(path);
+    const [requestPath, setRequestPath] = useState(path);
+    const [queryConfig, setQueryConfig] = useState();
     const [options, setOptions] = useState(queryOptions);
+    const { options: queryConfigOptions, setConfig } = useQueryConfig();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
-    const sendRequest = async (res, rej, pageParam) => {
+    const sendRequest = async (res, rej, queryKey, pageParam) => {
         if (load) {
             // get request headers
             const globalHeaders = getHeaders();
-            const getResponse = await makeRequest({
+            const requestOptions = {
                 path: pageParam ?? requestPath,
                 headers: { ...globalHeaders, ...headers },
                 baseURL: baseUrl ?? API_URL,
                 timeout: TIMEOUT,
-            });
-            if (getResponse.status) {
-                res(getResponse);
+            };
+            let shouldContinue = true;
+            if (queryConfigOptions.queryMiddleware) {
+                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+            }
+            if (shouldContinue) {
+                const getResponse = await makeRequest(requestOptions);
+                if (getResponse.status) {
+                    res(getResponse);
+                }
+                else {
+                    rej(getResponse);
+                }
             }
             else {
-                rej(getResponse);
+                rej(null);
             }
         }
         else {
@@ -47,8 +60,8 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         queryParams.set('page', String(lastPageItem));
         return pathname + '?' + queryParams.toString();
     };
-    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath }) => new Promise((res, rej) => sendRequest(res, rej, pageParam)), {
-        enabled: load,
+    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
+        enabled: load || !queryConfigOptions.pauseFutureQueries,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
         ...options,
@@ -59,28 +72,38 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         });
     };
     const get = async (link, fetchOptions) => {
-        await setOptionsAsync(fetchOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        if (!queryConfigOptions.pauseFutureQueries) {
+            await setOptionsAsync(fetchOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setQueryConfig({ link, fetchOptions });
+            return undefined;
+        }
     };
     const updatedPathAsync = async (link) => {
         startTransition(() => {
-            updatePath(link);
+            setRequestPath(link);
         });
     };
     useEffect(() => {
         if (keyTracker) {
-            // set expiration time for the tracker
-            queryClient.setQueryDefaults([keyTracker], {
-                cacheTime: Infinity,
-                staleTime: Infinity,
-            });
-            queryClient.setQueryData([keyTracker], [requestPath, {}]);
+            setConfig({ [keyTracker]: [requestPath, {}] });
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [keyTracker, requestPath]);
+    useEffect(() => {
+        if (!queryConfigOptions.pauseFutureQueries && queryConfig) {
+            get(queryConfig.link, queryConfig.fetchOptions);
+            setQueryConfig(undefined);
         }
-    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [queryConfigOptions.pauseFutureQueries]);
     return {
         get,
         ...query,
+        isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries,
     };
 };
 

package/dist/queries/useGetInfiniteRequest.js.map

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

package/dist/queries/useGetRequest.d.ts

@@ -8,7 +8,8 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     queryOptions?: TanstackQueryOption<TResponse> | undefined;
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
-    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    isLoading: boolean | undefined;
+    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>;
@@ -18,7 +19,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: IRequestSuccess<TResponse>;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: true;
     isSuccess: false;
@@ -41,7 +41,8 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    isLoading: boolean | undefined;
+    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>;
@@ -51,7 +52,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
-    isLoading: false;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: true;
@@ -74,7 +74,8 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    isLoading: boolean | undefined;
+    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>;
@@ -84,7 +85,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: undefined;
     error: any;
     isError: true;
-    isLoading: false;
     isLoadingError: true;
     isRefetchError: false;
     isSuccess: false;
@@ -107,7 +107,8 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
+    isLoading: boolean | undefined;
+    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>;
@@ -117,7 +118,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     data: undefined;
     error: null;
     isError: false;
-    isLoading: true;
     isLoadingError: false;
     isRefetchError: false;
     isSuccess: false;

package/dist/queries/useGetRequest.js

@@ -2,17 +2,20 @@ import { useQueryClient, useQuery } from '@tanstack/react-query';
 import { useState, useMemo, useEffect, startTransition } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryConfig } from '../config/useQueryConfig.js';
 import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import '../request/request.enum.js';
 
 const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
-    const [requestPath, updatePath] = useState(path);
+    const [requestPath, setRequestPath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
     const [page, setPage] = useState(1);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
+    const { options: queryConfigOptions, setConfig } = useQueryConfig();
+    const [queryConfig, setQueryConfig] = useState();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -20,18 +23,29 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         if (load) {
             // get request headers
             const globalHeaders = getHeaders();
-            const [url] = (queryKey ?? []);
-            const getResponse = await makeRequest({
-                path: url ?? requestPath,
+            const [url] = queryKey;
+            const requestUrl = (url ?? requestPath);
+            const requestOptions = {
+                path: requestUrl,
                 headers: { ...globalHeaders, ...headers },
                 baseURL: baseUrl ?? API_URL,
                 timeout: TIMEOUT,
-            });
-            if (getResponse.status) {
-                res(getResponse);
+            };
+            let shouldContinue = true;
+            if (queryConfigOptions.queryMiddleware) {
+                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+            }
+            if (shouldContinue) {
+                const getResponse = await makeRequest(requestOptions);
+                if (getResponse.status) {
+                    res(getResponse);
+                }
+                else {
+                    rej(getResponse);
+                }
             }
             else {
-                rej(getResponse);
+                rej(null);
             }
         }
         else {
@@ -44,24 +58,20 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     });
     useEffect(() => {
         if (path) {
-            updatePath(path);
+            setRequestPath(path);
         }
     }, [path]);
     useEffect(() => {
         if (keyTracker) {
-            // set expiration time for the tracker
-            queryClient.setQueryDefaults([keyTracker], {
-                cacheTime: Infinity,
-                staleTime: Infinity,
-            });
-            queryClient.setQueryData([keyTracker], [requestPath, {}]);
+            setConfig({ [keyTracker]: [requestPath, {}] });
         }
-    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [keyTracker, requestPath]);
     const nextPage = () => {
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
             if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
-                updatePath(constructPaginationLink(requestPath, pagination.next_page));
+                setRequestPath(constructPaginationLink(requestPath, pagination.next_page));
             }
         }
     };
@@ -69,7 +79,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
             if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
-                updatePath(constructPaginationLink(requestPath, pagination.previous_page));
+                setRequestPath(constructPaginationLink(requestPath, pagination.previous_page));
             }
         }
     };
@@ -86,11 +96,11 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         return link;
     };
     const gotoPage = (pageNumber) => {
-        updatePath(constructPaginationLink(requestPath, pageNumber));
+        setRequestPath(constructPaginationLink(requestPath, pageNumber));
     };
     const updatedPathAsync = async (link) => {
         startTransition(() => {
-            updatePath(link);
+            setRequestPath(link);
         });
     };
     const setOptionsAsync = async (fetchOptions) => {
@@ -99,13 +109,27 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         });
     };
     const get = async (link, fetchOptions) => {
-        await setOptionsAsync(fetchOptions);
-        await updatedPathAsync(link);
-        return query.data;
+        if (!queryConfigOptions.pauseFutureQueries) {
+            await setOptionsAsync(fetchOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setQueryConfig({ link, fetchOptions });
+            return undefined;
+        }
     };
+    useEffect(() => {
+        if (!queryConfigOptions.pauseFutureQueries && queryConfig) {
+            get(queryConfig.link, queryConfig.fetchOptions);
+            setQueryConfig(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [queryConfigOptions.pauseFutureQueries]);
     return {
         ...query,
-        updatePath,
+        isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries,
+        setRequestPath,
         nextPage,
         prevPage,
         get,

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

@@ -4,11 +4,11 @@ import type { DefaultRequestOptions } from './queries.interface';
 export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     path: string;
 } & DefaultRequestOptions) => {
+    isLoading: boolean | undefined;
     data: undefined;
     error: null;
     isError: false;
     isIdle: true;
-    isLoading: false;
     isSuccess: false;
     status: "idle";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
@@ -19,14 +19,14 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     isPaused: boolean;
     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>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
+    isLoading: boolean | undefined;
     data: undefined;
     error: null;
     isError: false;
     isIdle: false;
-    isLoading: true;
     isSuccess: false;
     status: "loading";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
@@ -37,14 +37,14 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     isPaused: boolean;
     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>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
+    isLoading: boolean | undefined;
     data: undefined;
     error: IRequestError;
     isError: true;
     isIdle: false;
-    isLoading: false;
     isSuccess: false;
     status: "error";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
@@ -55,14 +55,14 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     isPaused: boolean;
     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>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 } | {
+    isLoading: boolean | undefined;
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;
     isIdle: false;
-    isLoading: false;
     isSuccess: true;
     status: "success";
     mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
@@ -73,6 +73,6 @@ export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     isPaused: boolean;
     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>>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
     uploadProgressPercent: number;
 };

package/dist/queries/usePatchRequest.js

@@ -1,4 +1,5 @@
 import { useMutation } from '@tanstack/react-query';
+import { useState, useEffect } from 'react';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
@@ -12,12 +13,13 @@ import { HttpMethod } from '../request/request.enum.js';
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const [mutationConfig, setMutationConfig] = useState();
     const { getHeaders } = useQueryHeaders();
     const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const patchResponse = await makeRequest({
+        const requestOptions = {
             path: path,
             body: data,
             method: HttpMethod.PATCH,
@@ -25,30 +27,61 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
             baseURL: baseUrl ?? API_URL,
             timeout: TIMEOUT,
             onUploadProgress,
-        });
-        if (patchResponse.status) {
-            // scroll to top after success
-            if (config.options?.context !== 'app') {
-                scrollToTop();
+        };
+        let shouldContinue = true;
+        if (config.options.mutationMiddleware) {
+            shouldContinue = await config.options.mutationMiddleware({
+                mutationKey: [path, { type: 'mutation' }],
+                ...requestOptions,
+            });
+        }
+        if (shouldContinue) {
+            const patchResponse = await makeRequest(requestOptions);
+            if (patchResponse.status) {
+                // scroll to top after success
+                if (config.options.context !== 'app') {
+                    scrollToTop();
+                }
+                res(patchResponse);
+            }
+            else {
+                // scroll to top after error
+                if (config.options.context !== 'app') {
+                    scrollToTop();
+                }
+                rej(patchResponse);
             }
-            res(patchResponse);
         }
         else {
-            // scroll to top after error
-            if (config.options?.context !== 'app') {
-                scrollToTop();
-            }
-            rej(patchResponse);
+            rej(null);
         }
     };
     // register post mutation
     const mutation = useMutation((dataData) => new Promise((res, rej) => {
         return sendRequest(res, rej, dataData);
-    }));
+    }), { mutationKey: [path, { type: 'mutation' }] });
     const patch = async (data, options) => {
-        return mutation.mutateAsync(data, options);
+        if (!config.options.pauseFutureMutations) {
+            return mutation.mutateAsync(data, options);
+        }
+        else {
+            setMutationConfig({ data, options });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!config.options.pauseFutureMutations && mutationConfig) {
+            patch(mutationConfig.data, mutationConfig.options);
+            setMutationConfig(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [config.options.pauseFutureMutations]);
+    return {
+        patch,
+        uploadProgressPercent,
+        ...mutation,
+        isLoading: mutation.isLoading || config.options.pauseFutureMutations,
     };
-    return { patch, uploadProgressPercent, ...mutation };
 };
 
 export { usePatchRequest };