@ventlio/tanstack-query 0.3.0 → 0.3.2

package/dist/config/bootstrapQueryRequest.js

@@ -7,7 +7,7 @@ const bootstrapQueryRequest = (queryClient, options) => {
         headers: {
             Authorization: ``,
         },
-        ...options,
+        options,
     };
     queryClient.setDefaultOptions({
         queries: {

package/dist/config/useQueryConfig.js

@@ -2,35 +2,9 @@ import { useQueryClient } from '@tanstack/react-query';
 
 const useQueryConfig = () => {
     const queryClient = useQueryClient();
-    const setConfig = (options) => {
-        let mutationMeta = queryClient.getMutationDefaults()?.meta ?? {};
-        let queryMeta = queryClient.getQueryDefaults()?.meta ?? {};
-        const { pauseFutureMutations, pauseFutureQueries, mutationMiddleware, queryMiddleware, ...otherOptions } = options;
-        if (pauseFutureMutations) {
-            mutationMeta.pauseFutureMutations = pauseFutureMutations;
-        }
-        if (mutationMiddleware) {
-            mutationMeta.mutationMiddleware = mutationMiddleware;
-        }
-        mutationMeta = { meta: { ...mutationMeta, ...otherOptions } };
-        if (pauseFutureQueries) {
-            queryMeta.pauseFutureQueries = pauseFutureQueries;
-        }
-        if (queryMiddleware) {
-            queryMeta.mutationMiddleware = queryMiddleware;
-        }
-        queryMeta = { meta: { ...queryMeta, ...otherOptions } };
-        const defaultMutationOptions = queryClient.defaultMutationOptions();
-        const defaultQueryOptions = queryClient.defaultQueryOptions();
-        queryClient.setDefaultOptions({
-            queries: { ...defaultQueryOptions, meta: queryMeta },
-            mutations: { ...defaultMutationOptions, meta: mutationMeta },
-        });
-    };
     const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {});
     const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {});
-    const options = { ...queryMeta, ...mutationMeta };
-    return { options, setConfig };
+    return { ...queryMeta, ...mutationMeta };
 };
 
 export { useQueryConfig };

package/dist/config/useQueryConfig.js.map

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

package/dist/config/useQueryHeaders.js

@@ -1,12 +1,23 @@
+import { useQueryClient } from '@tanstack/react-query';
 import { useQueryConfig } from './useQueryConfig.js';
 
 const useQueryHeaders = () => {
-    const { setConfig, ...config } = useQueryConfig();
+    const queryClient = useQueryClient();
+    const { headers, options } = useQueryConfig();
     const getHeaders = () => {
-        return config.options?.headers;
+        return headers;
     };
-    const setQueryHeaders = (headers) => {
-        setConfig({ headers });
+    const setQueryHeaders = (newHeaders) => {
+        const defaultMeta = {
+            headers: { ...headers, ...newHeaders },
+            options,
+        };
+        queryClient.setDefaultOptions({
+            queries: {
+                meta: defaultMeta,
+            },
+            mutations: { meta: defaultMeta },
+        });
     };
     return { setQueryHeaders, getHeaders };
 };

package/dist/config/useQueryHeaders.js.map

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

package/dist/config/useReactNativeEnv.js

@@ -2,9 +2,9 @@ import { useQueryConfig } from './useQueryConfig.js';
 
 const useReactNativeEnv = () => {
     const config = useQueryConfig();
-    const appUrl = config.options.environments?.appBaseUrl;
-    const appTimeout = config.options.environments?.appTimeout;
-    const isApp = config.options.context === 'app';
+    const appUrl = config.options?.environments?.appBaseUrl;
+    const appTimeout = config.options?.environments?.appTimeout;
+    const isApp = config.options?.context === 'app';
     return { appUrl, appTimeout, isApp };
 };
 

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * from './config';
 export * from './helpers';
+export * from './hooks';
 export * from './model';
 export * from './queries';
 export * from './request';
+export * from './stores';
 export * from './types';

package/dist/index.js

@@ -5,6 +5,7 @@ export { useQueryHeaders } from './config/useQueryHeaders.js';
 export { useReactNativeEnv } from './config/useReactNativeEnv.js';
 export { scrollToTop } from './helpers/scrollToTop.js';
 export { getDateInFuture } from './helpers/timeFuncs.js';
+export { useUploadProgress } from './hooks/useUploadProgress.js';
 export { useKeyTrackerModel } from './model/useKeyTrackerModel.js';
 export { useQueryModel } from './model/useQueryModel.js';
 export { useRefetchQuery } from './model/useRefetchQuery.js';
@@ -18,4 +19,5 @@ export { buildFormData } from './request/buildFormData.js';
 export { makeRequest } from './request/make-request.js';
 export { ContentType, HttpMethod } from './request/request.enum.js';
 export { errorTransformer, successTransformer } from './request/transformer.js';
+export { usePauseFutureRequests } from './stores/usePauseFutureRequests.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import 'url-search-params-polyfill';
 import { useQueryClient, useQuery, useInfiniteQuery, useMutation } from '@tanstack/react-query';
+import { useState, useEffect, useMemo, startTransition } from 'react';
 import result from 'lodash.result';
 import lodashSet from 'lodash.set';
-import { useState, useEffect, useMemo, startTransition } from 'react';
 import axios from 'axios';
+import { create } from 'zustand';
 
 const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
@@ -12,7 +13,7 @@ const bootstrapQueryRequest = (queryClient, options) => {
         headers: {
             Authorization: ``,
         },
-        ...options,
+        options,
     };
     queryClient.setDefaultOptions({
         queries: {
@@ -24,42 +25,16 @@ const bootstrapQueryRequest = (queryClient, options) => {
 
 const useQueryConfig = () => {
     const queryClient = useQueryClient();
-    const setConfig = (options) => {
-        let mutationMeta = queryClient.getMutationDefaults()?.meta ?? {};
-        let queryMeta = queryClient.getQueryDefaults()?.meta ?? {};
-        const { pauseFutureMutations, pauseFutureQueries, mutationMiddleware, queryMiddleware, ...otherOptions } = options;
-        if (pauseFutureMutations) {
-            mutationMeta.pauseFutureMutations = pauseFutureMutations;
-        }
-        if (mutationMiddleware) {
-            mutationMeta.mutationMiddleware = mutationMiddleware;
-        }
-        mutationMeta = { meta: { ...mutationMeta, ...otherOptions } };
-        if (pauseFutureQueries) {
-            queryMeta.pauseFutureQueries = pauseFutureQueries;
-        }
-        if (queryMiddleware) {
-            queryMeta.mutationMiddleware = queryMiddleware;
-        }
-        queryMeta = { meta: { ...queryMeta, ...otherOptions } };
-        const defaultMutationOptions = queryClient.defaultMutationOptions();
-        const defaultQueryOptions = queryClient.defaultQueryOptions();
-        queryClient.setDefaultOptions({
-            queries: { ...defaultQueryOptions, meta: queryMeta },
-            mutations: { ...defaultMutationOptions, meta: mutationMeta },
-        });
-    };
     const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {});
     const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {});
-    const options = { ...queryMeta, ...mutationMeta };
-    return { options, setConfig };
+    return { ...queryMeta, ...mutationMeta };
 };
 
 const useReactNativeEnv = () => {
     const config = useQueryConfig();
-    const appUrl = config.options.environments?.appBaseUrl;
-    const appTimeout = config.options.environments?.appTimeout;
-    const isApp = config.options.context === 'app';
+    const appUrl = config.options?.environments?.appBaseUrl;
+    const appTimeout = config.options?.environments?.appTimeout;
+    const isApp = config.options?.context === 'app';
     return { appUrl, appTimeout, isApp };
 };
 
@@ -74,12 +49,22 @@ const useEnvironmentVariables = () => {
 };
 
 const useQueryHeaders = () => {
-    const { setConfig, ...config } = useQueryConfig();
+    const queryClient = useQueryClient();
+    const { headers, options } = useQueryConfig();
     const getHeaders = () => {
-        return config.options?.headers;
+        return headers;
     };
-    const setQueryHeaders = (headers) => {
-        setConfig({ headers });
+    const setQueryHeaders = (newHeaders) => {
+        const defaultMeta = {
+            headers: { ...headers, ...newHeaders },
+            options,
+        };
+        queryClient.setDefaultOptions({
+            queries: {
+                meta: defaultMeta,
+            },
+            mutations: { meta: defaultMeta },
+        });
     };
     return { setQueryHeaders, getHeaders };
 };
@@ -100,14 +85,20 @@ function getDateInFuture(days) {
     return date.getTime();
 }
 
+const useUploadProgress = () => {
+    const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
+    const onUploadProgress = (progressEvent) => {
+        const { loaded, total } = progressEvent;
+        const percentage = Math.round((loaded / total) * 100);
+        setUploadProgressPercent(percentage);
+    };
+    return { onUploadProgress, uploadProgressPercent };
+};
+
 const useKeyTrackerModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
-        const meta = {
-            ...queryClient.getDefaultOptions().mutations?.meta,
-            ...queryClient.getDefaultOptions().queries?.meta,
-        };
-        const queryKey = meta[innerKeyTracker ?? keyTracker];
+        const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
         return queryKey;
     };
     const refetchQuery = async (innerKeyTracker) => {
@@ -411,12 +402,28 @@ function getAppFiles(body, fileSelectors = []) {
     return files;
 }
 
+const usePauseFutureRequests = create((set) => {
+    const pauseFutureQueries = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    const pauseFutureMutation = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    return {
+        isFutureMutationsPaused: false,
+        isFutureQueriesPaused: false,
+        pauseFutureQueries,
+        pauseFutureMutation,
+    };
+});
+
 const useDeleteRequest = (deleteOptions) => {
     const { baseUrl, headers } = deleteOptions ?? {};
     const [requestPath, setRequestPath] = useState('');
     const [options, setOptions] = useState();
-    const [destroyConfig, setDestroyConfig] = useState();
     const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, queryKey) => {
@@ -431,7 +438,7 @@ const useDeleteRequest = (deleteOptions) => {
             timeout: TIMEOUT,
         };
         let shouldContinue = true;
-        if (queryConfigOptions.queryMiddleware) {
+        if (queryConfigOptions?.queryMiddleware) {
             shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
         }
         if (shouldContinue) {
@@ -455,7 +462,7 @@ const useDeleteRequest = (deleteOptions) => {
         return setOptions(fetchOptions);
     };
     const destroy = async (link, internalDeleteOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
+        if (!isFutureQueriesPaused) {
             // set enabled to be true for every delete
             internalDeleteOptions = internalDeleteOptions ?? {};
             internalDeleteOptions.enabled = true;
@@ -464,28 +471,28 @@ const useDeleteRequest = (deleteOptions) => {
             return query.data;
         }
         else {
-            // save delete config
-            setDestroyConfig({ link, internalDeleteOptions });
+            setRequestPayload({ link, internalDeleteOptions });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!queryConfigOptions.pauseFutureQueries && destroyConfig) {
-            destroy(destroyConfig.link, destroyConfig.internalDeleteOptions);
-            setDestroyConfig(undefined);
+        if (!isFutureQueriesPaused && requestPayload) {
+            destroy(requestPayload.link, requestPayload.internalDeleteOptions);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [queryConfigOptions.pauseFutureQueries]);
-    return { destroy, ...query, isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries };
+    }, [isFutureQueriesPaused]);
+    return { destroy, ...query, isLoading: query.isLoading || isFutureQueriesPaused };
 };
 
 const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
     const [requestPath, setRequestPath] = useState(path);
-    const [queryConfig, setQueryConfig] = useState();
     const [options, setOptions] = useState(queryOptions);
-    const { options: queryConfigOptions, setConfig } = useQueryConfig();
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -500,7 +507,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
                 timeout: TIMEOUT,
             };
             let shouldContinue = true;
-            if (queryConfigOptions.queryMiddleware) {
+            if (queryConfigOptions?.queryMiddleware) {
                 shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
             }
             if (shouldContinue) {
@@ -532,7 +539,7 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         return pathname + '?' + queryParams.toString();
     };
     const query = useInfiniteQuery([requestPath, {}], ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)), {
-        enabled: load || !queryConfigOptions.pauseFutureQueries,
+        enabled: load && !isFutureQueriesPaused,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
         ...options,
@@ -543,16 +550,23 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         });
     };
     const get = async (link, fetchOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
+        if (!isFutureQueriesPaused) {
             await setOptionsAsync(fetchOptions);
             await updatedPathAsync(link);
             return query.data;
         }
         else {
-            setQueryConfig({ link, fetchOptions });
+            setRequestPayload({ link, fetchOptions });
             return undefined;
         }
     };
+    useEffect(() => {
+        if (!isFutureQueriesPaused && requestPayload) {
+            get(requestPayload.link, requestPayload.fetchOptions);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureQueriesPaused]);
     const updatedPathAsync = async (link) => {
         startTransition(() => {
             setRequestPath(link);
@@ -560,21 +574,18 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     };
     useEffect(() => {
         if (keyTracker) {
-            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);
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                cacheTime: Infinity,
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [queryConfigOptions.pauseFutureQueries]);
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
     return {
         get,
         ...query,
-        isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries,
+        isLoading: query.isLoading || isFutureQueriesPaused,
     };
 };
 
@@ -584,8 +595,9 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const [page, setPage] = useState(1);
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
-    const { options: queryConfigOptions, setConfig } = useQueryConfig();
-    const [queryConfig, setQueryConfig] = useState();
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -602,7 +614,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
                 timeout: TIMEOUT,
             };
             let shouldContinue = true;
-            if (queryConfigOptions.queryMiddleware) {
+            if (queryConfigOptions?.queryMiddleware) {
                 shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
             }
             if (shouldContinue) {
@@ -623,7 +635,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         }
     };
     const query = useQuery([requestPath, {}], ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)), {
-        enabled: load,
+        enabled: load && !isFutureQueriesPaused,
         ...options,
     });
     useEffect(() => {
@@ -633,10 +645,14 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     }, [path]);
     useEffect(() => {
         if (keyTracker) {
-            setConfig({ [keyTracker]: [requestPath, {}] });
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                cacheTime: Infinity,
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [keyTracker, requestPath]);
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
     const nextPage = () => {
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
@@ -679,26 +695,26 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         });
     };
     const get = async (link, fetchOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
+        if (!isFutureQueriesPaused) {
             await setOptionsAsync(fetchOptions);
             await updatedPathAsync(link);
             return query.data;
         }
         else {
-            setQueryConfig({ link, fetchOptions });
+            setRequestPayload({ link, fetchOptions });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!queryConfigOptions.pauseFutureQueries && queryConfig) {
-            get(queryConfig.link, queryConfig.fetchOptions);
-            setQueryConfig(undefined);
+        if (!isFutureQueriesPaused && requestPayload) {
+            get(requestPayload.link, requestPayload.fetchOptions);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [queryConfigOptions.pauseFutureQueries]);
+    }, [isFutureQueriesPaused]);
     return {
         ...query,
-        isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries,
+        isLoading: query.isLoading || isFutureQueriesPaused,
         setRequestPath,
         nextPage,
         prevPage,
@@ -709,20 +725,11 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     };
 };
 
-const useUploadProgress = () => {
-    const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
-    const onUploadProgress = (progressEvent) => {
-        const { loaded, total } = progressEvent;
-        const percentage = Math.round((loaded / total) * 100);
-        setUploadProgressPercent(percentage);
-    };
-    return { onUploadProgress, uploadProgressPercent };
-};
-
 const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
-    const [mutationConfig, setMutationConfig] = useState();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
     const { getHeaders } = useQueryHeaders();
     const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
@@ -738,7 +745,7 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
             onUploadProgress,
         };
         let shouldContinue = true;
-        if (config.options.mutationMiddleware) {
+        if (config.options?.mutationMiddleware) {
             shouldContinue = await config.options.mutationMiddleware({
                 mutationKey: [path, { type: 'mutation' }],
                 ...requestOptions,
@@ -748,14 +755,14 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
             const patchResponse = await makeRequest(requestOptions);
             if (patchResponse.status) {
                 // scroll to top after success
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 res(patchResponse);
             }
             else {
                 // scroll to top after error
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 rej(patchResponse);
@@ -770,36 +777,32 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         return sendRequest(res, rej, dataData);
     }), { mutationKey: [path, { type: 'mutation' }] });
     const patch = async (data, options) => {
-        if (!config.options.pauseFutureMutations) {
+        if (!isFutureMutationsPaused) {
             return mutation.mutateAsync(data, options);
         }
         else {
-            setMutationConfig({ data, options });
+            setRequestPayload({ data, options });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!config.options.pauseFutureMutations && mutationConfig) {
-            patch(mutationConfig.data, mutationConfig.options);
-            setMutationConfig(undefined);
+        if (!isFutureMutationsPaused && requestPayload) {
+            patch(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [config.options.pauseFutureMutations]);
-    return {
-        patch,
-        uploadProgressPercent,
-        ...mutation,
-        isLoading: mutation.isLoading || config.options.pauseFutureMutations,
-    };
+    }, [isFutureMutationsPaused]);
+    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
 };
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const config = useQueryConfig();
-    const [mutationConfig, setMutationConfig] = useState();
     const { getHeaders } = useQueryHeaders();
     const { isApp } = useReactNativeEnv();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
     const sendRequest = async (res, rej, postData) => {
         // get request headers
         const globalHeaders = getHeaders();
@@ -821,7 +824,7 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             ...requestConfig,
         };
         let shouldContinue = true;
-        if (config.options.mutationMiddleware) {
+        if (config.options?.mutationMiddleware) {
             shouldContinue = await config.options.mutationMiddleware({
                 mutationKey: [path, { type: 'mutation' }],
                 ...requestOptions,
@@ -831,14 +834,14 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
             const postResponse = await makeRequest(requestOptions);
             if (postResponse.status) {
                 // scroll to top after success
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 res(postResponse);
             }
             else {
                 // scroll to top after error
-                if (config.options.context !== 'app') {
+                if (config.options?.context !== 'app') {
                     scrollToTop();
                 }
                 rej(postResponse);
@@ -853,24 +856,24 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         mutationKey: [path, { type: 'mutation' }],
     });
     const post = async (data, options) => {
-        if (!config.options.pauseFutureMutations) {
+        if (!isFutureMutationsPaused) {
             const { requestConfig, ...otherOptions } = options ?? {};
             return mutation.mutateAsync({ data, requestConfig }, otherOptions);
         }
         else {
-            setMutationConfig({ data, options });
+            setRequestPayload({ data, options });
             return undefined;
         }
     };
     useEffect(() => {
-        if (!config.options.pauseFutureMutations && mutationConfig) {
-            post(mutationConfig.data, mutationConfig.options);
-            setMutationConfig(undefined);
+        if (!isFutureMutationsPaused && requestPayload) {
+            post(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [config.options.pauseFutureMutations]);
-    return { post, uploadProgressPercent, ...mutation };
+    }, [isFutureMutationsPaused]);
+    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isLoading || isFutureMutationsPaused };
 };
 
-export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery };
+export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };
 //# sourceMappingURL=index.mjs.map

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) => {
     refetchQuery: (innerKeyTracker?: string) => Promise<void>;
-    getQueryKey: (innerKeyTracker?: string) => any[];
+    getQueryKey: (innerKeyTracker?: string) => any[] | undefined;
 };