nox-validation 1.0.1

package/lib/validate.js

@@ -0,0 +1,867 @@
+const constants = require("./constant");
+const {
+  findDisallowedKeys,
+  formatLabel,
+  getLastChildKey,
+  buildNestedStructure,
+  getValue,
+  setValue,
+  isEmpty,
+} = require("./helpers");
+
+const typeChecks = {
+  date: (val, data) => {
+    if (val instanceof Date && !isNaN(val)) return true;
+    if (typeof val === "string" && !isNaN(Date.parse(val))) {
+      if (data && data?.key && data?.updateValue) {
+        data.updateValue(data.key, new Date(val));
+      }
+      return true;
+    }
+    return false;
+  },
+  [constants.types.DATE]: (val, data) => {
+    if (val instanceof Date && !isNaN(val)) return true;
+    if (typeof val === "string" && !isNaN(Date.parse(val))) {
+      if (data && data?.key && data?.updateValue) {
+        data.updateValue(data.key, new Date(val));
+      }
+      return true;
+    }
+    return false;
+  },
+  [constants.types.BOOLEAN]: (val, data) => {
+    if (typeof val === "boolean") return true;
+    if (typeof val === "string") {
+      const lowerVal = val.toLowerCase();
+      if (lowerVal === "true" || lowerVal === "false") {
+        if (data && data?.key && data?.updateValue) {
+          data.updateValue(data.key, lowerVal === "true");
+        }
+        return true;
+      }
+    }
+    return false;
+  },
+  [constants.types.DATE_TIME]: (val, data) => {
+    if (val instanceof Date && !isNaN(val)) return true;
+    if (typeof val === "string" && !isNaN(Date.parse(val))) {
+      if (data && data?.key && data?.updateValue) {
+        data.updateValue(data.key, new Date(val));
+      }
+      return true;
+    }
+    return false;
+  },
+  [constants.types.NUMBER]: (val, data) => {
+    if (typeof val === "number" && !isNaN(val)) return true;
+    if (typeof val === "string" && !isNaN(parseFloat(val))) {
+      if (data && data?.key && data?.updateValue) {
+        data.updateValue(data.key, parseFloat(val));
+      }
+      return true;
+    }
+    return false;
+  },
+
+  [constants.types.TIME]: (val) =>
+    typeof val === "string" &&
+    /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/.test(val),
+  [constants.types.STRING]: (val) => typeof val === "string",
+  [constants.types.OBJECT]: (val) =>
+    typeof val === "object" && val !== null && !Array.isArray(val),
+  [constants.types.ARRAY]: (val) => Array.isArray(val),
+  [constants.types.OBJECT_ID]: (val) =>
+    typeof val === "string" && /^[0-9a-fA-F]{24}$/.test(val),
+  [constants.types.MIXED]: (val) => (val ? true : false),
+  [constants.types.BUFFER]: (val) => val instanceof Buffer,
+  [constants.types.ALIAS]: (val) => (val ? true : false),
+};
+
+const handleMinMaxValidation = (
+  fieldValue,
+  ruleValue,
+  ruleType,
+  field,
+  addError,
+  currentPath,
+) => {
+  let message = "";
+  const fieldLabel = formatLabel(field.display_label);
+
+  if (ruleType === constants.rulesTypes.MIN) {
+    if (
+      field.type === constants.types.STRING &&
+      typeChecks[constants.types.STRING](fieldValue) &&
+      fieldValue?.length < ruleValue[0]
+    ) {
+      message = constants.rulesMessages.MIN_STRING.replace(
+        `{field}`,
+        fieldLabel,
+      ).replace(`{min}`, ruleValue[0]);
+    } else if (
+      field.type === constants.types.NUMBER &&
+      typeChecks[constants.types.NUMBER](fieldValue) &&
+      fieldValue < ruleValue[0]
+    ) {
+      message = constants.rulesMessages.MIN_NUMBER.replace(
+        `{field}`,
+        fieldLabel,
+      ).replace(`{min}`, ruleValue[0]);
+    }
+  }
+
+  if (ruleType === constants.rulesTypes.MAX) {
+    if (
+      field.type === constants.types.STRING &&
+      typeChecks[constants.types.STRING](fieldValue) &&
+      fieldValue?.length > ruleValue[0]
+    ) {
+      message = constants.rulesMessages.MAX_STRING.replace(
+        `{field}`,
+        fieldLabel,
+      ).replace(`{max}`, ruleValue[0]);
+    } else if (
+      field.type === constants.types.NUMBER &&
+      typeChecks[constants.types.NUMBER](fieldValue) &&
+      fieldValue > ruleValue[0]
+    ) {
+      message = constants.rulesMessages.MAX_NUMBER.replace(
+        `{field}`,
+        fieldLabel,
+      ).replace(`{max}`, ruleValue[0]);
+    }
+  }
+
+  if (message) {
+    addError(
+      currentPath,
+      { label: fieldLabel, fieldPath: currentPath, description: "", message },
+      field,
+    );
+  }
+};
+
+const validateMetaRules = (
+  field,
+  addError,
+  providedValue,
+  currentPath,
+  updateValue,
+) => {
+  const fieldValue = providedValue;
+  const { required = false, nullable = false } = field?.meta ?? {};
+
+  if (required && isEmpty(fieldValue) && fieldValue !== null) {
+    const message = constants.rulesMessages.REQUIRED.replace(
+      `{field}`,
+      formatLabel(field.display_label),
+    );
+    addError(
+      currentPath,
+      {
+        label: formatLabel(field.display_label),
+        fieldPath: currentPath,
+        description: "",
+        message,
+      },
+      field,
+    );
+  }
+
+  if (!nullable && fieldValue === null) {
+    const message = constants.rulesMessages.NOT_NULLABLE.replace(
+      `{field}`,
+      formatLabel(field.display_label),
+    );
+    addError(
+      currentPath,
+      {
+        label: formatLabel(field.display_label),
+        fieldPath: currentPath,
+        description: "",
+        message,
+      },
+      field,
+    );
+  }
+
+  if (
+    !isEmpty(fieldValue) &&
+    typeChecks[field.type] &&
+    !typeChecks[field.type](fieldValue, { key: currentPath, updateValue })
+  ) {
+    const message = constants.rulesMessages.INVALID_TYPE.replace(
+      `{field}`,
+      formatLabel(field.display_label),
+    ).replace(`{type}`, field?.type);
+    addError(
+      currentPath,
+      {
+        label: formatLabel(field.display_label),
+        fieldPath: currentPath,
+        description: "",
+        message,
+      },
+      field,
+    );
+  }
+};
+
+const handleRegexValidation = (
+  fieldValue,
+  rule,
+  field,
+  addError,
+  currentPath,
+) => {
+  let message = "";
+  const fieldLabel = formatLabel(field.display_label);
+  const flags = `${rule.options.case_sensitive ? "" : "i"}${rule.options.multiline ? "m" : ""}${
+    rule.options.global ? "g" : ""
+  }`;
+  const regex = new RegExp(rule.value[0], flags);
+
+  const isValid = (() => {
+    switch (rule.options.type) {
+      case constants.regexTypes.MATCH:
+        message = constants.rulesMessages.REGEX_MATCH;
+        return regex.test(fieldValue);
+      case constants.regexTypes.START_WITH:
+        message = constants.rulesMessages.REGEX_START_WITH;
+        return fieldValue?.startsWith(
+          rule.value[0].replace(/^\//, "").replace(/\/$/, ""),
+        );
+      case constants.regexTypes.ENDS_WITH:
+        message = constants.rulesMessages.REGEX_ENDS_WITH;
+        return fieldValue?.endsWith(
+          rule.value[0].replace(/^\//, "").replace(/\/$/, ""),
+        );
+      case constants.regexTypes.CONTAINS:
+        message = constants.rulesMessages.REGEX_CONTAINS;
+        return regex.test(fieldValue);
+      case constants.regexTypes.EXACT:
+        message = constants.rulesMessages.REGEX_EXACT;
+        return (
+          fieldValue === rule.value[0].replace(/^\//, "").replace(/\/$/, "")
+        );
+      case constants.regexTypes.NOT_START_WITH:
+        message = constants.rulesMessages.REGEX_NOT_START_WITH;
+        return !fieldValue?.startsWith(
+          rule.value[0].replace(/^\//, "").replace(/\/$/, ""),
+        );
+      case constants.regexTypes.NOT_ENDS_WITH:
+        message = constants.rulesMessages.REGEX_NOT_ENDS_WITH;
+        return !fieldValue?.endsWith(
+          rule.value[0].replace(/^\//, "").replace(/\/$/, ""),
+        );
+      case constants.regexTypes.NOT_CONTAINS:
+        message = constants.rulesMessages.REGEX_NOT_CONTAINS;
+        return !regex.test(fieldValue);
+      default:
+        return false;
+    }
+  })();
+
+  if (!isValid) {
+    message = message
+      ?.replace(`{field}`, fieldLabel)
+      ?.replace(`{value}`, rule.value[0]);
+    addError(
+      currentPath,
+      { label: fieldLabel, fieldPath: currentPath, description: "", message },
+      field,
+    );
+  }
+};
+
+const validateOperatorRule = (
+  fieldValue,
+  rule,
+  field,
+  addError,
+  currentPath,
+  formData,
+) => {
+  const { isFieldCompare = false } = rule?.options ?? {};
+  let valid = false;
+
+  const isNumber = field.type === constants.types.NUMBER;
+  const isDate = field.type === constants.types.DATE || field.type === "date";
+  const isDateTime = field.type === constants.types.DATE_TIME;
+  const isTime = field.type === constants.types.TIME;
+  const isArray = field.type === constants.types.ARRAY;
+
+  const parseTime = (timeStr) => {
+    if (!timeStr || typeof timeStr !== "string") return null;
+    const [hh, mm, ss] = timeStr.split(":").map(Number);
+    return hh * 3600 + mm * 60 + ss;
+  };
+
+  const getComparableValue = (value, forMessage = false) => {
+    if (isNumber) return Number(value);
+    if (isDate) {
+      const date = new Date(value);
+      date.setHours(0, 0, 0, 0);
+      if (forMessage) {
+        return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
+      }
+      return Math.floor(date.getTime() / 1000);
+    }
+    if (isDateTime) {
+      const date = new Date(value);
+
+      if (forMessage) {
+        return (
+          `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")} ` +
+          `${String(date.getUTCHours()).padStart(2, "0")}:${String(date.getUTCMinutes()).padStart(2, "0")}:${String(date.getUTCSeconds()).padStart(2, "0")}`
+        );
+      }
+
+      return Math.floor(date.getTime() / 1000);
+    }
+    if (isTime) {
+      if (forMessage) {
+        return value;
+      }
+      return parseTime(value);
+    }
+    return value;
+  };
+
+  rule.value = rule.value?.map((key) => {
+    const value = isFieldCompare
+      ? getComparableValue(getValue(formData, key), true)
+      : getComparableValue(key, true);
+    return value ? value : key;
+  });
+
+  const fieldValueParsed = getComparableValue(fieldValue);
+
+  const messageValue = Array.isArray(rule.value)
+    ? rule.value.join(", ")
+    : String(rule.value);
+  let message = "";
+
+  switch (rule.options.operator) {
+    case constants.operatorTypes.AND:
+      message = constants.rulesMessages.AND?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", messageValue);
+      valid = isArray
+        ? rule.value.every((val) => fieldValue.includes(val))
+        : rule.value.every((val) => val === fieldValueParsed);
+      break;
+    case constants.operatorTypes.OR:
+      message = constants.rulesMessages.OR?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", messageValue);
+      valid = isArray
+        ? rule.value.some((val) => fieldValue.includes(val))
+        : rule.value.some((val) => val === fieldValueParsed);
+      break;
+    case constants.operatorTypes.EQUAL:
+      message = constants.rulesMessages.EQUAL?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = fieldValueParsed === getComparableValue(rule.value[0]);
+      break;
+    case constants.operatorTypes.NOT_EQUAL:
+      message = constants.rulesMessages.NOT_EQUAL?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = fieldValueParsed !== getComparableValue(rule.value[0]);
+      break;
+    case constants.operatorTypes.LESS_THAN:
+      message = constants.rulesMessages.LESS_THAN?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = fieldValueParsed < getComparableValue(rule.value[0]);
+      break;
+    case constants.operatorTypes.LESS_THAN_EQUAL:
+      message = constants.rulesMessages.LESS_THAN_EQUAL?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = fieldValueParsed <= getComparableValue(rule.value[0]);
+      break;
+    case constants.operatorTypes.GREATER_THAN:
+      message = constants.rulesMessages.GREATER_THAN?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = fieldValueParsed > getComparableValue(rule.value[0]);
+      break;
+    case constants.operatorTypes.GREATER_THAN_EQUAL:
+      message = constants.rulesMessages.GREATER_THAN_EQUAL?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = fieldValueParsed >= getComparableValue(rule.value[0]);
+      break;
+    case constants.operatorTypes.IN:
+      message = constants.rulesMessages.IN?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", messageValue);
+      valid = rule.value.includes(fieldValue);
+      break;
+    case constants.operatorTypes.NOT_IN:
+      message = constants.rulesMessages.NOT_IN?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", messageValue);
+      valid = !rule.value.includes(fieldValue);
+      break;
+    case constants.operatorTypes.EXISTS:
+      message = constants.rulesMessages.EXISTS?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      );
+      valid = rule.value[0]
+        ? fieldValue !== undefined
+        : fieldValue === undefined;
+      break;
+    case constants.operatorTypes.TYPE:
+      message = constants.rulesMessages.TYPE?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = typeChecks[rule.value[0]](fieldValue);
+      break;
+    case constants.operatorTypes.MOD:
+      message = constants.rulesMessages.MOD?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )
+        ?.replace("{value[1]}", rule.value[1])
+        ?.replace("{value[0]}", rule.value[0]);
+      valid = isNumber && fieldValue % rule.value[0] === rule.value[1];
+      break;
+    case constants.operatorTypes.ALL:
+      message = constants.rulesMessages.ALL?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", messageValue);
+      valid = isArray && rule.value.every((val) => fieldValue.includes(val));
+      break;
+    case constants.operatorTypes.SIZE:
+      message = constants.rulesMessages.SIZE?.replace(
+        `{field}`,
+        formatLabel(field.display_label),
+      )?.replace("{value}", rule.value[0]);
+      valid = isArray && fieldValue.length === rule.value[0];
+      break;
+    default:
+      console.log(`Unknown Operator : ${rule.options.operator}`);
+      break;
+  }
+  if (!valid) {
+    addError(
+      currentPath,
+      {
+        label: formatLabel(field.display_label),
+        fieldPath: currentPath,
+        description: "",
+        message,
+      },
+      field,
+    );
+  }
+};
+
+const generateErrorMessage = (ruleKey, fieldLabel, additionalValues = {}) => {
+  let message = constants.rulesMessages[ruleKey]?.replace(
+    `{field}`,
+    fieldLabel,
+  );
+  Object.entries(additionalValues).forEach(([key, value]) => {
+    message = message.replace(`{${key}}`, value);
+  });
+  return message;
+};
+
+const handleRule = (rule, field, value, addError, currentPath, formData) => {
+  const ruleValue = rule?.value;
+  const messageValue = Array.isArray(ruleValue)
+    ? ruleValue.join(", ")
+    : String(ruleValue);
+  const fieldLabel = formatLabel(field.display_label);
+
+  const addValidationError = (ruleKey, extraValues = {}) =>
+    addError(
+      currentPath,
+      {
+        label: fieldLabel,
+        fieldPath: currentPath,
+        description: "",
+        message: generateErrorMessage(ruleKey, fieldLabel, extraValues),
+      },
+      field,
+    );
+
+  switch (rule.case) {
+    case constants.rulesTypes.EMPTY:
+      if (value) addValidationError("EMPTY");
+      break;
+    case constants.rulesTypes.NOT_EMPTY:
+      if (!value || value.length === 0) addValidationError("NOT_EMPTY");
+      break;
+    case constants.rulesTypes.ONE_OF:
+      if (!ruleValue?.includes(value))
+        addValidationError("ONE_OF", { value: messageValue });
+      break;
+    case constants.rulesTypes.NOT_ONE_OF:
+      if (ruleValue?.includes(value))
+        addValidationError("NOT_ONE_OF", { value: messageValue });
+      break;
+    case constants.rulesTypes.NOT_ALLOWED:
+      if (ruleValue?.includes(value)) addValidationError("NOT_ALLOWED");
+      break;
+    case constants.rulesTypes.MIN:
+    case constants.rulesTypes.MAX:
+      handleMinMaxValidation(
+        value,
+        ruleValue,
+        rule.case,
+        field,
+        addError,
+        currentPath,
+      );
+      break;
+    case constants.rulesTypes.REGEX:
+      handleRegexValidation(value, rule, field, addError, currentPath);
+      break;
+    case constants.rulesTypes.OPERATOR:
+      validateOperatorRule(value, rule, field, addError, currentPath, formData);
+      break;
+    default:
+      console.warn(`Unknown Rule: ${rule.case}`, fieldLabel);
+  }
+};
+
+const validateField = (
+  field,
+  value,
+  fieldPath = "",
+  addError,
+  formData,
+  updateValue,
+) => {
+  const currentPath = fieldPath
+    ? `${fieldPath}.${field.key.split(".").pop()}`
+    : field.key;
+  const fieldLabel = formatLabel(field.display_label);
+
+  validateMetaRules(field, addError, value, currentPath, updateValue);
+
+  if (
+    field.type === constants.types.OBJECT &&
+    field.children &&
+    value &&
+    typeChecks[constants.types.OBJECT](value)
+  ) {
+    field.children.forEach((child) =>
+      validateField(
+        child,
+        value[child.key.split(".").pop()],
+        currentPath,
+        addError,
+        updateValue,
+      ),
+    );
+  } else if (field.type === constants.types.ARRAY && Array.isArray(value)) {
+    const itemType = field?.array_type || field?.schema_definition?.type;
+    if (itemType) {
+      value.forEach((item, index) => {
+        if (!typeChecks[itemType](item)) {
+          addError(`${currentPath}[${index}]`, {
+            label: fieldLabel,
+            fieldPath: `${currentPath}[${index}]`,
+            description: "",
+            message: generateErrorMessage("INVALID_TYPE", fieldLabel, {
+              type: itemType,
+            }),
+          });
+        }
+      });
+    }
+    if (field.children?.length > 0) {
+      value.forEach((item, index) => {
+        field.children.forEach((child) =>
+          validateField(
+            child,
+            item[child.key.split(".").pop()],
+            `${currentPath}[${index}]`,
+            addError,
+            updateValue,
+          ),
+        );
+      });
+    }
+  } else {
+    if (!applyValidations(field, value, addError, currentPath, formData)) {
+      addError(
+        currentPath,
+        {
+          label: fieldLabel,
+          fieldPath: currentPath,
+          description: "",
+          message: `Invalid value for ${currentPath}`,
+        },
+        field,
+      );
+    }
+  }
+};
+
+const applyValidations = (field, value, addError, currentPath, formData) => {
+  if (!field.validations || value === null || value === undefined) return true;
+  return !field.validations.some(
+    (rule) =>
+      handleRule(rule, field, value, addError, currentPath, formData) === false,
+  );
+};
+
+const schema = {
+  formData: { type: constants.types.OBJECT, array_type: null },
+  formId: { type: constants.types.OBJECT_ID, array_type: null },
+  isSeparatedFields: { type: constants.types.BOOLEAN, array_type: null },
+  relations: {
+    type: constants.types.ARRAY,
+    array_type: constants.types.OBJECT,
+  },
+  fields: { type: constants.types.ARRAY, array_type: constants.types.OBJECT },
+  relationalFields: { type: constants.types.OBJECT, array_type: null },
+  abortEarly: { type: constants.types.BOOLEAN, array_type: null },
+  byPassKeys: {
+    type: constants.types.ARRAY,
+    array_type: constants.types.STRING,
+  },
+  apiVersion: { type: constants.types.STRING, array_type: null },
+};
+
+const validate = (data) => {
+  const {
+    formData,
+    isSeparatedFields,
+    fields,
+    relationalFields,
+    relations,
+    formId,
+    abortEarly,
+    byPassKeys,
+    apiVersion,
+  } = data;
+  let result = { status: true, errors: {}, data: formData };
+
+  const updateValue = (key, value) => {
+    setValue(result.data, key, value);
+  };
+
+  const addError = (fieldPath, obj, field) => {
+    if (byPassKeys.some((key) => fieldPath.startsWith(key))) return;
+    if (!result.errors[fieldPath] && !field?.meta?.hidden) {
+      result.errors[fieldPath] = obj;
+      result.status = false;
+    }
+    if (abortEarly && !result.status) return result;
+  };
+
+  // Validate Parameters Starts
+
+  // Validate Data
+  const defaultField = { meta: { hidden: false } };
+  if (!data) {
+    const message = constants.rulesMessages.REQUIRED.replace(
+      `{field}`,
+      formatLabel("data"),
+    );
+    addError(
+      "data",
+      {
+        label: formatLabel("data"),
+        fieldPath: "data",
+        description: "",
+        message,
+      },
+      defaultField,
+    );
+    return result;
+  }
+
+  // validate data type
+  if (!typeChecks[constants.types.OBJECT](data)) {
+    const message = constants.rulesMessages.INVALID_TYPE.replace(
+      `{field}`,
+      formatLabel("data"),
+    ).replace(`{type}`, constants.types.OBJECT);
+    addError(
+      "data",
+      {
+        label: formatLabel("data"),
+        fieldPath: "data",
+        description: "",
+        message,
+      },
+      defaultField,
+    );
+    return result;
+  }
+
+  // Validate Parameters
+  Object.keys(schema).forEach((key) => {
+    const expectedType = schema[key].type;
+    const fieldValue = data[key];
+    // Skip empty values
+    if (fieldValue == null || fieldValue == undefined) {
+      const message = constants.rulesMessages.REQUIRED.replace(
+        `{field}`,
+        formatLabel(key),
+      );
+      addError(
+        key,
+        {
+          label: formatLabel(key),
+          fieldPath: key,
+          description: "",
+          message,
+        },
+        defaultField,
+      );
+      return;
+    }
+
+    // Validate field type
+    if (!typeChecks[expectedType] || !typeChecks[expectedType](fieldValue)) {
+      const message = constants.rulesMessages.INVALID_TYPE.replace(
+        `{field}`,
+        key,
+      ).replace(`{type}`, expectedType);
+      addError(
+        key,
+        {
+          label: formatLabel(key),
+          fieldPath: key,
+          description: "",
+          message,
+        },
+        defaultField,
+      );
+      return;
+    }
+
+    // Check array items if the field is an array
+    if (expectedType === constants.types.ARRAY && typeChecks[expectedType]) {
+      fieldValue.forEach((item, index) => {
+        // Determine the expected type of array items
+        const arrayItemType = schema[key].array_type; // Define item types like "relations[]": "object"
+
+        if (
+          arrayItemType &&
+          typeChecks[arrayItemType] &&
+          !typeChecks[arrayItemType](item)
+        ) {
+          const message = constants.rulesMessages.INVALID_TYPE.replace(
+            `{field}`,
+            `${key}[${index}]`,
+          ).replace(`{type}`, arrayItemType);
+          addError(
+            `${key}[${index}]`,
+            {
+              label: formatLabel(`${key}[${index}]`),
+              fieldPath: `${key}[${index}]`,
+              description: "",
+              message,
+            },
+            defaultField,
+          );
+        }
+      });
+    }
+  });
+
+  // Validate API Version
+  if (!constants.API_VERSIONS.includes(apiVersion)) {
+    const message = constants.rulesMessages.IN.replace(
+      `{field}`,
+      formatLabel("apiVersion"),
+    ).replace(`{value}`, constants.API_VERSIONS.join(", "));
+    addError(
+      "apiVersion",
+      {
+        label: formatLabel("apiVersion"),
+        fieldPath: "apiVersion",
+        description: "",
+        message,
+      },
+      defaultField,
+    );
+  }
+
+  if (!result.status) {
+    return result;
+  }
+
+  // Validate Parameters END
+
+  // Get Relational Field
+  let schemaFields = fields;
+  let allFields = isSeparatedFields ? [] : fields;
+
+  if (!isSeparatedFields) {
+    schemaFields = fields.filter(
+      (field) => field?.schema_id?.toString() === formId?.toString(),
+    );
+  }
+
+  const fieldOptions =
+    buildNestedStructure(
+      schemaFields || [],
+      allFields,
+      relations,
+      formData,
+      relationalFields,
+      isSeparatedFields,
+      apiVersion,
+    ) || [];
+
+  findDisallowedKeys(formData, fieldOptions).forEach((fieldPath) => {
+    if (abortEarly && !result.status) return result;
+    const fieldKey = getLastChildKey(fieldPath);
+    if (fieldKey && !result.errors[fieldPath]) {
+      addError(fieldPath, {
+        label: formatLabel(fieldKey),
+        fieldPath,
+        description: "",
+        message: generateErrorMessage(
+          "NOT_ALLOWED_FIELD",
+          formatLabel(fieldKey),
+          {
+            field: formatLabel(fieldKey),
+          },
+        ),
+      });
+    }
+  });
+
+  fieldOptions.forEach((field) => {
+    if (abortEarly && !result.status) return result;
+    validateField(
+      field,
+      formData[field.value],
+      "",
+      addError,
+      formData,
+      updateValue,
+    );
+  });
+  return result;
+};
+
+module.exports = { validate, validateField ,typeChecks};