@ventlio/tanstack-query 0.2.89 → 0.3.1

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

@@ -12,9 +12,8 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
     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();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -29,7 +28,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) {
@@ -61,7 +60,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,
         getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
         getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
         ...options,
@@ -72,15 +71,9 @@ const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, b
         });
     };
     const get = async (link, fetchOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
-            await setOptionsAsync(fetchOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setQueryConfig({ link, fetchOptions });
-            return undefined;
-        }
+        await setOptionsAsync(fetchOptions);
+        await updatedPathAsync(link);
+        return query.data;
     };
     const updatedPathAsync = async (link) => {
         startTransition(() => {
@@ -89,21 +82,17 @@ 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,
     };
 };
 

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,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     queryOptions?: TanstackQueryOption<TResponse> | undefined;
     keyTracker?: string | undefined;
 } & DefaultRequestOptions) => {
-    isLoading: boolean | undefined;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -19,6 +18,7 @@ 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,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    isLoading: boolean | undefined;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -52,6 +51,7 @@ 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,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    isLoading: boolean | undefined;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -85,6 +84,7 @@ 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,6 @@ export declare const useGetRequest: <TResponse extends Record<string, any>>({ pa
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
 } | {
-    isLoading: boolean | undefined;
     setRequestPath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;
     prevPage: () => void;
@@ -118,6 +117,7 @@ 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

@@ -14,8 +14,7 @@ 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();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -32,7 +31,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) {
@@ -63,10 +62,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;
@@ -109,26 +112,12 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
         });
     };
     const get = async (link, fetchOptions) => {
-        if (!queryConfigOptions.pauseFutureQueries) {
-            await setOptionsAsync(fetchOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setQueryConfig({ link, fetchOptions });
-            return undefined;
-        }
+        await setOptionsAsync(fetchOptions);
+        await updatedPathAsync(link);
+        return query.data;
     };
-    useEffect(() => {
-        if (!queryConfigOptions.pauseFutureQueries && queryConfig) {
-            get(queryConfig.link, queryConfig.fetchOptions);
-            setQueryConfig(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [queryConfigOptions.pauseFutureQueries]);
     return {
         ...query,
-        isLoading: query.isLoading || queryConfigOptions.pauseFutureQueries,
         setRequestPath,
         nextPage,
         prevPage,

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> | undefined>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
     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> | undefined>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
     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> | undefined>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
     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> | undefined>;
+    patch: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
     uploadProgressPercent: number;
 };

package/dist/queries/usePatchRequest.js

@@ -1,5 +1,4 @@
 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';
@@ -13,7 +12,6 @@ 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) => {
@@ -29,7 +27,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,
@@ -39,14 +37,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);
@@ -61,27 +59,9 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
         return sendRequest(res, rej, dataData);
     }), { mutationKey: [path, { type: 'mutation' }] });
     const patch = async (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 mutation.mutateAsync(data, options);
     };
+    return { patch, uploadProgressPercent, ...mutation };
 };
 
 export { usePatchRequest };

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.d.ts

@@ -39,7 +39,7 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     } & {
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    }) | undefined) => Promise<IRequestSuccess<TResponse>>;
     uploadProgressPercent: number;
 } | {
     data: undefined;
@@ -75,7 +75,7 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     } & {
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    }) | undefined) => Promise<IRequestSuccess<TResponse>>;
     uploadProgressPercent: number;
 } | {
     data: undefined;
@@ -111,7 +111,7 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     } & {
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    }) | undefined) => Promise<IRequestSuccess<TResponse>>;
     uploadProgressPercent: number;
 } | {
     data: IRequestSuccess<TResponse>;
@@ -147,6 +147,6 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, he
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
     } & {
         requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    }) | undefined) => Promise<IRequestSuccess<TResponse>>;
     uploadProgressPercent: number;
 };

package/dist/queries/usePostRequest.js

@@ -4,7 +4,6 @@ import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
 import { useQueryConfig } from '../config/useQueryConfig.js';
 import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import { useReactNativeEnv } from '../config/useReactNativeEnv.js';
-import { useState, useEffect } from 'react';
 import { scrollToTop } from '../helpers/scrollToTop.js';
 import { useUploadProgress } from '../hooks/useUploadProgress.js';
 import 'axios';
@@ -14,7 +13,6 @@ import { HttpMethod } from '../request/request.enum.js';
 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();
@@ -39,7 +37,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,
@@ -49,14 +47,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);
@@ -71,22 +69,9 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelect
         mutationKey: [path, { type: 'mutation' }],
     });
     const post = async (data, options) => {
-        if (!config.options.pauseFutureMutations) {
-            const { requestConfig, ...otherOptions } = options ?? {};
-            return mutation.mutateAsync({ data, requestConfig }, otherOptions);
-        }
-        else {
-            setMutationConfig({ data, options });
-            return undefined;
-        }
+        const { requestConfig, ...otherOptions } = options ?? {};
+        return mutation.mutateAsync({ data, requestConfig }, otherOptions);
     };
