@ventlio/tanstack-query 0.1.3 → 0.1.4

package/dist/helpers/index.d.ts

@@ -1 +1 @@
-export declare const scrollToTop: () => void;
+export * from './scrollToTop';

package/dist/helpers/scrollToTop.d.ts

@@ -0,0 +1 @@
+export declare const scrollToTop: () => void;

package/dist/helpers/scrollToTop.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const scrollToTop = () => {
+    window.scrollTo({
+        top: 0,
+        behavior: 'smooth',
+    });
+};
+
+exports.scrollToTop = scrollToTop;
+//# sourceMappingURL=scrollToTop.js.map

package/dist/helpers/scrollToTop.js.map

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,6 +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 axiosInstance = require('./request/axios-instance.js');
 var buildFormData = require('./request/buildFormData.js');
 var makeRequest = require('./request/make-request.js');
@@ -10,6 +15,11 @@ 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.axiosInstance = axiosInstance.axiosInstance;
 exports.buildFormData = buildFormData.buildFormData;
 exports.makeRequest = makeRequest.makeRequest;

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,7 +1,16 @@
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { useState, startTransition } from 'react';
 import axios from 'axios';
 
 const API_BASE_URL = '';
 
+const scrollToTop = () => {
+    window.scrollTo({
+        top: 0,
+        behavior: 'smooth',
+    });
+};
+
 const axiosInstance = (headers) => {
     return axios.create({
         baseURL: 'https://api.ventlio.com',
@@ -17,7 +26,7 @@ const buildFormData = (body) => {
         formData.append(key, body[key]);
     });
     body = formData;
-    return { body };
+    return body;
 };
 
 var HttpMethod;
@@ -55,25 +64,23 @@ const successTransformer = (data) => {
     };
 };
 
