@ventlio/tanstack-query 0.1.13 → 0.2.1

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export * from './constants';
 export * from './helpers';
 export * from './queries';
 export * from './request';

package/dist/index.js

@@ -1,11 +1,11 @@
 'use strict';
 
-var index = require('./constants/index.js');
 var scrollToTop = require('./helpers/scrollToTop.js');
 var useDeleteRequest = require('./queries/useDeleteRequest.js');
 var useGetRequest = require('./queries/useGetRequest.js');
 var usePatchRequest = require('./queries/usePatchRequest.js');
 var usePostRequest = require('./queries/usePostRequest.js');
+var useQueryConfig = require('./queries/useQueryConfig.js');
 var axiosInstance = require('./request/axios-instance.js');
 var buildFormData = require('./request/buildFormData.js');
 var makeRequest = require('./request/make-request.js');
@@ -14,12 +14,12 @@ var transformer = require('./request/transformer.js');
 
 
 
-exports.API_BASE_URL = index.API_BASE_URL;
 exports.scrollToTop = scrollToTop.scrollToTop;
 exports.useDeleteRequest = useDeleteRequest.useDeleteRequest;
 exports.useGetRequest = useGetRequest.useGetRequest;
 exports.usePatchRequest = usePatchRequest.usePatchRequest;
 exports.usePostRequest = usePostRequest.usePostRequest;
+exports.useQueryConfig = useQueryConfig.useQueryConfig;
 exports.axiosInstance = axiosInstance.axiosInstance;
 exports.buildFormData = buildFormData.buildFormData;
 exports.makeRequest = makeRequest.makeRequest;

package/dist/index.mjs

@@ -1,9 +1,7 @@
-import { useQuery, useMutation } from '@tanstack/react-query';
+import { useQueryClient, useQuery, useMutation } from '@tanstack/react-query';
 import { useState, useEffect, startTransition } from 'react';
 import axios from 'axios';
 