-    useEffect(() => {
-        if (!config.options.pauseFutureMutations && mutationConfig) {
-            post(mutationConfig.data, mutationConfig.options);
-            setMutationConfig(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [config.options.pauseFutureMutations]);
     return { post, uploadProgressPercent, ...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

@@ -14,19 +14,16 @@ export interface BootstrapConfig {
     queryMiddleware?: (queryRequestConfig?: IMakeRequest & {
         queryKey: QueryKey;
     }) => Promise<boolean>;
-    pauseFutureMutations?: boolean;
-    pauseFutureQueries?: boolean;
-    headers?: RawAxiosRequestHeaders;
 }
 export interface BootstrapModelConfig {
     idColumn: string;
 }
 export type ContextType = 'app' | 'web' | 'electronjs';
 export interface TanstackQueryConfig {
-    options: BootstrapConfig;
-    setConfig: (options: BootstrapConfig) => void;
+    headers: RawAxiosRequestHeaders;
+    options?: BootstrapConfig;
 }
 export interface IUseQueryHeaders {
-    getHeaders: () => BootstrapConfig['headers'];
-    setQueryHeaders: (header: BootstrapConfig['headers']) => void;
+    getHeaders: () => TanstackQueryConfig['headers'];
+    setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
 }

package/package.json

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

package/src/config/useQueryConfig.ts

@@ -1,48 +1,11 @@
-import type { MutationMeta, QueryMeta } from '@tanstack/react-query';
 import { useQueryClient } from '@tanstack/react-query';
-import type { BootstrapConfig, TanstackQueryConfig } from '../types';
+import type { TanstackQueryConfig } from '../types';
 
 export const useQueryConfig = (): TanstackQueryConfig => {
   const queryClient = useQueryClient();
 
-  const setConfig = (options: BootstrapConfig) => {
-    let mutationMeta: MutationMeta | undefined = queryClient.getMutationDefaults()?.meta ?? {};
-    let queryMeta: QueryMeta | undefined = queryClient.getQueryDefaults()?.meta ?? {};
+  const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {}) as unknown as TanstackQueryConfig;
+  const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {}) as unknown as TanstackQueryConfig;
 
-    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 ?? {}) as unknown as BootstrapConfig;
-  const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {}) as unknown as BootstrapConfig;
-
-  const options: BootstrapConfig = { ...queryMeta, ...mutationMeta };
-  return { options, setConfig };
+  return { ...queryMeta, ...mutationMeta };
 };

package/src/config/useQueryHeaders.ts

@@ -1,15 +1,27 @@
-import type { BootstrapConfig, IUseQueryHeaders } from '../types';
+import { useQueryClient } from '@tanstack/react-query';
+import type { IUseQueryHeaders, TanstackQueryConfig } from '../types';
 import { useQueryConfig } from './useQueryConfig';
 
 export const useQueryHeaders = (): IUseQueryHeaders => {
-  const { setConfig, ...config } = useQueryConfig();
+  const queryClient = useQueryClient();
+  const { headers, options } = useQueryConfig();
 
-  const getHeaders = (): BootstrapConfig['headers'] => {
-    return config.options?.headers;
+  const getHeaders = (): TanstackQueryConfig['headers'] => {
+    return headers;
   };
 
-  const setQueryHeaders = (headers: BootstrapConfig['headers']) => {
-    setConfig({ headers });
+  const setQueryHeaders = (newHeaders: TanstackQueryConfig['headers']) => {
+    const defaultMeta = {
+      headers: { ...headers, ...newHeaders },
+      options,
+    };
+
+    queryClient.setDefaultOptions({
+      queries: {
+        meta: defaultMeta,
+      },
+      mutations: { meta: defaultMeta },
+    });
   };
 
   return { setQueryHeaders, getHeaders };

package/src/config/useReactNativeEnv.ts

@@ -3,9 +3,9 @@ import { useQueryConfig } from './useQueryConfig';
 export const useReactNativeEnv = () => {
   const config = useQueryConfig();
 
-  const appUrl: string | undefined = config.options.environments?.appBaseUrl;
-  const appTimeout: number | undefined = config.options.environments?.appTimeout;
-  const isApp = config.options.context === 'app';
+  const appUrl: string | undefined = config.options?.environments?.appBaseUrl;
+  const appTimeout: number | undefined = config.options?.environments?.appTimeout;
+  const isApp = config.options?.context === 'app';
 
   return { appUrl, appTimeout, isApp };
 };