@ventlio/tanstack-query 0.2.21 → 0.2.23

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,4 +1,4 @@
-export * from './useQueryBaseURL';
+export * from './config.interface';
+export * from './useEnvironmentVariables';
 export * from './useQueryConfig';
 export * from './useQueryHeaders';
-export * from './useQueryTimeout';

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

@@ -4,8 +4,8 @@ var reactQuery = require('@tanstack/react-query');
 
 const useQueryConfig = () => {
     const queryClient = reactQuery.useQueryClient();
-    const { headers = {}, baseURL = '', timeout = 10000, } = queryClient.getQueryData(['config']) ?? {};
-    return { headers, baseURL, timeout };
+    const { headers = {} } = queryClient.getQueryData(['config']) ?? {};
+    return { headers };
 };
 
 exports.useQueryConfig = useQueryConfig;

package/dist/index.js

@@ -1,9 +1,8 @@
 'use strict';
 
-var useQueryBaseURL = require('./config/useQueryBaseURL.js');
+var useEnvironmentVariables = require('./config/useEnvironmentVariables.js');
 var useQueryConfig = require('./config/useQueryConfig.js');
 var useQueryHeaders = require('./config/useQueryHeaders.js');
-var useQueryTimeout = require('./config/useQueryTimeout.js');
 var scrollToTop = require('./helpers/scrollToTop.js');
 var useKeyTrackerModel = require('./model/useKeyTrackerModel.js');
 var useQueryModel = require('./model/useQueryModel.js');
@@ -20,10 +19,9 @@ var transformer = require('./request/transformer.js');
 
 
 
-exports.useQueryBaseURL = useQueryBaseURL.useQueryBaseURL;
+exports.useEnvironmentVariables = useEnvironmentVariables.useEnvironmentVariables;
 exports.useQueryConfig = useQueryConfig.useQueryConfig;
 exports.useQueryHeaders = useQueryHeaders.useQueryHeaders;
-exports.useQueryTimeout = useQueryTimeout.useQueryTimeout;
 exports.scrollToTop = scrollToTop.scrollToTop;
 exports.useKeyTrackerModel = useKeyTrackerModel.useKeyTrackerModel;
 exports.useQueryModel = useQueryModel.useQueryModel;

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,25 +2,19 @@ import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
 import { useState, useMemo, useEffect, startTransition } from 'react';
 import axios from 'axios';
 
