@ventlio/tanstack-query 0.2.52 → 0.2.54

package/dist/config/bootstrapQueryRequest.d.ts

@@ -1,2 +1,3 @@
 import type { QueryClient } from '@tanstack/react-query';
-export declare const bootstrapQueryRequest: (queryClient: QueryClient) => void;
+import type { BootstrapQueryRequest } from '../types';
+export declare const bootstrapQueryRequest: (queryClient: QueryClient, options?: BootstrapQueryRequest) => void;

package/dist/config/bootstrapQueryRequest.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const bootstrapQueryRequest = (queryClient) => {
+const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
     queryClient.setQueryDefaults(['config'], {
         staleTime: Infinity,
@@ -11,6 +11,7 @@ const bootstrapQueryRequest = (queryClient) => {
         headers: {
             Authorization: ``,
         },
+        options,
     });
 };
 

package/dist/config/bootstrapQueryRequest.js.map

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

package/dist/config/index.d.ts

@@ -1,5 +1,7 @@
 export * from './bootstrapQueryRequest';
 export * from './config.interface';
+export * from './loadReactNativeEnv';
 export * from './useEnvironmentVariables';
 export * from './useQueryConfig';
 export * from './useQueryHeaders';
+export * from './useReactNativeEnv';

package/dist/config/loadReactNativeEnv.d.ts

@@ -0,0 +1,2 @@
+export declare const REACT_NATIVE_API_URL: string;
+export declare const REACT_NATIVE_API_TIMEOUT: number;

package/dist/config/loadReactNativeEnv.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var _env = require('@env');
+
+// eslint-disable-next-line import/no-unresolved
+const REACT_NATIVE_API_URL = _env.API_URL;
+const REACT_NATIVE_API_TIMEOUT = _env.API_TIMEOUT;
+
+exports.REACT_NATIVE_API_TIMEOUT = REACT_NATIVE_API_TIMEOUT;
+exports.REACT_NATIVE_API_URL = REACT_NATIVE_API_URL;
+//# sourceMappingURL=loadReactNativeEnv.js.map

package/dist/config/loadReactNativeEnv.js.map

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

package/dist/config/useEnvironmentVariables.js

@@ -1,8 +1,11 @@
 'use strict';
 
+var useReactNativeEnv = require('./useReactNativeEnv.js');
+
 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;
+    const { appTimeout, appUrl } = useReactNativeEnv.useReactNativeEnv();
+    const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL || appUrl;
+    const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT || appTimeout;
     return {
         API_URL: url,
         TIMEOUT: Number(timeout),

package/dist/config/useEnvironmentVariables.js.map

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

package/dist/config/useReactNativeEnv.d.ts

@@ -0,0 +1,4 @@
+export declare const useReactNativeEnv: () => {
+    appUrl: string | undefined;
+    appTimeout: number | undefined;
+};

package/dist/config/useReactNativeEnv.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var react = require('react');
+
+const useReactNativeEnv = () => {
+    const queryClient = reactQuery.useQueryClient();
+    const [appUrl, setAppUrl] = react.useState(undefined);
+    const [appTimeout, setAppTimeout] = react.useState();
+    react.useEffect(() => {
+        const config = queryClient.getQueryData(['config']);
+        const loadReactNativeEnvIfNeeded = async () => {
+            if (config?.options?.environment === 'app') {
+                const { REACT_NATIVE_API_TIMEOUT, REACT_NATIVE_API_URL } = await require('./loadReactNativeEnv');
+                setAppUrl(REACT_NATIVE_API_URL);
+                setAppTimeout(REACT_NATIVE_API_TIMEOUT);
+            }
+        };
+        loadReactNativeEnvIfNeeded();
+    }, [queryClient]);
+    return { appUrl, appTimeout };
+};
+
+exports.useReactNativeEnv = useReactNativeEnv;
+//# sourceMappingURL=useReactNativeEnv.js.map

package/dist/config/useReactNativeEnv.js.map

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

package/dist/index.js

@@ -1,9 +1,11 @@
 'use strict';
 
 var bootstrapQueryRequest = require('./config/bootstrapQueryRequest.js');
+var loadReactNativeEnv = require('./config/loadReactNativeEnv.js');
 var useEnvironmentVariables = require('./config/useEnvironmentVariables.js');
 var useQueryConfig = require('./config/useQueryConfig.js');
 var useQueryHeaders = require('./config/useQueryHeaders.js');
+var useReactNativeEnv = require('./config/useReactNativeEnv.js');
 var scrollToTop = require('./helpers/scrollToTop.js');
 var timeFuncs = require('./helpers/timeFuncs.js');
 var useKeyTrackerModel = require('./model/useKeyTrackerModel.js');
@@ -22,9 +24,12 @@ var transformer = require('./request/transformer.js');
 
 
 exports.bootstrapQueryRequest = bootstrapQueryRequest.bootstrapQueryRequest;
+exports.REACT_NATIVE_API_TIMEOUT = loadReactNativeEnv.REACT_NATIVE_API_TIMEOUT;
+exports.REACT_NATIVE_API_URL = loadReactNativeEnv.REACT_NATIVE_API_URL;
 exports.useEnvironmentVariables = useEnvironmentVariables.useEnvironmentVariables;
 exports.useQueryConfig = useQueryConfig.useQueryConfig;
 exports.useQueryHeaders = useQueryHeaders.useQueryHeaders;
+exports.useReactNativeEnv = useReactNativeEnv.useReactNativeEnv;
 exports.scrollToTop = scrollToTop.scrollToTop;
 exports.getDateInFuture = timeFuncs.getDateInFuture;
 exports.useKeyTrackerModel = useKeyTrackerModel.useKeyTrackerModel;

package/dist/index.js.map

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

package/dist/index.mjs

@@ -1,8 +1,9 @@
+import { API_URL, API_TIMEOUT } from '@env';
 import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
-import { useState, useMemo, useEffect, startTransition } from 'react';
+import { useState, useEffect, useMemo, startTransition } from 'react';
 import axios from 'axios';
 
-const bootstrapQueryRequest = (queryClient) => {
+const bootstrapQueryRequest = (queryClient, options) => {
     // make query config doesn't expire
     queryClient.setQueryDefaults(['config'], {
         staleTime: Infinity,
@@ -13,12 +14,36 @@ const bootstrapQueryRequest = (queryClient) => {
         headers: {
             Authorization: ``,
         },
+        options,
     });
 };
 
+// eslint-disable-next-line import/no-unresolved
+const REACT_NATIVE_API_URL = API_URL;
+const REACT_NATIVE_API_TIMEOUT = API_TIMEOUT;
+
+const useReactNativeEnv = () => {
+    const queryClient = useQueryClient();
+    const [appUrl, setAppUrl] = useState(undefined);
+    const [appTimeout, setAppTimeout] = useState();
+    useEffect(() => {
+        const config = queryClient.getQueryData(['config']);
+        const loadReactNativeEnvIfNeeded = async () => {
+            if (config?.options?.environment === 'app') {
+                const { REACT_NATIVE_API_TIMEOUT, REACT_NATIVE_API_URL } = await require('./loadReactNativeEnv');
+                setAppUrl(REACT_NATIVE_API_URL);
+                setAppTimeout(REACT_NATIVE_API_TIMEOUT);
+            }
+        };
+        loadReactNativeEnvIfNeeded();
+    }, [queryClient]);
+    return { appUrl, appTimeout };
+};
+
 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;
+    const { appTimeout, appUrl } = useReactNativeEnv();
+    const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL || appUrl;
+    const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT || appTimeout;
     return {
         API_URL: url,
         TIMEOUT: Number(timeout),
@@ -73,9 +98,7 @@ const useQueryHeaders = () => {
 const useKeyTrackerModel = (keyTracker) => {
     const queryClient = useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
-        const queryKey = queryClient.getQueryData([
-            innerKeyTracker ?? keyTracker,
-        ]);
+        const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
         return queryKey;
     };
     const refetchQuery = async (innerKeyTracker) => {
@@ -105,7 +128,7 @@ const useRefetchQuery = async (queryKey) => {
     return { refetchQuery };
 };
 
-const axiosInstance = ({ baseURL, timeout, headers, }) => {
+const axiosInstance = ({ baseURL, timeout, headers }) => {
     return axios.create({
         baseURL,
         timeout,
@@ -121,9 +144,7 @@ const buildFormData = (body) => {
                 formData.append(key, item);
             }
             else if (item instanceof Object) {
-                formData.append(key, new Blob([JSON.stringify(item)], {
-                    type: 'application/json',
-                }));
+                formData.append(key, JSON.stringify(item));
             }
             else {
                 formData.append(key, item);
@@ -135,9 +156,7 @@ const buildFormData = (body) => {
             formData.append(key, value);
         }
         else {
-            formData.append(key, new Blob([JSON.stringify(value)], {
-                type: 'application/json',
-            }));
+            formData.append(key, JSON.stringify(value));
         }
     };
     const handlePrimitiveValue = (key, value) => {
@@ -325,8 +344,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const nextPage = () => {
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
-            if (pagination.next_page !== pagination.current_page &&
-                pagination.next_page > pagination.current_page) {
+            if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
                 updatePath(constructPaginationLink(requestPath, pagination.next_page));
             }
         }
@@ -334,8 +352,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const prevPage = () => {
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
-            if (pagination.previous_page !== pagination.current_page &&
-                pagination.previous_page < pagination.current_page) {
+            if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
                 updatePath(constructPaginationLink(requestPath, pagination.previous_page));
             }
         }
@@ -382,7 +399,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     };
 };
 
-const usePatchRequest = ({ path, baseUrl, headers, }) => {
+const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders();
     const sendRequest = async (res, rej, data) => {
@@ -462,5 +479,5 @@ const usePostRequest = ({ path, isFormData = false, baseUrl, headers, }) => {
     return { post, ...mutation };
 };
 
-export { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useRefetchQuery };
+export { ContentType, HttpMethod, REACT_NATIVE_API_TIMEOUT, REACT_NATIVE_API_URL, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetRequest, useKeyTrackerModel, usePatchRequest, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, 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/model/useKeyTrackerModel.js

@@ -5,9 +5,7 @@ var reactQuery = require('@tanstack/react-query');
 const useKeyTrackerModel = (keyTracker) => {
     const queryClient = reactQuery.useQueryClient();
     const getQueryKey = (innerKeyTracker) => {
-        const queryKey = queryClient.getQueryData([
-            innerKeyTracker ?? keyTracker,
-        ]);
+        const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
         return queryKey;
     };
     const refetchQuery = async (innerKeyTracker) => {

package/dist/model/useKeyTrackerModel.js.map

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

package/dist/queries/useDeleteRequest.js

@@ -2,6 +2,7 @@
 
 var reactQuery = require('@tanstack/react-query');
 var react = require('react');
+require('@env');
 var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryHeaders = require('../config/useQueryHeaders.js');
 require('axios');

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');
+require('@env');
 var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryHeaders = require('../config/useQueryHeaders.js');
 require('axios');
@@ -55,8 +56,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const nextPage = () => {
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
-            if (pagination.next_page !== pagination.current_page &&
-                pagination.next_page > pagination.current_page) {
+            if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
                 updatePath(constructPaginationLink(requestPath, pagination.next_page));
             }
         }
@@ -64,8 +64,7 @@ const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl,
     const prevPage = () => {
         if (query.data?.data.pagination) {
             const pagination = query.data.data.pagination;
-            if (pagination.previous_page !== pagination.current_page &&
-                pagination.previous_page < pagination.current_page) {
+            if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
                 updatePath(constructPaginationLink(requestPath, pagination.previous_page));
             }
         }

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

@@ -1,7 +1,7 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request/request.interface';
 import type { DefaultRequestOptions } from './queries.interface';
-export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers, }: {
+export declare const usePatchRequest: <TResponse>({ path, baseUrl, headers }: {
     path: string;
 } & DefaultRequestOptions) => {
     data: undefined;

package/dist/queries/usePatchRequest.js

@@ -1,14 +1,16 @@
 'use strict';
 
 var reactQuery = require('@tanstack/react-query');
+require('@env');
 var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryHeaders = require('../config/useQueryHeaders.js');
+require('react');
 var scrollToTop = require('../helpers/scrollToTop.js');
 require('axios');
 var makeRequest = require('../request/make-request.js');
 var request_enum = require('../request/request.enum.js');
 
-const usePatchRequest = ({ path, baseUrl, headers, }) => {
+const usePatchRequest = ({ path, baseUrl, headers }) => {
     const { API_URL, TIMEOUT } = useEnvironmentVariables.useEnvironmentVariables();
     const { getHeaders } = useQueryHeaders.useQueryHeaders();
     const sendRequest = async (res, rej, data) => {

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,8 +1,10 @@
 'use strict';
 
 var reactQuery = require('@tanstack/react-query');
+require('@env');
 var useEnvironmentVariables = require('../config/useEnvironmentVariables.js');
 var useQueryHeaders = require('../config/useQueryHeaders.js');
+require('react');
 require('axios');
 var makeRequest = require('../request/make-request.js');
 var request_enum = require('../request/request.enum.js');

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/request/axios-instance.d.ts

@@ -1,3 +1,3 @@
 import type { AxiosInstance } from 'axios';
 import type { IMakeRequest } from './request.interface';
-export declare const axiosInstance: ({ baseURL, timeout, headers, }: Partial<IMakeRequest>) => AxiosInstance;
+export declare const axiosInstance: ({ baseURL, timeout, headers }: Partial<IMakeRequest>) => AxiosInstance;

package/dist/request/axios-instance.js

@@ -2,7 +2,7 @@
 
 var axios = require('axios');
 
-const axiosInstance = ({ baseURL, timeout, headers, }) => {
+const axiosInstance = ({ baseURL, timeout, headers }) => {
     return axios.create({
         baseURL,
         timeout,

package/dist/request/buildFormData.js

@@ -8,9 +8,7 @@ const buildFormData = (body) => {
                 formData.append(key, item);
             }
             else if (item instanceof Object) {
-                formData.append(key, new Blob([JSON.stringify(item)], {
-                    type: 'application/json',
-                }));
+                formData.append(key, JSON.stringify(item));
             }
             else {
                 formData.append(key, item);
@@ -22,9 +20,7 @@ const buildFormData = (body) => {
             formData.append(key, value);
         }
         else {
-            formData.append(key, new Blob([JSON.stringify(value)], {
-                type: 'application/json',
-            }));
+            formData.append(key, JSON.stringify(value));
         }
     };
     const handlePrimitiveValue = (key, value) => {

package/dist/request/buildFormData.js.map

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

package/dist/types/index.d.ts

@@ -1,6 +1,10 @@
 import type { RawAxiosRequestHeaders } from 'axios';
+export interface BootstrapQueryRequest {
+    environment: 'app' | 'web' | 'electronjs';
+}
 export interface TanstackQueryConfig {
     headers: RawAxiosRequestHeaders;
+    options?: BootstrapQueryRequest;
 }
 export interface IUseQueryHeaders {
     getHeaders: () => TanstackQueryConfig['headers'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.2.52",
+  "version": "0.2.54",
   "license": "MIT",
   "main": "dist/index.js",
   "contributors": [
@@ -30,7 +30,8 @@
     "axios": "^1.3.4",
     "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
     "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0",
-    "react-native": "*"
+    "react-native": "*",
+    "react-native-dotenv": "3.4.8"
   },
   "peerDependenciesMeta": {
     "react-native": {
@@ -54,6 +55,7 @@
     "@types/node": "*",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.2.0",
+    "@types/react-native-dotenv": "^0.2.0",
     "@typescript-eslint/eslint-plugin": "^5.54.1",
     "@typescript-eslint/parser": "^5.54.1",
     "axios": "^1.3.4",
@@ -71,6 +73,7 @@
     "prettier": "^2.8.4",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
+    "react-native-dotenv": "3.4.8",
     "rimraf": "^4.4.0",
     "rollup": "^3.19.1",
     "rollup-plugin-typescript2": "^0.34.1",

package/src/__tests__/queries/usePostRequest.spec.ts

@@ -15,9 +15,7 @@ describe('usePostRequest', () => {
   });
 
   it('should return post function and mutation object', () => {
-    const { result } = renderHook(() =>
-      usePostRequest<{ id: number; name: string }>({ path })
-    );
+    const { result } = renderHook(() => usePostRequest<{ id: number; name: string }>({ path }));
 
     expect(result.current.post).toBeInstanceOf(Function);
     expect(result.current.isLoading).toBe(false);
@@ -28,9 +26,7 @@ describe('usePostRequest', () => {
   it('should make post request and return response data', async () => {
     mockAxios.onPost(path).reply(200, response);
 
-    const { result, waitForNextUpdate } = renderHook(() =>
-      usePostRequest<{ id: number; name: string }>({ path })
-    );
+    const { result, waitForNextUpdate } = renderHook(() => usePostRequest<{ id: number; name: string }>({ path }));
 
     const responsePromise = result.current.post(postData);
 
@@ -48,9 +44,7 @@ describe('usePostRequest', () => {
     const errorMessage = 'Request failed with status code 500';
     mockAxios.onPost(path).reply(500, { message: errorMessage });
 
-    const { result, waitForNextUpdate } = renderHook(() =>
-      usePostRequest<{ id: number; name: string }>({ path })
-    );
+    const { result, waitForNextUpdate } = renderHook(() => usePostRequest<{ id: number; name: string }>({ path }));
 
     const responsePromise = result.current.post(postData);
 
@@ -72,9 +66,7 @@ describe('usePostRequest', () => {
     formData.append('name', 'John Doe');
     mockAxios.onPost(path).reply(200, response);
 
-    const { result } = renderHook(() =>
-      usePostRequest<{ id: number; name: string }>({ path, isFormData: true })
-    );
+    const { result } = renderHook(() => usePostRequest<{ id: number; name: string }>({ path, isFormData: true }));
 
     const responsePromise = result.current.post(formData);
 

package/src/config/bootstrapQueryRequest.ts

@@ -1,7 +1,7 @@
 import type { QueryClient } from '@tanstack/react-query';
-import type { TanstackQueryConfig } from '../types';
+import type { BootstrapQueryRequest, TanstackQueryConfig } from '../types';
 
-export const bootstrapQueryRequest = (queryClient: QueryClient): void => {
+export const bootstrapQueryRequest = (queryClient: QueryClient, options?: BootstrapQueryRequest): void => {
   // make query config doesn't expire
   queryClient.setQueryDefaults(['config'], {
     staleTime: Infinity,
@@ -13,5 +13,6 @@ export const bootstrapQueryRequest = (queryClient: QueryClient): void => {
     headers: {
       Authorization: ``,
     },
+    options,
   });
 };

package/src/config/index.ts

@@ -1,5 +1,7 @@
 export * from './bootstrapQueryRequest';
 export * from './config.interface';
+export * from './loadReactNativeEnv';
 export * from './useEnvironmentVariables';
 export * from './useQueryConfig';
 export * from './useQueryHeaders';
+export * from './useReactNativeEnv';

package/src/config/loadReactNativeEnv.ts

@@ -0,0 +1,5 @@
+// eslint-disable-next-line import/no-unresolved
+import { API_TIMEOUT, API_URL } from '@env';
+
+export const REACT_NATIVE_API_URL = API_URL;
+export const REACT_NATIVE_API_TIMEOUT = API_TIMEOUT;

package/src/config/useEnvironmentVariables.ts

@@ -1,9 +1,10 @@
 import type { IConfig } from './config.interface';
+import { useReactNativeEnv } from './useReactNativeEnv';
 
 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;
+  const { appTimeout, appUrl } = useReactNativeEnv();
+  const url = process.env.REACT_APP_API_URL || process.env.NEXT_PUBLIC_API_URL || appUrl;
+  const timeout = process.env.REACT_APP_API_TIMEOUT || process.env.NEXT_PUBLIC_API_TIMEOUT || appTimeout;
 
   return {
     API_URL: url as string,

package/src/config/useQueryConfig.ts

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

package/src/config/useReactNativeEnv.ts

@@ -0,0 +1,26 @@
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect, useState } from 'react';
+import type { TanstackQueryConfig } from '../types';
+
+export const useReactNativeEnv = () => {
+  const queryClient = useQueryClient();
+
+  const [appUrl, setAppUrl] = useState<string | undefined>(undefined);
+  const [appTimeout, setAppTimeout] = useState<number | undefined>();
+
+  useEffect(() => {
+    const config = queryClient.getQueryData<TanstackQueryConfig>(['config']);
+
+    const loadReactNativeEnvIfNeeded = async () => {
+      if (config?.options?.environment === 'app') {
+        const { REACT_NATIVE_API_TIMEOUT, REACT_NATIVE_API_URL } = await require('./loadReactNativeEnv');
+        setAppUrl(REACT_NATIVE_API_URL);
+        setAppTimeout(REACT_NATIVE_API_TIMEOUT);
+      }
+    };
+
+    loadReactNativeEnvIfNeeded();
+  }, [queryClient]);
+
+  return { appUrl, appTimeout };
+};

package/src/env.d.ts

@@ -0,0 +1,4 @@
+declare module '@env' {
+  export const API_URL: string;
+  export const API_TIMEOUT: number;
+}

package/src/model/useKeyTrackerModel.ts

@@ -4,9 +4,7 @@ export const useKeyTrackerModel = <T>(keyTracker: string) => {
   const queryClient = useQueryClient();
 
   const getQueryKey = (innerKeyTracker?: string) => {
-    const queryKey: any[] | undefined = queryClient.getQueryData([
-      innerKeyTracker ?? keyTracker,
-    ]);
+    const queryKey: any[] | undefined = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
 
     return queryKey;
   };

package/src/model/useQueryModel.ts

@@ -1,10 +1,7 @@
 import type { QueryFilters } from '@tanstack/react-query';
 import { useQueryClient } from '@tanstack/react-query';
 
-export const useQueryModel = (
-  queryKey: any[],
-  filters?: QueryFilters | undefined
-) => {
+export const useQueryModel = (queryKey: any[], filters?: QueryFilters | undefined) => {
   const queryClient = useQueryClient();
 
   return queryClient.getQueryData(queryKey, filters);

package/src/queries/useDeleteRequest.ts

@@ -7,9 +7,7 @@ import type { IRequestError, IRequestSuccess } from '../request';
 import { HttpMethod, makeRequest } from '../request';
 import type { DefaultRequestOptions } from './queries.interface';
 
-export const useDeleteRequest = <TResponse>(
-  deleteOptions?: DefaultRequestOptions
-) => {
+export const useDeleteRequest = <TResponse>(deleteOptions?: DefaultRequestOptions) => {
   const { baseUrl, headers } = deleteOptions ?? {};
   const [requestPath, updateDeletePath] = useState<string>('');
   const [options, setOptions] = useState<any>();
@@ -18,10 +16,7 @@ export const useDeleteRequest = <TResponse>(
 
   const { getHeaders } = useQueryHeaders();
 
-  const sendRequest = async (
-    res: (value: any) => void,
-    rej: (reason?: any) => void
-  ) => {
+  const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void) => {
     // get request headers
     const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
@@ -41,10 +36,7 @@ export const useDeleteRequest = <TResponse>(
 
   const query = useQuery<any, any, IRequestSuccess<TResponse>>(
     [requestPath, {}],
-    () =>
-      new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) =>
-        sendRequest(res, rej)
-      ),
+    () => new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => sendRequest(res, rej)),
     { enabled: false, ...options }
   );
 

package/src/queries/useGetRequest.ts

@@ -6,11 +6,7 @@ import { useEnvironmentVariables, useQueryHeaders } from '../config';
 
 import type { IRequestError, IRequestSuccess } from '../request';
 import { makeRequest } from '../request';
-import type {
-  DefaultRequestOptions,
-  IPagination,
-  TanstackQueryOption,
-} from './queries.interface';
+import type { DefaultRequestOptions, IPagination, TanstackQueryOption } from './queries.interface';
 
 export const useGetRequest = <TResponse extends Record<string, any>>({
   path,
@@ -39,10 +35,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
 
   const sendRequest = async (
     res: (
-      value:
-        | IRequestError
-        | IRequestSuccess<TResponse>
-        | PromiseLike<IRequestError | IRequestSuccess<TResponse>>
+      value: IRequestError | IRequestSuccess<TResponse> | PromiseLike<IRequestError | IRequestSuccess<TResponse>>
     ) => void,
     rej: (reason?: any) => void
   ) => {
@@ -64,10 +57,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
 
   const query = useQuery<any, any, IRequestSuccess<TResponse>>(
     [requestPath, {}],
-    () =>
-      new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) =>
-        sendRequest(res, rej)
-      ),
+    () => new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => sendRequest(res, rej)),
     {
       enabled: load,
       ...options,
@@ -95,10 +85,7 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   const nextPage = () => {
     if (query.data?.data.pagination) {
       const pagination: IPagination = query.data.data.pagination;
-      if (
-        pagination.next_page !== pagination.current_page &&
-        pagination.next_page > pagination.current_page
-      ) {
+      if (pagination.next_page !== pagination.current_page && pagination.next_page > pagination.current_page) {
         updatePath(constructPaginationLink(requestPath, pagination.next_page));
       }
     }
@@ -107,13 +94,8 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   const prevPage = () => {
     if (query.data?.data.pagination) {
       const pagination: IPagination = query.data.data.pagination;
-      if (
-        pagination.previous_page !== pagination.current_page &&
-        pagination.previous_page < pagination.current_page
-      ) {
-        updatePath(
-          constructPaginationLink(requestPath, pagination.previous_page)
-        );
+      if (pagination.previous_page !== pagination.current_page && pagination.previous_page < pagination.current_page) {
+        updatePath(constructPaginationLink(requestPath, pagination.previous_page));
       }
     }
   };

package/src/queries/usePatchRequest.ts

@@ -4,26 +4,15 @@ import type { RawAxiosRequestHeaders } from 'axios';
 import { useEnvironmentVariables, useQueryHeaders } from '../config';
 import { scrollToTop } from '../helpers';
 import { HttpMethod, makeRequest } from '../request';
-import type {
-  IRequestError,
-  IRequestSuccess,
-} from '../request/request.interface';
+import type { IRequestError, IRequestSuccess } from '../request/request.interface';
 import type { DefaultRequestOptions } from './queries.interface';
 
-export const usePatchRequest = <TResponse>({
-  path,
-  baseUrl,
-  headers,
-}: { path: string } & DefaultRequestOptions) => {
+export const usePatchRequest = <TResponse>({ path, baseUrl, headers }: { path: string } & DefaultRequestOptions) => {
   const { API_URL, TIMEOUT } = useEnvironmentVariables();
 
   const { getHeaders } = useQueryHeaders();
 
-  const sendRequest = async (
-    res: (value: any) => void,
-    rej: (reason?: any) => void,
-    data: any
-  ) => {
+  const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, data: any) => {
     // get request headers
     const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
@@ -60,9 +49,7 @@ export const usePatchRequest = <TResponse>({
 
   const patch = async (
     data: any,
-    options?:
-      | MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown>
-      | undefined
+    options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined
   ): Promise<IRequestSuccess<TResponse>> => {
     return mutation.mutateAsync(data, options);
   };

package/src/queries/usePostRequest.ts

@@ -20,11 +20,7 @@ export const usePostRequest = <TResponse>({
 
   const { getHeaders } = useQueryHeaders();
 
-  const sendRequest = async (
-    res: (value: any) => void,
-    rej: (reason?: any) => void,
-    postData: any
-  ) => {
+  const sendRequest = async (res: (value: any) => void, rej: (reason?: any) => void, postData: any) => {
     // get request headers
     const globalHeaders: RawAxiosRequestHeaders = getHeaders();
 
@@ -57,16 +53,11 @@ export const usePostRequest = <TResponse>({
 
   // register post mutation
   const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
-    async (postData: any) =>
-      new Promise<IRequestSuccess<TResponse>>((res, rej) =>
-        sendRequest(res, rej, postData)
-      )
+    async (postData: any) => new Promise<IRequestSuccess<TResponse>>((res, rej) => sendRequest(res, rej, postData))
   );
   const post = async (
     data: any,
-    options?:
-      | MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown>
-      | undefined
+    options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined
   ): Promise<IRequestSuccess<TResponse>> => {
     return mutation.mutateAsync(data, options);
   };

package/src/request/axios-instance.ts

@@ -2,11 +2,7 @@ import type { AxiosInstance } from 'axios';
 import axios from 'axios';
 import type { IMakeRequest } from './request.interface';
 
-export const axiosInstance = ({
-  baseURL,
-  timeout,
-  headers,
-}: Partial<IMakeRequest>): AxiosInstance => {
+export const axiosInstance = ({ baseURL, timeout, headers }: Partial<IMakeRequest>): AxiosInstance => {
   return axios.create({
     baseURL,
     timeout,

package/src/request/buildFormData.ts

@@ -6,12 +6,7 @@ export const buildFormData = (body: Record<string, any>) => {
       if (item instanceof File) {
         formData.append(key, item);
       } else if (item instanceof Object) {
-        formData.append(
-          key,
-          new Blob([JSON.stringify(item)], {
-            type: 'application/json',
-          })
-        );
+        formData.append(key, JSON.stringify(item));
       } else {
         formData.append(key, item);
       }
@@ -22,12 +17,7 @@ export const buildFormData = (body: Record<string, any>) => {
     if (value instanceof File) {
       formData.append(key, value);
     } else {
-      formData.append(
-        key,
-        new Blob([JSON.stringify(value)], {
-          type: 'application/json',
-        })
-      );
+      formData.append(key, JSON.stringify(value));
     }
   };
 

package/src/request/transformer.ts

@@ -1,14 +1,7 @@
-import type {
-  IRequestError,
-  IRequestSuccess,
-  IServerRequestError,
-  IServerRequestSuccess,
-} from './request.interface';
+import type { IRequestError, IRequestSuccess, IServerRequestError, IServerRequestSuccess } from './request.interface';
 
 //
-export const errorTransformer = (
-  data: IServerRequestError & { statusCode: number }
-): IRequestError => {
+export const errorTransformer = (data: IServerRequestError & { statusCode: number }): IRequestError => {
   return {
     message: data.message,
     statusCode: data.statusCode,
@@ -19,9 +12,7 @@ export const errorTransformer = (
 };
 
 //
-export const successTransformer = <T>(
-  data: IServerRequestSuccess & { statusCode: number }
-): IRequestSuccess<T> => {
+export const successTransformer = <T>(data: IServerRequestSuccess & { statusCode: number }): IRequestSuccess<T> => {
   return {
     message: data.message ?? 'Request successful',
     statusCode: data.statusCode,

package/src/types/index.ts

@@ -1,7 +1,12 @@
 import type { RawAxiosRequestHeaders } from 'axios';
 
+export interface BootstrapQueryRequest {
+  environment: 'app' | 'web' | 'electronjs';
+}
+
 export interface TanstackQueryConfig {
   headers: RawAxiosRequestHeaders;
+  options?: BootstrapQueryRequest;
 }
 
 export interface IUseQueryHeaders {