vtlab-generic-functions 1.0.4

package/utils/index.js

@@ -0,0 +1,579 @@
+const { stringify } = require("flatted");
+const countriesQuery = require("countries-code");
+const config = require("../config");
+const awslambda = require("../lambda");
+const lookup = require("country-data").lookup;
+
+/**
+ * Access object with key as a dot notation.
+ * @param obj Eg object is {depth0: {depth1: depth2: 'valueOfDepth2'}}
+ * @param key string of 'depth0.depth1.depth2'
+ * @returns {*} values of obj.depth0.depth1.depth2
+ */
+const getObjectByString = (obj, key) => {
+  const keys = key.split(".");
+  let temp = obj;
+  for (let i = 0; i < keys.length; i++) {
+    temp = temp[keys[i]];
+  }
+  return temp;
+};
+
+const dataToString = (payload, type = "error") => {
+  try {
+    if (payload.response) {
+      //Often return from axios request
+      return { res: stringify(payload.response) };
+    }
+    if (payload instanceof Error) {
+      return { res: JSON.stringify(payload.message) };
+    }
+    if (typeof payload === "string") {
+      return { res: JSON.stringify(payload) };
+    }
+    switch (type) {
+      case "error":
+        let { code, ...err } = payload;
+        return {
+          code,
+          res:
+            err instanceof Error
+              ? JSON.stringify(err.message)
+              : JSON.stringify(err),
+        };
+      case "data":
+        return { res: JSON.stringify(payload) };
+      default:
+        return { res: JSON.stringify(payload) };
+    }
+  } catch (err) {
+    let strToReturn = "Error while stringifying";
+    try {
+      strToReturn = stringify(payload);
+    } catch (err) {
+      return { res: strToReturn };
+    }
+    return { res: strToReturn };
+  }
+};
+
+const getMessageFromValidator = (validator) => {
+  let messageToReturn = "Something went badly wrong validating request format";
+  if (validator.error && validator.error.message) {
+    if (typeof validator.error.message === "string") {
+      messageToReturn = messageToReturn + ":" + validator.error.message;
+    } else if (Array.isArray(validator.error.message)) {
+      messageToReturn =
+        messageToReturn + "  [" + validator.error.message.join(";") + "]";
+    }
+  } else {
+    messageToReturn = "Everything looks OK";
+  }
+  return messageToReturn;
+};
+
+const sleep = (ms) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+
+const replaceInvalidXMLChars = (inputString, useHTMLEntities = false) => {
+  if (!inputString || typeof inputString !== "string") {
+    return inputString;
+  }
+  if (useHTMLEntities) {
+    inputString = inputString.replace(/&/g, "&amp;");
+    inputString = inputString.replace(/</g, "&lt;");
+    inputString = inputString.replace(/>/g, "&gt;");
+    inputString = inputString.replace(/"/g, "&quot;");
+    inputString = inputString.replace(/'/g, "&apos;");
+  } else {
+    inputString = inputString.replace(/&/g, "");
+    inputString = inputString.replace(/</g, "");
+    inputString = inputString.replace(/>/g, "");
+    inputString = inputString.replace(/"/g, "");
+    inputString = inputString.replace(/'/g, "");
+  }
+
+  return inputString;
+}; //replaceInvalidXMLChars
+
+// wrapper function for countriesQuery lib
+const getCountryNameByCode = (CountryCode = "") => {
+  try {
+    let country = countriesQuery.getCountry(CountryCode);
+    return country && country !== "Wrong Country Code Input" ? country : ""; //remove static error message from library
+  } catch (err) {
+    return "";
+  }
+};
+
+const getCountryCodeByName = (CountryName = "") => {
+  try {
+    let country = lookup.countries({ name: CountryName });
+    return country && country.length > 0 ? country[0].alpha2 : ""; //remove static error message from library
+  } catch (err) {
+    return "";
+  }
+};
+
+// wrapper function for countriesQuery lib
+const convertAlphaCode = (countryCode = "") => {
+  try {
+    let alphaCode = countriesQuery.convertAlphaCode(countryCode.trim());
+    return alphaCode && alphaCode !== "Wrong Country Code Input"
+      ? alphaCode
+      : ""; //remove static error message from library
+  } catch (err) {
+    return "";
+  }
+};
+
+let processCountry = (country, countryIso) => {
+  try {
+    if (country && (!countryIso || countryIso === "")) {
+      // case1: country is > 3chars
+      if (country.length > 3) {
+        return {
+          country,
+          isoCode: getCountryCodeByName(country),
+        };
+      } else {
+        // case 2: country is <= 3 chars
+        return {
+          country: getCountryNameByCode(country),
+          isoCode: country.length === 3 ? convertAlphaCode(country) : country,
+        };
+      }
+    }
+    if (country && countryIso && country !== "" && countryIso !== "") {
+      let a, b;
+      // case1: country is > 3chars
+      if (country.length > 3) {
+        a = country;
+      } else {
+        // case 2: country is <= 3 chars
+        a = getCountryNameByCode(countryIso);
+      }
+      // case 3: countryIso >= 3 chars => transform to iso 2
+      if (countryIso.length >= 3) {
+        b = convertAlphaCode(countryIso);
+      } else {
+        b = countryIso;
+      }
+      return { country: a, isoCode: b };
+    }
+    if ((!country || country === "") && countryIso) {
+      let a, b;
+      // case 1: countryIso >= 3 chars => transform to iso 2
+      if (countryIso.length >= 3) {
+        b = convertAlphaCode(countryIso);
+      } else {
+        b = countryIso;
+      }
+      // infers country from countryIso
+      a = getCountryNameByCode(countryIso);
+      return { country: a, isoCode: b };
+    }
+    if ((!country || country === "") && (!countryIso || !countryIso === "")) {
+      throw "Error";
+    }
+  } catch (e) {
+    return { country: "", isoCode: "" };
+  }
+};
+
+const fixSizeField = (
+  data,
+  {
+    type = "string",
+    size = 3,
+    nDecimalDigits = 1,
+    completeOnTheRight = true,
+    stringPlaceholder = " ",
+  } = {}
+) => {
+  let res = "";
+  data = data ? String(data) : "";
+  let completeDirection = (value, placeholder, size, completeOnTheRight) => {
+    if (completeOnTheRight) {
+      return value + String(placeholder).repeat(size);
+    } else {
+      return String(placeholder).repeat(size) + value;
+    }
+  };
+
+  switch (type) {
+    case "string":
+      {
+        if (!data) data = "";
+        data = data.toString();
+        let needToCompleteSize = size - data.length;
+        if (needToCompleteSize < 0) {
+          res = data.substring(0, size);
+        } else {
+          res = completeDirection(
+            data,
+            stringPlaceholder,
+            needToCompleteSize,
+            completeOnTheRight
+          );
+        }
+      }
+      break;
+    case "number":
+      {
+        if (!data) data = 0;
+        let numberToString = data.toString();
+        let intPart = numberToString.split(".")[0];
+        let decPart = numberToString.split(".")[1];
+        //calculate decimal part of the number
+        if (!decPart) {
+          decPart = "0".repeat(nDecimalDigits);
+        } else {
+          let needToCompleteDecPart = nDecimalDigits - decPart.length;
+          if (needToCompleteDecPart < 0) {
+            decPart = decPart.substring(0, nDecimalDigits);
+          } else {
+            decPart = decPart + "0".repeat(needToCompleteDecPart);
+          }
+        }
+        res = intPart;
+        if (nDecimalDigits > 0) {
+          res += "." + decPart;
+        }
+        let needToCompleteSize = size - res.length;
+        if (needToCompleteSize < 0) {
+          res = res.substring(0, size);
+        } else {
+          res = "0".repeat(needToCompleteSize) + res;
+        }
+      }
+      break;
+    default:
+  }
+  return res;
+};
+
+const getValueOrNull = (_value, path) => {
+  try {
+    let value = { ..._value };
+    // check that the value has a value
+    if (!value || !Object.keys(value).length || value === "") {
+      return null;
+    }
+    return path
+      .split(/\].|\]\[|\[|\./) // split on [] or .
+      .map((el) =>
+        el
+          .replace(/\]$/, "")
+          //In case you want to parse an ESCAPE propertie with [] or . in the name, you should use
+          // () instead of [] and , instead of .
+          .replace("(", "[")
+          .replace(")", "]")
+          .replace(",", ".")
+      )
+      .reduce(
+        (obj, el) =>
+          obj && typeof obj !== "undefined" && obj[el] ? obj[el] : null,
+        value
+      );
+  } catch (e) {
+    console.log(e);
+    throw `Error trying to get Path: ${path} in value`;
+  }
+};
+
+// allows to return a value in case of null and also to validate if its a required field or not
+const getValueOrNullControl = (
+  value = {},
+  path = "",
+  isRequired = true,
+  nullCase = ""
+) => {
+  try {
+    const result = getValueOrNull(value, path);
+    if (!result && isRequired)
+      throw new Error(`Value path ${path} is required`);
+    if (!result && !isRequired && nullCase != null && nullCase !== undefined)
+      return nullCase;
+    return result;
+  } catch (e) {
+    throw new Error(`Failed trying to get value with path ${path}`);
+  }
+};
+
+// use it to create safe fields for csv files writing
+const generateCSVField = (
+  obj,
+  path,
+  separator = ";",
+  lastValue = false,
+  replaceValue = " ",
+  alternativeValue = { path: null, obj: null }
+) => {
+  let value = path ? getValueOrNull(obj, path) : obj;
+  if (value) {
+    if (
+      typeof value === "string" ||
+      typeof value === "number" ||
+      typeof value === "boolean" ||
+      typeof value === "bigint"
+    ) {
+      value = String(value).replace(
+        new RegExp(`\n|\r\n|\r|\f|${separator}`, "g"),
+        replaceValue
+      );
+    } else {
+      value = "";
+    }
+    if (!lastValue) {
+      return value + separator;
+    }
+    return value;
+  } else if (alternativeValue && alternativeValue.path) {
+    value = generateCSVField(
+      alternativeValue.obj ?? obj,
+      alternativeValue.path,
+      separator,
+      lastValue,
+      replaceValue
+    );
+    return value;
+  }
+  return separator;
+};
+
+const promisesCollector = (elements, fn, params) => {
+  // set vars
+  let promises = [];
+
+  // validations
+  if (!Array.isArray(elements) || elements.length < 1) {
+    // throw error
+    throw "Wrong input data";
+  }
+
+  // iterate over every element
+  for (let element of elements) {
+    // push the promise to the array of promises
+    promises.push(fn(element, params));
+  }
+
+  // return promises result as a promise
+  return Promise.all(promises);
+};
+
+const batchPromiseCollector = async (
+  elements,
+  fn,
+  params = {},
+  batchSize = 10
+) => {
+  for (let i = 0; i < elements.length; i += batchSize) {
+    const requests = elements.slice(i, i + batchSize).map((item) => {
+      if (item && typeof item === "object") {
+        return fn({ ...item, ...params });
+      } else {
+        return fn(item, params);
+      }
+    });
+    await Promise.all(requests);
+  }
+};
+
+const batchPromiseCollectorWithIndex = async (
+  elements,
+  fn,
+  params = {},
+  batchSize = 10
+) => {
+  for (let i = 0; i < elements.length; i += batchSize) {
+    const requests = elements.slice(i, i + batchSize).map((item, index) => {
+      return fn(item, i + index, params);
+    });
+    await Promise.all(requests);
+  }
+};
+
+/**
+ * Group an array of objects by a property
+ * @param array
+ * @param key
+ * @returns {{}}
+ */
+const groupBy = (array, key) => {
+  // set vars
+  let result = {};
+
+  // validations
+  if (!Array.isArray(array) || array.length < 1) {
+    // throw error
+    throw "Wrong input data";
+  }
+
+  // iterate over every element
+  for (let element of array) {
+    // set the key
+    let keyValue = element[key];
+
+    // if the key is not set
+    if (!keyValue) {
+      // throw error
+      throw "Wrong input data";
+    }
+
+    // if the key is not set
+    if (!result[keyValue]) {
+      // set the key
+      result[keyValue] = [];
+    }
+
+    // push the element to the array of elements
+    result[keyValue].push(element);
+  }
+
+  // return the result
+  return result;
+};
+
+const generateUuid = (length = 8) => {
+  // create string of a fixed length
+  let value = new Array(length + 1).join("x");
+  return value.replace(/[xy]/g, function (c) {
+    let r = (Math.random() * 16) | 0,
+      v = c == "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+/**
+ * Merge PDF
+ * @param path
+ * @param s3Pointers
+ * @param extension
+ * @returns {Promise<unknown>}
+ */
+const mergePDF = async (path, s3Pointers, extension) => {
+  let credentials = await config.get();
+
+  if (!credentials || !credentials.microservices) {
+    throw "No credentials loaded";
+  }
+
+  let mergePDFFunction = credentials.microservices.mergePDF.functionName;
+
+  let lambdaStageVariable = {
+    S3BUCKET: credentials.s3bucket,
+    ACCESS_KEY_ID: credentials.awsCredentials.accessKeyId,
+    SECRET_ACCESS_KEY: credentials.awsCredentials.secretAccessKey,
+  };
+  return new Promise(async (resolve, reject) => {
+    try {
+      if (Array.isArray(s3Pointers) && s3Pointers.length > 1) {
+        if (!path) {
+          throw new Error('"mergePDF" invalid path');
+        }
+        extension = extension ? extension : "pdf";
+        let payload = JSON.stringify({
+          s3files: s3Pointers,
+          stageVariables: lambdaStageVariable,
+          responseOption: {
+            type: "S3Path",
+            signedURL: false,
+            saveLocation: `${path}${new Date().getTime()}.${extension}`,
+          },
+        });
+
+        let lambdaResult = await awslambda.invokeLambda(
+          payload,
+          mergePDFFunction
+        );
+
+        if (lambdaResult.statusCode !== 200) {
+          throw new Error(
+            `Lambda function ${mergePDFFunction} returned status code ${lambdaResult.statusCode}`
+          );
+        }
+        resolve(lambdaResult.file);
+      } else {
+        throw new Error('"mergePDF" invalid array');
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+const getMessageAndCodeFromError = (err) => {
+  const returnData = {};
+
+  //if the error is string
+  if (typeof err === "string") {
+    try {
+      err = JSON.parse(err);
+    } catch (e) {
+      return {
+        message: err,
+        code: 417,
+      };
+    }
+  }
+
+  //axios normal error
+  if (
+    getValueOrNull(err, "response.status") &&
+    getValueOrNull(err, "response.data")
+  ) {
+    return {
+      message: err.response.data,
+      code: err.response.status,
+    };
+  }
+
+  //if is axios error in array
+  if (err && Array.isArray(err) && err.length > 0) {
+    returnData.code = err[0].status;
+    returnData.message = err[err[0].data];
+  } else if (err.message) {
+    //normal error
+    returnData.message = err.message;
+    if (err.code) {
+      returnData.code = err.code;
+    } else if (getValueOrNull(err, "response.status")) {
+      returnData.code = err.response.status;
+    } else {
+      //set default code
+      returnData.code = 417;
+    }
+  } else {
+    //default
+    returnData.message = err;
+    returnData.code = 417;
+  }
+  return returnData;
+};
+
+module.exports = {
+  dataToString,
+  getMessageFromValidator,
+  getValueOrNull,
+  getObjectByString,
+  sleep,
+  replaceInvalidXMLChars,
+  getCountryNameByCode,
+  convertAlphaCode,
+  getCountryCodeByName,
+  processCountry,
+  fixSizeField,
+  getValueOrNullControl,
+  generateCSVField,
+  promisesCollector,
+  batchPromiseCollector,
+  batchPromiseCollectorWithIndex,
+  groupBy,
+  generateUuid,
+  mergePDF,
+  getMessageAndCodeFromError,
+};

package/validator/index.js

@@ -0,0 +1,44 @@
+const joiValidations = require('./joiSchema');
+
+
+/**
+ * To validate the data with Joi Schema. if this is true it throw error validation to the try catch. If it's false it just return the validation instead of throw.
+ * If the validation is for Request we need to send the validation message to the user. If it's the response validation we don't need to send to the user.
+ * @param data data needs to be validated
+ * @param schema schema used to validate
+ * @param canThrow Boolean to throw the error result
+ * @returns {*} throw error to the catch || return validated data
+ */
+const validateWithJoi = (data, schema, canThrow = true) => {
+  if(!schema) throw new Error('Schema was not found')
+
+  // validate the schema
+  const validationResult = schema.validate(data, {abortEarly: false, stripUnknown: true});
+
+  //Throw error back the api-gateway (user request)
+  if (canThrow) {
+    if (validationResult.error) {
+      throw ({
+        message: validationResult.error.message
+      });
+    }
+    return validationResult.value;
+
+  //  return validation result to function. Did not throw to the user request
+  } else {
+    return validationResult;
+  }
+};
+
+
+// exportable methods
+const validateRequest = (event, model,canThrow = true) => validateWithJoi(event, joiValidations[model],canThrow);
+const validate = (event, model,canThrow = true) => validateWithJoi(event, joiValidations[model],canThrow);
+const validateResponse = (event, model) => validateWithJoi(event, joiValidations[model], false);
+
+module.exports = {
+  validateRequest: validateRequest,
+  validate: validate,
+  validateResponse: validateResponse,
+  validateWithJoi: validateWithJoi
+};