nox-validation 1.2.0 → 1.2.2

package/lib/constant.js

@@ -161,6 +161,7 @@ const LANGUAGES = Object.freeze({
 });
 
 const LOCALE_NL_MESSAGES = Object.freeze({
+  ADD_CHOICE: `Voeg minstens één optie toe voor {field}.`, 
   INVALID_VALUE: `{field} bevat een ongeldige waarde.`,
   EMPTY: `{field} moet leeg zijn.`,
   NOT_EMPTY: `{field} mag niet leeg zijn.`,
@@ -205,6 +206,7 @@ const LOCALE_NL_MESSAGES = Object.freeze({
 });
 
 const LOCALE_EN_MESSAGES = Object.freeze({
+  ADD_CHOICE:`Please add at least one choice for {field}.`,
   INVALID_VALUE: `{field} contains invalid value.`,
   EMPTY: `{field} should be empty.`,
   NOT_EMPTY: `{field} should not be empty.`,
@@ -249,6 +251,7 @@ const LOCALE_EN_MESSAGES = Object.freeze({
 });
 
 const LOCALE_LV_MESSAGES = Object.freeze({
+  ADD_CHOICE: `Lūdzu, pievienojiet vismaz vienu izvēli laukam {field}.`, 
   INVALID_VALUE: `{field} satur nederīgu vērtību.`,
   EMPTY: `{field} jābūt tukšam.`,
   NOT_EMPTY: `{field} nedrīkst būt tukšs.`,
@@ -293,6 +296,7 @@ const LOCALE_LV_MESSAGES = Object.freeze({
 });
 
 const LOCALE_PL_MESSAGES = Object.freeze({
+  ADD_CHOICE: `Proszę dodać co najmniej jedną opcję dla {field}.`,
   INVALID_VALUE: `{field} zawiera nieprawidłową wartość.`,
   EMPTY: `{field} powinno być puste.`,
   NOT_EMPTY: `{field} nie powinno być puste.`,
@@ -337,6 +341,7 @@ const LOCALE_PL_MESSAGES = Object.freeze({
 });
 
 const LOCALE_RO_MESSAGES = Object.freeze({
+  ADD_CHOICE: `Vă rugăm să adăugați cel puțin o opțiune pentru {field}.`, 
   INVALID_VALUE: `{field} conține o valoare invalidă.`,
   EMPTY: `{field} trebuie să fie gol.`,
   NOT_EMPTY: `{field} nu trebuie să fie gol.`,
@@ -381,6 +386,7 @@ const LOCALE_RO_MESSAGES = Object.freeze({
 });
 
 const LOCALE_RU_MESSAGES = Object.freeze({
+  ADD_CHOICE: `Пожалуйста, добавьте хотя бы один вариант для {field}.`,
   INVALID_VALUE: `{field} содержит недопустимое значение.`,
   EMPTY: `{field} должно быть пустым.`,
   NOT_EMPTY: `{field} не должно быть пустым.`,

package/lib/helpers.js

@@ -355,7 +355,14 @@ const convertTypesV1 = (field) => {
   return { type, array_type, find_relations };
 };
 
-const generateField = (name, path, schema_definition_type, type, childrenFields = [],relationType="none") => {
+const generateField = (
+  name,
+  path,
+  schema_definition_type,
+  type,
+  childrenFields = [],
+  relationType = "none"
+) => {
   childrenFields = childrenFields?.map((child) => {
     return {
       ...child,
@@ -375,7 +382,7 @@ const generateField = (name, path, schema_definition_type, type, childrenFields
       required: false,
       nullable: false,
       hidden: false,
-      interface:relationType
+      interface: relationType,
     },
     validations: [],
     schema_definition: {
@@ -398,7 +405,7 @@ const createChildrenFieldsFiles = (key) => {
     constants.types.ARRAY
   );
   return [existingField, deleteField];
-}
+};
 
 const generateRelationalFieldV1 = (key = "", collectionFields = [], relationType) => {
   if (relationType === constants.interfaces.MANY_TO_ANY) {
@@ -581,7 +588,7 @@ const getForeignCollectionDetails = ({
         this_collection: mainTable.one_collection_id,
         this_field: "_id",
         foreign_collection:
-          iFace === constants.interfaces.MANY_TO_MANY 
+          iFace === constants.interfaces.MANY_TO_MANY
             ? relational?.one_collection_id
             : iFace === constants.interfaces.MANY_TO_ANY
             ? relational?.one_allowed_collections_id
@@ -667,8 +674,7 @@ const getCachedOrFetchFields = (schemaId, allFields, relational_fields) => {
   return fields;
 };
 
-const getChildFields = (relationDetail, allFields, relational_fields, isTranslation,name) => {
-
+const getChildFields = (relationDetail, allFields, relational_fields, isTranslation, name) => {
   let key = isTranslation
     ? [
         ...(Array.isArray(relationDetail.junction_collection)
@@ -723,16 +729,16 @@ const buildNestedStructure = ({
   schemaFields.forEach((item) => {
     const pathParts = item.path.split(".");
     const key = pathParts.join(".");
-    const isV2File = apiVersion === constants.API_VERSION.V2 && [
-      constants.interfaces.FILES,
-      constants.interfaces.FILE,
-      constants.interfaces.FILE_IMAGE,
-    ].includes(item?.meta?.interface);
+    const isV2File =
+      apiVersion === constants.API_VERSION.V2 &&
+      [
+        constants.interfaces.FILES,
+        constants.interfaces.FILE,
+        constants.interfaces.FILE_IMAGE,
+      ].includes(item?.meta?.interface);
 
     const currentDepth = currentDepthMap.get(isRoot ? item.path : rootPath) || 0;
 
-    // if (currentDepth >= maxLevel) return;
-
     let childFields;
 
     let definedType = generateType(item, apiVersion);
@@ -752,7 +758,8 @@ const buildNestedStructure = ({
           relationDetail,
           allFields,
           relational_fields,
-          item?.meta?.interface === constants.interfaces.TRANSLATIONS,key
+          item?.meta?.interface === constants.interfaces.TRANSLATIONS,
+          key
         );
       } else {
         childFields = getCachedFields(relationDetail, relational_fields);
@@ -776,7 +783,7 @@ const buildNestedStructure = ({
       }
     }
 
-    if(isV2File){
+    if (isV2File) {
       definedType.array_type = constants.types.OBJECT;
       definedType.type = constants.types.OBJECT;
       childFields = createChildrenFieldsFiles(key);
@@ -794,15 +801,14 @@ const buildNestedStructure = ({
         nullable: item.meta?.nullable || false,
         hidden: item.meta?.hidden || false,
       },
-      validations:
-        item?.meta?.validations?.rules?.length > 0
-          ? generateModifiedRules(item?.meta, item?.meta?.validations?.validation_msg)
-          : [],
+      validations: generateModifiedRules(item?.meta, item?.meta?.validations?.validation_msg),
       custom_error_message: item?.meta?.validations?.validation_msg,
       children:
         childFields?.length > 0
-          ? isV2File ? childFields:apiVersion === constants.API_VERSION.V1 &&
-            item.meta?.interface !== constants.interfaces.TRANSLATIONS
+          ? isV2File
+            ? childFields
+            : apiVersion === constants.API_VERSION.V1 &&
+              item.meta?.interface !== constants.interfaces.TRANSLATIONS
             ? generateRelationalFieldV1(key, childFields, item.meta?.interface)
             : generateRelationalField(key, childFields, item.meta?.interface)
           : [],
@@ -981,129 +987,145 @@ const generateFieldCompareRules = (rule) => {
 };
 
 const generateModifiedRules = (meta, custom_message) => {
-  return meta?.validations?.rules?.map((rule, index) => {
+  let rules = [];
+  if(meta?.validations?.rules?.length > 0){
+    rules = 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":
+          modifiedRule.case = constants.rulesTypes.REGEX;
+          modifiedRule.value = [rule[rule.rule].value];
+          modifiedRule.options = {
+            type: constants.regexTypes.CONTAINS,
+            case_sensitive: !rule[rule.rule].insensitive,
+            multiline: false,
+            global: false,
+          };
+          break;
+        case "doesNotContain":
+          modifiedRule.case = constants.rulesTypes.REGEX;
+          modifiedRule.value = [rule[rule.rule].value];
+          modifiedRule.options = {
+            type: constants.regexTypes.NOT_CONTAINS,
+            case_sensitive: !rule[rule.rule].insensitive,
+            multiline: false,
+            global: false,
+          };
+          break;
+        case "startsWith":
+          modifiedRule.case = constants.rulesTypes.REGEX;
+          modifiedRule.value = [rule[rule.rule].value];
+          modifiedRule.options = {
+            type: constants.regexTypes.START_WITH,
+            case_sensitive: !rule[rule.rule].insensitive,
+          };
+          break;
+        case "doesNotStartWith":
+          modifiedRule.case = constants.rulesTypes.REGEX;
+          modifiedRule.value = [rule[rule.rule].value];
+          modifiedRule.options = {
+            type: constants.regexTypes.NOT_START_WITH,
+            case_sensitive: !rule[rule.rule].insensitive,
+          };
+          break;
+        case "endsWith":
+          modifiedRule.case = constants.rulesTypes.REGEX;
+          modifiedRule.value = [rule[rule.rule].value];
+          modifiedRule.options = {
+            type: constants.regexTypes.ENDS_WITH,
+            case_sensitive: !rule[rule.rule].insensitive,
+          };
+          break;
+        case "doesNotEndWith":
+          modifiedRule.case = constants.rulesTypes.REGEX;
+          modifiedRule.value = [rule[rule.rule].value];
+          modifiedRule.options = {
+            type: constants.regexTypes.NOT_ENDS_WITH,
+            case_sensitive: !rule[rule.rule].insensitive,
+          };
+          break;
+        case "matchesRegExp":
+          modifiedRule.case = constants.rulesTypes.REGEX;
+          modifiedRule.value = [rule.matchesRegExp.value];
+          modifiedRule.options.type = constants.regexTypes.MATCH;
+          break;
+        case "equals":
+          modifiedRule.case = constants.rulesTypes.OPERATOR;
+          modifiedRule.options.operator = constants.operatorTypes.EQUAL;
+          modifiedRule.value = [rule[rule.rule].value];
+          break;
+        case "doesNotEqual":
+          modifiedRule.case = constants.rulesTypes.OPERATOR;
+          modifiedRule.options.operator = constants.operatorTypes.NOT_EQUAL;
+          modifiedRule.value = [rule[rule.rule].value];
+          break;
+        case "lessThan":
+          modifiedRule.case = constants.rulesTypes.OPERATOR;
+          modifiedRule.options.operator = constants.operatorTypes.LESS_THAN;
+          modifiedRule.value = [rule[rule.rule].value];
+          break;
+        case "lessThanOrEqualTo":
+          modifiedRule.case = constants.rulesTypes.OPERATOR;
+          modifiedRule.options.operator = constants.operatorTypes.LESS_THAN_EQUAL;
+          modifiedRule.value = [rule[rule.rule].value];
+          break;
+        case "greaterThan":
+          modifiedRule.case = constants.rulesTypes.OPERATOR;
+          modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN;
+          modifiedRule.value = [rule[rule.rule].value];
+          break;
+        case "greaterThanOrEqualTo":
+          modifiedRule.case = constants.rulesTypes.OPERATOR;
+          modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN_EQUAL;
+          modifiedRule.value = [rule[rule.rule].value];
+          break;
+        case "isEmpty":
+          modifiedRule.case = constants.rulesTypes.EMPTY;
+          modifiedRule.value = [];
+          break;
+        case "isNotEmpty":
+          modifiedRule.case = constants.rulesTypes.NOT_EMPTY;
+          modifiedRule.value = [];
+          break;
+        case "isOneOf":
+          modifiedRule.case = constants.rulesTypes.ONE_OF;
+          modifiedRule.value = rule[rule.rule].value;
+          break;
+        case "isNotOneOf":
+          modifiedRule.case = constants.rulesTypes.NOT_ONE_OF;
+          modifiedRule.value = [rule[rule.rule].value];
+          break;
+        case constants.rulesTypes.FIELD_COMPARE: {
+          const fieldRule = generateFieldCompareRules(rule);
+          modifiedRule.case = fieldRule.case;
+          modifiedRule.options = fieldRule.options;
+          modifiedRule.value = fieldRule.value;
+          break;
+        }
+      }
+  
+      return modifiedRule;
+    });
+  }
+  const { options } = meta;
+  if (options?.choices?.length > 0) {
+    const choices = options?.choices?.map((item) => item?.value);
     let modifiedRule = {
-      identifier: String(index),
-      case: constants.rulesTypes.RULES_COMPARE,
-      value: [],
+      identifier: String(rules?.length + 1),
+      case: constants.rulesTypes.ONE_OF,
+      value: choices,
       options: {},
       custom_message,
     };
-    switch (rule.rule) {
-      case "contains":
-        modifiedRule.case = constants.rulesTypes.REGEX;
-        modifiedRule.value = [rule[rule.rule].value];
-        modifiedRule.options = {
-          type: constants.regexTypes.CONTAINS,
-          case_sensitive: !rule[rule.rule].insensitive,
-          multiline: false,
-          global: false,
-        };
-        break;
-      case "doesNotContain":
-        modifiedRule.case = constants.rulesTypes.REGEX;
-        modifiedRule.value = [rule[rule.rule].value];
-        modifiedRule.options = {
-          type: constants.regexTypes.NOT_CONTAINS,
-          case_sensitive: !rule[rule.rule].insensitive,
-          multiline: false,
-          global: false,
-        };
-        break;
-      case "startsWith":
-        modifiedRule.case = constants.rulesTypes.REGEX;
-        modifiedRule.value = [rule[rule.rule].value];
-        modifiedRule.options = {
-          type: constants.regexTypes.START_WITH,
-          case_sensitive: !rule[rule.rule].insensitive,
-        };
-        break;
-      case "doesNotStartWith":
-        modifiedRule.case = constants.rulesTypes.REGEX;
-        modifiedRule.value = [rule[rule.rule].value];
-        modifiedRule.options = {
-          type: constants.regexTypes.NOT_START_WITH,
-          case_sensitive: !rule[rule.rule].insensitive,
-        };
-        break;
-      case "endsWith":
-        modifiedRule.case = constants.rulesTypes.REGEX;
-        modifiedRule.value = [rule[rule.rule].value];
-        modifiedRule.options = {
-          type: constants.regexTypes.ENDS_WITH,
-          case_sensitive: !rule[rule.rule].insensitive,
-        };
-        break;
-      case "doesNotEndWith":
-        modifiedRule.case = constants.rulesTypes.REGEX;
-        modifiedRule.value = [rule[rule.rule].value];
-        modifiedRule.options = {
-          type: constants.regexTypes.NOT_ENDS_WITH,
-          case_sensitive: !rule[rule.rule].insensitive,
-        };
-        break;
-      case "matchesRegExp":
-        modifiedRule.case = constants.rulesTypes.REGEX;
-        modifiedRule.value = [rule.matchesRegExp.value];
-        modifiedRule.options.type = constants.regexTypes.MATCH;
-        break;
-      case "equals":
-        modifiedRule.case = constants.rulesTypes.OPERATOR;
-        modifiedRule.options.operator = constants.operatorTypes.EQUAL;
-        modifiedRule.value = [rule[rule.rule].value];
-        break;
-      case "doesNotEqual":
-        modifiedRule.case = constants.rulesTypes.OPERATOR;
-        modifiedRule.options.operator = constants.operatorTypes.NOT_EQUAL;
-        modifiedRule.value = [rule[rule.rule].value];
-        break;
-      case "lessThan":
-        modifiedRule.case = constants.rulesTypes.OPERATOR;
-        modifiedRule.options.operator = constants.operatorTypes.LESS_THAN;
-        modifiedRule.value = [rule[rule.rule].value];
-        break;
-      case "lessThanOrEqualTo":
-        modifiedRule.case = constants.rulesTypes.OPERATOR;
-        modifiedRule.options.operator = constants.operatorTypes.LESS_THAN_EQUAL;
-        modifiedRule.value = [rule[rule.rule].value];
-        break;
-      case "greaterThan":
-        modifiedRule.case = constants.rulesTypes.OPERATOR;
-        modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN;
-        modifiedRule.value = [rule[rule.rule].value];
-        break;
-      case "greaterThanOrEqualTo":
-        modifiedRule.case = constants.rulesTypes.OPERATOR;
-        modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN_EQUAL;
-        modifiedRule.value = [rule[rule.rule].value];
-        break;
-      case "isEmpty":
-        modifiedRule.case = constants.rulesTypes.EMPTY;
-        modifiedRule.value = [];
-        break;
-      case "isNotEmpty":
-        modifiedRule.case = constants.rulesTypes.NOT_EMPTY;
-        modifiedRule.value = [];
-        break;
-      case "isOneOf":
-        modifiedRule.case = constants.rulesTypes.ONE_OF;
-        modifiedRule.value = rule[rule.rule].value;
-        break;
-      case "isNotOneOf":
-        modifiedRule.case = constants.rulesTypes.NOT_ONE_OF;
-        modifiedRule.value = [rule[rule.rule].value];
-        break;
-      case constants.rulesTypes.FIELD_COMPARE: {
-        const fieldRule = generateFieldCompareRules(rule);
-        modifiedRule.case = fieldRule.case;
-        modifiedRule.options = fieldRule.options;
-        modifiedRule.value = fieldRule.value;
-        break;
-      }
-    }
-
-    return modifiedRule;
-  });
+    rules.push(modifiedRule)
+  }
+  return rules;
 };
 
 const getFieldsGroupBySchemaId = (arr) => {

package/lib/validate.js

@@ -10,6 +10,8 @@ const {
   getParentKey,
 } = require("./helpers");
 
+const choices = ["radio", "checkboxes", "dropdown_multiple", "dropdown"];
+
 const typeChecks = {
   date: (val, data) => {
     if (val instanceof Date && !isNaN(val)) return true;
@@ -134,18 +136,81 @@ const handleMinMaxValidation = (
   }
 };
 
+const isEmptyRelational = ({ api_version, value, interface }) => {
+  if (api_version === constants.API_VERSION.V1 && interface !== constants.interfaces.TRANSLATIONS) {
+    if (interface === constants.interfaces.MANY_TO_ANY) {
+      return (
+        value &&
+        typeChecks[constants.types.OBJECT](value) &&
+        value.hasOwnProperty("collection") &&
+        value.hasOwnProperty("sort") &&
+        value.hasOwnProperty("item") &&
+        value.collection !== null &&
+        value.collection !== "" &&
+        value.sort !== null &&
+        value.sort !== "" &&
+        value.item !== null &&
+        value.item !== ""
+      );
+    } else {
+      return value?.length > 0;
+    }
+  } else {
+    return value?.create?.length > 0 || value?.existing?.length > 0;
+  }
+  return false;
+};
+
 const validateMetaRules = (
   field,
   addError,
   providedValue,
   currentPath,
   updateValue,
-  error_messages
+  error_messages,
+  onlyFormFields,
+  apiVersion
 ) => {
   const fieldValue = providedValue;
-  const { required = false, nullable = false } = field?.meta ?? {};
+  const { required = false, nullable = false, options } = field?.meta ?? {};
+  const isRelational = [
+    constants.interfaces.FILES,
+    constants.interfaces.FILE,
+    constants.interfaces.FILE_IMAGE,
+    constants.interfaces.MANY_TO_MANY,
+    constants.interfaces.ONE_TO_MANY,
+    constants.interfaces.MANY_TO_ONE,
+    constants.interfaces.MANY_TO_ANY,
+    constants.interfaces.TRANSLATIONS,
+  ].includes(field?.meta?.interface);
+
+  if (
+    choices.includes(field?.meta?.interface) &&
+    (!options?.choices || options?.choices?.length > 0)
+  ) {
+    const message = error_messages.ADD_CHOICE.replace(`{field}`, formatLabel(field.display_label));
+    addError(
+      currentPath,
+      {
+        label: formatLabel(field.display_label),
+        fieldPath: currentPath,
+        description: "",
+        message,
+      },
+      field
+    );
+  }
+
+  const isValidRelational =
+    required && isRelational && !onlyFormFields
+      ? isEmptyRelational({
+          api_version: apiVersion,
+          value: fieldValue,
+          interface: field?.meta?.interface,
+        })
+      : true;
 
-  if (required && isEmpty(fieldValue) && fieldValue !== null) {
+  if ((required && isEmpty(fieldValue)) || !isValidRelational) {
     const message = error_messages.REQUIRED.replace(`{field}`, formatLabel(field.display_label));
     addError(
       currentPath,
@@ -564,14 +629,24 @@ const validateField = (
   formData,
   updateValue,
   error_messages,
-  onlyFormFields
+  onlyFormFields,
+  apiVersion
 ) => {
   if (onlyFormFields == true && (value === undefined || value === null)) return;
 
   const currentPath = fieldPath ? `${fieldPath}.${field.key.split(".").pop()}` : field.key;
   const fieldLabel = formatLabel(field.display_label);
 
-  validateMetaRules(field, addError, value, currentPath, updateValue, error_messages);
+  validateMetaRules(
+    field,
+    addError,
+    value,
+    currentPath,
+    updateValue,
+    error_messages,
+    onlyFormFields,
+    apiVersion
+  );
 
   if (
     field.type === constants.types.OBJECT &&
@@ -618,15 +693,22 @@ const validateField = (
         formData,
         updateValue,
         error_messages,
-        onlyFormFields
+        onlyFormFields,
+        apiVersion
       )
     );
   } 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) => {
+        const itemPath = `${currentPath}[${index}]`;
+
+        if (choices.includes(field?.meta?.interface)) {
+          applyValidations(field, item, addError, itemPath, formData, error_messages);
+        }
+
         if (!typeChecks[itemType](item)) {
-          addError(`${currentPath}[${index}]`, {
+          addError(itemPath, {
             label: fieldLabel,
             fieldPath: `${currentPath}[${index}]`,
             description: "",
@@ -653,7 +735,8 @@ const validateField = (
             formData,
             updateValue,
             error_messages,
-            onlyFormFields
+            onlyFormFields,
+            apiVersion
           )
         );
       });
@@ -725,7 +808,8 @@ const validate = (data) => {
     onlyFormFields,
   } = data;
 
-  const error_messages = constants.LOCALE_MESSAGES[language] ?? constants.LOCALE_MESSAGES[constants.LANGUAGES.en];
+  const error_messages =
+    constants.LOCALE_MESSAGES[language] ?? constants.LOCALE_MESSAGES[constants.LANGUAGES.en];
 
   let result = { status: true, errors: {}, data: formData };
 
@@ -923,7 +1007,8 @@ const validate = (data) => {
       formData,
       updateValue,
       error_messages,
-      onlyFormFields
+      onlyFormFields,
+      apiVersion
     );
   });
   return result;

package/package.json

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