-async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, formData, }) {
-    // construct api full url
-    const apiFullUrl = `${API_BASE_URL}${path}`;
+async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, isFormData, }) {
     // configure body
-    body = formData ? buildFormData(body) : body;
+    body = isFormData ? buildFormData(body) : body;
     // configure request header
     const headers = {
         Authorization: `Bearer ${bearerToken}`,
     };
-    if (!formData) {
+    if (!isFormData) {
         headers['Content-Type'] = ContentType.APPLICATION_JSON;
     }
     try {
         const axios = axiosInstance(headers);
         //   send request
         const resp = await axios({
-            url: apiFullUrl,
+            url: path,
             method,
-            data: formData ? body : JSON.stringify(body),
+            data: body,
         });
         // get response json
         const jsonResp = await resp.data();
@@ -97,5 +104,207 @@ async function makeRequest({ body, method = HttpMethod.GET, path, bearerToken, f
     }
 }
 
-export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, successTransformer };
+const useDeleteRequest = () => {
+    const [requestPath, updateDeletePath] = useState('');
+    const [options, setOptions] = useState();
+    const authToken = '';
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
+        setTimeout(async () => {
+            const postResponse = await makeRequest({
+                path: requestPath,
+                bearerToken: authToken,
+                method: HttpMethod.DELETE,
+            });
+            if (postResponse.status) {
+                res(postResponse);
+            }
+            else {
+                rej(postResponse);
+            }
+        }, 200);
+    }), { ...options });
+    const updatedPathAsync = async (link) => {
+        return updateDeletePath(link);
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        return setOptions(fetchOptions);
+    };
+    const deleteR = async (link, fetchOptions) => {
+        await updatedPathAsync(link);
+        await setOptionsAsync(fetchOptions);
+        return query.refetch({
+            queryKey: [link, {}],
+        });
+    };
+    return { updateDeletePath, deleteR, ...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 sendRequest = async (res, rej) => {
+        const postResponse = await makeRequest({
+            path: requestPath,
+            bearerToken: authToken,
+        });
+        if (postResponse.status) {
+            res(postResponse);
+        }
+        else {
+            rej(postResponse);
+        }
+    };
+    const query = useQuery([requestPath, {}], () => new Promise((res, rej) => {
+        return sendRequest(res, rej);
+    }), {
+        enabled: load,
+        ...options,
+    });
+    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) {
+                updatePath(constructPaginationLink(requestPath, pagination.next_page));
+            }
+        }
+    };
+    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) {
+                updatePath(constructPaginationLink(requestPath, pagination.previous_page));
+            }
+        }
+    };
+    const constructPaginationLink = (link, pageNumber) => {
+        const oldLink = link;
+        if (link.includes('?')) {
+            if (link.includes('?page=')) {
+                // replace current page number with new number
+                link = link.replace(/\?page=(\d+)/gim, `?page=${pageNumber}`);
+            }
+            else if (link.includes('&page=')) {
+                link = link.replace(/&page=(\d+)/gim, `&page=${pageNumber}`);
+            }
+            else {
+                link = `${link}&page=${pageNumber}`;
+            }
+        }
+        else {
+            link = `${link}?page=${pageNumber}`;
+        }
+        // only update page when pagination is done
+        if (oldLink !== link) {
+            setPage(pageNumber);
+        }
+        return link;
+    };
+    const gotoPage = (pageNumber) => {
+        updatePath(constructPaginationLink(requestPath, pageNumber));
+    };
+    const updatedPathAsync = async (link) => {
+        startTransition(() => {
+            updatePath(link);
+        });
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        startTransition(() => {
+            setOptions(fetchOptions);
+        });
+    };
+    const get = async (link, fetchOptions) => {
+        await setOptionsAsync(fetchOptions);
+        await updatedPathAsync(link);
+        return query.data;
+    };
+    return {
+        ...query,
+        updatePath,
+        nextPage,
+        prevPage,
+        get,
+        gotoPage,
+        page,
+        queryKey: [requestPath, {}],
+    };
+};
+
+const usePatchRequest = ({ path, isFormData = false, }) => {
+    const authToken = '';
+    const [resetForm, setResetForm] = useState(false);
+    // register post mutation
+    const mutation = useMutation((postData) => new Promise((res, rej) => {
+        setResetForm(false);
+        makeRequest({
+            path: path,
+            body: postData,
+            method: HttpMethod.PATCH,
+            bearerToken: authToken,
+            isFormData,
+        }).then((postResponse) => {
+            if (postResponse.status) {
+                setResetForm(true);
+                // scroll to top after success
+                scrollToTop();
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                rej(postResponse);
+            }
+        });
+    }));
+    const patch = async (postData, options) => {
+        return mutation.mutateAsync(postData, options);
+    };
+    return { patch, ...mutation, resetForm };
+};
+
+const usePostRequest = ({ path, isFormData = false, }) => {
+    const authToken = '';
+    const [resetForm, setResetForm] = useState(false);
+    // 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,
+        }).then((postResponse) => {
+            if (postResponse.status) {
+                setResetForm(true);
+                // scroll to top after success
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                rej(postResponse);
+            }
+        });
+    }));
+    const post = async (postData, options) => {
+        return mutation.mutateAsync(postData, options);
+    };
+    return { post, ...mutation, resetForm };
+};
+
+export { API_BASE_URL, ContentType, HttpMethod, axiosInstance, buildFormData, errorTransformer, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useGetRequest, usePatchRequest, usePostRequest };
 //# 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/queries.interface.d.ts

@@ -1,3 +1,5 @@
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
 export interface IPagination {
     current_page: number;
     next_page: number;
@@ -6,3 +8,4 @@ export interface IPagination {
     size: number;
     total: number;
 }
+export type TanstackQueryOption<TResponse> = UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, Array<any>>;

package/dist/queries/useDeleteRequest.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import type { MutateOptions, QueryObserverResult } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
 export declare const useDeleteRequest: <TResponse>() => {

package/dist/queries/useDeleteRequest.js

@@ -0,0 +1,45 @@
+'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');
+
+const useDeleteRequest = () => {
+    const [requestPath, updateDeletePath] = react.useState('');
+    const [options, setOptions] = react.useState();
+    const authToken = '';
+    const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
+        setTimeout(async () => {
+            const postResponse = await makeRequest.makeRequest({
+                path: requestPath,
+                bearerToken: authToken,
+                method: request_enum.HttpMethod.DELETE,
+            });
+            if (postResponse.status) {
+                res(postResponse);
+            }
+            else {
+                rej(postResponse);
+            }
+        }, 200);
+    }), { ...options });
+    const updatedPathAsync = async (link) => {
+        return updateDeletePath(link);
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        return setOptions(fetchOptions);
+    };
+    const deleteR = async (link, fetchOptions) => {
+        await updatedPathAsync(link);
+        await setOptionsAsync(fetchOptions);
+        return query.refetch({
+            queryKey: [link, {}],
+        });
+    };
+    return { updateDeletePath, deleteR, ...query };
+};
+
+exports.useDeleteRequest = useDeleteRequest;
+//# sourceMappingURL=useDeleteRequest.js.map

