@ventlio/tanstack-query 0.2.86 → 0.2.87

package/dist/index.mjs

@@ -393,31 +393,42 @@ function getAppFiles(body, fileSelectors = []) {
 
 const useDeleteRequest = (deleteOptions) => {
     const { baseUrl, headers } = deleteOptions ?? {};
-    const [requestPath, updateDeletePath] = useState('');
+    const [requestPath, setRequestPath] = useState('');
     const [options, setOptions] = 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);
@@ -436,26 +447,37 @@ const useDeleteRequest = (deleteOptions) => {
 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 [options, setOptions] = useState(queryOptions);
+    const { options: queryConfigOptions } = 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 {
@@ -473,7 +495,7 @@ 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)), {
+    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
         enabled: load,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
@@ -491,7 +513,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     };
     const updatedPathAsync = async (link) => {
         startTransition(() => {
-            updatePath(link);
+            setRequestPath(link);
         });
     };
     useEffect(() => {
@@ -511,11 +533,12 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
 };
 
 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 } = useQueryConfig();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -523,18 +546,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 {
@@ -547,7 +581,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     });
     useEffect(() => {
         if (path) {
-            updatePath(path);
+            setRequestPath(path);
         }
     }, [path]);
     useEffect(() => {
@@ -564,7 +598,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         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));
             }
         }
     };
@@ -572,7 +606,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));
             }
         }
     };
@@ -589,11 +623,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) => {
@@ -608,7 +642,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     };
     return {
         ...query,
-        updatePath,
+        setRequestPath,
         nextPage,
         prevPage,
         get,
@@ -636,7 +670,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
     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,
@@ -644,26 +678,39 @@ 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);
     };
@@ -681,7 +728,7 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         const globalHeaders = getHeaders();
         const { data, requestConfig } = postData;
         delete requestConfig?.body;
-        const postResponse = await makeRequest({
+        const requestOptions = {
             path,
             body: data,
             method: HttpMethod.POST,
@@ -695,20 +742,33 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             },
             onUploadProgress,
             ...requestConfig,
-        });
-        if (postResponse.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 postResponse = await makeRequest(requestOptions);
+            if (postResponse.status) {
+                // scroll to top after success
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                rej(postResponse);
             }
-            res(postResponse);
         }
         else {
-            // scroll to top after error
-            if (config.options?.context !== 'app') {
-                scrollToTop();
-            }
-            rej(postResponse);
+            rej(null);
         }
     };
     // register post mutation

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/queries/useDeleteRequest.js

@@ -2,38 +2,50 @@ import { useQuery } from '@tanstack/react-query';
 import { useState } 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 { 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);

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.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,37 @@ 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 [options, setOptions] = useState(queryOptions);
+    const { options: queryConfigOptions } = 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,7 +59,7 @@ 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)), {
+    const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
         enabled: load,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
@@ -65,7 +77,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     };
     const updatedPathAsync = async (link) => {
         startTransition(() => {
-            updatePath(link);
+            setRequestPath(link);
         });
     };
     useEffect(() => {

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,7 @@ 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>>;
+    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>;
@@ -41,7 +41,7 @@ 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>>;
+    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>;
@@ -74,7 +74,7 @@ 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>>;
+    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>;
@@ -107,7 +107,7 @@ 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>>;
+    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>;

package/dist/queries/useGetRequest.js

@@ -2,17 +2,19 @@ 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 } = useQueryConfig();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -20,18 +22,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,7 +57,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     });
     useEffect(() => {
         if (path) {
-            updatePath(path);
+            setRequestPath(path);
         }
     }, [path]);
     useEffect(() => {
@@ -61,7 +74,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         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 +82,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 +99,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) => {
@@ -105,7 +118,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     };
     return {
         ...query,
-        updatePath,
+        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.js

@@ -17,7 +17,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
     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,26 +25,39 @@ 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);
     };

package/dist/queries/usePatchRequest.js.map

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

package/dist/queries/usePostRequest.js

@@ -21,7 +21,7 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         const globalHeaders = getHeaders();
         const { data, requestConfig } = postData;
         delete requestConfig?.body;
-        const postResponse = await makeRequest({
+        const requestOptions = {
             path,
             body: data,
             method: HttpMethod.POST,
@@ -35,20 +35,33 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             },
             onUploadProgress,
             ...requestConfig,
-        });
-        if (postResponse.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 postResponse = await makeRequest(requestOptions);
+            if (postResponse.status) {
+                // scroll to top after success
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                rej(postResponse);
             }
-            res(postResponse);
         }
         else {
-            // scroll to top after error
-            if (config.options?.context !== 'app') {
-                scrollToTop();
-            }
-            rej(postResponse);
+            rej(null);
         }
     };
     // register post mutation

