drapcode-utility 1.9.6 → 1.9.78

package/build/utils/query-utils.js

@@ -0,0 +1,254 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueOfProjectConstant = exports.isFixedValueQuery = exports.getMinMaxValue = exports.checkDate = exports.modifyQuery = exports.mongoSelectQuery = exports.getSearchObjQuery = void 0;
+var drapcode_constant_1 = require("drapcode-constant");
+var date_util_1 = require("./date-util");
+var util_1 = require("./util");
+var getSearchObjQuery = function (searchObj, searchQueryTypeObj, timezone) {
+    var searchAggregateQuery = [];
+    var likeQuery = [];
+    Object.entries(searchObj).forEach(function (_a) {
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        var key = _a[0], value = _a[1];
+        if (value) {
+            var searchQueryTypeKey = searchQueryTypeObj[key];
+            if (searchQueryTypeKey) {
+                if (searchQueryTypeKey === "boolean") {
+                    // if input is string and db field type is boolean
+                    searchAggregateQuery.push({
+                        $addFields: (_b = {},
+                            _b["_".concat(key)] = "$".concat(key),
+                            _b),
+                    });
+                    likeQuery.push((_c = {},
+                        _c["_".concat(key)] = toBoolean(value),
+                        _c));
+                }
+                else if (__spreadArray(__spreadArray([], drapcode_constant_1.OptionTypeFields, true), drapcode_constant_1.BelongsToReferenceField, true).includes(searchQueryTypeKey)) {
+                    // if input is string and db field type is array
+                    searchAggregateQuery.push({
+                        $addFields: (_d = {},
+                            _d["_".concat(key)] = "$".concat(key),
+                            _d),
+                    });
+                    likeQuery.push((_e = {},
+                        _e["_".concat(key)] = { $all: [value] },
+                        _e));
+                }
+                else if (searchQueryTypeKey === "tel") {
+                    // handling value when db field type is tel
+                    searchAggregateQuery.push({
+                        $addFields: (_f = {},
+                            _f["_".concat(key)] = { $toString: "$".concat(key) },
+                            _f),
+                    });
+                    likeQuery.push((_g = {},
+                        _g["_".concat(key)] = {
+                            $regex: value.startsWith("+") ? value.replace("+", "") : value,
+                            $options: "i",
+                        },
+                        _g));
+                }
+                else if (searchQueryTypeKey === "number") {
+                    if (key.startsWith("min_") || key.startsWith("max_")) {
+                        var fieldKey = key.replace("min_", "");
+                        fieldKey = fieldKey.replace("max_", "");
+                        var numericValue = Number(value);
+                        if (key.startsWith("min_")) {
+                            likeQuery.push((_h = {}, _h["".concat(fieldKey)] = { $gte: numericValue }, _h));
+                        }
+                        else if (key.startsWith("max_")) {
+                            likeQuery.push((_j = {}, _j["".concat(fieldKey)] = { $lte: numericValue }, _j));
+                        }
+                    }
+                    else {
+                        // handling value when db field type is Double/Int
+                        searchAggregateQuery.push({
+                            $addFields: (_k = {},
+                                _k["_".concat(key)] = { $toString: { $toLong: "$".concat(key) } },
+                                _k),
+                        });
+                        likeQuery.push((_l = {},
+                            _l["_".concat(key)] = {
+                                $regex: value,
+                                $options: "i",
+                            },
+                            _l));
+                    }
+                }
+                else if (__spreadArray(__spreadArray([
+                    drapcode_constant_1.FieldTypes.date.id
+                ], drapcode_constant_1.systemDateField, true), [
+                    drapcode_constant_1.FieldTypes.time_slot.id,
+                ], false).includes(searchQueryTypeKey)) {
+                    if (key.startsWith("start_") || key.startsWith("end_")) {
+                        var fieldKey = key.replace("start_", "");
+                        fieldKey = fieldKey.replace("end_", "");
+                        searchAggregateQuery.push({
+                            $addFields: (_m = {},
+                                _m["_".concat(key)] = { $toString: "$".concat(fieldKey) },
+                                _m),
+                        });
+                        if (key.startsWith("start_")) {
+                            likeQuery.push((_o = {},
+                                _o["_".concat(key)] = {
+                                    $gte: (0, date_util_1.timezoneDateParse)(value, true, true),
+                                },
+                                _o));
+                        }
+                        else if (key.startsWith("end_")) {
+                            likeQuery.push((_p = {},
+                                _p["_".concat(key)] = {
+                                    $lt: (0, date_util_1.timezoneDateParse)(value, true),
+                                },
+                                _p));
+                        }
+                    }
+                }
+                else {
+                    // if input is string and db field type is number
+                    // converting db field to string first
+                    searchAggregateQuery.push({
+                        $addFields: (_q = {},
+                            _q["_".concat(key)] = { $toString: "$".concat(key) },
+                            _q),
+                    });
+                    likeQuery.push((_r = {},
+                        _r["_".concat(key)] = {
+                            $regex: value,
+                            $options: "i",
+                        },
+                        _r));
+                }
+            }
+            else {
+                likeQuery.push((_s = {},
+                    _s[key] = {
+                        $regex: value,
+                        $options: "i",
+                    },
+                    _s));
+            }
+        }
+    });
+    console.log("==> searchAggregateQuery", JSON.stringify(searchAggregateQuery));
+    console.log("==> likeQuery", JSON.stringify(likeQuery));
+    return { searchAggregateQuery: searchAggregateQuery, likeQuery: likeQuery };
+};
+exports.getSearchObjQuery = getSearchObjQuery;
+var mongoSelectQuery = function (query) {
+    if (query === void 0) { query = {}; }
+    var projection = {};
+    var fieldsInclude = query.fieldsInclude, fieldsExclude = query.fieldsExclude, finder = query.finder;
+    if (!fieldsExclude)
+        fieldsExclude = [];
+    if (fieldsInclude[0] === "*") {
+        fieldsExclude.map(function (field) {
+            if (field)
+                return (projection["".concat(field)] = 0);
+        });
+    }
+    else {
+        if (["FIND_ALL", "FIND"].includes(finder))
+            fieldsInclude = (0, util_1.processFieldsInclude)(fieldsInclude);
+        fieldsInclude.map(function (field) {
+            if (field)
+                return (projection["".concat(field)] = 1);
+        });
+    }
+    return projection;
+};
+exports.mongoSelectQuery = mongoSelectQuery;
+var modifyQuery = function (obj, hasAndQueryConjunction) {
+    if (obj === void 0) { obj = {}; }
+    if (hasAndQueryConjunction === void 0) { hasAndQueryConjunction = false; }
+    var arr = [];
+    Object.entries(obj).forEach(function (_a) {
+        var key = _a[0], value = _a[1];
+        if (hasAndQueryConjunction) {
+            arr.push({ $and: value });
+        }
+        else {
+            arr.push({ $or: value });
+        }
+    });
+    return arr;
+};
+exports.modifyQuery = modifyQuery;
+var toBoolean = function (value) {
+    if (!value) {
+        return false;
+    }
+    switch (value.toLocaleLowerCase()) {
+        case "true":
+        case "1":
+        case "on":
+        case "yes":
+            return true;
+        default:
+            return false;
+    }
+};
+var checkDate = function (queryValue) {
+    return ("" + queryValue).match(date_util_1.DATE_REGEX);
+};
+exports.checkDate = checkDate;
+var getMinMaxValue = function (value) {
+    var isFixedValue = (0, exports.isFixedValueQuery)(value);
+    if (isFixedValue)
+        value = value.replace("FIXED_VALUE::", "");
+    var isValid = value && value.includes("---");
+    if (isValid) {
+        var isInteger = value.includes("^");
+        var result = value.split("---");
+        var endValue = result[1];
+        if (isInteger && result.length)
+            endValue = endValue.slice(0, -1);
+        return { startValue: result[0], endValue: endValue, isInteger: isInteger, isFixedValue: isFixedValue };
+    }
+    else {
+        return { startValue: "", endValue: "", isFixedValue: isFixedValue };
+    }
+};
+exports.getMinMaxValue = getMinMaxValue;
+// TODO: can be refactor with entity condition
+var isFixedValueQuery = function (value) {
+    var isFixeValue = false;
+    if (value && Array.isArray(value)) {
+        value.forEach(function (val) {
+            if (typeof val === "string" || val instanceof String)
+                isFixeValue = val.startsWith("FIXED_VALUE::");
+        });
+    }
+    else {
+        if (value && (typeof value === "string" || value instanceof String))
+            isFixeValue = value.startsWith("FIXED_VALUE::");
+    }
+    return isFixeValue;
+};
+exports.isFixedValueQuery = isFixedValueQuery;
+var getValueOfProjectConstant = function (value, currentUser, timezone) {
+    if (!timezone)
+        timezone = "(GMT+5:30)";
+    timezone = timezone.substring(4, 10);
+    var result;
+    if (value === drapcode_constant_1.CURRENT_USER)
+        return currentUser["uuid"];
+    if (value === drapcode_constant_1.CURRENT_DATE)
+        result = (0, date_util_1.createLoggerDateFormat)(timezone);
+    if ([drapcode_constant_1.CURRENT_TIME, drapcode_constant_1.CURRENT_DATE_TIME].includes(value))
+        result = (0, date_util_1.createLogsDateFormat)(timezone);
+    if (drapcode_constant_1.DateTimeUnit.some(function (cnst) { return value.includes(cnst); }))
+        result = (0, date_util_1.getDateValue)(value, timezone);
+    return result;
+};
+exports.getValueOfProjectConstant = getValueOfProjectConstant;