package/dist/queries/useDeleteRequest.js.map

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

package/dist/queries/useGetRequest.d.ts

@@ -1,9 +1,11 @@
+/// <reference types="react" />
 import type { UseQueryOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
+import type { TanstackQueryOption } from './queries.interface';
 export declare const useGetRequest: <TResponse extends Record<string, any>>({ path, load, queryOptions, }: {
     path: string;
     load?: boolean | undefined;
-    queryOptions?: UseQueryOptions<IRequestSuccess<TResponse | undefined>, IRequestError, IRequestSuccess<TResponse | undefined>, any[]> | undefined;
+    queryOptions?: TanstackQueryOption<TResponse> | undefined;
 }) => {
     updatePath: import("react").Dispatch<import("react").SetStateAction<string>>;
     nextPage: () => void;

package/dist/queries/useGetRequest.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var react = require('react');
+require('axios');
+var makeRequest = require('../request/make-request.js');
+require('../request/request.enum.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 sendRequest = async (res, rej) => {
+        const postResponse = await makeRequest.makeRequest({
+            path: requestPath,
+            bearerToken: authToken,
+        });
+        if (postResponse.status) {
+            res(postResponse);
+        }
+        else {
+            rej(postResponse);
+        }
+    };
+    const query = reactQuery.useQuery([requestPath, {}], () => new Promise((res, rej) => {
+        return sendRequest(res, rej);
+    }), {
+        enabled: load,
+        ...options,
+    });
+    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) {
+                updatePath(constructPaginationLink(requestPath, pagination.next_page));
+            }
+        }
+    };
+    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) {
+                updatePath(constructPaginationLink(requestPath, pagination.previous_page));
+            }
+        }
+    };
+    const constructPaginationLink = (link, pageNumber) => {
+        const oldLink = link;
+        if (link.includes('?')) {
+            if (link.includes('?page=')) {
+                // replace current page number with new number
+                link = link.replace(/\?page=(\d+)/gim, `?page=${pageNumber}`);
+            }
+            else if (link.includes('&page=')) {
+                link = link.replace(/&page=(\d+)/gim, `&page=${pageNumber}`);
+            }
+            else {
+                link = `${link}&page=${pageNumber}`;
+            }
+        }
+        else {
+            link = `${link}?page=${pageNumber}`;
+        }
+        // only update page when pagination is done
+        if (oldLink !== link) {
+            setPage(pageNumber);
+        }
+        return link;
+    };
+    const gotoPage = (pageNumber) => {
+        updatePath(constructPaginationLink(requestPath, pageNumber));
+    };
+    const updatedPathAsync = async (link) => {
+        react.startTransition(() => {
+            updatePath(link);
+        });
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        react.startTransition(() => {
+            setOptions(fetchOptions);
+        });
+    };
+    const get = async (link, fetchOptions) => {
+        await setOptionsAsync(fetchOptions);
+        await updatedPathAsync(link);
+        return query.data;
+    };
+    return {
+        ...query,
+        updatePath,
+        nextPage,
+        prevPage,
+        get,
+        gotoPage,
+        page,
+        queryKey: [requestPath, {}],
+    };
+};
+
+exports.useGetRequest = useGetRequest;
+//# sourceMappingURL=useGetRequest.js.map

package/dist/queries/useGetRequest.js.map

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

package/dist/queries/usePatchRequest.d.ts