package/dist/queries/usePostRequest.js.map

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

package/dist/types/index.d.ts

@@ -1,4 +1,6 @@
+import type { QueryKey } from '@tanstack/react-query';
 import type { RawAxiosRequestHeaders } from 'axios';
+import type { IMakeRequest } from '../request';
 export interface BootstrapConfig {
     environments?: {
         appBaseUrl: string;
@@ -6,8 +8,12 @@ export interface BootstrapConfig {
     };
     context?: ContextType;
     modelConfig?: BootstrapModelConfig;
-    mutationMiddleware?: (mutateRequest?: any, mutateResponse?: any) => Promise<boolean>;
-    queryMiddleware?: (queryRequest?: any, queryResponse?: any) => Promise<boolean>;
+    mutationMiddleware?: (mutateRequestConfig?: IMakeRequest & {
+        mutationKey: QueryKey;
+    }) => Promise<boolean>;
+    queryMiddleware?: (queryRequestConfig?: IMakeRequest & {
+        queryKey: QueryKey;
+    }) => Promise<boolean>;
 }
 export interface BootstrapModelConfig {
     idColumn: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.86",
+  "version": "0.2.87",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [

package/src/queries/useDeleteRequest.ts

@@ -2,38 +2,52 @@ import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { useQuery } from '@tanstack/react-query';
 import type { RawAxiosRequestHeaders } from 'axios';
 import { useState } from 'react';
-import { useEnvironmentVariables, useQueryHeaders } from '../config';
+import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
 import type { IRequestError, IRequestSuccess } from '../request';
-import { HttpMethod, makeRequest } from '../request';
+import { makeRequest } from '../request';
 import type { DefaultRequestOptions } from './queries.interface';
 
 export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOptions) => {
   const { baseUrl, headers } = deleteOptions ?? {};
-  const [requestPath, updateDeletePath] = useState<string>('');
+  const [requestPath, setRequestPath] = useState<string>('');
   const [options, setOptions] = useState<any>();
 
+  const { options: queryConfigOptions } = useQueryConfig();
+
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
 
   const { getHeaders } = useQueryHeaders();
 
-  const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, queryKey?: QueryKey) => {
+  const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, queryKey: QueryKey) => {
     // get request headers
     const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
-    const [url] = (queryKey ?? []) as string[];
+    const [url] = queryKey;
+    const requestUrl = (url ?? requestPath) as string;
 
-    const postResponse = await makeRequest<TResponse>({
-      path: url ?? requestPath,
+    const requestOptions = {
+      path: requestUrl,
       headers: { ...globalHeaders, ...headers },
-      method: HttpMethod.DELETE,
       baseURL: baseUrl ?? API_URL,
       timeout: TIMEOUT,
-    });
+    };
+
+    let shouldContinue = true;
+
+    if (queryConfigOptions?.queryMiddleware) {
+      shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+    }
+
+    if (shouldContinue) {
+      const postResponse = await makeRequest<TResponse>(requestOptions);
 
-    if (postResponse.status) {
-      res(postResponse as IRequestSuccess<TResponse>);
+      if (postResponse.status) {
+        res(postResponse as IRequestSuccess<TResponse>);
+      } else {
+        rej(postResponse);
+      }
     } else {
-      rej(postResponse);
+      rej(null);
     }
   };
 
@@ -45,7 +59,7 @@ export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOption
   );
 
   const updatedPathAsync = async (link: string) => {
-    return updateDeletePath(link);
+    return setRequestPath(link);
   };
 
   const setOptionsAsync = async (fetchOptions: any) => {

package/src/queries/useGetInfiniteRequest.ts

@@ -1,8 +1,8 @@
-import type { InfiniteData, UseQueryOptions } from '@tanstack/react-query';
+import type { InfiniteData, QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { useInfiniteQuery, useQueryClient } from '@tanstack/react-query';
 import type { RawAxiosRequestHeaders } from 'axios';
 import { startTransition, useEffect, useMemo, useState } from 'react';
-import { useEnvironmentVariables, useQueryHeaders } from '../config';
+import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
 
 import type { IRequestError, IRequestSuccess } from '../request';
 import { makeRequest } from '../request';
@@ -32,9 +32,10 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
 } & DefaultRequestOptions) => {
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
   const { getHeaders } = useQueryHeaders();
-  const [requestPath, updatePath] = useState<string>(path);
+  const [requestPath, setRequestPath] = useState<string>(path);
 
   const [options, setOptions] = useState<any>(queryOptions);
+  const { options: queryConfigOptions } = useQueryConfig();
 
   let queryClient = useQueryClient();
 
@@ -49,23 +50,36 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
         | PromiseLike<IRequestError | IRequestSuccess<TResponse & { pagination: Pagination }>>
     ) => void,
     rej: (reason?: any) => void,
+    queryKey: QueryKey,
     pageParam?: string
   ) => {
     if (load) {
       // get request headers
       const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
-      const getResponse = await makeRequest<TResponse>({
+      const requestOptions = {
         path: pageParam ?? requestPath,
         headers: { ...globalHeaders, ...headers },
         baseURL: baseUrl ?? API_URL,
         timeout: TIMEOUT,
-      });
+      };
+
+      let shouldContinue = true;
+
+      if (queryConfigOptions?.queryMiddleware) {
+        shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+      }
+
+      if (shouldContinue) {
+        const getResponse = await makeRequest<TResponse>(requestOptions);
 
-      if (getResponse.status) {
-        res(getResponse as IRequestSuccess<TResponse & { pagination: Pagination }>);
+        if (getResponse.status) {
+          res(getResponse as IRequestSuccess<TResponse & { pagination: Pagination }>);
+        } else {
+          rej(getResponse);
+        }
       } else {
-        rej(getResponse);
+        rej(null);
       }
     } else {
       res(null as any);
@@ -96,9 +110,9 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
 
   const query = useInfiniteQuery<any, any, IRequestSuccess<TResponse & { pagination: Pagination }>>(
     [requestPath, {}],
-    ({ pageParam = requestPath }) =>
+    ({ pageParam = requestPath, queryKey }) =>
       new Promise<IRequestSuccess<TResponse & { pagination: Pagination }> | IRequestError>((res, rej) =>
-        sendRequest(res, rej, pageParam)
+        sendRequest(res, rej, queryKey, pageParam)
       ),
     {
       enabled: load,
@@ -140,7 +154,7 @@ export const useGetInfiniteRequest = <TResponse extends Record<string, any>>({
 
   const updatedPathAsync = async (link: string) => {
     startTransition(() => {
-      updatePath(link);
+      setRequestPath(link);
     });
   };
 

package/src/queries/useGetRequest.ts

@@ -2,7 +2,7 @@ import type { QueryKey, UseQueryOptions } from '@tanstack/react-query';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 import { startTransition, useEffect, useMemo, useState } from 'react';
 import type { RawAxiosRequestHeaders } from '../../node_modules/axios/index';
-import { useEnvironmentVariables, useQueryHeaders } from '../config';
+import { useEnvironmentVariables, useQueryConfig, useQueryHeaders } from '../config';
 
 import type { IRequestError, IRequestSuccess } from '../request';
 import { makeRequest } from '../request';
@@ -21,12 +21,13 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   queryOptions?: TanstackQueryOption<TResponse>;
   keyTracker?: string;
 } & DefaultRequestOptions) => {
-  const [requestPath, updatePath] = useState<string>(path);
+  const [requestPath, setRequestPath] = useState<string>(path);
   const [options, setOptions] = useState<any>(queryOptions);
   const [page, setPage] = useState<number>(1);
 
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
   const { getHeaders } = useQueryHeaders();
+  const { options: queryConfigOptions } = useQueryConfig();
 
   let queryClient = useQueryClient();
 
@@ -38,25 +39,38 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
       value: IRequestError | IRequestSuccess<TResponse> | PromiseLike<IRequestError | IRequestSuccess<TResponse>>
     ) => void,
     rej: (reason?: any) => void,
-    queryKey?: QueryKey
+    queryKey: QueryKey
   ) => {
     if (load) {
       // get request headers
       const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
-      const [url] = (queryKey ?? []) as string[];
+      const [url] = queryKey;
+      const requestUrl = (url ?? requestPath) as string;
 
-      const getResponse = await makeRequest<TResponse>({
-        path: url ?? requestPath,
+      const requestOptions = {
+        path: requestUrl,
         headers: { ...globalHeaders, ...headers },
         baseURL: baseUrl ?? API_URL,
         timeout: TIMEOUT,
-      });
+      };
+
+      let shouldContinue = true;
+
+      if (queryConfigOptions?.queryMiddleware) {
+        shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+      }
+
+      if (shouldContinue) {
+        const getResponse = await makeRequest<TResponse>(requestOptions);
 
-      if (getResponse.status) {
-        res(getResponse as IRequestSuccess<TResponse>);
+        if (getResponse.status) {
+          res(getResponse as IRequestSuccess<TResponse>);
+        } else {
+          rej(getResponse);
+        }
       } else {
-        rej(getResponse);
+        rej(null);
       }
     } else {
       res(null as any);
@@ -75,7 +89,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
 
   useEffect(() => {
     if (path) {
-      updatePath(path);
+      setRequestPath(path);
     }
   }, [path]);
 
@@ -95,7 +109,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     if (query.data?.data.pagination) {
       const pagination: IPagination = 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));
       }
     }
   };
@@ -104,7 +118,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     if (query.data?.data.pagination) {
       const pagination: IPagination = 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));
       }
     }
   };
