@ventlio/tanstack-query 0.5.4 → 0.5.5

package/dist/queries/usePatchRequest.js

@@ -11,76 +11,92 @@ import 'axios';
 import { makeRequest } from '../request/make-request.js';
 import { HttpMethod } from '../request/request.enum.js';
 
-const usePatchRequest = ({ path, baseUrl, headers }) => {
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
-    const config = useQueryConfig();
-    const sendRequest = async (res, rej, data) => {
-        // get request headers
-        const requestOptions = {
-            path: path,
-            body: data,
-            method: HttpMethod.PATCH,
-            headers: { ...globalHeaders, ...headers },
-            baseURL: baseUrl ?? API_URL,
-            timeout: TIMEOUT,
-            onUploadProgress,
-        };
-        let shouldContinue = true;
-        if (config.options?.mutationMiddleware) {
-            shouldContinue = await config.options.mutationMiddleware({
-                mutationKey: [path, { type: 'mutation' }],
-                ...requestOptions,
-            });
-        }
-        if (shouldContinue) {
-            const patchResponse = await makeRequest(requestOptions);
-            if (patchResponse.status) {
-                // scroll to top after success
-                if (config.options?.context !== 'app') {
-                    scrollToTop();
-                }
-                res(patchResponse);
-            }
-            else {
-                // scroll to top after error
-                if (config.options?.context !== 'app') {
-                    scrollToTop();
-                }
-                rej(patchResponse);
-            }
-        }
-        else {
-            rej(null);
-        }
-    };
-    // register post mutation
-    const mutation = useMutation({
-        mutationKey: [path, { type: 'mutation' }],
-        mutationFn: (dataData) => new Promise((res, rej) => {
-            return sendRequest(res, rej, dataData);
-        }),
-    });
-    const patch = async (data, options) => {
-        if (!isFutureMutationsPaused) {
-            return mutation.mutateAsync(data, options);
-        }
-        else {
-            setRequestPayload({ data, options });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureMutationsPaused && requestPayload) {
-            patch(requestPayload.data, requestPayload.options);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureMutationsPaused]);
-    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
+const usePatchRequest = ({ path, baseUrl, headers }) => {
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const { uploadProgressPercent, onUploadProgress } = useUploadProgress();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureMutationsPaused = usePauseFutureRequests((state) => state.isFutureMutationsPaused);
+    const config = useQueryConfig();
+    const sendRequest = async (res, rej, data) => {
+        // get request headers
+        const requestOptions = {
+            path: path,
+            body: data,
+            method: HttpMethod.PATCH,
+            headers: { ...globalHeaders, ...headers },
+            baseURL: baseUrl ?? API_URL,
+            timeout: TIMEOUT,
+            onUploadProgress,
+        };
+        let shouldContinue = true;
+        if (config.options?.mutationMiddleware) {
+            shouldContinue = await config.options.mutationMiddleware({
+                mutationKey: [path, { type: 'mutation' }],
+                ...requestOptions,
+            });
+        }
+        if (shouldContinue) {
+            let patchResponse;
+            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;
+                }
+                patchResponse = middlewareResponse;
+            }
+            else {
+                patchResponse = await makeRequest(requestOptions);
+            }
+            if (patchResponse.status) {
+                // scroll to top after success
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                res(patchResponse);
+            }
+            else {
+                // scroll to top after error
+                if (config.options?.context !== 'app') {
+                    scrollToTop();
+                }
+                rej(patchResponse);
+            }
+        }
+        else {
+            rej(null);
+        }
+    };
+    // register post mutation
+    const mutation = useMutation({
+        mutationKey: [path, { type: 'mutation' }],
+        mutationFn: (dataData) => new Promise((res, rej) => {
+            return sendRequest(res, rej, dataData);
+        }),
+    });
+    const patch = async (data, options) => {
+        if (!isFutureMutationsPaused) {
+            return mutation.mutateAsync(data, options);
+        }
+        else {
+            setRequestPayload({ data, options });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureMutationsPaused && requestPayload) {
+            patch(requestPayload.data, requestPayload.options);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureMutationsPaused]);
+    return { patch, uploadProgressPercent, ...mutation, isLoading: mutation.isPending || isFutureMutationsPaused };
 };
 
 export { 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

@@ -1,157 +1,149 @@
-import type { MutateOptions } from '@tanstack/react-query';
-import type { IMakeRequest, IRequestError, IRequestSuccess } from '../request';
-import type { DefaultRequestOptions } from './queries.interface';
-export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, headers, fileSelectors, }: {
-    path: string;
-    isFormData?: boolean | undefined;
-    fileSelectors?: string[] | undefined;
-} & 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, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, 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, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown>;
-    post: <T>(data?: T | undefined, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
-        data: T;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown> & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | ({
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: undefined;
-    variables: {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    };
-    error: null;
-    isError: false;
-    isIdle: false;
-    isPending: true;
-    isSuccess: false;
-    status: "pending";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, 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, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown>;
-    post: <T>(data?: T | undefined, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
-        data: T;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown> & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | ({
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: undefined;
-    error: IRequestError;
-    variables: {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    };
-    isError: true;
-    isIdle: false;
-    isPending: false;
-    isSuccess: false;
-    status: "error";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, 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, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown>;
-    post: <T>(data?: T | undefined, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
-        data: T;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown> & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | ({
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-} | {
-    isLoading: boolean;
-    data: IRequestSuccess<TResponse>;
-    error: null;
-    variables: {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    };
-    isError: false;
-    isIdle: false;
-    isPending: false;
-    isSuccess: true;
-    status: "success";
-    mutate: import("@tanstack/react-query/build/legacy/types").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, 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, {
-        data: any;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown>;
-    post: <T>(data?: T | undefined, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
-        data: T;
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }, unknown> & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | ({
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    } & {
-        requestConfig?: Partial<Omit<IMakeRequest, "body">> | undefined;
-    }) | undefined) => Promise<IRequestSuccess<TResponse> | undefined>;
-    uploadProgressPercent: number;
-};
+import type { MutateOptions } from '@tanstack/react-query';
+import type { IMakeRequest, IRequestError, IRequestSuccess } from '../request';
+import type { DefaultRequestOptions } from './queries.interface';
+export declare const usePostRequest: <TResponse>({ path, isFormData, baseUrl, headers, fileSelectors, }: {
+    path: string;
+    isFormData?: boolean;
+    fileSelectors?: 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, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    post: <T>(data?: T, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
+        data: T;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown> | {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    } | undefined) & {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    };
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    post: <T>(data?: T, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
+        data: T;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown> | {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    } | undefined) & {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: undefined;
+    error: IRequestError;
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    };
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    post: <T>(data?: T, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
+        data: T;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown> | {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    } | undefined) & {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+} | {
+    isLoading: boolean;
+    data: IRequestSuccess<TResponse>;
+    error: null;
+    variables: {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    };
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: import("@tanstack/react-query").UseMutateFunction<IRequestSuccess<TResponse>, IRequestError, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: IRequestError | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: import("@tanstack/react-query").UseMutateAsyncFunction<IRequestSuccess<TResponse>, IRequestError, {
+        data: any;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown>;
+    post: <T>(data?: T, options?: (MutateOptions<IRequestSuccess<TResponse>, IRequestError, {
+        data: T;
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }, unknown> | {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    } | undefined) & {
+        requestConfig?: Partial<Omit<IMakeRequest, "body">>;
+    }) => Promise<IRequestSuccess<TResponse> | undefined>;
+    uploadProgressPercent: number;
+};