@@ -1,8 +1,8 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request/request.interface';
-export declare const usePatchRequest: <TResponse>({ path, formData, }: {
+export declare const usePatchRequest: <TResponse>({ path, isFormData, }: {
     path: string;
-    formData?: boolean | undefined;
+    isFormData?: boolean | undefined;
 }) => {
     resetForm: boolean;
     data: undefined;

package/dist/queries/usePatchRequest.js

@@ -0,0 +1,46 @@
+'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');
+
+const usePatchRequest = ({ path, isFormData = false, }) => {
+    const authToken = '';
+    const [resetForm, setResetForm] = react.useState(false);
+    // 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,
+        }).then((postResponse) => {
+            if (postResponse.status) {
+                setResetForm(true);
+                // scroll to top after success
+                scrollToTop.scrollToTop();
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                rej(postResponse);
+            }
+        });
+    }));
+    const patch = async (postData, options) => {
+        return mutation.mutateAsync(postData, options);
+    };
+    return { patch, ...mutation, resetForm };
+};
+
+exports.usePatchRequest = usePatchRequest;
+//# sourceMappingURL=usePatchRequest.js.map

package/dist/queries/usePatchRequest.js.map

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

package/dist/queries/usePostRequest.d.ts

@@ -1,8 +1,8 @@
 import type { MutateOptions } from '@tanstack/react-query';
 import type { IRequestError, IRequestSuccess } from '../request';
-export declare const usePostRequest: <TResponse>({ path, formData, }: {
+export declare const usePostRequest: <TResponse>({ path, isFormData, }: {
     path: string;
-    formData?: boolean | undefined;
+    isFormData?: boolean | undefined;
 }) => {
     resetForm: boolean;
     data: undefined;

package/dist/queries/usePostRequest.js

@@ -0,0 +1,48 @@
+'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');
+
+const usePostRequest = ({ path, isFormData = false, }) => {
+    const authToken = '';
+    const [resetForm, setResetForm] = react.useState(false);
+    // 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,
+        }).then((postResponse) => {
+            if (postResponse.status) {
+                setResetForm(true);
+                // scroll to top after success
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                window.scrollTo({
+                    top: 0,
+                    behavior: 'smooth',
+                });
+                rej(postResponse);
+            }
+        });
+    }));
+    const post = async (postData, options) => {
+        return mutation.mutateAsync(postData, options);
+    };
+    return { post, ...mutation, resetForm };
+};
+
+exports.usePostRequest = usePostRequest;
+//# sourceMappingURL=usePostRequest.js.map

package/dist/queries/usePostRequest.js.map

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

package/dist/request/buildFormData.d.ts

@@ -1,3 +1 @@
-export declare const buildFormData: (body: any) => {
-    body: any;
-};
+export declare const buildFormData: (body: Record<string, any>) => Record<string, any>;

package/dist/request/buildFormData.js

@@ -7,7 +7,7 @@ const buildFormData = (body) => {
         formData.append(key, body[key]);
     });
     body = formData;