package/build/utils/rest-client.d.ts

@@ -0,0 +1,6 @@
+export declare const callCurlRequest: (setting: any, user?: any, tenant?: any, userSetting?: any, subTenant?: any, data?: any, timeout?: number, timeoutMessage?: string, envConstants?: {}, downloadBytes?: boolean, requestDataType?: string, wrapJsonDataInArray?: boolean, projectId?: string, dataTransferObject?: any, isRawJSON?: boolean, browserStorageData?: any) => Promise<{
+    data: any;
+    status: number;
+    success: boolean;
+    headers: {};
+}>;

package/build/utils/rest-client.js

@@ -0,0 +1,342 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callCurlRequest = void 0;
+var axios_1 = __importDefault(require("axios"));
+var util_1 = require("./util");
+var drapcode_logger_1 = require("drapcode-logger");
+var FormData = require("form-data");
+var fs = require("fs");
+var qs = require("qs");
+var callCurlRequest = function (setting, user, tenant, userSetting, subTenant, data, timeout, timeoutMessage, envConstants, downloadBytes, requestDataType, wrapJsonDataInArray, projectId, dataTransferObject, isRawJSON, browserStorageData) {
+    if (user === void 0) { user = {}; }
+    if (tenant === void 0) { tenant = {}; }
+    if (userSetting === void 0) { userSetting = {}; }
+    if (subTenant === void 0) { subTenant = {}; }
+    if (data === void 0) { data = {}; }
+    if (timeout === void 0) { timeout = 0; }
+    if (timeoutMessage === void 0) { timeoutMessage = ""; }
+    if (envConstants === void 0) { envConstants = {}; }
+    if (downloadBytes === void 0) { downloadBytes = false; }
+    if (requestDataType === void 0) { requestDataType = ""; }
+    if (wrapJsonDataInArray === void 0) { wrapJsonDataInArray = false; }
+    if (projectId === void 0) { projectId = ""; }
+    if (dataTransferObject === void 0) { dataTransferObject = {}; }
+    if (isRawJSON === void 0) { isRawJSON = false; }
+    if (browserStorageData === void 0) { browserStorageData = {}; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var url, params, methodType, authType, requestHeader, accessToken, _a, headers, isMultipart, files, _b, awsSignPluginConfig, _c, sessionValue, sessionFormValue, sessionStorageValue, localStorageValue, cookiesValue, headerValue, requestParams, toDeleteFiles, objectArray, settingsHeaderObjectArray, dataHeaderObjectArray, mergedHeaders_1, settingsHasContentType_1, settingsContentTypeKey_1, headerContentTypeUrlEncoded, isUrlEncoded, result, errorMessage, error_1, err, errData, errStatus;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    url = setting.url, params = setting.params, methodType = setting.methodType, authType = setting.authType, requestHeader = setting.requestHeader, accessToken = setting.accessToken, _a = setting.headers, headers = _a === void 0 ? [] : _a, isMultipart = setting.isMultipart, files = setting.files, _b = setting.awsSignPluginConfig, awsSignPluginConfig = _b === void 0 ? null : _b;
+                    _c = browserStorageData || {}, sessionValue = _c.sessionValue, sessionFormValue = _c.sessionFormValue, sessionStorageValue = _c.sessionStorageData, localStorageValue = _c.localStorageData, cookiesValue = _c.cookiesData;
+                    drapcode_logger_1.logger.info("STEP 1 Replacing placeholder key values...", {
+                        label: projectId,
+                    });
+                    // Uncomment below only when needed for debugging
+                    // logger.info(
+                    //   `STEP 1 Replacing URL Session Value: ${sessionValue ? JSON.stringify(sessionValue) : ""
+                    //   }, Session Form Value: ${sessionFormValue ? JSON.stringify(sessionFormValue) : ""
+                    //   }, Browser Storage Data: ${browserStorageData ? JSON.stringify(browserStorageData) : ""
+                    //   }, Session Storage: ${sessionStorageValue ? JSON.stringify(sessionStorageValue) : ""
+                    //   }, Local Storage: ${localStorageValue ? JSON.stringify(localStorageValue) : ""
+                    //   }, Session Cookies: ${cookiesValue ? JSON.stringify(cookiesValue) : ""
+                    //   }, Headers: ${headers ? JSON.stringify(headers) : ""}`,
+                    //   { label: projectId }
+                    // );
+                    if (url.includes("{{current_user.") &&
+                        (!user || Object.keys(user).length == 0)) {
+                        drapcode_logger_1.logger.info("**2 Sending back", { label: projectId });
+                        return [2 /*return*/, prepareReturnObject("User is not logged in. URL is wrong")];
+                    }
+                    if (data || user || tenant || envConstants || userSetting || subTenant) {
+                        url = (0, util_1.replaceDataValueIntoExpression)(url, data, user, tenant, userSetting, subTenant, sessionValue, envConstants, sessionFormValue, localStorageValue, cookiesValue);
+                    }
+                    if (!url) {
+                        drapcode_logger_1.logger.info("**5 url not found", { label: projectId });
+                        return [2 /*return*/, prepareReturnObject("URL is wrong")];
+                    }
+                    drapcode_logger_1.logger.info("STEP 2: URL replaced and replacing header", {
+                        label: projectId,
+                    });
+                    headerValue = (0, util_1.mergeObjects)(headers, data, user, tenant, userSetting, subTenant, sessionValue, envConstants, sessionFormValue, dataTransferObject, localStorageValue, cookiesValue);
+                    headerValue = {
+                        headers: __assign({}, headerValue),
+                    };
+                    drapcode_logger_1.logger.info("STEP 3: Replacing Header Auth", { label: projectId });
+                    drapcode_logger_1.logger.info("accessToken: ".concat(accessToken, " authType: ").concat(authType), {
+                        label: projectId,
+                    });
+                    if (accessToken) {
+                        headerValue.headers[requestHeader] = authType
+                            ? "".concat(authType, " ").concat(accessToken)
+                            : accessToken;
+                    }
+                    if (params && params.length) {
+                        requestParams = (0, util_1.mergeObjects)(params, data, user, tenant, userSetting, subTenant, sessionValue, envConstants, sessionFormValue, dataTransferObject, localStorageValue, cookiesValue);
+                        headerValue.params = requestParams;
+                    }
+                    //unflat data before api call
+                    data = data ? (0, util_1.unflattenObject)(data) : data;
+                    drapcode_logger_1.logger.info("Before headers: ".concat(JSON.stringify(headerValue.headers)), {
+                        label: projectId,
+                    });
+                    drapcode_logger_1.logger.info("isMultipart: ".concat(isMultipart), { label: projectId });
+                    toDeleteFiles = [];
+                    if (isMultipart || (requestDataType && requestDataType === "FORM_DATA")) {
+                        objectArray = Object.entries(data);
+                        data = new FormData();
+                        objectArray.forEach(function (_a) {
+                            var key = _a[0], value = _a[1];
+                            if (files && files.includes(key)) {
+                                drapcode_logger_1.logger.info("".concat(key, " files.includes(key): ").concat(files.includes(key)), {
+                                    label: projectId,
+                                });
+                                drapcode_logger_1.logger.info("value: ".concat(value), { label: projectId });
+                                data.append(key, fs.createReadStream(value));
+                                toDeleteFiles.push(value);
+                            }
+                            else {
+                                data.append(key, value);
+                            }
+                        });
+                        settingsHeaderObjectArray = Object.entries(headerValue.headers);
+                        dataHeaderObjectArray = Object.entries(data.getHeaders());
+                        mergedHeaders_1 = {};
+                        settingsHasContentType_1 = false;
+                        settingsContentTypeKey_1 = "";
+                        settingsHeaderObjectArray.forEach(function (_a) {
+                            var key = _a[0], value = _a[1];
+                            if (key && key.toLowerCase() === "content-type") {
+                                settingsHasContentType_1 = true;
+                                settingsContentTypeKey_1 = key;
+                            }
+                            else {
+                                mergedHeaders_1[key] = value;
+                            }
+                        });
+                        dataHeaderObjectArray.forEach(function (_a) {
+                            var key = _a[0], value = _a[1];
+                            if (key && key === "content-type" && settingsHasContentType_1) {
+                                mergedHeaders_1[settingsContentTypeKey_1] = value;
+                            }
+                            else {
+                                mergedHeaders_1[key] = value;
+                            }
+                        });
+                        drapcode_logger_1.logger.info("*** merged headers :>> ".concat(mergedHeaders_1), {
+                            label: projectId,
+                        });
+                        headerValue.headers = __assign({}, mergedHeaders_1);
+                    }
+                    drapcode_logger_1.logger.info("After headers ".concat(JSON.stringify(headerValue.headers)), {
+                        label: projectId,
+                    });
+                    drapcode_logger_1.logger.info("** App Environment: ".concat(process.env.APP_ENV), {
+                        label: projectId,
+                    });
+                    headerContentTypeUrlEncoded = setting.headers.find(function (head) {
+                        if (head === void 0) { head = {}; }
+                        return head.key &&
+                            head.key.toLowerCase() === "content-type" &&
+                            head.value === "application/x-www-form-urlencoded";
+                    });
+                    isUrlEncoded = !!headerContentTypeUrlEncoded;
+                    drapcode_logger_1.logger.info("** isUrlEncoded: ".concat(isUrlEncoded), { label: projectId });
+                    //Add Environment in Header for Lambda USE
+                    headerValue.headers["x-project-env"] = process.env.APP_ENV;
+                    if (downloadBytes) {
+                        headerValue["responseType"] = "stream";
+                    }
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 3, , 4]);
+                    result = null;
+                    if (!isRawJSON) {
+                        if (requestDataType === "FORM_URL_ENCODED" || isUrlEncoded) {
+                            data = qs.stringify(data);
+                            drapcode_logger_1.logger.info("**17 Encoded data:", data, { label: projectId });
+                        }
+                        if (requestDataType === "NO_BODY_DATA")
+                            data = {};
+                    }
+                    return [4 /*yield*/, makeAxiosCall(projectId, methodType, url, headerValue, data, timeout, wrapJsonDataInArray, awsSignPluginConfig)];
+                case 2:
+                    result = _d.sent();
+                    drapcode_logger_1.logger.info("result.headers: ".concat(result === null || result === void 0 ? void 0 : result.headers), { label: projectId });
+                    if (!result) {
+                        errorMessage = "No Response from Server";
+                        return [2 /*return*/, prepareReturnObject(errorMessage)];
+                    }
+                    drapcode_logger_1.logger.info("result.status: ".concat(result === null || result === void 0 ? void 0 : result.status), { label: projectId });
+                    deleteLocalFiles(isMultipart, toDeleteFiles);
+                    return [2 /*return*/, prepareReturnObject(result.data, result.status, true, result === null || result === void 0 ? void 0 : result.headers)];
+                case 3:
+                    error_1 = _d.sent();
+                    deleteLocalFiles(isMultipart, toDeleteFiles);
+                    err = error_1;
+                    errData = null, errStatus = 400;
+                    if (err.response) {
+                        drapcode_logger_1.logger.info("err.response.data: ".concat(err.response.data ? JSON.stringify(err.response.data) : ""), {
+                            label: projectId,
+                        });
+                        drapcode_logger_1.logger.info("err.response.status: ".concat(err.response.status), {
+                            label: projectId,
+                        });
+                        drapcode_logger_1.logger.info("err.response.headers: ".concat(err.response.headers ? JSON.stringify(err.response.headers) : ""), {
+                            label: projectId,
+                        });
+                        errData = err.response.data;
+                        errStatus = err.response.status;
+                    }
+                    else if (err.request) {
+                        errData = "No Response Received from the API";
+                        drapcode_logger_1.logger.info("err.request: ".concat(err.request), { label: projectId });
+                    }
+                    else {
+                        if (err.message.includes("ECONNABORTED")) {
+                            errData = timeoutMessage || "No response received from the REST API";
+                        }
+                        else {
+                            errData = err.message;
+                        }
+                    }
+                    return [2 /*return*/, prepareReturnObject(errData, errStatus)];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+};
+exports.callCurlRequest = callCurlRequest;
+var deleteLocalFiles = function (isMultipart, toDeleteFiles) {
+    if (isMultipart && toDeleteFiles) {
+        toDeleteFiles.forEach(function (filePath) {
+            console.log("==> TO DELETE FILES ARRAY filePath :>> ", filePath);
+            fs.exists(filePath, function (exists) {
+                if (exists) {
+                    console.log("File exists. Deleting now ...");
+                    fs.unlinkSync(filePath);
+                }
+                else {
+                    console.log("File not found, so not deleting.");
+                }
+            });
+        });
+    }
+};
+var prepareReturnObject = function (data, status, success, headers) {
+    if (status === void 0) { status = 400; }
+    if (success === void 0) { success = false; }
+    if (headers === void 0) { headers = {}; }
+    return {
+        data: data,
+        status: status,
+        success: success,
+        headers: headers,
+    };
+};
+var makeAxiosCall = function (projectId, methodType, url, axiosConfig, data, timeout, wrapJsonDataInArray, awsSignPluginConfig) { return __awaiter(void 0, void 0, void 0, function () {
+    var result, instance, dataArray_1, awsRes;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                axiosConfig = __assign({ url: url, method: methodType }, axiosConfig);
+                result = "";
+                instance = axios_1.default.create();
+                instance.defaults.timeout = timeout * 1000;
+                switch (methodType) {
+                    case "GET":
+                        axiosConfig["data"] = data ? data : {};
+                        break;
+                    case "POST":
+                    case "PUT":
+                    case "PATCH":
+                        if (wrapJsonDataInArray) {
+                            dataArray_1 = [];
+                            if (Object.keys(data) && Object.keys(data).length) {
+                                if (Object.keys(data)[0] === "0") {
+                                    Object.keys(data).map(function (dataKey) {
+                                        dataArray_1.push(data[dataKey]);
+                                    });
+                                    data = dataArray_1;
+                                }
+                            }
+                        }
+                        axiosConfig["data"] = data;
+                        break;
+                    case "DELETE":
+                        //Sending data object via axiosConfig
+                        if (data && Object.entries(data).length) {
+                            axiosConfig["data"] = __assign({}, data);
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                if (!awsSignPluginConfig) return [3 /*break*/, 2];
+                return [4 /*yield*/, (0, util_1.getAwsSignature)(axiosConfig, awsSignPluginConfig)];
+            case 1:
+                awsRes = _a.sent();
+                if (awsRes.error)
+                    return [2 /*return*/, awsRes.error];
+                axiosConfig = __assign(__assign({}, awsRes.data), { url: url, data: data });
+                _a.label = 2;
+            case 2:
+                console.log("\n ==> Final axiosConfig for projectID: ".concat(projectId, ":>> "), axiosConfig);
+                return [4 /*yield*/, (0, axios_1.default)(__assign({}, axiosConfig))];
+            case 3:
+                result = _a.sent();
+                return [2 /*return*/, result];
+        }
+    });
+}); };