@ventlio/tanstack-query 0.5.4 → 0.5.5

package/dist/index.mjs

@@ -6,880 +6,957 @@ import result from 'lodash.result';
 import lodashSet from 'lodash.set';
 import axios from 'axios';
 
-const bootstrapQueryRequest = (queryClient, options) => {
-    // make query config doesn't expire
-    // set default query config
-    const defaultMeta = {
-        headers: {
-            Authorization: ``,
-        },
-        options,
-    };
-    queryClient.setDefaultOptions({
-        queries: {
-            meta: defaultMeta,
-        },
-        mutations: { meta: defaultMeta },
-    });
+const bootstrapQueryRequest = (queryClient, options) => {
+    // make query config doesn't expire
+    // set default query config
+    const defaultMeta = {
+        headers: {
+            Authorization: ``,
+        },
+        options,
+    };
+    queryClient.setDefaultOptions({
+        queries: {
+            meta: defaultMeta,
+        },
+        mutations: { meta: defaultMeta },
+    });
 };
 
-const useQueryConfig = () => {
-    const queryClient = useQueryClient();
-    const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {});
-    const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {});
-    return { ...queryMeta, ...mutationMeta };
+const useQueryConfig = () => {
+    const queryClient = useQueryClient();
+    const mutationMeta = (queryClient.getDefaultOptions().mutations?.meta ?? {});
+    const queryMeta = (queryClient.getDefaultOptions().queries?.meta ?? {});
+    return { ...queryMeta, ...mutationMeta };
 };
 