-    return { body };
+    return body;
 };
 
 exports.buildFormData = buildFormData;

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, formData, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;
+export declare function makeRequest<TResponse>({ body, method, path, bearerToken, isFormData, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;

package/dist/request/make-request.js

@@ -1,30 +1,27 @@
 'use strict';
 
-var index = require('../constants/index.js');
 var axiosInstance = require('./axios-instance.js');
 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, formData, }) {
-    // construct api full url
-    const apiFullUrl = `${index.API_BASE_URL}${path}`;
+async function makeRequest({ body, method = request_enum.HttpMethod.GET, path, bearerToken, isFormData, }) {
     // configure body
-    body = formData ? buildFormData.buildFormData(body) : body;
+    body = isFormData ? buildFormData.buildFormData(body) : body;
     // configure request header
     const headers = {
         Authorization: `Bearer ${bearerToken}`,
     };
-    if (!formData) {
+    if (!isFormData) {
         headers['Content-Type'] = request_enum.ContentType.APPLICATION_JSON;
     }
     try {
         const axios = axiosInstance.axiosInstance(headers);
         //   send request
         const resp = await axios({
-            url: apiFullUrl,
+            url: path,
             method,
-            data: formData ? body : JSON.stringify(body),
+            data: body,
         });
         // get response json
         const jsonResp = await resp.data();

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,10 @@
 import type { HttpMethod } from './request.enum';
 export interface IMakeRequest {
     path: string;
-    body?: BodyInit | null;
+    body?: Record<string, any> | null;
     method?: HttpMethod;
     bearerToken?: string;
-    formData?: boolean;
+    isFormData?: boolean;
 }
 export interface AxiosInstanceOption {
     bearerToken?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ventlio/tanstack-query",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "license": "MIT",
   "main": "dist/index.js",
   "repository": {
@@ -14,13 +14,13 @@
     "url": "https://ventlio.com"
   },
   "scripts": {
-    "build": "rollup --config rollup.config.ts --configPlugin rollup-plugin-typescript2",
+    "build": "rimraf dist && rollup --config rollup.config.ts --configPlugin rollup-plugin-typescript2",
     "build:watch": "yarn build -w"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^4.26.1",
-    "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
     "axios": "^1.3.4",
+    "react": "^16.8.0 || ^17.0.0 || ^18.0.0",
     "react-native": "*"
   },
   "peerDependenciesMeta": {
@@ -55,6 +55,7 @@
     "eslint-plugin-react-hooks": "^4.6.0",
     "prettier": "^2.8.4",
     "react": "^18.2.0",
+    "rimraf": "^4.4.0",
     "rollup": "^3.19.1",
     "rollup-plugin-typescript2": "^0.34.1",
     "ts-node": "^10.9.1",

package/src/helpers/index.ts

@@ -1,6 +1 @@
-export const scrollToTop = () => {
-  window.scrollTo({
-    top: 0,
-    behavior: 'smooth',
-  });
-};
+export * from './scrollToTop';

package/src/helpers/scrollToTop.ts

@@ -0,0 +1,6 @@
+export const scrollToTop = () => {
+  window.scrollTo({
+    top: 0,
+    behavior: 'smooth',
+  });
+};

package/src/index.ts

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

package/src/queries/queries.interface.ts

@@ -1,3 +1,6 @@
+import type { UseQueryOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request';
+
 export interface IPagination {
   current_page: number;
   next_page: number;
@@ -6,3 +9,10 @@ export interface IPagination {
   size: number;
   total: number;
 }
+
+export type TanstackQueryOption<TResponse> = UseQueryOptions<
+  IRequestSuccess<TResponse | undefined>,
+  IRequestError,
+  IRequestSuccess<TResponse | undefined>,
+  Array<any>
+>;

package/src/queries/useGetRequest.ts

@@ -3,7 +3,7 @@ import { useQuery } from '@tanstack/react-query';
 import { startTransition, useState } from 'react';
 import type { IRequestError, IRequestSuccess } from '../request';
 import { makeRequest } from '../request';
-import type { IPagination } from './queries.interface';
+import type { IPagination, TanstackQueryOption } from './queries.interface';
 
 export const useGetRequest = <TResponse extends Record<string, any>>({
   path,
@@ -12,35 +12,38 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
 }: {
   path: string;
   load?: boolean;
-  queryOptions?: UseQueryOptions<
-    IRequestSuccess<TResponse | undefined>,
-    IRequestError,
-    IRequestSuccess<TResponse | undefined>,
-    Array<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 sendRequest = async (
+    res: (
+      value:
+        | IRequestError
+        | IRequestSuccess<TResponse>
+        | PromiseLike<IRequestError | IRequestSuccess<TResponse>>
+    ) => void,
+    rej: (reason?: any) => void
+  ) => {
+    const postResponse = await makeRequest<TResponse>({
+      path: requestPath,
+      bearerToken: authToken,
+    });
+    if (postResponse.status) {
+      res(postResponse as IRequestSuccess<TResponse>);
+    } else {
+      rej(postResponse);
+    }
+  };
+
   const query = useQuery<any, any, IRequestSuccess<TResponse>>(
     [requestPath, {}],
     () =>
       new Promise<IRequestSuccess<TResponse> | IRequestError>((res, rej) => {
-        // work on removing this setTimeout, it was added to delay for the requestPath to be updated successfully
-        // could have used hook for this but will miss the purpose
-        setTimeout(async () => {
-          const postResponse = await makeRequest<TResponse>({
-            path: requestPath,
-            bearerToken: authToken,
-          });
-          if (postResponse.status) {
-            res(postResponse as IRequestSuccess<TResponse>);
-          } else {
-            rej(postResponse);
-          }
-        }, 200);
+        return sendRequest(res, rej);
       }),
     {
       enabled: load,
@@ -60,6 +63,20 @@ 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)
+        );
+      }
+    }
+  };
+
   const constructPaginationLink = (link: string, pageNumber: number) => {
     const oldLink = link;
     if (link.includes('?')) {
@@ -82,20 +99,6 @@ export const useGetRequest = <TResponse extends Record<string, any>>({
     return link;
   };
 
-  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)
-        );
-      }
-    }
-  };
-
   const gotoPage = (pageNumber: number) => {
     updatePath(constructPaginationLink(requestPath, pageNumber));
   };

package/src/queries/usePatchRequest.ts

@@ -11,10 +11,10 @@ import type {
 
 export const usePatchRequest = <TResponse>({
   path,
-  formData = false,
+  isFormData = false,
 }: {
   path: string;
-  formData?: boolean;
+  isFormData?: boolean;
 }) => {
   const authToken = '';
   const [resetForm, setResetForm] = useState<boolean>(false);
@@ -30,7 +30,7 @@ export const usePatchRequest = <TResponse>({
           body: postData,
           method: HttpMethod.PATCH,
           bearerToken: authToken,
-          formData,
+          isFormData,
         }).then((postResponse) => {
           if (postResponse.status) {
             setResetForm(true);

package/src/queries/usePostRequest.ts

@@ -6,10 +6,10 @@ import { HttpMethod, makeRequest } from '../request';
 
 export const usePostRequest = <TResponse>({
   path,
-  formData = false,
+  isFormData = false,
 }: {
   path: string;
-  formData?: boolean;
+  isFormData?: boolean;
 }) => {
   const authToken = '';
 
@@ -25,7 +25,7 @@ export const usePostRequest = <TResponse>({
           body: postData,
           method: HttpMethod.POST,
           bearerToken: authToken,
-          formData,
+          isFormData,
         }).then((postResponse) => {
           if (postResponse.status) {
             setResetForm(true);

package/src/request/buildFormData.ts

@@ -1,11 +1,13 @@
-export const buildFormData = (body: any) => {
+export const buildFormData = (body: Record<string, any>) => {
   const formData = new FormData();
 
   const bodyKeys = Object.keys(body);
+
   bodyKeys.forEach((key) => {
     formData.append(key, body[key]);
   });
+
   body = formData;
 
-  return { body };
+  return body;
 };

package/src/request/make-request.ts

@@ -1,4 +1,4 @@
-import { API_BASE_URL } from '../constants';
+import type { RawAxiosRequestHeaders } from 'axios';
 import { axiosInstance } from './axios-instance';
 
 import { buildFormData } from './buildFormData';
@@ -11,20 +11,17 @@ export async function makeRequest<TResponse>({
   method = HttpMethod.GET,
   path,
   bearerToken,
-  formData,
+  isFormData,
 }: IMakeRequest) {
-  // construct api full url
-  const apiFullUrl = `${API_BASE_URL}${path}`;
-
   // configure body
-  body = formData ? (buildFormData(body) as any) : body;
+  body = isFormData ? buildFormData(body as Record<string, any>) : body;
 
   // configure request header
-  const headers: Record<string, any> = {
+  const headers: RawAxiosRequestHeaders = {
     Authorization: `Bearer ${bearerToken}`,
   };
 
-  if (!formData) {
+  if (!isFormData) {
     headers['Content-Type'] = ContentType.APPLICATION_JSON;
   }
 
@@ -33,9 +30,9 @@ export async function makeRequest<TResponse>({
 
     //   send request
     const resp = await axios({
-      url: apiFullUrl,
+      url: path,
       method,
-      data: formData ? body : JSON.stringify(body),
+      data: body,
     });
 
     // get response json

package/src/request/request.interface.ts

@@ -2,10 +2,10 @@ import type { HttpMethod } from './request.enum';
 
 export interface IMakeRequest {
   path: string;
-  body?: BodyInit | null;
+  body?: Record<string, any> | null;
   method?: HttpMethod;
   bearerToken?: string;
-  formData?: boolean;
+  isFormData?: boolean;
 }
 
 export interface AxiosInstanceOption {