@ventlio/tanstack-query 0.5.4 → 0.5.5

package/dist/queries/usePostRequest.js

@@ -12,84 +12,100 @@ import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
 
-const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const config = useQueryConfig();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const { isApp } = useReactNativeEnv();
-    const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
-    const sendRequest = async (res, rej, postData) => {
-        // get request headers
-        const { data, requestConfig } = postData;
-        delete requestConfig?.body;
-        const requestOptions = {
-            path,
-            body: data,
-            method: HttpMethod.POST,
-            isFormData,
-            headers: { ...globalHeaders, ...headers },
-            baseURL: baseUrl ?? API_URL,
-            timeout: TIMEOUT,
-            appFileConfig: {
-                isApp,
-                fileSelectors,
-            },
-            onUploadProgress,
-            ...requestConfig,
-        };
-        let shouldContinue = true;
-        if (config.options?.mutationMiddleware) {
-            shouldContinue = await config.options.mutationMiddleware({
-                mutationKey: [path, { type: 'mutation' }],
-                ...requestOptions,
-            });
-        }
-        if (shouldContinue) {
-            const postResponse = await makeRequest(requestOptions);
-            if (postResponse.status) {
-                // scroll to top after success
-                if (config.options?.context !== 'app') {
-                    scrollToTop();
-                }
-                res(postResponse);
-            }
-            else {
-                // scroll to top after error
-                if (config.options?.context !== 'app') {
-                    scrollToTop();
-                }
-                rej(postResponse);
-            }
-        }
-        else {
-            rej(null);
-        }
-    };
-    // register post mutation
-    const mutation = useMutation({
-        mutationKey: [path, { type: 'mutation' }],
-        mutationFn: async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)),
-    });
-    const post = async (data, options) => {
-        if (!isFutureMutationsPaused) {
-            const { requestConfig, ...otherOptions } = options ?? {};
-            return mutation.mutateAsync({ data, requestConfig }, otherOptions);
-        }
-        else {
-            setRequestPayload({ data, options });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureMutationsPaused && requestPayload) {
-            post(requestPayload.data, requestPayload.options);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureMutationsPaused]);
-    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
+const usePostRequest = ({ path, isFormData = false, baseUrl, headers, fileSelectors, }) => {
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const config = useQueryConfig();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const { isApp } = useReactNativeEnv();
+    const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
+    const sendRequest = async (res, rej, postData) => {
+        // get request headers
+        const { data, requestConfig } = postData;
+        delete requestConfig?.body;
+        const requestOptions = {
+            path,
+            body: data,
+            method: HttpMethod.POST,
+            isFormData,
+            headers: { ...globalHeaders, ...headers },
+            baseURL: baseUrl ?? API_URL,
+            timeout: TIMEOUT,
+            appFileConfig: {
+                isApp,
+                fileSelectors,
+            },
+            onUploadProgress,
+            ...requestConfig,
+        };
+        let shouldContinue = true;
+        if (config.options?.mutationMiddleware) {
+            shouldContinue = await config.options.mutationMiddleware({
+                mutationKey: [path, { type: 'mutation' }],
+                ...requestOptions,
+            });
+        }
+        if (shouldContinue) {
+            let postResponse;
+            if (config.options?.middleware) {
+                // perform global middleware
+                const middlewareResponse = await config.options.middleware(async () => await makeRequest(requestOptions), {
+                    path,
+                    baseUrl: baseUrl ?? API_URL,
+                    body: data,
+                });
+                if (!middlewareResponse) {
+                    rej();
+                    return;
+                }
+                postResponse = middlewareResponse;
+            }
+            else {
+                postResponse = await makeRequest(requestOptions);
+            }
+            if (postResponse.status) {
+                // scroll to top after success
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                res(postResponse);
+            }
+            else {
+                // scroll to top after error
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                rej(postResponse);
+            }
+        }
+        else {
+            rej(null);
+        }
+    };
+    // register post mutation
+    const mutation = useMutation({
+        mutationKey: [path, { type: 'mutation' }],
+        mutationFn: async (postData) => new Promise((res, rej) => sendRequest(res, rej, postData)),
+    });
+    const post = async (data, options) => {
+        if (!isFutureMutationsPaused) {
+            const { requestConfig, ...otherOptions } = options ?? {};
+            return mutation.mutateAsync({ data, requestConfig }, otherOptions);
+        }
+        else {
+            setRequestPayload({ data, options });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureMutationsPaused && requestPayload) {
+            post(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureMutationsPaused]);
+    return { post, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
 };
 
 export { 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/usePutRequest.d.ts

@@ -1,86 +1,86 @@
-import type { MutateOptions } from '@tanstack/react-query';
-import type { IRequestError, IRequestSuccess } from '../request/request.interface';
-import type { DefaultRequestOptions } from './queries.interface';
-export declare const usePutRequest: <TResponse>({ path, baseUrl, headers }: {
-    path: string;
-} & DefaultRequestOptions) => {
-    isLoading: boolean;
-    data: undefined;
-    variables: undefined;
-    error: null;
-    isError: false;
-    isIdle: true;
-    isPending: false;
-    isSuccess: false;
-    status: "idle";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: undefined;
-    variables: void;
-    error: null;
-    isError: false;
-    isIdle: false;
-    isPending: true;
-    isSuccess: false;
-    status: "pending";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: undefined;
-    error: IRequestError;
-    variables: void;
-    isError: true;
-    isIdle: false;
-    isPending: false;
-    isSuccess: false;
-    status: "error";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: IRequestSuccess<TResponse>;
-    error: null;
-    variables: void;
-    isError: false;
-    isIdle: false;
-    isPending: false;
-    isSuccess: true;
-    status: "success";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    reset: () => void;
-    context: unknown;
-    failureCount: number;
-    failureReason: IRequestError | null;
-    isPaused: boolean;
-    submittedAt: number;
-    mutateAsync: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
-    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-};
+import type { MutateOptions } from '@tanstack/react-query';
+import type { IRequestError, IRequestSuccess } from '../request/request.interface';
+import type { DefaultRequestOptions } from './queries.interface';
+export declare const usePutRequest: <TResponse>({ path, baseUrl, headers }: {
+    path: string;
+} & DefaultRequestOptions) => {
+    isLoading: boolean;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    variables: void;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: IRequestError;
+    variables: void;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    variables: void;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, void, unknown>;
+    put: (data: any, options?: MutateOptions<IRequestSuccess<TResponse>, IRequestError, void, unknown> | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+};

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;
+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,11 +1,11 @@
 import axios from 'axios';
 
-const axiosInstance = ({ baseURL, timeout, headers }) => {
-    return axios.create({
-        baseURL,
-        timeout,
-        headers,
-    });
+const axiosInstance = ({ baseURL, timeout, headers }) => {
+    return axios.create({
+        baseURL,
+        timeout,
+        headers,
+    });
 };
 
 export { axiosInstance };

package/dist/request/buildFormData.d.ts

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

package/dist/request/buildFormData.js

@@ -1,43 +1,43 @@
-const buildFormData = (body) => {
-    const formData = new FormData();
-    const handleArrayValue = (key, value) => {
-        for (const item of value) {
-            if (item instanceof File) {
-                formData.append(key, item);
-            }
-            else if (item instanceof Object) {
-                formData.append(key, JSON.stringify(item));
-            }
-            else {
-                formData.append(key, item);
-            }
-        }
-    };
-    const handleObjectValue = (key, value) => {
-        if (value instanceof File) {
-            formData.append(key, value);
-        }
-        else {
-            formData.append(key, JSON.stringify(value));
-        }
-    };
-    const handlePrimitiveValue = (key, value) => {
-        formData.append(key, value);
-    };
-    const bodyKeys = Object.keys(body);
-    bodyKeys.forEach((key) => {
-        const inputValue = body[key];
-        if (Array.isArray(inputValue) && inputValue.length > 0) {
-            handleArrayValue(key, inputValue);
-        }
-        else if (inputValue instanceof Object) {
-            handleObjectValue(key, inputValue);
-        }
-        else {
-            handlePrimitiveValue(key, inputValue);
-        }
-    });
-    return formData;
+const buildFormData = (body) => {
+    const formData = new FormData();
+    const handleArrayValue = (key, value) => {
+        for (const item of value) {
+            if (item instanceof File) {
+                formData.append(key, item);
+            }
+            else if (item instanceof Object) {
+                formData.append(key, JSON.stringify(item));
+            }
+            else {
+                formData.append(key, item);
+            }
+        }
+    };
+    const handleObjectValue = (key, value) => {
+        if (value instanceof File) {
+            formData.append(key, value);
+        }
+        else {
+            formData.append(key, JSON.stringify(value));
+        }
+    };
+    const handlePrimitiveValue = (key, value) => {
+        formData.append(key, value);
+    };
+    const bodyKeys = Object.keys(body);
+    bodyKeys.forEach((key) => {
+        const inputValue = body[key];
+        if (Array.isArray(inputValue) && inputValue.length > 0) {
+            handleArrayValue(key, inputValue);
+        }
+        else if (inputValue instanceof Object) {
+            handleObjectValue(key, inputValue);
+        }
+        else {
+            handlePrimitiveValue(key, inputValue);
+        }
+    });
+    return formData;
 };
 
 export { buildFormData };

package/dist/request/index.d.ts

@@ -1,6 +1,6 @@
-export * from './axios-instance';
-export * from './buildFormData';
-export * from './make-request';
-export * from './request.enum';
-export * from './request.interface';
-export * from './transformer';
+export * from './axios-instance';
+export * from './buildFormData';
+export * from './make-request';
+export * from './request.enum';
+export * from './request.interface';
+export * from './transformer';

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, isFormData, headers, baseURL, timeout, appFileConfig, onUploadProgress, }: IMakeRequest): Promise<import("./request.interface").IRequestError>;
+import type { IMakeRequest, IRequestError, IRequestSuccess } from './request.interface';
+export declare function makeRequest<TResponse>({ body, method, path, isFormData, headers, baseURL, timeout, appFileConfig, onUploadProgress, }: IMakeRequest): Promise<IRequestSuccess<TResponse> | IRequestError>;