@@ -127,12 +141,12 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   };
 
   const gotoPage = (pageNumber: number) => {
-    updatePath(constructPaginationLink(requestPath, pageNumber));
+    setRequestPath(constructPaginationLink(requestPath, pageNumber));
   };
 
   const updatedPathAsync = async (link: string) => {
     startTransition(() => {
-      updatePath(link);
+      setRequestPath(link);
     });
   };
 
@@ -159,7 +173,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
 
   return {
     ...query,
-    updatePath,
+    setRequestPath,
     nextPage,
     prevPage,
     get,

package/src/queries/usePatchRequest.ts

@@ -20,7 +20,7 @@ export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: s
     // get request headers
     const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
-    const patchResponse = await makeRequest<TResponse>({
+    const requestOptions = {
       path: path,
       body: data,
       method: HttpMethod.PATCH,
@@ -28,20 +28,34 @@ export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: s
       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<TResponse>(requestOptions);
+      if (patchResponse.status) {
+        // scroll to top after success
+        if (config.options?.context !== 'app') {
+          scrollToTop();
+        }
+        res(patchResponse as IRequestSuccess<TResponse>);
+      } else {
+        // scroll to top after error
+        if (config.options?.context !== 'app') {
+          scrollToTop();
+        }
+        rej(patchResponse);
       }
-      res(patchResponse as IRequestSuccess<TResponse>);
     } else {
-      // scroll to top after error
-      if (config.options?.context !== 'app') {
-        scrollToTop();
-      }
-      rej(patchResponse);
+      rej(null);
     }
   };
 
@@ -50,7 +64,8 @@ export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: s
     (dataData: any) =>
       new Promise<IRequestSuccess<TResponse>>((res, rej) => {
         return sendRequest(res, rej, dataData);
-      })
+      }),
+    { mutationKey: [path, { type: 'mutation' }] }
   );
 
   const patch = async (

package/src/queries/usePostRequest.ts

@@ -40,7 +40,7 @@ export const usePostRequest = <TResponse>({
 
     delete requestConfig?.body;
 
-    const postResponse = await makeRequest<TResponse>({
+    const requestOptions = {
       path,
       body: data,
       method: HttpMethod.POST,
@@ -54,21 +54,36 @@ export const usePostRequest = <TResponse>({
       },
       onUploadProgress,
       ...requestConfig,
-    });
+    };
 
-    if (postResponse.status) {
-      // scroll to top after success
+    let shouldContinue = true;
 
-      if (config.options?.context !== 'app') {
-        scrollToTop();
+    if (config.options?.mutationMiddleware) {
+      shouldContinue = await config.options.mutationMiddleware({
+        mutationKey: [path, { type: 'mutation' }],
+        ...requestOptions,
+      });
+    }
+
+    if (shouldContinue) {
+      const postResponse = await makeRequest<TResponse>(requestOptions);
+
+      if (postResponse.status) {
+        // scroll to top after success
+
+        if (config.options?.context !== 'app') {
+          scrollToTop();
+        }
+        res(postResponse as IRequestSuccess<TResponse>);
+      } else {
+        // scroll to top after error
+        if (config.options?.context !== 'app') {
+          scrollToTop();
+        }
+        rej(postResponse);
       }
-      res(postResponse as IRequestSuccess<TResponse>);
     } else {
-      // scroll to top after error
-      if (config.options?.context !== 'app') {
-        scrollToTop();
-      }
-      rej(postResponse);
+      rej(null);
     }
   };
 

package/src/types/index.ts

@@ -1,4 +1,6 @@
+import type { QueryKey } from '@tanstack/react-query';
 import type { RawAxiosRequestHeaders } from 'axios';
+import type { IMakeRequest } from '../request';
 
 export interface BootstrapConfig {
   environments?: {
@@ -7,8 +9,8 @@ export interface BootstrapConfig {
   };
   context?: ContextType;
   modelConfig?: BootstrapModelConfig;
-  mutationMiddleware?: (mutateRequest?: any, mutateResponse?: any) => Promise<boolean>;
-  queryMiddleware?: (queryRequest?: any, queryResponse?: any) => Promise<boolean>;
+  mutationMiddleware?: (mutateRequestConfig?: IMakeRequest & { mutationKey: QueryKey }) => Promise<boolean>;
+  queryMiddleware?: (queryRequestConfig?: IMakeRequest & { queryKey: QueryKey }) => Promise<boolean>;
 }
 
 export interface BootstrapModelConfig {