-const useQueryConfig = () => {
-    const queryClient = useQueryClient();
-    const { headers = {}, baseURL = '', timeout = 10000, } = queryClient.getQueryData(['config']) ?? {};
-    return { headers, baseURL, timeout };
+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 useQueryBaseURL = () => {
-    const { baseURL } = useQueryConfig();
+const useQueryConfig = () => {
     const queryClient = useQueryClient();
-    const setQueryBaseUrl = (newBaseUrl) => {
-        queryClient.setQueryData(['config'], (config) => {
-            const newConfig = {
-                ...config,
-                baseURL: newBaseUrl,
-            };
-            return newConfig;
-        });
-    };
-    return { baseURL, setQueryBaseUrl };
+    const { headers = {} } = queryClient.getQueryData(['config']) ?? {};
+    return { headers };
 };
 
 const useQueryHeaders = () => {
@@ -35,18 +29,6 @@ const useQueryHeaders = () => {
     return { headers, setQueryHeaders };
 };
 
-const useQueryTimeout = () => {
-    const { timeout } = useQueryConfig();
-    const queryClient = useQueryClient();
-    const setQueryTimeout = (newTimeout) => {
-        queryClient.setQueryData(['config'], (config) => {
-            const newConfig = { ...config, timeout: newTimeout };
-            return newConfig;
-        });
-    };
-    return { timeout, setQueryTimeout };
-};
-
 const scrollToTop = () => {
     window.scrollTo({
         top: 0,
@@ -188,15 +170,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);
@@ -230,7 +213,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, []);
@@ -238,8 +222,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);
@@ -326,7 +310,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({
@@ -334,8 +319,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
@@ -359,7 +344,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({
@@ -368,8 +354,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
@@ -395,5 +381,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, useQueryConfig, useQueryHeaders, useQueryModel, 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/dist/types/index.d.ts

@@ -1,18 +1,8 @@
 import type { RawAxiosRequestHeaders } from 'axios';
 export interface TanstackQueryConfig {
-    baseURL: string;
-    timeout?: number;
     headers: RawAxiosRequestHeaders;
 }
 export interface IUseQueryHeaders {
     headers: TanstackQueryConfig['headers'];
     setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
 }
-export interface IUseQueryTimeout {
-    timeout: TanstackQueryConfig['timeout'];
-    setQueryTimeout: (timeout: TanstackQueryConfig['timeout']) => void;
-}
-export interface IUseQueryBaseURL {
-    baseURL: TanstackQueryConfig['baseURL'];
-    setQueryBaseUrl: (baseURL: TanstackQueryConfig['baseURL']) => void;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "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,4 +1,4 @@
-export * from './useQueryBaseURL';
+export * from './config.interface';
+export * from './useEnvironmentVariables';
 export * from './useQueryConfig';
 export * from './useQueryHeaders';
-export * from './useQueryTimeout';

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/useQueryConfig.ts

@@ -4,11 +4,8 @@ import type { TanstackQueryConfig } from '../types';
 export const useQueryConfig = (): TanstackQueryConfig => {
   const queryClient = useQueryClient();
 
-  const {
-    headers = {},
-    baseURL = '',
-    timeout = 10000,
-  } = queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
+  const { headers = {} } =
+    queryClient.getQueryData<TanstackQueryConfig>(['config']) ?? {};
 
-  return { headers, baseURL, timeout };
+  return { headers };
 };

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

package/src/types/index.ts

@@ -1,8 +1,6 @@
 import type { RawAxiosRequestHeaders } from 'axios';
 
 export interface TanstackQueryConfig {
-  baseURL: string;
-  timeout?: number;
   headers: RawAxiosRequestHeaders;
 }
 
@@ -10,13 +8,3 @@ export interface IUseQueryHeaders {
   headers: TanstackQueryConfig['headers'];
   setQueryHeaders: (header: TanstackQueryConfig['headers']) => void;
 }
-
-export interface IUseQueryTimeout {
-  timeout: TanstackQueryConfig['timeout'];
-  setQueryTimeout: (timeout: TanstackQueryConfig['timeout']) => void;
-}
-
-export interface IUseQueryBaseURL {
-  baseURL: TanstackQueryConfig['baseURL'];
-  setQueryBaseUrl: (baseURL: TanstackQueryConfig['baseURL']) => void;
-}

package/dist/config/useQueryBaseURL.d.ts

@@ -1,2 +0,0 @@
-import type { IUseQueryBaseURL } from '../types';
-export declare const useQueryBaseURL: () => IUseQueryBaseURL;

package/dist/config/useQueryBaseURL.js

@@ -1,22 +0,0 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var useQueryConfig = require('./useQueryConfig.js');
-
-const useQueryBaseURL = () => {
-    const { baseURL } = useQueryConfig.useQueryConfig();
-    const queryClient = reactQuery.useQueryClient();
-    const setQueryBaseUrl = (newBaseUrl) => {
-        queryClient.setQueryData(['config'], (config) => {
-            const newConfig = {
-                ...config,
-                baseURL: newBaseUrl,
-            };
-            return newConfig;
-        });
-    };
-    return { baseURL, setQueryBaseUrl };
-};
-
-exports.useQueryBaseURL = useQueryBaseURL;
-//# sourceMappingURL=useQueryBaseURL.js.map

package/dist/config/useQueryBaseURL.js.map

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

package/dist/config/useQueryTimeout.d.ts

@@ -1,2 +0,0 @@
-import type { IUseQueryTimeout } from '../types';
-export declare const useQueryTimeout: () => IUseQueryTimeout;

package/dist/config/useQueryTimeout.js

@@ -1,19 +0,0 @@
-'use strict';
-
-var reactQuery = require('@tanstack/react-query');
-var useQueryConfig = require('./useQueryConfig.js');
-
-const useQueryTimeout = () => {
-    const { timeout } = useQueryConfig.useQueryConfig();
-    const queryClient = reactQuery.useQueryClient();
-    const setQueryTimeout = (newTimeout) => {
-        queryClient.setQueryData(['config'], (config) => {
-            const newConfig = { ...config, timeout: newTimeout };
-            return newConfig;
-        });
-    };
-    return { timeout, setQueryTimeout };
-};
-
-exports.useQueryTimeout = useQueryTimeout;
-//# sourceMappingURL=useQueryTimeout.js.map

package/dist/config/useQueryTimeout.js.map

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

package/src/config/useQueryBaseURL.ts

@@ -1,21 +0,0 @@
-import { useQueryClient } from '@tanstack/react-query';
-import type { IUseQueryBaseURL, TanstackQueryConfig } from '../types';
-import { useQueryConfig } from './useQueryConfig';
-
-export const useQueryBaseURL = (): IUseQueryBaseURL => {
-  const { baseURL } = useQueryConfig();
-  const queryClient = useQueryClient();
-
-  const setQueryBaseUrl = (newBaseUrl: TanstackQueryConfig['baseURL']) => {
-    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config): any => {
-      const newConfig = {
-        ...config,
-        baseURL: newBaseUrl,
-      };
-
-      return newConfig;
-    });
-  };
-
-  return { baseURL, setQueryBaseUrl };
-};

package/src/config/useQueryTimeout.ts

@@ -1,18 +0,0 @@
-import { useQueryClient } from '@tanstack/react-query';
-import type { IUseQueryTimeout, TanstackQueryConfig } from '../types';
-import { useQueryConfig } from './useQueryConfig';
-
-export const useQueryTimeout = (): IUseQueryTimeout => {
-  const { timeout } = useQueryConfig();
-  const queryClient = useQueryClient();
-
-  const setQueryTimeout = (newTimeout: TanstackQueryConfig['timeout']) => {
-    queryClient.setQueryData<TanstackQueryConfig>(['config'], (config): any => {
-      const newConfig = { ...config, timeout: newTimeout };
-
-      return newConfig;
-    });
-  };
-
-  return { timeout, setQueryTimeout };
-};