-const API_BASE_URL = 'https://pokeapi.co/api/v2';
-
 const scrollToTop = () => {
     window.scrollTo({
         top: 0,
@@ -11,10 +9,10 @@ const scrollToTop = () => {
     });
 };
 
-const axiosInstance = (headers) => {
+const axiosInstance = ({ baseURL, timeout, headers, }) => {
     return axios.create({
-        baseURL: API_BASE_URL,
-        timeout: 100000,
+        baseURL,
+        timeout,
         headers,
     });
 };
@@ -64,18 +62,15 @@ const successTransformer = (data) => {
     };
 };
 
-async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, isFormData, }) {
+async function makeRequest({ body, method = HttpMethod.GET, path, isFormData, headers = {}, baseURL, timeout, }) {
     // configure body
     body = isFormData ? buildFormData(body) : body;
     // configure request header
-    const headers = {
-        Authorization: `Bearer ${bearerToken}`,
-    };
     if (!isFormData) {
         headers['Content-Type'] = ContentType.APPLICATION_JSON;
     }
     try {
-        const axios = axiosInstance(headers);
+        const axios = axiosInstance({ baseURL, headers, timeout });
         //   send request
         const resp = await axios({
             url: path,
@@ -104,16 +99,26 @@ async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, i
     }
 }
 
+const useQueryConfig = () => {
+    const { getQueryData } = useQueryClient();
+    const { headers, baseURL, timeout } = getQueryData([
+        'config',
+    ]);
+    return { headers, baseURL, timeout };
+};
+
 const useDeleteRequest = () => {
     const [requestPath, updateDeletePath] = useState('');
     const [options, setOptions] = useState();
-    const authToken = '';
+    const { headers, baseURL, timeout } = useQueryConfig();
     const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
         setTimeout(async () => {
             const postResponse = await makeRequest({
                 path: requestPath,
-                bearerToken: authToken,
+                headers,
                 method: HttpMethod.DELETE,
+                baseURL,
+                timeout,
             });
             if (postResponse.status) {
                 res(postResponse);
@@ -129,25 +134,31 @@ const useDeleteRequest = () => {
     const setOptionsAsync = async (fetchOptions) => {
         return setOptions(fetchOptions);
     };
-    const deleteR = async (link, fetchOptions) => {
+    const destroy = async (link, deleteOptions) => {
+        // set enabled to be true for every delete
+        deleteOptions = deleteOptions ?? {};
+        deleteOptions.enabled = true;
         await updatedPathAsync(link);
-        await setOptionsAsync(fetchOptions);
-        return query.refetch({
-            queryKey: [link, {}],
-        });
+        await setOptionsAsync(deleteOptions);
+        // return query.refetch<TResponse>({
+        //   queryKey: [link, {}],
+        // });
+        return query.data;
     };
-    return { updateDeletePath, deleteR, ...query };
+    return { destroy, ...query };
 };
 
 const useGetRequest = ({ path, load = false, queryOptions, }) => {
     const [requestPath, updatePath] = useState(path);
-    const authToken = '';
     const [options, setOptions] = useState(queryOptions);
     const [page, setPage] = useState(1);
+    const { headers, baseURL, timeout } = useQueryConfig();
     const sendRequest = async (res, rej) => {
         const postResponse = await makeRequest({
             path: requestPath,
-            bearerToken: authToken,
+            headers,
+            baseURL,
+            timeout,
         });
         if (postResponse.status) {
             res(postResponse);
@@ -228,21 +239,19 @@ const useGetRequest = ({ path, load = false, queryOptions, }) => {
     };
 };
 
-const usePatchRequest = ({ path, isFormData = false, }) => {
-    const authToken = '';
-    const [resetForm, setResetForm] = useState(false);
+const usePatchRequest = ({ path, }) => {
+    const { headers, baseURL, timeout } = useQueryConfig();
     // register post mutation
     const mutation = useMutation((postData) => new Promise((res, rej) => {
-        setResetForm(false);
         makeRequest({
             path: path,
             body: postData,
             method: HttpMethod.PATCH,
-            bearerToken: authToken,
-            isFormData,
+            headers,
+            baseURL,
+            timeout,
         }).then((postResponse) => {
             if (postResponse.status) {
-                setResetForm(true);
                 // scroll to top after success
                 scrollToTop();
                 res(postResponse);
@@ -260,24 +269,23 @@ const usePatchRequest = ({ path, isFormData = false, }) => {
     const patch = async (postData, options) => {
         return mutation.mutateAsync(postData, options);
     };
-    return { patch, ...mutation, resetForm };
+    return { patch, ...mutation };
 };
 
 const usePostRequest = ({ path, isFormData = false, }) => {
-    const authToken = '';
-    const [resetForm, setResetForm] = useState(false);
+    const { headers, baseURL, timeout } = useQueryConfig();
     // register post mutation
     const mutation = useMutation(async (postData) => new Promise((res, rej) => {
-        setResetForm(false);
         makeRequest({
             path: path,
             body: postData,
             method: HttpMethod.POST,
-            bearerToken: authToken,
             isFormData,
+            headers,
+            baseURL,
+            timeout,
         }).then((postResponse) => {
             if (postResponse.status) {
-                setResetForm(true);
                 // scroll to top after success
                 window.scrollTo({
                     top: 0,
@@ -298,8 +306,8 @@ const usePostRequest = ({ path, isFormData = false, }) => {
     const post = async (postData, options) => {
         return mutation.mutateAsync(postData, options);
     };
-    return { post, ...mutation, resetForm };
+    return { post, ...mutation };
 };
 
-export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useGetRequest, usePatchRequest, usePostRequest };
+export { ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useGetRequest, usePatchRequest, usePostRequest, useQueryConfig };
 //# 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/index.d.ts

@@ -1,4 +1,6 @@
+export * from './queries.interface';
 export * from './useDeleteRequest';
 export * from './useGetRequest';
 export * from './usePatchRequest';
 export * from './usePostRequest';
+export * from './useQueryConfig';

package/dist/queries/useDeleteRequest.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="react" />
-import type { MutateOptions, QueryObserverResult } from '@tanstack/react-query';
+import type { UseQueryOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
 export declare const useDeleteRequest: <TResponse>() => {
     data: IRequestSuccess<TResponse>;
@@ -24,11 +23,10 @@ export declare const useDeleteRequest: <TResponse>() => {
     isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: IRequestSuccess<TResponse>;
     error: null;
@@ -52,11 +50,10 @@ export declare const useDeleteRequest: <TResponse>() => {
     isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: undefined;
     error: any;
@@ -80,11 +77,10 @@ export declare const useDeleteRequest: <TResponse>() => {
     isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 } | {
     data: undefined;
     error: null;
@@ -108,9 +104,8 @@ export declare const useDeleteRequest: <TResponse>() => {
     isPreviousData: boolean;
     isRefetching: boolean;
     isStale: boolean;
-    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    refetch: <TPageData>(options?: (import("@tanstack/react-query").RefetchOptions & import("@tanstack/react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("@tanstack/react-query").QueryObserverResult<IRequestSuccess<TResponse>, any>>;
     remove: () => void;
     fetchStatus: import("@tanstack/react-query").FetchStatus;
-    updateDeletePath: import("react").Dispatch<import("react").SetStateAction<string>>;
-    deleteR: (link: string, fetchOptions?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>>;
+    destroy: (link: string, deleteOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
 };

package/dist/queries/useDeleteRequest.js

@@ -5,17 +5,20 @@ var react = require('react');
 require('axios');
 var makeRequest = require('../request/make-request.js');
 var request_enum = require('../request/request.enum.js');
+var useQueryConfig = require('./useQueryConfig.js');
 
 const useDeleteRequest = () => {
     const [requestPath, updateDeletePath] = react.useState('');
     const [options, setOptions] = react.useState();
-    const authToken = '';
+    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
     const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
         setTimeout(async () => {
             const postResponse = await makeRequest.makeRequest({
                 path: requestPath,
-                bearerToken: authToken,
+                headers,
                 method: request_enum.HttpMethod.DELETE,
+                baseURL,
+                timeout,
             });
             if (postResponse.status) {
                 res(postResponse);
@@ -31,14 +34,18 @@ const useDeleteRequest = () => {
     const setOptionsAsync = async (fetchOptions) => {
         return setOptions(fetchOptions);
     };
-    const deleteR = async (link, fetchOptions) => {
+    const destroy = async (link, deleteOptions) => {
+        // set enabled to be true for every delete
+        deleteOptions = deleteOptions ?? {};
+        deleteOptions.enabled = true;
         await updatedPathAsync(link);
-        await setOptionsAsync(fetchOptions);
-        return query.refetch({
-            queryKey: [link, {}],
-        });
+        await setOptionsAsync(deleteOptions);
+        // return query.refetch<TResponse>({
+        //   queryKey: [link, {}],
+        // });
+        return query.data;
     };
-    return { updateDeletePath, deleteR, ...query };
+    return { destroy, ...query };
 };
 
 exports.useDeleteRequest = useDeleteRequest;

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

@@ -5,16 +5,19 @@ var react = require('react');
 require('axios');
 var makeRequest = require('../request/make-request.js');
 require('../request/request.enum.js');
+var useQueryConfig = require('./useQueryConfig.js');
 
 const useGetRequest = ({ path, load = false, queryOptions, }) => {
     const [requestPath, updatePath] = react.useState(path);
-    const authToken = '';
     const [options, setOptions] = react.useState(queryOptions);
     const [page, setPage] = react.useState(1);
+    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
     const sendRequest = async (res, rej) => {
         const postResponse = await makeRequest.makeRequest({
             path: requestPath,
-            bearerToken: authToken,
+            headers,
+            baseURL,
+            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.d.ts

@@ -1,10 +1,9 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request/request.interface';
-export declare const usePatchRequest: <TResponse>({ path, isFormData, }: {
+export declare const usePatchRequest: <TResponse>({ path, }: {
     path: string;
     isFormData?: boolean | undefined;
 }) => {
-    resetForm: boolean;
     data: undefined;
     error: null;
     isError: false;
@@ -22,7 +21,6 @@ export declare const usePatchRequest: <TResponse>({ path, isFormData, }: {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
-    resetForm: boolean;
     data: undefined;
     error: null;
     isError: false;
@@ -40,7 +38,6 @@ export declare const usePatchRequest: <TResponse>({ path, isFormData, }: {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
-    resetForm: boolean;
     data: undefined;
     error: IRequestError;
     isError: true;
@@ -58,7 +55,6 @@ export declare const usePatchRequest: <TResponse>({ path, isFormData, }: {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     patch: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
-    resetForm: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;

package/dist/queries/usePatchRequest.js

@@ -1,27 +1,25 @@
 'use strict';
 
 var reactQuery = require('@tanstack/react-query');
-var react = 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');
+var useQueryConfig = require('./useQueryConfig.js');
 
-const usePatchRequest = ({ path, isFormData = false, }) => {
-    const authToken = '';
-    const [resetForm, setResetForm] = react.useState(false);
+const usePatchRequest = ({ path, }) => {
+    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
     // register post mutation
     const mutation = reactQuery.useMutation((postData) => new Promise((res, rej) => {
-        setResetForm(false);
         makeRequest.makeRequest({
             path: path,
             body: postData,
             method: request_enum.HttpMethod.PATCH,
-            bearerToken: authToken,
-            isFormData,
+            headers,
+            baseURL,
+            timeout,
         }).then((postResponse) => {
             if (postResponse.status) {
-                setResetForm(true);
                 // scroll to top after success
                 scrollToTop.scrollToTop();
                 res(postResponse);
@@ -39,7 +37,7 @@ const usePatchRequest = ({ path, isFormData = false, }) => {
     const patch = async (postData, options) => {
         return mutation.mutateAsync(postData, options);
     };
-    return { patch, ...mutation, resetForm };
+    return { patch, ...mutation };
 };
 
 exports.usePatchRequest = usePatchRequest;

package/dist/queries/usePatchRequest.js.map

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

package/dist/queries/usePostRequest.d.ts

@@ -4,7 +4,6 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     path: string;
     isFormData?: boolean | undefined;
 }) => {
-    resetForm: boolean;
     data: undefined;
     error: null;
     isError: false;
@@ -22,7 +21,6 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
-    resetForm: boolean;
     data: undefined;
     error: null;
     isError: false;
@@ -40,7 +38,6 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
-    resetForm: boolean;
     data: undefined;
     error: IRequestError;
     isError: true;
@@ -58,7 +55,6 @@ export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
     post: (postData: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse>>;
 } | {
-    resetForm: boolean;
     data: IRequestSuccess<TResponse>;
     error: null;
     isError: false;

package/dist/queries/usePostRequest.js

@@ -1,26 +1,25 @@
 'use strict';
 
 var reactQuery = require('@tanstack/react-query');
-var react = require('react');
 require('axios');
 var makeRequest = require('../request/make-request.js');
 var request_enum = require('../request/request.enum.js');
+var useQueryConfig = require('./useQueryConfig.js');
 
 const usePostRequest = ({ path, isFormData = false, }) => {
-    const authToken = '';
-    const [resetForm, setResetForm] = react.useState(false);
+    const { headers, baseURL, timeout } = useQueryConfig.useQueryConfig();
     // register post mutation
     const mutation = reactQuery.useMutation(async (postData) => new Promise((res, rej) => {
-        setResetForm(false);
         makeRequest.makeRequest({
             path: path,
             body: postData,
             method: request_enum.HttpMethod.POST,
-            bearerToken: authToken,
             isFormData,
+            headers,
+            baseURL,
+            timeout,
         }).then((postResponse) => {
             if (postResponse.status) {
-                setResetForm(true);
                 // scroll to top after success
                 window.scrollTo({
                     top: 0,
@@ -41,7 +40,7 @@ const usePostRequest = ({ path, isFormData = false, }) => {
     const post = async (postData, options) => {
         return mutation.mutateAsync(postData, options);
     };
-    return { post, ...mutation, resetForm };
+    return { post, ...mutation };
 };
 
 exports.usePostRequest = usePostRequest;

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

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

package/dist/queries/useQueryConfig.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+
+const useQueryConfig = () => {
+    const { getQueryData } = reactQuery.useQueryClient();
+    const { headers, baseURL, timeout } = getQueryData([
+        'config',
+    ]);
+    return { headers, baseURL, timeout };
+};
+
+exports.useQueryConfig = useQueryConfig;
+//# sourceMappingURL=useQueryConfig.js.map

package/dist/queries/useQueryConfig.js.map

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

package/dist/request/axios-instance.d.ts

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

package/dist/request/axios-instance.js

@@ -1,12 +1,11 @@
 'use strict';
 
 var axios = require('axios');
-var index = require('../constants/index.js');
 
-const axiosInstance = (headers) => {
+const axiosInstance = ({ baseURL, timeout, headers, }) => {
     return axios.create({
-        baseURL: index.API_BASE_URL,
-        timeout: 100000,
+        baseURL,
+        timeout,
         headers,
     });
 };

package/dist/request/axios-instance.js.map

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

package/dist/request/make-request.d.ts

@@ -1,2 +1,2 @@
 import type { IMakeRequest } from './request.interface';
-export declare function makeRequest<TResponse>({ body, method, path, bearerToken, isFormData, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;
+export declare function makeRequest<TResponse>({ body, method, path, isFormData, headers, baseURL, timeout, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;

package/dist/request/make-request.js

@@ -5,18 +5,15 @@ var buildFormData = require('./buildFormData.js');
 var request_enum = require('./request.enum.js');
 var transformer = require('./transformer.js');
 
-async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, bearerToken, isFormData, }) {
+async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, isFormData, headers = {}, baseURL, timeout, }) {
     // configure body
     body = isFormData ? buildFormData.buildFormData(body) : body;
     // configure request header
-    const headers = {
-        Authorization: `Bearer ${bearerToken}`,
-    };
     if (!isFormData) {
         headers['Content-Type'] = request_enum.ContentType.APPLICATION_JSON;
     }
     try {
-        const axios = axiosInstance.axiosInstance(headers);
+        const axios = axiosInstance.axiosInstance({ baseURL, headers, timeout });
         //   send request
         const resp = await axios({
             url: path,

package/dist/request/make-request.js.map

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

package/dist/request/request.interface.d.ts

@@ -1,10 +1,13 @@
+import type { RawAxiosRequestHeaders } from 'axios';
 import type { HttpMethod } from './request.enum';
 export interface IMakeRequest {
+    baseURL: string;
+    timeout?: number;
     path: string;
     body?: Record<string, any> | null;
     method?: HttpMethod;
-    bearerToken?: string;
     isFormData?: boolean;
+    headers: RawAxiosRequestHeaders;
 }
 export interface AxiosInstanceOption {
     bearerToken?: string;

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
 import type { RawAxiosRequestHeaders } from 'axios';
 export interface TanstackQueryConfig {
-    baseUrl: string;
+    baseURL: string;
     timeout?: number;
-    headers?: RawAxiosRequestHeaders;
+    headers: RawAxiosRequestHeaders;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.1.13",
+  "version": "0.2.1",
   "license": "MIT",
   "main": "dist/index.js",
   "repository": {

package/src/index.ts

@@ -1,4 +1,3 @@
-export * from './constants';
 export * from './helpers';
 export * from './queries';
 export * from './request';

package/src/queries/index.ts

@@ -1,4 +1,6 @@
+export * from './queries.interface';
 export * from './useDeleteRequest';
 export * from './useGetRequest';
 export * from './usePatchRequest';
 export * from './usePostRequest';
+export * from './useQueryConfig';

package/src/queries/useDeleteRequest.ts

@@ -1,13 +1,16 @@
-import type { MutateOptions, QueryObserverResult } from '@tanstack/react-query';
+import type { UseQueryOptions } from '@tanstack/react-query';
 import { useQuery } from '@tanstack/react-query';
 import { useState } from 'react';
 import type { IRequestError, IRequestSuccess } from '../request';
 import { HttpMethod, makeRequest } from '../request';
+import { useQueryConfig } from './useQueryConfig';
 
 export const useDeleteRequest = <TResponse>() => {
   const [requestPath, updateDeletePath] = useState<string>('');
   const [options, setOptions] = useState<any>();
-  const authToken = '';
+
+  const { headers, baseURL, timeout } = useQueryConfig();
+
   const query = useQuery<any, any, IRequestSuccess<TResponse>>(
     [requestPath, {}],
     () =>
@@ -15,8 +18,10 @@ export const useDeleteRequest = <TResponse>() => {
         setTimeout(async () => {
           const postResponse = await makeRequest<TResponse>({
             path: requestPath,
-            bearerToken: authToken,
+            headers,
             method: HttpMethod.DELETE,
+            baseURL,
+            timeout,
           });
           if (postResponse.status) {
             res(postResponse as IRequestSuccess<TResponse>);
@@ -35,18 +40,29 @@ export const useDeleteRequest = <TResponse>() => {
   const setOptionsAsync = async (fetchOptions: any) => {
     return setOptions(fetchOptions);
   };
-  const deleteR = async (
+
+  const destroy = async (
     link: string,
-    fetchOptions?:
-      | MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown>
-      | undefined
-  ): Promise<QueryObserverResult<IRequestSuccess<TResponse>, any>> => {
+    deleteOptions?: UseQueryOptions<
+      IRequestSuccess<TResponse | undefined>,
+      IRequestError,
+      IRequestSuccess<TResponse | undefined>,
+      Array<any>
+    >
+  ): Promise<IRequestSuccess<TResponse> | undefined> => {
+    // set enabled to be true for every delete
+    deleteOptions = deleteOptions ?? {};
+    deleteOptions.enabled = true;
+
     await updatedPathAsync(link);
-    await setOptionsAsync(fetchOptions);
+    await setOptionsAsync(deleteOptions);
+
+    // return query.refetch<TResponse>({
+    //   queryKey: [link, {}],
+    // });
 
-    return query.refetch<TResponse>({
-      queryKey: [link, {}],
-    });
+    return query.data;
   };
-  return { updateDeletePath, deleteR, ...query };
+
+  return { destroy, ...query };
 };

package/src/queries/useGetRequest.ts

@@ -15,10 +15,15 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   queryOptions?: TanstackQueryOption<TResponse>;
 }) => {
   const [requestPath, updatePath] = useState<string>(path);
-  const authToken = '';
   const [options, setOptions] = useState<any>(queryOptions);
   const [page, setPage] = useState<number>(1);
 
+  const { headers, baseURL, timeout } = {
+    headers: {},
+    baseURL: '',
+    timeout: 449542,
+  };
+
   const sendRequest = async (
     res: (
       value:
@@ -30,7 +35,9 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
   ) => {
     const postResponse = await makeRequest<TResponse>({
       path: requestPath,
-      bearerToken: authToken,
+      headers,
+      baseURL,
+      timeout,
     });
     if (postResponse.status) {
       res(postResponse as IRequestSuccess<TResponse>);

package/src/queries/usePatchRequest.ts

@@ -1,6 +1,5 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import { useMutation } from '@tanstack/react-query';
-import { useState } from 'react';
 import { scrollToTop } from '../helpers';
 import { HttpMethod, makeRequest } from '../request';
 
@@ -8,32 +7,29 @@ import type {
   IRequestError,
   IRequestSuccess,
 } from '../request/request.interface';
+import { useQueryConfig } from './useQueryConfig';
 
 export const usePatchRequest = <TResponse>({
   path,
-  isFormData = false,
 }: {
   path: string;
   isFormData?: boolean;
 }) => {
-  const authToken = '';
-  const [resetForm, setResetForm] = useState<boolean>(false);
+  const { headers, baseURL, timeout } = useQueryConfig();
 
   // register post mutation
   const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
     (postData: any) =>
       new Promise<IRequestSuccess<TResponse>>((res, rej) => {
-        setResetForm(false);
-
         makeRequest<TResponse>({
           path: path,
           body: postData,
           method: HttpMethod.PATCH,
-          bearerToken: authToken,
-          isFormData,
+          headers,
+          baseURL,
+          timeout,
         }).then((postResponse) => {
           if (postResponse.status) {
-            setResetForm(true);
             // scroll to top after success
             scrollToTop();
             res(postResponse as IRequestSuccess<TResponse>);
@@ -48,6 +44,7 @@ export const usePatchRequest = <TResponse>({
         });
       })
   );
+
   const patch = async (
     postData: any,
     options?:
@@ -57,5 +54,5 @@ export const usePatchRequest = <TResponse>({
     return mutation.mutateAsync(postData, options);
   };
 
-  return { patch, ...mutation, resetForm };
+  return { patch, ...mutation };
 };

package/src/queries/usePostRequest.ts

@@ -1,8 +1,8 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import { useMutation } from '@tanstack/react-query';
-import { useState } from 'react';
 import type { IRequestError, IRequestSuccess } from '../request';
 import { HttpMethod, makeRequest } from '../request';
+import { useQueryConfig } from './useQueryConfig';
 
 export const usePostRequest = <TResponse>({
   path,
@@ -11,24 +11,22 @@ export const usePostRequest = <TResponse>({
   path: string;
   isFormData?: boolean;
 }) => {
-  const authToken = '';
-
-  const [resetForm, setResetForm] = useState<boolean>(false);
+  const { headers, baseURL, timeout } = useQueryConfig();
 
   // register post mutation
   const mutation = useMutation<IRequestSuccess<TResponse>, IRequestError>(
     async (postData: any) =>
       new Promise<IRequestSuccess<TResponse>>((res, rej) => {
-        setResetForm(false);
         makeRequest<TResponse>({
           path: path,
           body: postData,
           method: HttpMethod.POST,
-          bearerToken: authToken,
           isFormData,
+          headers,
+          baseURL,
+          timeout,
         }).then((postResponse) => {
           if (postResponse.status) {
-            setResetForm(true);
             // scroll to top after success
             window.scrollTo({
               top: 0,
@@ -55,5 +53,5 @@ export const usePostRequest = <TResponse>({
     return mutation.mutateAsync(postData, options);
   };
 
-  return { post, ...mutation, resetForm };
+  return { post, ...mutation };
 };

package/src/queries/useQueryConfig.ts

@@ -0,0 +1,12 @@
+import { useQueryClient } from '@tanstack/react-query';
+import type { TanstackQueryConfig } from '../types';
+
+export const useQueryConfig = (): TanstackQueryConfig => {
+  const { getQueryData } = useQueryClient();
+
+  const { headers, baseURL, timeout } = getQueryData<TanstackQueryConfig>([
+    'config',
+  ]) as TanstackQueryConfig;
+
+  return { headers, baseURL, timeout };
+};

package/src/request/axios-instance.ts

@@ -1,13 +1,15 @@
-import type { AxiosInstance, RawAxiosRequestHeaders } from 'axios';
+import type { AxiosInstance } from 'axios';
 import axios from 'axios';
-import { API_BASE_URL } from '../constants';
+import type { IMakeRequest } from './request.interface';
 
-export const axiosInstance = (
-  headers: RawAxiosRequestHeaders
-): AxiosInstance => {
+export const axiosInstance = ({
+  baseURL,
+  timeout,
+  headers,
+}: Partial<IMakeRequest>): AxiosInstance => {
   return axios.create({
-    baseURL: API_BASE_URL,
-    timeout: 100000,
+    baseURL,
+    timeout,
     headers,
   });
 };

package/src/request/make-request.ts

@@ -1,4 +1,3 @@
-import type { RawAxiosRequestHeaders } from 'axios';
 import { axiosInstance } from './axios-instance';
 
 import { buildFormData } from './buildFormData';
@@ -10,23 +9,22 @@ export async function makeRequest<TResponse>({
   body,
   method = HttpMethod.GET,
   path,
-  bearerToken,
   isFormData,
+  headers = {},
+  baseURL,
+  timeout,
 }: IMakeRequest) {
   // configure body
   body = isFormData ? buildFormData(body as Record<string, any>) : body;
 
   // configure request header
-  const headers: RawAxiosRequestHeaders = {
-    Authorization: `Bearer ${bearerToken}`,
-  };
 
   if (!isFormData) {
     headers['Content-Type'] = ContentType.APPLICATION_JSON;
   }
 
   try {
-    const axios = axiosInstance(headers);
+    const axios = axiosInstance({ baseURL, headers, timeout });
 
     //   send request
     const resp = await axios({

package/src/request/request.interface.ts

@@ -1,11 +1,14 @@
+import type { RawAxiosRequestHeaders } from 'axios';
 import type { HttpMethod } from './request.enum';
 
 export interface IMakeRequest {
+  baseURL: string;
+  timeout?: number;
   path: string;
   body?: Record<string, any> | null;
   method?: HttpMethod;
-  bearerToken?: string;
   isFormData?: boolean;
+  headers: RawAxiosRequestHeaders;
 }
 
 export interface AxiosInstanceOption {

package/src/types/index.ts

@@ -1,7 +1,7 @@
 import type { RawAxiosRequestHeaders } from 'axios';
 
 export interface TanstackQueryConfig {
-  baseUrl: string;
+  baseURL: string;
   timeout?: number;
-  headers?: RawAxiosRequestHeaders;
+  headers: RawAxiosRequestHeaders;
 }

package/dist/constants/index.d.ts

@@ -1 +0,0 @@
-export declare const API_BASE_URL = "https://pokeapi.co/api/v2";

package/dist/constants/index.js

@@ -1,6 +0,0 @@
-'use strict';
-
-const API_BASE_URL = 'https://pokeapi.co/api/v2';
-
-exports.API_BASE_URL = API_BASE_URL;
-//# sourceMappingURL=index.js.map

package/dist/constants/index.js.map

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

package/src/constants/index.ts

@@ -1 +0,0 @@
-export const API_BASE_URL = 'https://pokeapi.co/api/v2';