nox-validation 1.7.2 → 1.7.4

package/lib/helpers.js

@@ -1604,6 +1604,23 @@ const rebuildFullPath = (nodePath, fullPath, modifierFn) => {
     : `${modifiedNodePath}`.replace(/\.+/g, ".");
 };
 
+const trimBasicPath = (basePath, staticType = "update") => {
+  const regex = new RegExp(`${staticType}\\[\\d+\\]`, "g");
+  const matches = [...basePath.matchAll(regex)];
+
+  if (matches.length === 0) return basePath; // no update/create/delete/etc found
+
+  // Last matched dynamic segment (e.g. "update[3]")
+  const lastSegment = matches[matches.length - 1][0];
+
+  // Find starting index of this last segment
+  const idx = basePath.lastIndexOf(lastSegment);
+
+  // Return everything BEFORE this segment (and remove trailing dot)
+  const result = basePath.substring(0, idx).replace(/\.$/, "");
+  return result;
+};
+
 module.exports = {
   generateModifiedRules,
   getFieldsGroupBySchemaId,
@@ -1628,4 +1645,5 @@ module.exports = {
   remainingItems,
   formatDate,
   rebuildFullPath,
+  trimBasicPath,
 };

package/lib/validate.js

@@ -14,6 +14,7 @@ const {
   remainingItems,
   formatDate,
   rebuildFullPath,
+  trimBasicPath,
 } = require("./helpers");
 
 const choices = ["radio", "checkboxes", "dropdown_multiple", "dropdown"];
@@ -399,6 +400,7 @@ const validateMetaRules = (
           `{field}`,
           formatLabel(field.display_label)
         );
+
     addError(
       currentPath,
       translatedPath
@@ -470,8 +472,23 @@ const validateMetaRules = (
   ) {
     getSelectedNodes({
       node: field,
-      skipFn: (node) =>
-        node.meta?.interface === constants.interfaces.MANY_TO_ANY,
+      skipFn: (node) => {
+        let status = false;
+        if (node.meta?.interface === constants.interfaces.MANY_TO_ANY)
+          status = true;
+
+        if (
+          [
+            constants.interfaces.MANY_TO_MANY,
+            constants.interfaces.ONE_TO_MANY,
+            constants.interfaces.MANY_TO_ONE,
+            constants.interfaces.SEO,
+          ].includes(node.meta?.interface) &&
+          (!node.meta?.required || !node.meta?.hidden)
+        )
+          status = true;
+        return status;
+      },
       conditionFn: (node) =>
         node.meta?.required === true && !node.isRelationalUpdate,
       mapFn: (node) => ({
@@ -479,6 +496,24 @@ const validateMetaRules = (
         label: node.display_label,
       }),
       actionFn: (node) => {
+        const normalize = (path) => path.replace(/\[\d+\]/g, "[]");
+
+        const getRoot = (path) => normalize(path).split(".")[0];
+
+        const buildError = (path, translated) => {
+          if (!isEmpty(getValue(formData, path))) return;
+          let obj = {
+            label,
+            fieldPath: path,
+            description: "",
+            message,
+          };
+          if (translated) {
+            obj.translation_path = translated;
+          }
+          addError(path, obj, node);
+        };
+
         const isTranslationNode =
           node?.meta?.parentInterface === constants.interfaces.TRANSLATIONS ||
           field?.meta?.interface === constants.interfaces.TRANSLATIONS;
@@ -498,12 +533,25 @@ const validateMetaRules = (
 
         if (
           currentPath &&
-          currentPath?.trim() !== "" &&
-          !fPath.includes(currentPath)
+          currentPath.trim() !== "" &&
+          !normalize(fPath).startsWith(normalize(currentPath)) &&
+          getRoot(fPath) !== getRoot(currentPath)
         ) {
-          fPath = `${currentPath}.${fPath}`;
+          if (currentPath.includes(fPath)) {
+            fPath = currentPath;
+          } else fPath = `${currentPath}.${fPath}`;
         }
 
+        // if (
+        //   currentPath &&
+        //   currentPath?.trim() !== "" &&
+        //   !fPath.includes(currentPath)
+        //   // TODO: Need to Optimize This fPath => group.items.dropdown currentPath => group.items[0].dropdown final path becomes => group.items[0].dropdown.group.items.dropdown
+        //   // also translations.create[0].meta_description <=fPath  condition currentPath => seo.create[0].translations.create[0].meta_description then condition becomes true but parent is not same then need to merge
+        // ) {
+        //   fPath = `${currentPath}.${fPath}`;
+        // }
+
         if (staticType === "update") return;
         if (staticType === "delete" && !isTranslationNode) return;
         if (staticType === "existing" && !isTranslationNode) return;
@@ -511,34 +559,21 @@ const validateMetaRules = (
         const label = formatLabel(node.display_label);
         const message = error_messages.REQUIRED.replace("{field}", label);
 
-        const buildError = (path, translated) => {
-          if (!isEmpty(getValue(formData, path))) return;
-          let obj = {
-            label,
-            fieldPath: path,
-            description: "",
-            message,
-          };
-          if (translated) {
-            obj.translation_path = translated;
-          }
-          addError(path, obj, node);
-        };
-
         const isMultiLang =
           isTranslationNode &&
           Array.isArray(language_codes) &&
           language_codes.length > 1;
+
         if (isMultiLang) {
+          const fullPath = fPath;
+
           language_codes.forEach((lang, index) => {
             let langPath, transformedPath;
             let isAdded = false;
-
-            // Check if current language entry exists in fieldValue.create
+            // // Check if current language entry exists in fieldValue.create
             if (
               Array.isArray(fieldValue?.create) &&
               fieldValue?.create.some((item, idx) => {
-                // Check by languages_code or by index match
                 return item.languages_code === lang || idx === index;
               })
             ) {
@@ -549,25 +584,21 @@ const validateMetaRules = (
               node?.value?.includes("create[0].") ||
               node?.value?.includes("create[0]")
             ) {
-              langPath = rebuildFullPath(node.value, node.key, (path) =>
+              langPath = rebuildFullPath(node.value, fPath, (path) =>
                 path.replace(/create\[0\]\./, `create[${index}].`)
               );
-              transformedPath = rebuildFullPath(
-                node.value,
-                node.key,
-                (path) => {
-                  const newPath = path
-                    .replace(/\[0\]\./, `.${lang}.`)
-                    ?.replace("create", "");
-                  return newPath;
-                }
-              );
+              transformedPath = rebuildFullPath(node.value, fPath, (path) => {
+                const newPath = path
+                  .replace(/\[0\]\./, `.${lang}.`)
+                  ?.replace("create", "");
+                return newPath;
+              });
             } else {
-              langPath = rebuildFullPath(node.value, node.key, (path) => {
+              langPath = rebuildFullPath(node.value, fPath, (path) => {
                 return path.replace(/create\./, `create[${index}].`);
               });
 
-              transformedPath = rebuildFullPath(node.value, node.key, (path) =>
+              transformedPath = rebuildFullPath(node.value, fPath, (path) =>
                 path.replace(/\[0\]\./, `.${lang}.`)?.replace("create", "")
               );
             }
@@ -1128,16 +1159,7 @@ const validateField = (
   timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone,
   translatedPath = null
 ) => {
-  if (
-    onlyFormFields == true &&
-    value === undefined &&
-    ![constants.interfaces.TRANSLATIONS, constants.interfaces.SEO].includes(
-      field?.meta?.interface
-    )
-  )
-    return;
-
-  const { is_m2a_item } = field?.meta;
+  const { is_m2a_item, staticType = null, parentInterface } = field?.meta;
   const currentPath = fieldPath
     ? `${fieldPath}.${field.key.split(".").pop()}`
     : field.key;
@@ -1147,6 +1169,50 @@ const validateField = (
       ? `${translatedPath}.${field.key.split(".").pop()}`
       : field.key;
   }
+
+  if (
+    onlyFormFields == true &&
+    value === undefined &&
+    ![constants.interfaces.TRANSLATIONS, constants.interfaces.SEO].includes(
+      field?.meta?.interface
+    )
+  ) {
+    if (
+      onlyFormFields == true &&
+      value === undefined &&
+      staticType === "update" &&
+      parentInterface === constants.interfaces.TRANSLATIONS &&
+      field?.meta.required
+    ) {
+      const langCode = getValue(formData, fieldPath)?.languages_code;
+      const translationFieldPath = trimBasicPath(currentPath, staticType);
+      const existingItemValue = getValue(
+        existingForm,
+        translationFieldPath
+      )?.find((item) => item.languages_code === langCode)?.[
+        `${field.key.split(".").pop()}`
+      ];
+
+      if (isEmpty(existingItemValue)) {
+        const message = error_messages.REQUIRED.replace(
+          `{field}`,
+          formatLabel(`${field.key.split(".").pop()}`)
+        );
+        addError(
+          currentPath,
+          {
+            label: formatLabel(`${field.key.split(".").pop()}`),
+            fieldPath: currentPath,
+            translation_path: translatedPath,
+            description: "",
+            message,
+          },
+          field
+        );
+      }
+    } else return;
+  }
+
   const fieldLabel = formatLabel(field.display_label);
 
   validateMetaRules(
@@ -1263,6 +1329,13 @@ const validateField = (
           )
             trPath = trPath.replace(".update.", ".");
 
+          if (
+            trPath &&
+            field.meta?.staticType === "create" &&
+            trPath.includes(".create.")
+          )
+            trPath = trPath.replace(".create.", ".");
+
           validateField(
             child,
             item[child.key.split(".").pop()],

package/package.json

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