@ventlio/tanstack-query 0.2.20 → 0.2.22

package/dist/config/config.interface.d.ts

@@ -0,0 +1,4 @@
+export interface IConfig {
+    API_URL: string;
+    TIMEOUT: number;
+}

package/dist/config/index.d.ts

@@ -1,3 +1,5 @@
+export * from './config.interface';
+export * from './useEnvironmentVariables';
 export * from './useQueryBaseURL';
 export * from './useQueryConfig';
 export * from './useQueryHeaders';

package/dist/config/useEnvironmentVariables.d.ts

@@ -0,0 +1,2 @@
+import type { IConfig } from './config.interface';
+export declare const useEnvironmentVariables: () => IConfig;

package/dist/config/useEnvironmentVariables.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const useEnvironmentVariables = () => {
+    const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL;
+    const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT;
+    return {
+        API_URL: url,
+        TIMEOUT: Number(timeout),
+    };
+};
+
+exports.useEnvironmentVariables = useEnvironmentVariables;
+//# sourceMappingURL=useEnvironmentVariables.js.map

package/dist/config/useEnvironmentVariables.js.map

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

package/dist/config/useQueryBaseURL.js

@@ -8,8 +8,11 @@ const useQueryBaseURL = () => {
     const queryClient = reactQuery.useQueryClient();
     const setQueryBaseUrl = (newBaseUrl) => {
         queryClient.setQueryData(['config'], (config) => {
-            config.baseURL = newBaseUrl;
-            return config;
+            const newConfig = {
+                ...config,
+                baseURL: newBaseUrl,
+            };
+            return newConfig;
         });
     };
     return { baseURL, setQueryBaseUrl };

package/dist/config/useQueryBaseURL.js.map

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

package/dist/config/useQueryHeaders.js

@@ -8,8 +8,8 @@ const useQueryHeaders = () => {
     const queryClient = reactQuery.useQueryClient();
     const setQueryHeaders = (newHeaders) => {
         queryClient.setQueryData(['config'], (config) => {
-            config.headers = newHeaders;
-            return config;
+            const newConfig = { ...config, headers: newHeaders };
+            return newConfig;
         });
     };
     return { headers, setQueryHeaders };

package/dist/config/useQueryTimeout.js

@@ -8,8 +8,8 @@ const useQueryTimeout = () => {
     const queryClient = reactQuery.useQueryClient();
     const setQueryTimeout = (newTimeout) => {
         queryClient.setQueryData(['config'], (config) => {
-            config.timeout = newTimeout;
-            return config;
+            const newConfig = { ...config, timeout: newTimeout };
+            return newConfig;
         });
     };
     return { timeout, setQueryTimeout };

package/dist/index.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var useEnvironmentVariables = require('./config/useEnvironmentVariables.js');
 var useQueryBaseURL = require('./config/useQueryBaseURL.js');
 var useQueryConfig = require('./config/useQueryConfig.js');
 var useQueryHeaders = require('./config/useQueryHeaders.js');
@@ -20,6 +21,7 @@ var transformer = require('./request/transformer.js');
 
 
 
+exports.useEnvironmentVariables = useEnvironmentVariables.useEnvironmentVariables;
 exports.useQueryBaseURL = useQueryBaseURL.useQueryBaseURL;
 exports.useQueryConfig = useQueryConfig.useQueryConfig;
 exports.useQueryHeaders = useQueryHeaders.useQueryHeaders;

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

@@ -2,6 +2,15 @@ import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
 import { useState, useMemo, useEffect, startTransition } from 'react';
 import axios from 'axios';
 
+const useEnvironmentVariables = () => {
+    const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL;
+    const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT;
+    return {
+        API_URL: url,
+        TIMEOUT: Number(timeout),
+    };
+};
+
 const useQueryConfig = () => {
     const queryClient = useQueryClient();
     const { headers = {}, baseURL = '', timeout = 10000, } = queryClient.getQueryData(['config']) ?? {};
@@ -13,8 +22,11 @@ const useQueryBaseURL = () => {
     const queryClient = useQueryClient();
     const setQueryBaseUrl = (newBaseUrl) => {
         queryClient.setQueryData(['config'], (config) => {
-            config.baseURL = newBaseUrl;
-            return config;
+            const newConfig = {
+                ...config,
+                baseURL: newBaseUrl,
+            };
+            return newConfig;
         });
     };
     return { baseURL, setQueryBaseUrl };
@@ -25,8 +37,8 @@ const useQueryHeaders = () => {
     const queryClient = useQueryClient();
     const setQueryHeaders = (newHeaders) => {
         queryClient.setQueryData(['config'], (config) => {
-            config.headers = newHeaders;
-            return config;
+            const newConfig = { ...config, headers: newHeaders };
+            return newConfig;
         });
     };
     return { headers, setQueryHeaders };
@@ -37,8 +49,8 @@ const useQueryTimeout = () => {
     const queryClient = useQueryClient();
     const setQueryTimeout = (newTimeout) => {
         queryClient.setQueryData(['config'], (config) => {
-            config.timeout = newTimeout;
-            return config;
+            const newConfig = { ...config, timeout: newTimeout };
+            return newConfig;
         });
     };
     return { timeout, setQueryTimeout };
@@ -185,15 +197,16 @@ async function makeRequest({ body, method = HttpMethod.GET, path, isFormData, he
 const useDeleteRequest = () => {
     const [requestPath, updateDeletePath] = useState('');
     const [options, setOptions] = useState();
-    const { headers, baseURL, timeout } = useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { headers } = useQueryConfig();
     const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
         setTimeout(async () => {
             const postResponse = await makeRequest({
                 path: requestPath,
                 headers,
                 method: HttpMethod.DELETE,
-                baseURL,
-                timeout,
+                baseURL: API_URL,
+                timeout: TIMEOUT,
             });
             if (postResponse.status) {
                 res(postResponse);
@@ -227,7 +240,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
     const [requestPath, updatePath] = useState(path);
     const [options, setOptions] = useState(queryOptions);
     const [page, setPage] = useState(1);
-    const { headers, baseURL, timeout } = useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { headers } = useQueryConfig();
     let queryClient = useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = useMemo(() => queryClient, []);
@@ -235,8 +249,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
         const postResponse = await makeRequest({
             path: requestPath,
             headers,
-            baseURL,
-            timeout,
+            baseURL: API_URL,
+            timeout: TIMEOUT,
         });
         if (postResponse.status) {
             res(postResponse);
@@ -323,7 +337,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
 };
 
 const usePatchRequest = ({ path }) => {
-    const { headers, baseURL, timeout } = useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { headers } = useQueryConfig();
     // register post mutation
     const mutation = useMutation((postData) => new Promise((res, rej) => {
         makeRequest({
@@ -331,8 +346,8 @@ const usePatchRequest = ({ path }) => {
             body: postData,
             method: HttpMethod.PATCH,
             headers,
-            baseURL,
-            timeout,
+            baseURL: API_URL,
+            timeout: TIMEOUT,
         }).then((postResponse) => {
             if (postResponse.status) {
                 // scroll to top after success
@@ -356,7 +371,8 @@ const usePatchRequest = ({ path }) => {
 };
 
 const usePostRequest = ({ path, isFormData = false, }) => {
-    const { headers, baseURL, timeout } = useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { headers } = useQueryConfig();
     // register post mutation
     const mutation = useMutation(async (postData) => new Promise((res, rej) => {
         makeRequest({
@@ -365,8 +381,8 @@ const usePostRequest = ({ path, isFormData = false, }) => {
             method: HttpMethod.POST,
             isFormData,
             headers,
-            baseURL,
-            timeout,
+            baseURL: API_URL,
+            timeout: TIMEOUT,
         }).then((postResponse) => {
             if (postResponse.status) {
                 // scroll to top after success
@@ -392,5 +408,5 @@ const usePostRequest = ({ path, isFormData = false, }) => {
     return { post, ...mutation };
 };
 
-export { ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryBaseURL, useQueryConfig, useQueryHeaders, useQueryModel, useQueryTimeout, useRefetchQuery };
+export { ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryBaseURL, useQueryConfig, useQueryHeaders, useQueryModel, useQueryTimeout, useRefetchQuery };
 //# 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/queries/useDeleteRequest.js

@@ -2,6 +2,7 @@
 
 var reactQuery = require('@tanstack/react-query');
 var react = require('react');
+var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryConfig = require('../config/useQueryConfig.js');
 require('axios');
 var makeRequest = require('../request/make-request.js');
@@ -10,15 +11,16 @@ var request_enum = require('../request/request.enum.js');
 const useDeleteRequest = () => {
     const [requestPath, updateDeletePath] = react.useState('');
     const [options, setOptions] = react.useState();
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
+    const { headers } = useQueryConfig.useQueryConfig();
     const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
         setTimeout(async () => {
             const postResponse = await makeRequest.makeRequest({
                 path: requestPath,
                 headers,
                 method: request_enum.HttpMethod.DELETE,
-                baseURL,
-                timeout,
+                baseURL: API_URL,
+                timeout: TIMEOUT,
             });
             if (postResponse.status) {
                 res(postResponse);

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/useGetRequest.js

@@ -2,6 +2,7 @@
 
 var reactQuery = require('@tanstack/react-query');
 var react = require('react');
+var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryConfig = require('../config/useQueryConfig.js');
 require('axios');
 var makeRequest = require('../request/make-request.js');
@@ -11,7 +12,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
     const [requestPath, updatePath] = react.useState(path);
     const [options, setOptions] = react.useState(queryOptions);
     const [page, setPage] = react.useState(1);
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
+    const { headers } = useQueryConfig.useQueryConfig();
     let queryClient = reactQuery.useQueryClient();
     // eslint-disable-next-line react-hooks/exhaustive-deps
     queryClient = react.useMemo(() => queryClient, []);
@@ -19,8 +21,8 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, }) => {
         const postResponse = await makeRequest.makeRequest({
             path: requestPath,
             headers,
-            baseURL,
-            timeout,
+            baseURL: API_URL,
+            timeout: TIMEOUT,
         });
         if (postResponse.status) {
             res(postResponse);

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

@@ -5,10 +5,12 @@ var scrollToTop = require('../helpers/scrollToTop.js');
 require('axios');
 var makeRequest = require('../request/make-request.js');
 var request_enum = require('../request/request.enum.js');
+var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryConfig = require('../config/useQueryConfig.js');
 
 const usePatchRequest = ({ path }) => {
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
+    const { headers } = useQueryConfig.useQueryConfig();
     // register post mutation
     const mutation = reactQuery.useMutation((postData) => new Promise((res, rej) => {
         makeRequest.makeRequest({
@@ -16,8 +18,8 @@ const usePatchRequest = ({ path }) => {
             body: postData,
             method: request_enum.HttpMethod.PATCH,
             headers,
-            baseURL,
-            timeout,
+            baseURL: API_URL,
+            timeout: TIMEOUT,
         }).then((postResponse) => {
             if (postResponse.status) {
                 // scroll to top after success

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,13 +1,15 @@
 'use strict';
 
 var reactQuery = require('@tanstack/react-query');
+var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryConfig = require('../config/useQueryConfig.js');
 require('axios');
 var makeRequest = require('../request/make-request.js');
 var request_enum = require('../request/request.enum.js');
 
 const usePostRequest = ({ path, isFormData = false, }) => {
-    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
+    const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
+    const { headers } = useQueryConfig.useQueryConfig();
     // register post mutation
     const mutation = reactQuery.useMutation(async (postData) => new Promise((res, rej) => {
         makeRequest.makeRequest({
@@ -16,8 +18,8 @@ const usePostRequest = ({ path, isFormData = false, }) => {
             method: request_enum.HttpMethod.POST,
             isFormData,
             headers,
-            baseURL,
-            timeout,
+            baseURL: API_URL,
+            timeout: TIMEOUT,
         }).then((postResponse) => {
             if (postResponse.status) {
                 // scroll to top after success

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/package.json

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

package/src/config/config.interface.ts

@@ -0,0 +1,4 @@
+export interface IConfig {
+  API_URL: string;
+  TIMEOUT: number;
+}

package/src/config/index.ts

@@ -1,3 +1,5 @@
+export * from './config.interface';
+export * from './useEnvironmentVariables';
 export * from './useQueryBaseURL';
 export * from './useQueryConfig';
 export * from './useQueryHeaders';

package/src/config/useEnvironmentVariables.ts

@@ -0,0 +1,12 @@
+import type { IConfig } from './config.interface';
+
+export const useEnvironmentVariables = (): IConfig => {
+  const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL;
+  const timeout =
+    process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT;
+
+  return {
+    API_URL: url as string,
+    TIMEOUT: Number(timeout),
+  };
+};

package/src/config/useQueryBaseURL.ts

@@ -7,9 +7,13 @@ export const useQueryBaseURL = (): IUseQueryBaseURL => {
   const queryClient = useQueryClient();
 
   const setQueryBaseUrl = (newBaseUrl: TanstackQueryConfig['baseURL']) => {
-    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config) => {
-      (config as TanstackQueryConfig).baseURL = newBaseUrl;
-      return config;
+    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config): any => {
+      const newConfig = {
+        ...config,
+        baseURL: newBaseUrl,
+      };
+
+      return newConfig;
     });
   };
 

package/src/config/useQueryHeaders.ts

@@ -7,9 +7,9 @@ export const useQueryHeaders = (): IUseQueryHeaders => {
   const queryClient = useQueryClient();
 
   const setQueryHeaders = (newHeaders: TanstackQueryConfig['headers']) => {
-    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config) => {
-      (config as TanstackQueryConfig).headers = newHeaders;
-      return config;
+    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config): any => {
+      const newConfig = { ...config, headers: newHeaders };
+      return newConfig;
     });
   };
 

package/src/config/useQueryTimeout.ts

@@ -7,9 +7,10 @@ export const useQueryTimeout = (): IUseQueryTimeout => {
   const queryClient = useQueryClient();
 
   const setQueryTimeout = (newTimeout: TanstackQueryConfig['timeout']) => {
-    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config) => {
-      (config as TanstackQueryConfig).timeout = newTimeout;
-      return config;
+    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config): any => {
+      const newConfig = { ...config, timeout: newTimeout };
+
+      return newConfig;
     });
   };
 

package/src/queries/useDeleteRequest.ts

@@ -1,7 +1,7 @@
 import type { UseQueryOptions } from '@tanstack/react-query';
 import { useQuery } from '@tanstack/react-query';
 import { useState } from 'react';
-import { useQueryConfig } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 import type { IRequestError, IRequestSuccess } from '../request';
 import { HttpMethod, makeRequest } from '../request';
 
@@ -9,7 +9,9 @@ export const useDeleteRequest = <TResponse>() => {
   const [requestPath, updateDeletePath] = useState<string>('');
   const [options, setOptions] = useState<any>();
 
-  const { headers, baseURL, timeout } = useQueryConfig();
+  const { API_URL, TIMEOUT } = useEnvironmentVariables();
+
+  const { headers } = useQueryConfig();
 
   const query = useQuery<any, any, IRequestSuccess<TResponse>>(
     [requestPath, {}],
@@ -20,8 +22,8 @@ export const useDeleteRequest = <TResponse>() => {
             path: requestPath,
             headers,
             method: HttpMethod.DELETE,
-            baseURL,
-            timeout,
+            baseURL: API_URL,
+            timeout: TIMEOUT,
           });
           if (postResponse.status) {
             res(postResponse as IRequestSuccess<TResponse>);

package/src/queries/useGetRequest.ts

@@ -1,7 +1,7 @@
 import type { UseQueryOptions } from '@tanstack/react-query';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 import { startTransition, useEffect, useMemo, useState } from 'react';
-import { useQueryConfig } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 import type { IRequestError, IRequestSuccess } from '../request';
 import { makeRequest } from '../request';
 import type { IPagination, TanstackQueryOption } from './queries.interface';
@@ -21,7 +21,8 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   const [options, setOptions] = useState<any>(queryOptions);
   const [page, setPage] = useState<number>(1);
 
-  const { headers, baseURL, timeout } = useQueryConfig();
+  const { API_URL, TIMEOUT } = useEnvironmentVariables();
+  const { headers } = useQueryConfig();
 
   let queryClient = useQueryClient();
   // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -39,8 +40,8 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     const postResponse = await makeRequest<TResponse>({
       path: requestPath,
       headers,
-      baseURL,
-      timeout,
+      baseURL: API_URL,
+      timeout: TIMEOUT,
     });
     if (postResponse.status) {
       res(postResponse as IRequestSuccess<TResponse>);

package/src/queries/usePatchRequest.ts

@@ -3,14 +3,15 @@ import { useMutation } from '@tanstack/react-query';
 import { scrollToTop } from '../helpers';
 import { HttpMethod, makeRequest } from '../request';
 
-import { useQueryConfig } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 import type {
   IRequestError,
   IRequestSuccess,
 } from '../request/request.interface';
 
 export const usePatchRequest = <TResponse>({ path }: { path: string }) => {
-  const { headers, baseURL, timeout } = useQueryConfig();
+  const { API_URL, TIMEOUT } = useEnvironmentVariables();
+  const { headers } = useQueryConfig();
 
   // register post mutation
   const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
@@ -21,8 +22,8 @@ export const usePatchRequest = <TResponse>({ path }: { path: string }) => {
           body: postData,
           method: HttpMethod.PATCH,
           headers,
-          baseURL,
-          timeout,
+          baseURL: API_URL,
+          timeout: TIMEOUT,
         }).then((postResponse) => {
           if (postResponse.status) {
             // scroll to top after success

package/src/queries/usePostRequest.ts

@@ -1,6 +1,6 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import { useMutation } from '@tanstack/react-query';
-import { useQueryConfig } from '../config';
+import { useEnvironmentVariables, useQueryConfig } from '../config';
 import type { IRequestError, IRequestSuccess } from '../request';
 import { HttpMethod, makeRequest } from '../request';
 
@@ -11,7 +11,9 @@ export const usePostRequest = <TResponse>({
   path: string;
   isFormData?: boolean;
 }) => {
-  const { headers, baseURL, timeout } = useQueryConfig();
+  const { API_URL, TIMEOUT } = useEnvironmentVariables();
+
+  const { headers } = useQueryConfig();
 
   // register post mutation
   const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
@@ -23,8 +25,8 @@ export const usePostRequest = <TResponse>({
           method: HttpMethod.POST,
           isFormData,
           headers,
-          baseURL,
-          timeout,
+          baseURL: API_URL,
+          timeout: TIMEOUT,
         }).then((postResponse) => {
           if (postResponse.status) {
             // scroll to top after success