nox-validation 1.0.1 → 1.0.2

package/README.md

@@ -11,12 +11,15 @@ npm install nox-validation
 ## Library Exports
 
 ### **Validation Functions:**
+
 - `validate` - The core function for validating data.
 
 ### **Constants:**
+
 - `CONSTANTS` - A collection of predefined constants (likely including data types, error messages, validation rules, etc.).
 
 ### **Helper Functions (`HELPERS`):**
+
 - `validateSingleField` - Validates a single field against defined rules.
 - `validateType` - Performs type checks for data validation.
 - `fieldsMapping` - Groups fields by `schemaId` for structured access.
@@ -26,7 +29,6 @@ npm install nox-validation
 
 ## Usage
 
-
 ```javascript
 const { validate, helpers } = require("nox-validation");
 
@@ -91,10 +93,10 @@ const schema = [
     },
   },
 ];
-
 ```
 
 #### When `isSeparatedFields` is `true`
+
 ```javascript
 const result = validate({
   formData: {
@@ -109,10 +111,12 @@ const result = validate({
   abortEarly: false,
   byPassKeys: [],
   apiVersion: "v1",
+  language: "nl",
 });
 ```
 
 #### When `isSeparatedFields` is `false`
+
 ```javascript
 const result = validate({
   formData: {
@@ -127,10 +131,12 @@ const result = validate({
   abortEarly: false,
   byPassKeys: [],
   apiVersion: "v1",
+  language: "nl",
 });
 ```
 
 #### Output Example:
+
 ```javascript
 {
   status: true, // Validation passed
@@ -190,6 +196,11 @@ const result = validate({
 - Specifies the API version (`"v1"` or `"v2"`).
 - Helps in maintaining compatibility and version control.
 
+#### `language` (String)
+
+- Specifies the locale language (`"nl"` or `"en"`).
+- Determines the locale for validation messages.
+
 ## Result
 
 The `validate` function returns an object with two keys:

package/lib/constant.js

@@ -151,6 +151,104 @@ const API_VERSION = Object.freeze({
 
 const API_VERSIONS = Object.freeze(Object.values(API_VERSION));
 
+const LANGUAGES = Object.freeze({
+  en: "en",
+  nl: "nl",
+});
+
+const LOCALE_NL_MESSAGES = Object.freeze({
+  INVALID_VALUE: `{field} bevat een ongeldige waarde.`,
+  EMPTY: `{field} moet leeg zijn.`,
+  NOT_EMPTY: `{field} mag niet leeg zijn.`,
+  ONE_OF: `{field} moet een van de volgende waarden zijn: {value}.`,
+  NOT_ONE_OF: `{field} mag niet een van de volgende waarden zijn: {value}.`,
+  REQUIRED: `{field} is verplicht.`,
+  OPTIONAL: `{field} is optioneel.`,
+  NOT_NULLABLE: `{field} mag niet null zijn.`,
+  INVALID_TYPE: "{field} bevat een ongeldig invoertype. Alleen {type} is toegestaan.",
+  NOT_ALLOWED_FIELD: `{field} is niet toegestaan.`,
+  COMPARE: `{field} komt niet overeen met de verwachte waarde.`,
+  RULES_COMPARE: `{field} voldoet niet aan de vergelijkingsregels.`,
+  ALLOW: `{field} bevat alleen toegestane tekens.`,
+  NOT_ALLOWED: `{field} bevat niet-toegestane tekens.`,
+  REGEX_MATCH: `{field} heeft een ongeldig formaat.`,
+  REGEX_START_WITH: `{field} moet beginnen met {value}.`,
+  REGEX_ENDS_WITH: `{field} moet eindigen op {value}.`,
+  REGEX_CONTAINS: `{field} moet {value} bevatten.`,
+  REGEX_EXACT: `{field} moet exact {value} zijn.`,
+  REGEX_NOT_START_WITH: `{field} mag niet beginnen met {value}.`,
+  REGEX_NOT_ENDS_WITH: `{field} mag niet eindigen op {value}.`,
+  REGEX_NOT_CONTAINS: `{field} mag {value} niet bevatten.`,
+  MIN_STRING: `{field} moet minstens {min} tekens lang zijn.`,
+  MAX_STRING: `{field} mag maximaal {max} tekens lang zijn.`,
+  MIN_NUMBER: `{field} moet minstens {min} zijn.`,
+  MAX_NUMBER: `{field} mag maximaal {max} zijn.`,
+  AND: "{field} moet een van {value} zijn.",
+  OR: "{field} moet een van {value} zijn.",
+  EQUAL: "{field} moet gelijk zijn aan {value}.",
+  NOT_EQUAL: "{field} mag niet gelijk zijn aan {value}.",
+  LESS_THAN: "{field} moet kleiner zijn dan {value}.",
+  LESS_THAN_EQUAL: "{field} moet kleiner dan of gelijk zijn aan {value}.",
+  GREATER_THAN: "{field} moet groter zijn dan {value}.",
+  GREATER_THAN_EQUAL: "{field} moet groter dan of gelijk zijn aan {value}.",
+  IN: "{field} moet een van de volgende waarden zijn: {value}.",
+  NOT_IN: "{field} mag geen van de volgende waarden bevatten: {value}.",
+  EXISTS: "{field} moet bestaan.",
+  TYPE: "{field} moet van type {value} zijn.",
+  MOD: "{field} moet een restwaarde van {value[1]} hebben wanneer gedeeld door {value[0]}.",
+  ALL: "{field} moet alle van de volgende waarden bevatten: {value}.",
+  SIZE: "{field} moet een grootte van {value} hebben.",
+});
+
+const LOCALE_EN_MESSAGES = Object.freeze({
+  INVALID_VALUE: `{field} contains invalid value.`,
+  EMPTY: `{field} should be empty.`,
+  NOT_EMPTY: `{field} should not be empty.`,
+  ONE_OF: `{field} should be one of the following: {value}.`,
+  NOT_ONE_OF: `{field} should not be one of the following: {value}.`,
+  REQUIRED: `{field} is required.`,
+  OPTIONAL: `{field} is optional.`,
+  NOT_NULLABLE: `{field} can not be null.`,
+  INVALID_TYPE: "{field} contains invalid input type. Only {type} is allowed.",
+  NOT_ALLOWED_FIELD: `{field} is not allowed.`,
+  COMPARE: `{field} does not match the expected value.`,
+  RULES_COMPARE: `{field} does not meet the comparison rules.`,
+  ALLOW: `{field} contains allowed characters only.`,
+  NOT_ALLOWED: `{field} contains disallowed characters.`,
+  REGEX_MATCH: `{field} format is invalid.`,
+  REGEX_START_WITH: `{field} should start with {value}.`,
+  REGEX_ENDS_WITH: `{field} should end with {value}.`,
+  REGEX_CONTAINS: `{field} should contain {value}.`,
+  REGEX_EXACT: `{field} should be exactly {value}.`,
+  REGEX_NOT_START_WITH: `{field} should not be start with {value}.`,
+  REGEX_NOT_ENDS_WITH: `{field} should not be ends with {value}.`,
+  REGEX_NOT_CONTAINS: `{field} should not contains {value}.`,
+  MIN_STRING: `{field} must be at least {min} characters long.`,
+  MAX_STRING: `{field} must be at most {max} characters long.`,
+  MIN_NUMBER: `{field} must be at least {min}.`,
+  MAX_NUMBER: `{field} must be at most {max}.`,
+  AND: "{field} must be any of {value}",
+  OR: "{field} must be any of {value}",
+  EQUAL: "{field} must be equal to {value}",
+  NOT_EQUAL: "{field} must not be equal to {value}",
+  LESS_THAN: "{field} must be less than {value}",
+  LESS_THAN_EQUAL: "{field} must be less than or equal to {value}",
+  GREATER_THAN: "{field} must be greater than {value}",
+  GREATER_THAN_EQUAL: "{field} must be greater than or equal to {value}",
+  IN: "{field} must be one of the following: {value}",
+  NOT_IN: "{field} must not contain any of these values: {value}",
+  EXISTS: "{field} must exist",
+  TYPE: "{field} must be of type {value}",
+  MOD: "{field} must have a remainder of {value[1]} when divided by {value[0]}",
+  ALL: "{field} must contain all of the following values: {value}",
+  SIZE: "{field} must have a size of {value}",
+});
+
+const LOCALE_MESSAGES = Object.freeze({
+  [LANGUAGES.en]:LOCALE_EN_MESSAGES,
+  [LANGUAGES.nl]:LOCALE_NL_MESSAGES
+})
+
 module.exports = {
   dataTypes,
   operatorTypes,
@@ -162,4 +260,6 @@ module.exports = {
   interfaces,
   API_VERSIONS,
   API_VERSION,
+  LANGUAGES,
+  LOCALE_MESSAGES
 };

package/lib/helpers.js

@@ -293,12 +293,7 @@ const generateRelationalFieldV1 = (key = "", collectionFields = [], relationType
     return [
       generateField("collection", "collection", constants.types.STRING, constants.types.STRING),
       generateField("sort", "sort", constants.types.NUMBER, constants.types.NUMBER),
-      generateField(
-        "item",
-        "item",
-        constants.types.OBJECT_ID,
-        constants.types.OBJECT_ID,
-      ),
+      generateField("item", "item", constants.types.OBJECT_ID, constants.types.OBJECT_ID),
     ];
   } else {
     return [];
@@ -556,16 +551,15 @@ const getCachedOrFetchFields = (schemaId, allFields, relational_fields) => {
 
 const getChildFields = (relationDetail, allFields, relational_fields, isTranslation) => {
   let key = isTranslation
-  ? [
-      ...(Array.isArray(relationDetail.junction_collection)
-        ? relationDetail.junction_collection
-        : [relationDetail.junction_collection]),
-      ...(Array.isArray(relationDetail.foreign_collection)
-        ? relationDetail.foreign_collection
-        : [relationDetail.foreign_collection])
-    ]
-  : relationDetail.foreign_collection;
-
+    ? [
+        ...(Array.isArray(relationDetail.junction_collection)
+          ? relationDetail.junction_collection
+          : [relationDetail.junction_collection]),
+        ...(Array.isArray(relationDetail.foreign_collection)
+          ? relationDetail.foreign_collection
+          : [relationDetail.foreign_collection]),
+      ]
+    : relationDetail.foreign_collection;
 
   const isMultiple = Array.isArray(key);
 
@@ -647,8 +641,9 @@ const buildNestedStructure = (
       },
       validations:
         item?.meta?.validations?.rules?.length > 0
-          ? generateModifiedRules(item?.meta, formData)
+          ? generateModifiedRules(item?.meta, item?.meta?.validations?.validation_msg)
           : [],
+      custom_error_message: item?.meta?.validations?.validation_msg,
       children:
         childFields?.length > 0
           ? apiVersion === constants.API_VERSION.V1 &&
@@ -826,13 +821,14 @@ const generateFieldCompareRules = (rule) => {
   return modifiedRule;
 };
 
-const generateModifiedRules = (meta) => {
+const generateModifiedRules = (meta,custom_message) => {
   return meta?.validations?.rules?.map((rule, index) => {
     let modifiedRule = {
       identifier: String(index),
       case: constants.rulesTypes.RULES_COMPARE,
       value: [],
       options: {},
+      custom_message
     };
     switch (rule.rule) {
       case "contains":

package/lib/validate.js

@@ -65,14 +65,11 @@ const typeChecks = {
   },
 
   [constants.types.TIME]: (val) =>
-    typeof val === "string" &&
-    /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/.test(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.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.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),
@@ -85,6 +82,8 @@ const handleMinMaxValidation = (
   field,
   addError,
   currentPath,
+  error_messages,
+  custom_message
 ) => {
   let message = "";
   const fieldLabel = formatLabel(field.display_label);
@@ -95,19 +94,15 @@ const handleMinMaxValidation = (
       typeChecks[constants.types.STRING](fieldValue) &&
       fieldValue?.length < ruleValue[0]
     ) {
-      message = constants.rulesMessages.MIN_STRING.replace(
-        `{field}`,
-        fieldLabel,
-      ).replace(`{min}`, ruleValue[0]);
+      message = custom_message ?? error_messages.MIN_STRING;
+      message = message?.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]);
+      message = custom_message ?? error_messages.MIN_NUMBER;
+      message = message?.replace(`{field}`, fieldLabel).replace(`{min}`, ruleValue[0]);
     }
   }
 
@@ -117,19 +112,15 @@ const handleMinMaxValidation = (
       typeChecks[constants.types.STRING](fieldValue) &&
       fieldValue?.length > ruleValue[0]
     ) {
-      message = constants.rulesMessages.MAX_STRING.replace(
-        `{field}`,
-        fieldLabel,
-      ).replace(`{max}`, ruleValue[0]);
+      message = custom_message ?? error_messages.MAX_STRING;
+      message = message?.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]);
+      message = custom_message ?? error_messages.MAX_NUMBER;
+      message = message?.replace(`{field}`, fieldLabel).replace(`{max}`, ruleValue[0]);
     }
   }
 
@@ -137,7 +128,7 @@ const handleMinMaxValidation = (
     addError(
       currentPath,
       { label: fieldLabel, fieldPath: currentPath, description: "", message },
-      field,
+      field
     );
   }
 };
@@ -148,15 +139,13 @@ const validateMetaRules = (
   providedValue,
   currentPath,
   updateValue,
+  error_messages
 ) => {
   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),
-    );
+    const message = error_messages.REQUIRED.replace(`{field}`, formatLabel(field.display_label));
     addError(
       currentPath,
       {
@@ -165,14 +154,14 @@ const validateMetaRules = (
         description: "",
         message,
       },
-      field,
+      field
     );
   }
 
   if (!nullable && fieldValue === null) {
-    const message = constants.rulesMessages.NOT_NULLABLE.replace(
+    const message = error_messages.NOT_NULLABLE.replace(
       `{field}`,
-      formatLabel(field.display_label),
+      formatLabel(field.display_label)
     );
     addError(
       currentPath,
@@ -182,7 +171,7 @@ const validateMetaRules = (
         description: "",
         message,
       },
-      field,
+      field
     );
   }
 
@@ -191,9 +180,9 @@ const validateMetaRules = (
     typeChecks[field.type] &&
     !typeChecks[field.type](fieldValue, { key: currentPath, updateValue })
   ) {
-    const message = constants.rulesMessages.INVALID_TYPE.replace(
+    const message = error_messages.INVALID_TYPE.replace(
       `{field}`,
-      formatLabel(field.display_label),
+      formatLabel(field.display_label)
     ).replace(`{type}`, field?.type);
     addError(
       currentPath,
@@ -203,7 +192,7 @@ const validateMetaRules = (
         description: "",
         message,
       },
-      field,
+      field
     );
   }
 };
@@ -214,6 +203,8 @@ const handleRegexValidation = (
   field,
   addError,
   currentPath,
+  error_messages,
+  custom_message
 ) => {
   let message = "";
   const fieldLabel = formatLabel(field.display_label);
@@ -225,38 +216,28 @@ const handleRegexValidation = (
   const isValid = (() => {
     switch (rule.options.type) {
       case constants.regexTypes.MATCH:
-        message = constants.rulesMessages.REGEX_MATCH;
+        message = custom_message ?? error_messages.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(/\/$/, ""),
-        );
+        message = custom_message ?? error_messages.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(/\/$/, ""),
-        );
+        message = custom_message ?? error_messages.REGEX_ENDS_WITH;
+        return fieldValue?.endsWith(rule.value[0].replace(/^\//, "").replace(/\/$/, ""));
       case constants.regexTypes.CONTAINS:
-        message = constants.rulesMessages.REGEX_CONTAINS;
+        message = custom_message ?? error_messages.REGEX_CONTAINS;
         return regex.test(fieldValue);
       case constants.regexTypes.EXACT:
-        message = constants.rulesMessages.REGEX_EXACT;
-        return (
-          fieldValue === rule.value[0].replace(/^\//, "").replace(/\/$/, "")
-        );
+        message = custom_message ?? error_messages.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(/\/$/, ""),
-        );
+        message = custom_message ?? error_messages.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(/\/$/, ""),
-        );
+        message = custom_message ?? error_messages.REGEX_NOT_ENDS_WITH;
+        return !fieldValue?.endsWith(rule.value[0].replace(/^\//, "").replace(/\/$/, ""));
       case constants.regexTypes.NOT_CONTAINS:
-        message = constants.rulesMessages.REGEX_NOT_CONTAINS;
+        message = custom_message ?? error_messages.REGEX_NOT_CONTAINS;
         return !regex.test(fieldValue);
       default:
         return false;
@@ -264,13 +245,11 @@ const handleRegexValidation = (
   })();
 
   if (!isValid) {
-    message = message
-      ?.replace(`{field}`, fieldLabel)
-      ?.replace(`{value}`, rule.value[0]);
+    message = message?.replace(`{field}`, fieldLabel)?.replace(`{value}`, rule.value[0]);
     addError(
       currentPath,
       { label: fieldLabel, fieldPath: currentPath, description: "", message },
-      field,
+      field
     );
   }
 };
@@ -282,6 +261,8 @@ const validateOperatorRule = (
   addError,
   currentPath,
   formData,
+  error_messages,
+  custom_message
 ) => {
   const { isFieldCompare = false } = rule?.options ?? {};
   let valid = false;
@@ -304,7 +285,10 @@ const validateOperatorRule = (
       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 `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(
+          2,
+          "0"
+        )}-${String(date.getUTCDate()).padStart(2, "0")}`;
       }
       return Math.floor(date.getTime() / 1000);
     }
@@ -313,8 +297,13 @@ const validateOperatorRule = (
 
       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")}`
