@ventlio/tanstack-query 0.2.85 → 0.2.87

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

@@ -1,6 +1,7 @@
-import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
 import 'url-search-params-polyfill';
 import { useEnvironmentVariables } from '../config/useEnvironmentVariables.js';
+import { useQueryConfig } from '../config/useQueryConfig.js';
 import { useQueryHeaders } from '../config/useQueryHeaders.js';
 import { scrollToTop } from '../helpers/scrollToTop.js';
 import { useUploadProgress } from '../hooks/useUploadProgress.js';
@@ -12,12 +13,11 @@ const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
     const { getHeaders } = useQueryHeaders();
-    const queryClient = useQueryClient();
-    const config = queryClient.getQueryData(['config']);
+    const config = useQueryConfig();
     const sendRequest = async (res, rej, data) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const patchResponse = await makeRequest({
+        const requestOptions = {
             path: path,
             body: data,
             method: HttpMethod.PATCH,
@@ -25,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

@@ -1,6 +1,7 @@
-import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
 import 'url-search-params-polyfill';
 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 { scrollToTop } from '../helpers/scrollToTop.js';
@@ -11,17 +12,16 @@ import { HttpMethod } from '../request/request.enum.js';
 
 const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const queryClient = useQueryClient();
+    const config = useQueryConfig();
     const { getHeaders } = useQueryHeaders();
     const { isApp } = useReactNativeEnv();
     const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
     const sendRequest = async (res, rej, postData) => {
         // get request headers
         const globalHeaders = getHeaders();
-        const config = queryClient.getQueryData(['config']);
         const { data, requestConfig } = postData;
         delete requestConfig?.body;
-        const postResponse = await makeRequest({
+        const requestOptions = {
             path,
             body: data,
             method: HttpMethod.POST,
@@ -35,24 +35,39 @@ 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
-    const mutation = useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)));
+    const mutation = useMutation(async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)), {
+        mutationKey: [path, { type: 'mutation' }],
+    });
     const post = async (data, options) => {
         const { requestConfig, ...otherOptions } = options ?? {};
         return mutation.mutateAsync({ data, requestConfig }, otherOptions);

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,6 +8,12 @@ export interface BootstrapConfig {
     };
     context?: ContextType;
     modelConfig?: BootstrapModelConfig;
+    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.85",
+  "version": "0.2.87",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [

package/src/config/bootstrapQueryRequest.ts

@@ -1,19 +1,22 @@
 import type { QueryClient } from '@tanstack/react-query';
 import 'url-search-params-polyfill';
-import type { BootstrapConfig, TanstackQueryConfig } from '../types';
+import type { BootstrapConfig } from '../types';
 
 export const bootstrapQueryRequest = (queryClient: QueryClient, options?: BootstrapConfig): void => {
   // make query config doesn't expire
-  queryClient.setQueryDefaults(['config'], {
-    staleTime: Infinity,
-    cacheTime: Infinity,
-  });
 
   // set default query config
-  queryClient.setQueryData<TanstackQueryConfig>(['config'], {
+  const defaultMeta = {
     headers: {
       Authorization: ``,
     },
     options,
+  };
+
+  queryClient.setDefaultOptions({
+    queries: {
+      meta: defaultMeta,
+    },
+    mutations: { meta: defaultMeta },
   });
 };

package/src/config/useQueryConfig.ts

@@ -4,7 +4,8 @@ import type { TanstackQueryConfig } from '../types';
 export const useQueryConfig = (): TanstackQueryConfig => {
   const queryClient = useQueryClient();
 
-  const { headers = {}, options = {} } = queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
+  const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {}) as unknown as TanstackQueryConfig;
+  const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {}) as unknown as TanstackQueryConfig;
 
-  return { headers, options };
+  return { ...queryMeta, ...mutationMeta };
 };

package/src/config/useQueryHeaders.ts

@@ -1,33 +1,27 @@
 import { useQueryClient } from '@tanstack/react-query';
-import { getDateInFuture } from '../helpers';
 import type { IUseQueryHeaders, TanstackQueryConfig } from '../types';
+import { useQueryConfig } from './useQueryConfig';
 
 export const useQueryHeaders = (): IUseQueryHeaders => {
   const queryClient = useQueryClient();
+  const { headers, options } = useQueryConfig();
 
   const getHeaders = (): TanstackQueryConfig['headers'] => {
-    const config = queryClient.getQueryData(['config']) as TanstackQueryConfig;
-    return config.headers;
+    return headers;
   };
 
   const setQueryHeaders = (newHeaders: TanstackQueryConfig['headers']) => {
-    // make sure the config does not expire
-    queryClient.setQueryDefaults(['config'], {
-      staleTime: Infinity,
-      cacheTime: Infinity,
-    });
+    const defaultMeta = {
+      headers: { ...headers, ...newHeaders },
+      options,
+    };
 
-    // set the config
-    queryClient.setQueryData<TanstackQueryConfig>(
-      ['config'],
-      (config): TanstackQueryConfig => {
-        const newConfig = { ...config, headers: newHeaders };
-        return newConfig;
+    queryClient.setDefaultOptions({
+      queries: {
+        meta: defaultMeta,
       },
-      {
-        updatedAt: getDateInFuture(2),
-      }
-    );
+      mutations: { meta: defaultMeta },
+    });
   };
 
   return { setQueryHeaders, getHeaders };

package/src/config/useReactNativeEnv.ts

@@ -1,13 +1,11 @@
-import { useQueryClient } from '@tanstack/react-query';
-import type { TanstackQueryConfig } from '../types';
+import { useQueryConfig } from './useQueryConfig';
 
 export const useReactNativeEnv = () => {
-  const queryClient = useQueryClient();
-  const config = queryClient.getQueryData<TanstackQueryConfig>(['config']);
+  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 };
 };

package/src/model/useQueryModel.ts

@@ -1,7 +1,7 @@
 import { useQueryClient } from '@tanstack/react-query';
 import result from 'lodash.result';
 import { default as lodashSet } from 'lodash.set';
-import type { TanstackQueryConfig } from '../types';
+import { useQueryConfig } from '../config';
 import type { QueryModelAddPosition, QueryModelBuilder } from './model.interface';
 import { useKeyTrackerModel } from './useKeyTrackerModel';
 
@@ -9,6 +9,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
   const queryClient = useQueryClient();
   const { getQueryKey } = useKeyTrackerModel(keyTracker);
   const queryKey = getQueryKey() as any[];
+  const config = useQueryConfig();
 
   const add = (data: T, position?: QueryModelAddPosition, path?: string): T | undefined => {
     let records = (findAll(path) ?? []) as T[];
@@ -78,7 +79,7 @@ export const useQueryModel = <T>(keyTracker: string, exact: boolean = true): Que
   };
 
   const getModelConfig = () => {
-    const { options } = queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
+    const { options } = config;
     const { modelConfig } = options ?? {};
 
     return modelConfig;