-const useReactNativeEnv = () => {
-    const config = useQueryConfig();
-    const appUrl = config.options?.environments?.appBaseUrl;
-    const appTimeout = config.options?.environments?.appTimeout;
-    const isApp = config.options?.context === 'app';
-    return { appUrl, appTimeout, isApp };
+const useReactNativeEnv = () => {
+    const config = useQueryConfig();
+    const appUrl = config.options?.environments?.appBaseUrl;
+    const appTimeout = config.options?.environments?.appTimeout;
+    const isApp = config.options?.context === 'app';
+    return { appUrl, appTimeout, isApp };
 };
 
-const useEnvironmentVariables = () => {
-    const { appTimeout, appUrl } = useReactNativeEnv();
-    const url = process.env.REACT_APP_API_URL ?? process.env.NEXT_PUBLIC_API_URL ?? appUrl;
-    const timeout = process.env.REACT_APP_API_TIMEOUT ?? process.env.NEXT_PUBLIC_API_TIMEOUT ?? appTimeout;
-    return {
-        API_URL: url,
-        TIMEOUT: Number(timeout),
-    };
+const useEnvironmentVariables = () => {
+    const { appTimeout, appUrl } = useReactNativeEnv();
+    const url = process.env.REACT_APP_API_URL ?? process.env.NEXT_PUBLIC_API_URL ?? appUrl;
+    const timeout = process.env.REACT_APP_API_TIMEOUT ?? process.env.NEXT_PUBLIC_API_TIMEOUT ?? appTimeout;
+    return {
+        API_URL: url,
+        TIMEOUT: Number(timeout),
+    };
 };
 
-const useHeaderStore = create((set) => ({
-    headers: undefined,
-    setHeader(headers) {
-        set({ headers });
-    },
+const useHeaderStore = create((set) => ({
+    headers: undefined,
+    setHeader(headers) {
+        set({ headers });
+    },
 }));
 
-const usePauseFutureRequests = create((set) => {
-    const pauseFutureQueries = (status) => {
-        return set({ isFutureQueriesPaused: status });
-    };
-    const pauseFutureMutation = (status) => {
-        return set({ isFutureQueriesPaused: status });
-    };
-    return {
-        isFutureMutationsPaused: false,
-        isFutureQueriesPaused: false,
-        pauseFutureQueries,
-        pauseFutureMutation,
-    };
+const usePauseFutureRequests = create((set) => {
+    const pauseFutureQueries = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    const pauseFutureMutation = (status) => {
+        return set({ isFutureQueriesPaused: status });
+    };
+    return {
+        isFutureMutationsPaused: false,
+        isFutureQueriesPaused: false,
+        pauseFutureQueries,
+        pauseFutureMutation,
+    };
 });
 
-const useQueryHeaders = () => {
-    const { headers, setHeader } = useHeaderStore();
-    const getHeaders = () => {
-        return headers;
-    };
-    const setQueryHeaders = (newHeaders) => {
-        setHeader(newHeaders);
-    };
-    return { setQueryHeaders, getHeaders };
+const useQueryHeaders = () => {
+    const { headers, setHeader } = useHeaderStore();
+    const getHeaders = () => {
+        return headers;
+    };
+    const setQueryHeaders = (newHeaders) => {
+        setHeader(newHeaders);
+    };
+    return { setQueryHeaders, getHeaders };
 };
 
-const scrollToTop = () => {
-    window.scrollTo({
-        top: 0,
-        behavior: 'smooth',
-    });
+const scrollToTop = () => {
+    window.scrollTo({
+        top: 0,
+        behavior: 'smooth',
+    });
 };
 
-function getDateInFuture(days) {
-    // Create a new Date object
-    const date = new Date();
-    // Add the specified number of days to the date
-    date.setDate(date.getDate() + days);
-    // Get the Unix timestamp of the date (in milliseconds)
-    return date.getTime();
+function getDateInFuture(days) {
+    // Create a new Date object
+    const date = new Date();
+    // Add the specified number of days to the date
+    date.setDate(date.getDate() + days);
+    // Get the Unix timestamp of the date (in milliseconds)
+    return date.getTime();
 }
 
-const useUploadProgress = () => {
-    const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
-    const onUploadProgress = (progressEvent) => {
-        const { loaded, total } = progressEvent;
-        const percentage = Math.round((loaded / total) * 100);
-        setUploadProgressPercent(percentage);
-    };
-    return { onUploadProgress, uploadProgressPercent };
+const useUploadProgress = () => {
+    const [uploadProgressPercent, setUploadProgressPercent] = useState(0);
+    const onUploadProgress = (progressEvent) => {
+        const { loaded, total } = progressEvent;
+        const percentage = Math.round((loaded / total) * 100);
+        setUploadProgressPercent(percentage);
+    };
+    return { onUploadProgress, uploadProgressPercent };
 };
 
-const useKeyTrackerModel = (keyTracker) => {
-    const queryClient = useQueryClient();
-    const getQueryKey = (innerKeyTracker) => {
-        const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
-        return queryKey;
-    };
-    const refetchQuery = async (innerKeyTracker) => {
-        const queryKey = getQueryKey(innerKeyTracker ?? keyTracker);
-        await queryClient.refetchQueries({
-            queryKey,
-            exact: true,
-        });
-    };
-    return { refetchQuery, getQueryKey };
+const useKeyTrackerModel = (keyTracker) => {
+    const queryClient = useQueryClient();
+    const getQueryKey = (innerKeyTracker) => {
+        const queryKey = queryClient.getQueryData([innerKeyTracker ?? keyTracker]);
+        return queryKey;
+    };
+    const refetchQuery = async (innerKeyTracker) => {
+        const queryKey = getQueryKey(innerKeyTracker ?? keyTracker);
+        await queryClient.refetchQueries({
+            queryKey,
+            exact: true,
+        });
+    };
+    return { refetchQuery, getQueryKey };
 };
 
-const useQueryModel = (keyTracker) => {
-    const queryClient = useQueryClient();
-    const { getQueryKey } = useKeyTrackerModel(keyTracker);
-    const queryKey = getQueryKey();
-    const config = useQueryConfig();
-    const add = (data, position, path) => {
-        let records = (findAll(path) ?? []);
-        if (!position || position === 'end') {
-            records = [...records, data];
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        }
-        else if (position === 'start') {
-            records = [data, ...records];
-        }
-        if (!path) {
-            queryClient.setQueryData(queryKey, records);
-        }
-        else {
-            const queryData = queryClient.getQueryData(queryKey) ?? {};
-            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
-        }
-        return data;
-    };
-    const findAll = (path) => {
-        const data = queryClient.getQueryData(queryKey);
-        if (!data) {
-            return [];
-        }
-        if (!path) {
-            return Array.isArray(data) ? data : [data];
-        }
-        return result(data, path, []);
-    };
-    const findMany = (selector, path) => {
-        const data = (findAll(path) ?? []);
-        return data.filter(selector);
-    };
-    const find = (id, path) => {
-        const modelConfig = getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return undefined;
-        }
-        const data = (findAll(path) ?? []);
-        return data.find((record) => record[modelConfig.idColumn] === id);
-    };
-    const get = (path) => {
-        let data = queryClient.getQueryData(queryKey);
-        if (path) {
-            data = result(data, path);
-        }
-        return data;
-    };
-    const set = (newData, path) => {
-        if (path) {
-            const data = get();
-            newData = lodashSet(data, path, newData);
-        }
-        return queryClient.setQueryData(queryKey, () => newData);
-    };
-    const getModelConfig = () => {
-        const { options } = config;
-        const { modelConfig } = options ?? {};
-        return modelConfig;
-    };
-    const update = (id, data, path) => {
-        const oldData = (findAll(path) ?? []);
-        const modelConfig = getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return undefined;
-        }
-        const idColumn = modelConfig.idColumn;
-        let updatedRecord = undefined;
-        const newData = oldData.map((record) => {
-            let dataRecord = record;
-            if (dataRecord[idColumn] === id) {
-                dataRecord = { ...dataRecord, ...data };
-                updatedRecord = dataRecord;
-            }
-            return dataRecord;
-        });
-        if (!path) {
-            queryClient.setQueryData(queryKey, newData);
-        }
-        else {
-            const queryData = queryClient.getQueryData(queryKey) ?? {};
-            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
-        }
-        return updatedRecord;
-    };
-    const remove = (id, path) => {
-        const oldData = (findAll(path) ?? []);
-        const modelConfig = getModelConfig();
-        if (!modelConfig?.idColumn) {
-            return false;
-        }
-        const idColumn = modelConfig.idColumn;
-        let updated = false;
-        const newData = oldData.filter((record) => {
-            const dataRecord = record;
-            if (dataRecord[idColumn] === id) {
-                updated = true;
-                return false;
-            }
-            return true;
-        });
-        if (!path) {
-            queryClient.setQueryData(queryKey, newData);
-        }
-        else {
-            const queryData = queryClient.getQueryData(queryKey) ?? {};
-            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
-        }
-        return updated;
-    };
-    return { find, findAll, findMany, remove, update, add, get, set };
+const useQueryModel = (keyTracker) => {
+    const queryClient = useQueryClient();
+    const { getQueryKey } = useKeyTrackerModel(keyTracker);
+    const queryKey = getQueryKey();
+    const config = useQueryConfig();
+    const add = (data, position, path) => {
+        let records = (findAll(path) ?? []);
+        if (!position || position === 'end') {
+            records = [...records, data];
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        }
+        else if (position === 'start') {
+            records = [data, ...records];
+        }
+        if (!path) {
+            queryClient.setQueryData(queryKey, records);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, records));
+        }
+        return data;
+    };
+    const findAll = (path) => {
+        const data = queryClient.getQueryData(queryKey);
+        if (!data) {
+            return [];
+        }
+        if (!path) {
+            return Array.isArray(data) ? data : [data];
+        }
+        return result(data, path, []);
+    };
+    const findMany = (selector, path) => {
+        const data = (findAll(path) ?? []);
+        return data.filter(selector);
+    };
+    const find = (id, path) => {
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const data = (findAll(path) ?? []);
+        return data.find((record) => record[modelConfig.idColumn] === id);
+    };
+    const get = (path) => {
+        let data = queryClient.getQueryData(queryKey);
+        if (path) {
+            data = result(data, path);
+        }
+        return data;
+    };
+    const set = (newData, path) => {
+        if (path) {
+            const data = get();
+            newData = lodashSet(data, path, newData);
+        }
+        return queryClient.setQueryData(queryKey, () => newData);
+    };
+    const getModelConfig = () => {
+        const { options } = config;
+        const { modelConfig } = options ?? {};
+        return modelConfig;
+    };
+    const update = (id, data, path) => {
+        const oldData = (findAll(path) ?? []);
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return undefined;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updatedRecord = undefined;
+        const newData = oldData.map((record) => {
+            let dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                dataRecord = { ...dataRecord, ...data };
+                updatedRecord = dataRecord;
+            }
+            return dataRecord;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
+        }
+        return updatedRecord;
+    };
+    const remove = (id, path) => {
+        const oldData = (findAll(path) ?? []);
+        const modelConfig = getModelConfig();
+        if (!modelConfig?.idColumn) {
+            return false;
+        }
+        const idColumn = modelConfig.idColumn;
+        let updated = false;
+        const newData = oldData.filter((record) => {
+            const dataRecord = record;
+            if (dataRecord[idColumn] === id) {
+                updated = true;
+                return false;
+            }
+            return true;
+        });
+        if (!path) {
+            queryClient.setQueryData(queryKey, newData);
+        }
+        else {
+            const queryData = queryClient.getQueryData(queryKey) ?? {};
+            queryClient.setQueryData(queryKey, lodashSet(queryData, path, newData));
+        }
+        return updated;
+    };
+    return { find, findAll, findMany, remove, update, add, get, set };
 };
 
-const useRefetchQuery = async (queryKey) => {
-    const queryClient = useQueryClient();
-    const refetchQuery = async (innerQueryKey) => {
-        await queryClient.invalidateQueries({
-            queryKey: innerQueryKey ?? queryKey,
-            exact: true,
-        }, { throwOnError: true, cancelRefetch: true });
-        return queryClient.getQueriesData({ queryKey: innerQueryKey ?? queryKey });
-    };
-    return { refetchQuery };
+const useRefetchQuery = async (queryKey) => {
+    const queryClient = useQueryClient();
+    const refetchQuery = async (innerQueryKey) => {
+        await queryClient.invalidateQueries({
+            queryKey: innerQueryKey ?? queryKey,
+            exact: true,
+        }, { throwOnError: true, cancelRefetch: true });
+        return queryClient.getQueriesData({ queryKey: innerQueryKey ?? queryKey });
+    };
+    return { refetchQuery };
 };
 
-const axiosInstance = ({ baseURL, timeout, headers }) => {
-    return axios.create({
-        baseURL,
-        timeout,
-        headers,
-    });
+const axiosInstance = ({ baseURL, timeout, headers }) => {
+    return axios.create({
+        baseURL,
+        timeout,
+        headers,
+    });
 };
 
-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;
 };
 
-var HttpMethod;
-(function (HttpMethod) {
-    HttpMethod["GET"] = "GET";
-    HttpMethod["POST"] = "POST";
-    HttpMethod["PUT"] = "PUT";
-    HttpMethod["PATCH"] = "PATCH";
-    HttpMethod["DELETE"] = "DELETE";
-})(HttpMethod || (HttpMethod = {}));
-var ContentType;
-(function (ContentType) {
-    ContentType["APPLICATION_JSON"] = "application/json";
-    ContentType["MULTIPART_FORM_DATA"] = "multipart/form-data";
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "GET";
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["DELETE"] = "DELETE";
+})(HttpMethod || (HttpMethod = {}));
+var ContentType;
+(function (ContentType) {
+    ContentType["APPLICATION_JSON"] = "application/json";
+    ContentType["MULTIPART_FORM_DATA"] = "multipart/form-data";
 })(ContentType || (ContentType = {}));
 
-//
-const errorTransformer = (data) => {
-    return {
-        timeStamp: new Date(),
-        status: false,
-        data: data.data,
-        ...data,
-    };
-};
-//
-const successTransformer = (data) => {
-    return {
-        message: data.message ?? 'Request successful',
-        statusCode: data.statusCode,
-        timeStamp: new Date(),
-        status: true,
-        data: data.data,
-    };
+//
+const errorTransformer = (data) => {
+    return {
+        timeStamp: new Date(),
+        data: data.data,
+        ...data,
+        status: false,
+    };
+};
+//
+const successTransformer = (data) => {
+    return {
+        message: data.message ?? 'Request successful',
+        statusCode: data.statusCode,
+        timeStamp: new Date(),
+        status: true,
+        data: data.data,
+    };
 };
 
-async function makeRequest({ body = {}, method = HttpMethod.GET, path, isFormData, headers = {}, baseURL, timeout, appFileConfig, onUploadProgress, }) {
-    // check if file is included in mobile app environment and extract all file input to avoid
-    // it being formatted to object using axios formData builder
-    const isApp = appFileConfig?.isApp;
-    const appFiles = isApp ? getAppFiles(body, appFileConfig.fileSelectors) : {};
-    // configure body
-    body = (isFormData ? axios.toFormData(body) : body);
-    // configure request header1
-    configureRequestHeader(isFormData, headers, isApp, appFiles, body);
-    try {
-        const axiosRequest = axiosInstance({ baseURL, headers, timeout });
-        const axiosRequestConfig = {
-            url: path,
-            method,
-            onUploadProgress,
-        };
-        if (Object.keys(body).length > 0 || (isFormData && !isApp && [...body.keys()].length > 0)) {
-            axiosRequestConfig.data = body;
-        }
-        //   send request
-        const resp = await axiosRequest(axiosRequestConfig);
-        // get response json
-        const jsonResp = await resp.data;
-        // get response code
-        const responseCode = resp.status;
-        if (responseCode > 299) {
-            // server returned an error
-            return errorTransformer({ ...jsonResp, statusCode: responseCode });
-        }
-        return successTransformer({
-            statusCode: responseCode,
-            ...jsonResp,
-            status: resp.status,
-        });
-    }
-    catch (error) {
-        const errorData = error?.response?.data;
-        return errorTransformer({
-            statusCode: error.status,
-            message: error.message,
-            code: error.status || error.statusCode,
-            ...errorData,
-        });
-    }
-}
-const configureRequestHeader = (isFormData, headers, isApp, appFiles, body) => {
-    if (!isFormData) {
-        headers['Content-Type'] = ContentType.APPLICATION_JSON;
-    }
-    else if (isApp) {
-        headers['Content-Type'] = ContentType.MULTIPART_FORM_DATA;
-        // add the app files
-        for (const fileKey in appFiles) {
-            const currentFile = appFiles[fileKey];
-            if (Array.isArray(currentFile)) {
-                for (const innerFile of currentFile) {
-                    body.append(fileKey, innerFile);
-                }
-            }
-            else {
-                body.append(fileKey, currentFile);
-            }
-        }
-    }
-    else {
-        delete headers['Content-Type'];
-    }
-};
-function getAppFiles(body, fileSelectors = []) {
-    const files = {};
-    if (body) {
-        if (fileSelectors.length > 0) {
-            //
-            for (const fileKey of fileSelectors) {
-                files[fileKey] = body[fileKey];
-                delete body[fileKey];
-            }
-        }
-    }
-    return files;
+async function makeRequest({ body = {}, method = HttpMethod.GET, path, isFormData, headers = {}, baseURL, timeout, appFileConfig, onUploadProgress, }) {
+    // check if file is included in mobile app environment and extract all file input to avoid
+    // it being formatted to object using axios formData builder
+    const isApp = appFileConfig?.isApp;
+    const appFiles = isApp ? getAppFiles(body, appFileConfig.fileSelectors) : {};
+    // configure body
+    body = (isFormData ? axios.toFormData(body) : body);
+    // configure request header1
+    configureRequestHeader(isFormData, headers, isApp, appFiles, body);
+    try {
+        const axiosRequest = axiosInstance({ baseURL, headers, timeout });
+        const axiosRequestConfig = {
+            url: path,
+            method,
+            onUploadProgress,
+        };
+        if (Object.keys(body).length > 0 || (isFormData && !isApp && [...body.keys()].length > 0)) {
+            axiosRequestConfig.data = body;
+        }
+        //   send request
+        const resp = await axiosRequest(axiosRequestConfig);
+        // get response json
+        const jsonResp = await resp.data;
+        // get response code
+        const responseCode = resp.status;
+        if (responseCode > 299) {
+            // server returned an error
+            return errorTransformer({ ...jsonResp, statusCode: responseCode });
+        }
+        return successTransformer({
+            statusCode: responseCode,
+            ...jsonResp,
+            status: resp.status,
+        });
+    }
+    catch (error) {
+        const errorData = error?.response?.data;
+        return errorTransformer({
+            statusCode: error.status,
+            message: error.message,
+            code: error.status || error.statusCode,
+            ...errorData,
+        });
+    }
+}
+const configureRequestHeader = (isFormData, headers, isApp, appFiles, body) => {
+    if (!isFormData) {
+        headers['Content-Type'] = ContentType.APPLICATION_JSON;
+    }
+    else if (isApp) {
+        headers['Content-Type'] = ContentType.MULTIPART_FORM_DATA;
+        // add the app files
+        for (const fileKey in appFiles) {
+            const currentFile = appFiles[fileKey];
+            if (Array.isArray(currentFile)) {
+                for (const innerFile of currentFile) {
+                    body.append(fileKey, innerFile);
+                }
+            }
+            else {
+                body.append(fileKey, currentFile);
+            }
+        }
+    }
+    else {
+        delete headers['Content-Type'];
+    }
+};
+function getAppFiles(body, fileSelectors = []) {
+    const files = {};
+    if (body) {
+        if (fileSelectors.length > 0) {
+            //
+            for (const fileKey of fileSelectors) {
+                files[fileKey] = body[fileKey];
+                delete body[fileKey];
+            }
+        }
+    }
+    return files;
 }
 
-const useDeleteRequest = (deleteOptions) => {
-    const { baseUrl, headers } = deleteOptions ?? {};
-    const [requestPath, setRequestPath] = useState('');
-    const [options, setOptions] = useState();
-    const { options: queryConfigOptions } = useQueryConfig();
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const sendRequest = async (res, rej, queryKey) => {
-        const [url] = queryKey;
-        const requestUrl = (url ?? requestPath);
-        const requestOptions = {
-            path: requestUrl,
-            headers: { ...globalHeaders, ...headers },
-            baseURL: baseUrl ?? API_URL,
-            method: HttpMethod.DELETE,
-            timeout: TIMEOUT,
-        };
-        let shouldContinue = true;
-        if (queryConfigOptions?.queryMiddleware) {
-            shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
-        }
-        if (shouldContinue) {
-            const postResponse = await makeRequest(requestOptions);
-            if (postResponse.status) {
-                res(postResponse);
-            }
-            else {
-                rej(postResponse);
-            }
-        }
-        else {
-            rej(null);
-        }
-    };
-    const query = useQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
-        enabled: false,
-        ...options,
-    });
-    const updatedPathAsync = async (link) => {
-        return setRequestPath(link);
-    };
-    const setOptionsAsync = async (fetchOptions) => {
-        return setOptions(fetchOptions);
-    };
-    const destroy = async (link, internalDeleteOptions) => {
-        if (!isFutureQueriesPaused) {
-            // set enabled to be true for every delete
-            internalDeleteOptions = internalDeleteOptions
-                ? { ...internalDeleteOptions, queryKey: [link, {}], enabled: true }
-                : { queryKey: [link, {}], enabled: true };
-            await setOptionsAsync(internalDeleteOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setRequestPayload({ link, internalDeleteOptions });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureQueriesPaused && requestPayload) {
-            destroy(requestPayload.link, requestPayload.internalDeleteOptions);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureQueriesPaused]);
-    return { destroy, ...query, isLoading: query.isLoading || isFutureQueriesPaused };
+const useDeleteRequest = (deleteOptions) => {
+    const { baseUrl, headers } = deleteOptions ?? {};
+    const [requestPath, setRequestPath] = useState('');
+    const [options, setOptions] = useState();
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const sendRequest = async (res, rej, queryKey) => {
+        const [url] = queryKey;
+        const requestUrl = (url ?? requestPath);
+        const requestOptions = {
+            path: requestUrl,
+            headers: { ...globalHeaders, ...headers },
+            baseURL: baseUrl ?? API_URL,
+            method: HttpMethod.DELETE,
+            timeout: TIMEOUT,
+        };
+        let shouldContinue = true;
+        if (queryConfigOptions?.queryMiddleware) {
+            shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+        }
+        if (shouldContinue) {
+            let deleteResponse;
+            if (queryConfigOptions?.middleware) {
+                // perform global middleware
+                const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+                    path: requestUrl,
+                    baseUrl: baseUrl ?? API_URL,
+                });
+                if (!middlewareResponse) {
+                    rej();
+                    return;
+                }
+                deleteResponse = middlewareResponse;
+            }
+            else {
+                deleteResponse = await makeRequest(requestOptions);
+            }
+            if (deleteResponse.status) {
+                res(deleteResponse);
+            }
+            else {
+                rej(deleteResponse);
+            }
+        }
+        else {
+            rej(null);
+        }
+    };
+    const query = useQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
+        enabled: false,
+        ...options,
+    });
+    const updatedPathAsync = async (link) => {
+        return setRequestPath(link);
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        return setOptions(fetchOptions);
+    };
+    const destroy = async (link, internalDeleteOptions) => {
+        if (!isFutureQueriesPaused) {
+            // set enabled to be true for every delete
+            internalDeleteOptions = internalDeleteOptions
+                ? { ...internalDeleteOptions, queryKey: [link, {}], enabled: true }
+                : { queryKey: [link, {}], enabled: true };
+            await setOptionsAsync(internalDeleteOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setRequestPayload({ link, internalDeleteOptions });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureQueriesPaused && requestPayload) {
+            destroy(requestPayload.link, requestPayload.internalDeleteOptions);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureQueriesPaused]);
+    return { destroy, ...query, isLoading: query.isLoading || isFutureQueriesPaused };
 };
 
-const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const [requestPath, setRequestPath] = useState(path);
-    const [options, setOptions] = useState(queryOptions);
-    const { options: queryConfigOptions } = useQueryConfig();
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
-    let queryClient = useQueryClient();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    queryClient = useMemo(() => queryClient, []);
-    const sendRequest = async (res, rej, queryKey, pageParam) => {
-        if (load) {
-            // get request headers
-            const requestOptions = {
-                path: pageParam ?? requestPath,
-                headers: { ...globalHeaders, ...headers },
-                baseURL: baseUrl ?? API_URL,
-                timeout: TIMEOUT,
-            };
-            let shouldContinue = true;
-            if (queryConfigOptions?.queryMiddleware) {
-                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
-            }
-            if (shouldContinue) {
-                const getResponse = await makeRequest(requestOptions);
-                if (getResponse.status) {
-                    res(getResponse);
-                }
-                else {
-                    rej(getResponse);
-                }
-            }
-            else {
-                rej(null);
-            }
-        }
-        else {
-            res(null);
-        }
-    };
-    /**
-     *
-     * This pagination implementation is currently tied to our use case
-     */
-    const constructPaginationLink = (direction, lastPage) => {
-        const [pathname, queryString] = requestPath.split('?');
-        const queryParams = new URLSearchParams(queryString);
-        const lastPageItem = lastPage.data.pagination[direction];
-        queryParams.set('page', String(lastPageItem));
-        return pathname + '?' + queryParams.toString();
-    };
-    const query = useInfiniteQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
-        enabled: load && !isFutureQueriesPaused,
-        getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
-        getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
-        ...options,
-    });
-    const setOptionsAsync = async (fetchOptions) => {
-        startTransition(() => {
-            setOptions(fetchOptions);
-        });
-    };
-    const get = async (link, fetchOptions) => {
-        if (!isFutureQueriesPaused) {
-            await setOptionsAsync(fetchOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setRequestPayload({ link, fetchOptions });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureQueriesPaused && requestPayload) {
-            get(requestPayload.link, requestPayload.fetchOptions);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureQueriesPaused]);
-    const updatedPathAsync = async (link) => {
-        startTransition(() => {
-            setRequestPath(link);
-        });
-    };
-    useEffect(() => {
-        if (keyTracker) {
-            // set expiration time for the tracker
-            queryClient.setQueryDefaults([keyTracker], {
-                staleTime: Infinity,
-            });
-            queryClient.setQueryData([keyTracker], [requestPath, {}]);
-        }
-    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
-    return {
-        get,
-        ...query,
-        isLoading: query.isLoading || isFutureQueriesPaused,
-    };
+const useGetInfiniteRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const [requestPath, setRequestPath] = useState(path);
+    const [options, setOptions] = useState(queryOptions);
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
+    let queryClient = useQueryClient();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    queryClient = useMemo(() => queryClient, []);
+    const sendRequest = async (res, rej, queryKey, pageParam) => {
+        if (load) {
+            // get request headers
+            const requestOptions = {
+                path: pageParam ?? requestPath,
+                headers: { ...globalHeaders, ...headers },
+                baseURL: baseUrl ?? API_URL,
+                timeout: TIMEOUT,
+            };
+            let shouldContinue = true;
+            if (queryConfigOptions?.queryMiddleware) {
+                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+            }
+            if (shouldContinue) {
+                let getResponse;
+                if (queryConfigOptions?.middleware) {
+                    // perform global middleware
+                    const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+                        path,
+                        baseUrl: baseUrl ?? API_URL,
+                    });
+                    if (!middlewareResponse) {
+                        rej();
+                        return;
+                    }
+                    getResponse = middlewareResponse;
+                }
+                else {
+                    getResponse = await makeRequest(requestOptions);
+                }
+                if (getResponse.status) {
+                    res(getResponse);
+                }
+                else {
+                    rej(getResponse);
+                }
+            }
+            else {
+                rej(null);
+            }
+        }
+        else {
+            res(null);
+        }
+    };
+    /**
+     *
+     * This pagination implementation is currently tied to our use case
+     */
+    const constructPaginationLink = (direction, lastPage) => {
+        const [pathname, queryString] = requestPath.split('?');
+        const queryParams = new URLSearchParams(queryString);
+        const lastPageItem = lastPage.data.pagination[direction];
+        queryParams.set('page', String(lastPageItem));
+        return pathname + '?' + queryParams.toString();
+    };
+    const query = useInfiniteQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ pageParam = requestPath, queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey, pageParam)),
+        enabled: load && !isFutureQueriesPaused,
+        getNextPageParam: (lastPage) => constructPaginationLink('next_page', lastPage),
+        getPreviousPageParam: (lastPage) => constructPaginationLink('previous_page', lastPage),
+        ...options,
+    });
+    const setOptionsAsync = async (fetchOptions) => {
+        startTransition(() => {
+            setOptions(fetchOptions);
+        });
+    };
+    const get = async (link, fetchOptions) => {
+        if (!isFutureQueriesPaused) {
+            await setOptionsAsync(fetchOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setRequestPayload({ link, fetchOptions });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureQueriesPaused && requestPayload) {
+            get(requestPayload.link, requestPayload.fetchOptions);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureQueriesPaused]);
+    const updatedPathAsync = async (link) => {
+        startTransition(() => {
+            setRequestPath(link);
+        });
+    };
+    useEffect(() => {
+        if (keyTracker) {
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
+        }
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
+    return {
+        get,
+        ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
+    };
 };
 
-const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
-    const [requestPath, setRequestPath] = useState(path);
-    const [options, setOptions] = useState(queryOptions);
-    const [page, setPage] = useState(1);
-    const { API_URL, TIMEOUT } = useEnvironmentVariables();
-    const globalHeaders = useHeaderStore((state) => state.headers);
-    const { options: queryConfigOptions } = useQueryConfig();
-    const [requestPayload, setRequestPayload] = useState();
-    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
-    let queryClient = useQueryClient();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    queryClient = useMemo(() => queryClient, []);
-    const sendRequest = async (res, rej, queryKey) => {
-        if (load) {
-            const [url] = queryKey;
-            const requestUrl = (url ?? requestPath);
-            const requestOptions = {
-                path: requestUrl,
-                headers: { ...globalHeaders, ...headers },
-                baseURL: baseUrl ?? API_URL,
-                timeout: TIMEOUT,
-            };
-            let shouldContinue = true;
-            if (queryConfigOptions?.queryMiddleware) {
-                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
-            }
-            if (shouldContinue) {
-                const getResponse = await makeRequest(requestOptions);
-                if (getResponse.status) {
-                    res(getResponse);
-                }
-                else {
-                    rej(getResponse);
-                }
-            }
-            else {
-                rej(null);
-            }
-        }
-        else {
-            res(null);
-        }
-    };
-    const query = useQuery({
-        queryKey: [requestPath, {}],
-        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
-        enabled: load && !isFutureQueriesPaused,
-        ...options,
-    });
-    useEffect(() => {
-        if (path) {
-            setRequestPath(path);
-        }
-    }, [path]);
-    useEffect(() => {
-        if (keyTracker) {
-            // set expiration time for the tracker
-            queryClient.setQueryDefaults([keyTracker], {
-                staleTime: Infinity,
-            });
-            queryClient.setQueryData([keyTracker], [requestPath, {}]);
-        }
-    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
-    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) {
-                setRequestPath(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) {
-                setRequestPath(constructPaginationLink(requestPath, pagination.previous_page));
-            }
-        }
-    };
-    const constructPaginationLink = (link, pageNumber) => {
-        const [pathname, queryString] = link.split('?');
-        const queryParams = new URLSearchParams(queryString);
-        const oldPage = Number(queryParams.get('page'));
-        queryParams.set('page', pageNumber);
-        link = pathname + '?' + queryParams.toString();
-        // only update page when pagination number changed
-        if (oldPage !== pageNumber) {
-            setPage(pageNumber);
-        }
-        return link;
-    };
-    const gotoPage = (pageNumber) => {
-        setRequestPath(constructPaginationLink(requestPath, pageNumber));
-    };
-    const updatedPathAsync = async (link) => {
-        startTransition(() => {
-            setRequestPath(link);
-        });
-    };
-    const setOptionsAsync = async (fetchOptions) => {
-        startTransition(() => {
-            setOptions(fetchOptions);
-        });
-    };
-    const get = async (link, fetchOptions) => {
-        if (!isFutureQueriesPaused) {
-            await setOptionsAsync(fetchOptions);
-            await updatedPathAsync(link);
-            return query.data;
-        }
-        else {
-            setRequestPayload({ link, fetchOptions });
-            return undefined;
-        }
-    };
-    useEffect(() => {
-        if (!isFutureQueriesPaused && requestPayload) {
-            get(requestPayload.link, requestPayload.fetchOptions);
-            setRequestPayload(undefined);
-        }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isFutureQueriesPaused]);
-    return {
-        ...query,
-        isLoading: query.isLoading || isFutureQueriesPaused,
-        setRequestPath,
-        nextPage,
-        prevPage,
-        get,
-        gotoPage,
-        page,
-        queryKey: [requestPath, {}],
-    };
+const useGetRequest = ({ path, load = false, queryOptions, keyTracker, baseUrl, headers, }) => {
+    const [requestPath, setRequestPath] = useState(path);
+    const [options, setOptions] = useState(queryOptions);
+    const [page, setPage] = useState(1);
+    const { API_URL, TIMEOUT } = useEnvironmentVariables();
+    const globalHeaders = useHeaderStore((state) => state.headers);
+    const { options: queryConfigOptions } = useQueryConfig();
+    const [requestPayload, setRequestPayload] = useState();
+    const isFutureQueriesPaused = usePauseFutureRequests((state) => state.isFutureQueriesPaused);
+    let queryClient = useQueryClient();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    queryClient = useMemo(() => queryClient, []);
+    const sendRequest = async (res, rej, queryKey) => {
+        if (load) {
+            const [url] = queryKey;
+            const requestUrl = (url ?? requestPath);
+            const requestOptions = {
+                path: requestUrl,
+                headers: { ...globalHeaders, ...headers },
+                baseURL: baseUrl ?? API_URL,
+                timeout: TIMEOUT,
+            };
+            let shouldContinue = true;
+            if (queryConfigOptions?.queryMiddleware) {
+                shouldContinue = await queryConfigOptions.queryMiddleware({ queryKey, ...requestOptions });
+            }
+            if (shouldContinue) {
+                let getResponse;
+                if (queryConfigOptions?.middleware) {
+                    // perform global middleware
+                    const middlewareResponse = await queryConfigOptions.middleware(async () => await makeRequest(requestOptions), {
+                        path,
+                        baseUrl: baseUrl ?? API_URL,
+                    });
+                    if (!middlewareResponse) {
+                        rej();
+                        return;
+                    }
+                    getResponse = middlewareResponse;
+                }
+                else {
+                    getResponse = await makeRequest(requestOptions);
+                }
+                if (getResponse.status) {
+                    res(getResponse);
+                }
+                else {
+                    rej(getResponse);
+                }
+            }
+            else {
+                rej(null);
+            }
+        }
+        else {
+            res(null);
+        }
+    };
+    const query = useQuery({
+        queryKey: [requestPath, {}],
+        queryFn: ({ queryKey }) => new Promise((res, rej) => sendRequest(res, rej, queryKey)),
+        enabled: load && !isFutureQueriesPaused,
+        ...options,
+    });
+    useEffect(() => {
+        if (path) {
+            setRequestPath(path);
+        }
+    }, [path]);
+    useEffect(() => {
+        if (keyTracker) {
+            // set expiration time for the tracker
+            queryClient.setQueryDefaults([keyTracker], {
+                staleTime: Infinity,
+            });
+            queryClient.setQueryData([keyTracker], [requestPath, {}]);
+        }
+    }, [keyTracker, requestPath, queryClient, queryOptions?.staleTime]);
+    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) {
+                setRequestPath(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) {
+                setRequestPath(constructPaginationLink(requestPath, pagination.previous_page));
+            }
+        }
+    };
+    const constructPaginationLink = (link, pageNumber) => {
+        const [pathname, queryString] = link.split('?');
+        const queryParams = new URLSearchParams(queryString);
+        const oldPage = Number(queryParams.get('page'));
+        queryParams.set('page', pageNumber);
+        link = pathname + '?' + queryParams.toString();
+        // only update page when pagination number changed
+        if (oldPage !== pageNumber) {
+            setPage(pageNumber);
+        }
+        return link;
+    };
+    const gotoPage = (pageNumber) => {
+        setRequestPath(constructPaginationLink(requestPath, pageNumber));
+    };
+    const updatedPathAsync = async (link) => {
+        startTransition(() => {
+            setRequestPath(link);
+        });
+    };
+    const setOptionsAsync = async (fetchOptions) => {
+        startTransition(() => {
+            setOptions(fetchOptions);
+        });
+    };
+    const get = async (link, fetchOptions) => {
+        if (!isFutureQueriesPaused) {
+            await setOptionsAsync(fetchOptions);
+            await updatedPathAsync(link);
+            return query.data;
+        }
+        else {
+            setRequestPayload({ link, fetchOptions });
+            return undefined;
+        }
+    };
+    useEffect(() => {
+        if (!isFutureQueriesPaused && requestPayload) {
+            get(requestPayload.link, requestPayload.fetchOptions);
+            setRequestPayload(undefined);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isFutureQueriesPaused]);
+    return {
+        ...query,
+        isLoading: query.isLoading || isFutureQueriesPaused,
+        setRequestPath,
+        nextPage,
+        prevPage,
+        get,
+        gotoPage,
+        page,
+        queryKey: [requestPath, {}],
+    };
 };
 
-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 };
 };
 
-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 { ContentType, HttpMethod, axiosInstance, bootstrapQueryRequest, buildFormData, errorTransformer, getDateInFuture, makeRequest, scrollToTop, successTransformer, useDeleteRequest, useEnvironmentVariables, useGetInfiniteRequest, useGetRequest, useHeaderStore, useKeyTrackerModel, usePatchRequest, usePauseFutureRequests, usePostRequest, useQueryConfig, useQueryHeaders, useQueryModel, useReactNativeEnv, useRefetchQuery, useUploadProgress };