gx-node-api-errors/errors/translateJoiError.js

Library to use in node js APIs to handle errors

const errors = require("./baseErrors").errors;

function replaceFieldNameOnErrorMessage(data) {
  return data.message.replace(
    /"([^"]*)"/,
    `"${data.path[data.path.length - 1]}"`
  );
}

function replaceDynamicsNumericFields(data) {
  const findNumber = data.match(/(\d+)/);
  const message = ` ${data.substring(
    0,
    findNumber.index - 1
  )} {${data.substring(
    findNumber.index,
    findNumber.index + data.substring(findNumber.index).indexOf(" ")
  )}} ${data.substring(
    findNumber.index + data.substring(findNumber.index).indexOf(" ") + 1
  )}`;
  return message;
}

function replaceLastDynamics(data) {
  const replacedynamicType = `${data.substring(
    0,
    data.lastIndexOf(" ")
  )} {${data.substring(data.lastIndexOf(" ") + 1, data.length)}}`;

  return replacedynamicType;
}

function assignErrorMessage(data, message) {
  const error = errors.filter(
    (obj) => obj.errorMessage && obj.errorMessage.includes(message)
  );
  const newError = { ...error[0] };
  newError.errorMessage = replaceFieldNameOnErrorMessage(data);
  return newError;
}

function assignErrorMessageDynamicFields(data, message) {
  const error = errors.filter(
    (obj) => obj.errorMessage && obj.errorMessage.includes(message)
  );
  const newError = { ...error[0] };
  newError.errorMessage = replaceDynamicsNumericFields(
    replaceFieldNameOnErrorMessage(data)
  );
  return newError;
}

function assignErrorMessageLastDynamic(data, message) {
  const error = errors.filter(
    (obj) => obj.errorMessage && obj.errorMessage.includes(message)
  );
  const newError = { ...error[0] };
  newError.errorMessage = replaceLastDynamics(
    replaceFieldNameOnErrorMessage(data)
  );
  return newError;
}

function translateJoiError(data) {
  const { type } = data;
  if (type.includes("string.max")) {
    return assignErrorMessageDynamicFields(data, "maxLength");
  }
  if (type.includes("string.min")) {
    return assignErrorMessageDynamicFields(data, "minLength");
  }
  if (type.includes("number.min")) {
    return assignErrorMessageLastDynamic(data, "minValue");
  }
  if (type.includes("number.max")) {
    return assignErrorMessageLastDynamic(data, "maxValue");
  }
  if(type === 'string.pattern.base' || type === "string.pattern.invert.base" ){
    const error = errors.filter(
      (obj) => obj.errorMessage && obj.errorMessage.includes('required pattern')
      );
      return error[0];
  }
  if (type.includes(".base") || type.includes("string.email")) {
    return assignErrorMessageLastDynamic(data, "must be a ");
  }
  if (type.includes(".only")) {
    const error = errors.filter(
      (obj) => obj.errorMessage && obj.errorMessage.includes("must be one of ")
    );
    const newError = { ...error[0] };
    newError.errorMessage = replaceFieldNameOnErrorMessage(data);
    const replacedynamicType = `${newError.errorMessage.substring(
      0,
      newError.errorMessage.indexOf("[")
    )}{${newError.errorMessage.substring(
      newError.errorMessage.indexOf("["),
      newError.errorMessage.length
    )}}`;
    newError.errorMessage = replacedynamicType;
    return newError;
  }
  if (type.includes(".unknown") || type.includes(".allowUnknown")) {
    const returning = assignErrorMessage(data, "is not allowed");
    return returning;
  }
  if (type.includes(".empty")) {
    return assignErrorMessage(data, "empty");
  }
  if (type.includes("any.required")) {
    return assignErrorMessage(data, "required");
  }
  if (type.includes("any.custom")) {
    return assignErrorMessage(data, data.context.error.message);
  }
  if (type.includes("array.min") || type.includes("array.max")) {
    return assignErrorMessage(data, "array has invalid size");
  }

  return null;
}

module.exports = function parseJoiError(error) {
  let errorMessage = null;
  const getError = translateJoiError(error);
  if (error.type === "string.pattern.base" || error.type === "string.pattern.invert.base" ) {
    errorMessage = `{${
      error.path[error.path.length - 1]
    }} fails to match the required pattern`;
  } else if (error.type === "any.custom") {
    errorMessage = `{${error.path[error.path.length - 1]}} ${
      error.context.error.message
    }`;
  } else if (error.type === "array.min" || error.type === "array.max") {
    errorMessage = `{${
      error.path[error.path.length - 1]
    }} array has invalid size`;
  } else {
    errorMessage = getError.errorMessage;
  }

  errorMessage = errorMessage.replace(/['"]+/, "{");
  errorMessage = errorMessage.replace(/['"]+/, "}");

  return {
    field: error.path[error.path.length - 1],
    fieldValue: error.context.value,
    errorCode: getError.errorCode,
    errorType: "error",
    errorMessage,
  };
};