+          `${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")}`
         );
       }
 
@@ -338,123 +327,116 @@ const validateOperatorRule = (
 
   const fieldValueParsed = getComparableValue(fieldValue);
 
-  const messageValue = Array.isArray(rule.value)
-    ? rule.value.join(", ")
-    : String(rule.value);
+  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);
+      message = custom_message ?? error_messages.AND;
+      message = message
+        ?.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);
+      message = custom_message ?? error_messages.OR;
+      message = message
+        ?.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]);
+      message = custom_message ?? error_messages.EQUAL;
+      message = message
+        ?.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]);
+      message = custom_message ?? error_messages.NOT_EQUAL;
+      message = message
+        ?.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]);
+      message = custom_message ?? error_messages.LESS_THAN;
+      message = message
+        ?.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]);
+      message = custom_message ?? error_messages.LESS_THAN_EQUAL;
+      message = message
+        ?.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]);
+      message = custom_message ?? error_messages.GREATER_THAN;
+      message = message
+        ?.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]);
+      message = custom_message ?? error_messages.GREATER_THAN_EQUAL;
+      message = message
+        ?.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);
+      message = custom_message ?? error_messages.IN;
+      message = message
+        ?.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);
+      message = custom_message ?? error_messages.NOT_IN;
+      message = message
+        ?.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;
+      message = custom_message ?? error_messages.EXISTS;
+      message = message?.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]);
+      message = custom_message ?? error_messages.TYPE;
+      message = message
+        ?.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),
-      )
+      message = custom_message ?? error_messages.MOD;
+      message = message
+        ?.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);
+      message = custom_message ?? error_messages.ALL;
+      message = message
+        ?.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]);
+      message = custom_message ?? error_messages.SIZE;
+      message = message
+        ?.replace(`{field}`, formatLabel(field.display_label))
+        ?.replace("{value}", rule.value[0]);
       valid = isArray && fieldValue.length === rule.value[0];
       break;
     default:
@@ -470,58 +452,67 @@ const validateOperatorRule = (
         description: "",
         message,
       },
-      field,
+      field
     );
   }
 };
 
-const generateErrorMessage = (ruleKey, fieldLabel, additionalValues = {}) => {
-  let message = constants.rulesMessages[ruleKey]?.replace(
-    `{field}`,
-    fieldLabel,
-  );
+const generateErrorMessage = (
+  ruleKey,
+  fieldLabel,
+  additionalValues = {},
+  error_messages,
+  custom_message
+) => {
+  let message = custom_message ?? error_messages[ruleKey];
+  message = message?.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 handleRule = (rule, field, value, addError, currentPath, formData, error_messages) => {
   const ruleValue = rule?.value;
-  const messageValue = Array.isArray(ruleValue)
-    ? ruleValue.join(", ")
-    : String(ruleValue);
+  const messageValue = Array.isArray(ruleValue) ? ruleValue.join(", ") : String(ruleValue);
   const fieldLabel = formatLabel(field.display_label);
+  const custom_message = rule?.custom_message;
 
-  const addValidationError = (ruleKey, extraValues = {}) =>
+  const addValidationError = (ruleKey, extraValues = {}, custom_message) =>
     addError(
       currentPath,
       {
         label: fieldLabel,
         fieldPath: currentPath,
         description: "",
-        message: generateErrorMessage(ruleKey, fieldLabel, extraValues),
+        message: generateErrorMessage(
+          ruleKey,
+          fieldLabel,
+          extraValues,
+          error_messages,
+          custom_message
+        ),
       },
-      field,
+      field
     );
 
   switch (rule.case) {
     case constants.rulesTypes.EMPTY:
-      if (value) addValidationError("EMPTY");
+      if (value) addValidationError("EMPTY", {}, custom_message);
       break;
     case constants.rulesTypes.NOT_EMPTY:
-      if (!value || value.length === 0) addValidationError("NOT_EMPTY");
+      if (!value || value.length === 0) addValidationError("NOT_EMPTY", {}, custom_message);
       break;
     case constants.rulesTypes.ONE_OF:
       if (!ruleValue?.includes(value))
-        addValidationError("ONE_OF", { value: messageValue });
+        addValidationError("ONE_OF", { value: messageValue }, custom_message);
       break;
     case constants.rulesTypes.NOT_ONE_OF:
       if (ruleValue?.includes(value))
-        addValidationError("NOT_ONE_OF", { value: messageValue });
+        addValidationError("NOT_ONE_OF", { value: messageValue }, custom_message);
       break;
     case constants.rulesTypes.NOT_ALLOWED:
-      if (ruleValue?.includes(value)) addValidationError("NOT_ALLOWED");
+      if (ruleValue?.includes(value)) addValidationError("NOT_ALLOWED", {}, custom_message);
       break;
     case constants.rulesTypes.MIN:
     case constants.rulesTypes.MAX:
@@ -532,13 +523,32 @@ const handleRule = (rule, field, value, addError, currentPath, formData) => {
         field,
         addError,
         currentPath,
+        error_messages,
+        custom_message
       );
       break;
     case constants.rulesTypes.REGEX:
-      handleRegexValidation(value, rule, field, addError, currentPath);
+      handleRegexValidation(
+        value,
+        rule,
+        field,
+        addError,
+        currentPath,
+        error_messages,
+        custom_message
+      );
       break;
     case constants.rulesTypes.OPERATOR:
-      validateOperatorRule(value, rule, field, addError, currentPath, formData);
+      validateOperatorRule(
+        value,
+        rule,
+        field,
+        addError,
+        currentPath,
+        formData,
+        error_messages,
+        custom_message
+      );
       break;
     default:
       console.warn(`Unknown Rule: ${rule.case}`, fieldLabel);
@@ -552,13 +562,12 @@ const validateField = (
   addError,
   formData,
   updateValue,
+  error_messages
 ) => {
-  const currentPath = fieldPath
-    ? `${fieldPath}.${field.key.split(".").pop()}`
-    : field.key;
+  const currentPath = fieldPath ? `${fieldPath}.${field.key.split(".").pop()}` : field.key;
   const fieldLabel = formatLabel(field.display_label);
 
-  validateMetaRules(field, addError, value, currentPath, updateValue);
+  validateMetaRules(field, addError, value, currentPath, updateValue, error_messages);
 
   if (
     field.type === constants.types.OBJECT &&
@@ -573,7 +582,8 @@ const validateField = (
         currentPath,
         addError,
         updateValue,
-      ),
+        error_messages
+      )
     );
   } else if (field.type === constants.types.ARRAY && Array.isArray(value)) {
     const itemType = field?.array_type || field?.schema_definition?.type;
@@ -584,9 +594,14 @@ const validateField = (
             label: fieldLabel,
             fieldPath: `${currentPath}[${index}]`,
             description: "",
-            message: generateErrorMessage("INVALID_TYPE", fieldLabel, {
-              type: itemType,
-            }),
+            message: generateErrorMessage(
+              "INVALID_TYPE",
+              fieldLabel,
+              {
+                type: itemType,
+              },
+              error_messages
+            ),
           });
         }
       });
@@ -600,31 +615,32 @@ const validateField = (
             `${currentPath}[${index}]`,
             addError,
             updateValue,
-          ),
+            error_messages
+          )
         );
       });
     }
   } else {
-    if (!applyValidations(field, value, addError, currentPath, formData)) {
+    if (!applyValidations(field, value, addError, currentPath, formData, error_messages)) {
       addError(
         currentPath,
         {
           label: fieldLabel,
           fieldPath: currentPath,
           description: "",
-          message: `Invalid value for ${currentPath}`,
+          message: error_messages.INVALID_VALUE?.replace(`{field}`, fieldLabel),
         },
-        field,
+        field
       );
     }
   }
 };
 
-const applyValidations = (field, value, addError, currentPath, formData) => {
+const applyValidations = (field, value, addError, currentPath, formData, error_messages) => {
   if (!field.validations || value === null || value === undefined) return true;
   return !field.validations.some(
     (rule) =>
-      handleRule(rule, field, value, addError, currentPath, formData) === false,
+      handleRule(rule, field, value, addError, currentPath, formData, error_messages) === false
   );
 };
 
@@ -644,6 +660,7 @@ const schema = {
     array_type: constants.types.STRING,
   },
   apiVersion: { type: constants.types.STRING, array_type: null },
+  language: { type: constants.types.STRING, array_type: null },
 };
 
 const validate = (data) => {
@@ -657,7 +674,12 @@ const validate = (data) => {
     abortEarly,
     byPassKeys,
     apiVersion,
+    language,
   } = data;
+  const defaultLanguage = constants.LANGUAGES.length > 0 ? constants.LANGUAGES[0] : "en"; // Replace "en" with your actual default
+  const error_messages =
+    constants.LOCALE_MESSAGES[language] ?? constants.LOCALE_MESSAGES[defaultLanguage];
+
   let result = { status: true, errors: {}, data: formData };
 
   const updateValue = (key, value) => {
@@ -678,10 +700,7 @@ const validate = (data) => {
   // Validate Data
   const defaultField = { meta: { hidden: false } };
   if (!data) {
-    const message = constants.rulesMessages.REQUIRED.replace(
-      `{field}`,
-      formatLabel("data"),
-    );
+    const message = error_messages.REQUIRED.replace(`{field}`, formatLabel("data"));
     addError(
       "data",
       {
@@ -690,17 +709,17 @@ const validate = (data) => {
         description: "",
         message,
       },
-      defaultField,
+      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);
+    const message = error_messages.INVALID_TYPE.replace(`{field}`, formatLabel("data")).replace(
+      `{type}`,
+      constants.types.OBJECT
+    );
     addError(
       "data",
       {
@@ -709,7 +728,7 @@ const validate = (data) => {
         description: "",
         message,
       },
-      defaultField,
+      defaultField
     );
     return result;
   }
@@ -720,10 +739,7 @@ const validate = (data) => {
     const fieldValue = data[key];
     // Skip empty values
     if (fieldValue == null || fieldValue == undefined) {
-      const message = constants.rulesMessages.REQUIRED.replace(
-        `{field}`,
-        formatLabel(key),
-      );
+      const message = error_messages.REQUIRED.replace(`{field}`, formatLabel(key));
       addError(
         key,
         {
@@ -732,17 +748,17 @@ const validate = (data) => {
           description: "",
           message,
         },
-        defaultField,
+        defaultField
       );
       return;
     }
 
     // Validate field type
     if (!typeChecks[expectedType] || !typeChecks[expectedType](fieldValue)) {
-      const message = constants.rulesMessages.INVALID_TYPE.replace(
-        `{field}`,
-        key,
-      ).replace(`{type}`, expectedType);
+      const message = error_messages.INVALID_TYPE.replace(`{field}`, key).replace(
+        `{type}`,
+        expectedType
+      );
       addError(
         key,
         {
@@ -751,7 +767,7 @@ const validate = (data) => {
           description: "",
           message,
         },
-        defaultField,
+        defaultField
       );
       return;
     }
@@ -762,14 +778,10 @@ const validate = (data) => {
         // 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(
+        if (arrayItemType && typeChecks[arrayItemType] && !typeChecks[arrayItemType](item)) {
+          const message = error_messages.INVALID_TYPE.replace(
             `{field}`,
-            `${key}[${index}]`,
+            `${key}[${index}]`
           ).replace(`{type}`, arrayItemType);
           addError(
             `${key}[${index}]`,
@@ -779,7 +791,7 @@ const validate = (data) => {
               description: "",
               message,
             },
-            defaultField,
+            defaultField
           );
         }
       });
@@ -788,10 +800,10 @@ const validate = (data) => {
 
   // Validate API Version
   if (!constants.API_VERSIONS.includes(apiVersion)) {
-    const message = constants.rulesMessages.IN.replace(
-      `{field}`,
-      formatLabel("apiVersion"),
-    ).replace(`{value}`, constants.API_VERSIONS.join(", "));
+    const message = error_messages.IN.replace(`{field}`, formatLabel("apiVersion")).replace(
+      `{value}`,
+      constants.API_VERSIONS.join(", ")
+    );
     addError(
       "apiVersion",
       {
@@ -800,7 +812,7 @@ const validate = (data) => {
         description: "",
         message,
       },
-      defaultField,
+      defaultField
     );
   }
 
@@ -815,9 +827,7 @@ const validate = (data) => {
   let allFields = isSeparatedFields ? [] : fields;
 
   if (!isSeparatedFields) {
-    schemaFields = fields.filter(
-      (field) => field?.schema_id?.toString() === formId?.toString(),
-    );
+    schemaFields = fields.filter((field) => field?.schema_id?.toString() === formId?.toString());
   }
 
   const fieldOptions =
@@ -828,7 +838,7 @@ const validate = (data) => {
       formData,
       relationalFields,
       isSeparatedFields,
-      apiVersion,
+      apiVersion
     ) || [];
 
   findDisallowedKeys(formData, fieldOptions).forEach((fieldPath) => {
@@ -845,6 +855,7 @@ const validate = (data) => {
           {
             field: formatLabel(fieldKey),
           },
+          error_messages
         ),
       });
     }
@@ -859,9 +870,10 @@ const validate = (data) => {
       addError,
       formData,
       updateValue,
+      error_messages
     );
   });
   return result;
 };
 
-module.exports = { validate, validateField ,typeChecks};
+module.exports = { validate, validateField, typeChecks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nox-validation",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "validate dynamic schema",
   "main": "index.js",
   "scripts": {