nox-validation 1.4.1 → 1.4.3

package/lib/constant.js

@@ -143,6 +143,11 @@ const interfaces = Object.freeze({
   FILES: "files",
   TRANSLATIONS: "translations",
   RELATIONAL: "relational",
+  CHECKBOX: "checkboxes",
+  ITEMS: "items",
+  MULTIPLE_DROPDOWN: "dropdown_multiple",
+  TAGS: "tags",
+  ARRAY_OF_VALUES: "array_of_values",
 });
 
 const API_VERSION = Object.freeze({

package/lib/helpers.js

@@ -59,6 +59,52 @@ const keyExists = (obj, key, separator = ".") => {
   });
 };
 
+const remainingItems = ({ all = [], obj = {}, isM2A = false }) => {
+  const resultSet = new Set(all);
+
+  if (Array.isArray(obj.existing)) {
+    obj.existing.forEach((id) => {
+      if (isM2A && id && typeof id === "object" && "item" in id) {
+        resultSet.add(id.item);
+      } else {
+        resultSet.add(id);
+      }
+    });
+  }
+
+  if (Array.isArray(obj.create)) {
+    obj.create.forEach((item, idx) => {
+      if (item && item._id) {
+        resultSet.add(item._id);
+      } else if (item) {
+        resultSet.add(`create_${idx}`);
+      }
+    });
+  }
+
+  if (Array.isArray(obj.update)) {
+    obj.update.forEach((item) => {
+      if (isM2A && item && item.item) {
+        resultSet.add(item.item);
+      } else if (item && item._id) {
+        resultSet.add(item._id);
+      }
+    });
+  }
+
+  if (Array.isArray(obj.delete)) {
+    obj.delete.forEach((id) => {
+      if (isM2A && id && typeof id === "object" && "item" in id) {
+        resultSet.delete(id.item);
+      } else {
+        resultSet.delete(id);
+      }
+    });
+  }
+
+  return resultSet.size > 0;
+};
+
 const formatLabel = (str) => {
   return str
     ?.replace(/_/g, " ")
@@ -275,6 +321,7 @@ const generateField = (
       ...child,
       value: childKey,
       key: childValue,
+      isRelationalUpdate: path.includes("update"),
     };
   });
 
@@ -780,7 +827,7 @@ const buildNestedStructure = ({
         childFields = getCachedFields(relationDetail, relational_fields);
       }
       if (item.meta.interface === constants.interfaces.TRANSLATIONS) {
-        childFields = childFields.map(f => {
+        childFields = childFields.map((f) => {
           if (
             f.field === relationDetail.foreign_field ||
             f.field === relationDetail.junction_field_this
@@ -789,8 +836,8 @@ const buildNestedStructure = ({
               ...f,
               meta: {
                 ...f.meta,
-                interface: "none"
-              }
+                interface: "none",
+              },
             };
           }
           return f;
@@ -926,7 +973,7 @@ const buildNestedStructure = ({
 
       if (parentNode) {
         parentNode.children.push(node);
-      } 
+      }
       // else {
       //   console.warn("[WARN] Parent node not found for:", node);
       // }
@@ -1325,7 +1372,37 @@ const getSelectedNodes = ({
 
     if (Array.isArray(currentNode.children)) {
       currentNode.children.forEach((child) => {
-        if (!skipFn(currentNode)) traverse(child);
+        let childNode = {
+          ...child,
+          key:
+            currentNode.type === constants.types.ARRAY
+              ? child.key.replace(currentNode.key, `${currentNode.key}[0]`)
+              : child.key,
+        };
+
+        if (Array.isArray(child.children) && child.children.length > 0) {
+          const updateChildKeys = (node, parentKey, newParentKey) => {
+            let updatedNode = {
+              ...node,
+              key: node.key.replace(parentKey, newParentKey),
+            };
+            if (Array.isArray(node.children) && node.children.length > 0) {
+              updatedNode.children = node.children.map((c) =>
+                updateChildKeys(c, parentKey, newParentKey)
+              );
+            }
+            return updatedNode;
+          };
+          if (currentNode.type === constants.types.ARRAY) {
+            childNode = updateChildKeys(
+              child,
+              currentNode.key,
+              `${currentNode.key}[0]`
+            );
+          }
+        }
+
+        if (!skipFn(currentNode)) traverse(childNode);
       });
     }
   }
@@ -1355,4 +1432,5 @@ module.exports = {
   extractRelationalParents,
   getM2AItemParentPath,
   getSelectedNodes,
+  remainingItems,
 };

package/lib/validate.js

@@ -11,6 +11,7 @@ const {
   extractRelationalParents,
   getM2AItemParentPath,
   getSelectedNodes,
+  remainingItems,
 } = require("./helpers");
 
 const choices = ["radio", "checkboxes", "dropdown_multiple", "dropdown"];
@@ -60,9 +61,16 @@ const typeChecks = {
   [constants.types.TIME]: (val) =>
     typeof val === "string" &&
     /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/.test(val),
-  [constants.types.TIMESTAMP]: (val) =>
-    typeof val === "string" &&
-    /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/.test(val),
+  [constants.types.TIMESTAMP]: (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;
@@ -164,36 +172,70 @@ 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) {
+const isEmptyRelational = ({
+  api_version,
+  value,
+  interface,
+  onlyFormFields,
+  existingValue,
+}) => {
+  if (!onlyFormFields) {
+    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 &&
-        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 !== ""
+        value?.create?.length > 0 ||
+        value?.existing?.length > 0 ||
+        value?.update?.length > 0
       );
-    } else {
-      return value?.length > 0;
+    }
+  } else if (api_version === constants.API_VERSION.V2) {
+    if (isEmpty(existingValue)) return true;
+
+    switch (interface) {
+      case constants.interfaces.FILE:
+      case constants.interfaces.FILE_IMAGE:
+      case constants.interfaces.FILES:
+      case constants.interfaces.MANY_TO_MANY:
+      case constants.interfaces.ONE_TO_MANY:
+      case constants.interfaces.MANY_TO_ONE:
+        return remainingItems({
+          all: existingValue.map((item) => item._id),
+          obj: value,
+        });
+      case constants.interfaces.MANY_TO_ANY:
+        return remainingItems({
+          all: existingValue.map((item) => item.item),
+          obj: value,
+          isM2A: true,
+        });
+
+      // constants.interfaces.TRANSLATIONS,
+      default:
+        return true;
     }
   } else {
-    return (
-      value?.create?.length > 0 ||
-      value?.existing?.length > 0 ||
-      value?.update?.length > 0
-    );
+    return true;
   }
-  return false;
 };
 
 const validateMetaRules = (
@@ -207,12 +249,16 @@ const validateMetaRules = (
   apiVersion,
   fieldOptions,
   formData,
-  language_codes = []
+  language_codes = [],
+  existingForm = {}
 ) => {
   const fieldValue = providedValue;
 
   const { required = false, nullable = false, options } = field?.meta ?? {};
 
+  if (field.isRelationalUpdate) {
+    onlyFormFields = true;
+  }
   const isRelational = relational_interfaces.includes(field?.meta?.interface);
 
   if (
@@ -235,16 +281,53 @@ const validateMetaRules = (
     );
   }
 
+  const arrayInterfaces = [
+    constants.interfaces.CHECKBOX,
+    constants.interfaces.ITEMS,
+    constants.interfaces.MULTIPLE_DROPDOWN,
+    constants.interfaces.TAGS,
+    constants.interfaces.ARRAY_OF_VALUES,
+  ];
+
+  if (
+    required &&
+    arrayInterfaces.includes(field?.meta?.interface) &&
+    onlyFormFields &&
+    fieldValue &&
+    Array.isArray(fieldValue) &&
+    fieldValue?.length === 0
+  ) {
+    const message = error_messages.NOT_EMPTY.replace(
+      `{field}`,
+      formatLabel(field.display_label)
+    );
+    addError(
+      currentPath,
+      {
+        label: formatLabel(field.display_label),
+        fieldPath: currentPath,
+        description: "",
+        message,
+      },
+      field
+    );
+  }
+
   const isValidRelational =
-    required && isRelational && !onlyFormFields
+    required && isRelational
       ? isEmptyRelational({
           api_version: apiVersion,
           value: fieldValue,
           interface: field?.meta?.interface,
+          onlyFormFields,
+          existingValue: getValue(existingForm, currentPath),
         })
       : true;
 
-  if ((required && isEmpty(fieldValue)) || !isValidRelational) {
+  if (
+    (required && !onlyFormFields && isEmpty(fieldValue)) ||
+    !isValidRelational
+  ) {
     const message = error_messages.REQUIRED.replace(
       `{field}`,
       formatLabel(field.display_label)
@@ -279,18 +362,21 @@ const validateMetaRules = (
   }
 
   if (
-    !fieldValue &&
-    !field?.meta?.hidden &&
-    ![
-      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,
-      "none",
-    ].includes(field?.meta?.interface)
+    (isEmpty(fieldValue) &&
+      !field?.meta?.hidden &&
+      ![
+        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,
+        "none",
+      ].includes(field?.meta?.interface)) ||
+    (field?.meta?.interface === constants.interfaces.TRANSLATIONS &&
+      language_codes?.length &&
+      !onlyFormFields)
   ) {
     const isTranslationChild =
       field?.meta?.interface === constants.interfaces.TRANSLATIONS;
@@ -299,11 +385,14 @@ const validateMetaRules = (
       node: field,
       skipFn: (node) =>
         node.meta?.interface === constants.interfaces.MANY_TO_ANY,
-      conditionFn: (node) => node.meta?.required === true,
-      mapFn: (node) => ({ key: node.key, label: node.display_label }),
+      conditionFn: (node) =>
+        node.meta?.required === true && !node.isRelationalUpdate,
+      mapFn: (node) => ({
+        key: node.key,
+        label: node.display_label,
+      }),
       actionFn: (node) => {
         let fPath = node.key;
-
         if (fPath.includes("update.")) return;
         if (fPath.includes("create.") && !isTranslationChild) return;
         if (fPath.includes("delete.") && !isTranslationChild) return;
@@ -332,16 +421,31 @@ const validateMetaRules = (
 
         if (isMultiLang) {
           language_codes.forEach((lang, index) => {
-            const langPath = fPath.replace("create.", `create[${index}].`);
-            const transformedPath = fPath.replace("create.", `${lang}.`);
-            buildError(langPath, transformedPath);
+            let langPath,
+              transformedPath,
+              isAdded = false;
+
+            if (fPath.includes("create[0].")) {
+              const exist = fieldValue?.create?.find(
+                (item) => item.languages_code === lang
+              );
+              if (exist) isAdded = true;
+
+              langPath = fPath.replace("create[0].", `create[${index}].`);
+              transformedPath = fPath.replace("create[0].", `create[${lang}].`);
+            } else {
+              langPath = fPath.replace("create.", `create[${index}].`);
+              transformedPath = fPath.replace("create.", `create[${lang}].`);
+            }
+
+            if (!isAdded) buildError(langPath, transformedPath);
           });
         } else {
           const singlePath = fPath.replace(
             "create.",
             isTranslationChild ? "create[lang_code]." : "create[0]."
           );
-          buildError(singlePath);
+          if (isEmpty(fieldValue)) buildError(singlePath);
         }
       },
     });
@@ -789,16 +893,10 @@ const validateField = (
   onlyFormFields,
   apiVersion,
   fieldOptions,
-  language_codes
+  language_codes,
+  existingForm
 ) => {
-  const isRelational = relational_interfaces.includes(field?.meta?.interface);
-
-  if (
-    onlyFormFields == true &&
-    isRelational &&
-    (value === undefined || value === null)
-  )
-    return;
+  if (onlyFormFields == true && (value === undefined || value === null)) return;
 
   const { is_m2a_item } = field?.meta;
   const currentPath = fieldPath
@@ -818,7 +916,8 @@ const validateField = (
     apiVersion,
     fieldOptions,
     formData,
-    language_codes
+    language_codes,
+    existingForm
   );
 
   if (
@@ -854,7 +953,8 @@ const validateField = (
         onlyFormFields,
         apiVersion,
         fieldOptions,
-        language_codes
+        language_codes,
+        existingForm
       )
     );
   } else if (field.type === constants.types.ARRAY && Array.isArray(value)) {
@@ -905,7 +1005,8 @@ const validateField = (
             onlyFormFields,
             apiVersion,
             fieldOptions,
-            language_codes
+            language_codes,
+            existingForm
           )
         );
       });
@@ -1012,6 +1113,7 @@ const validate = (data) => {
     language,
     maxLevel,
     onlyFormFields,
+    existingForm = {},
   } = data;
 
   const error_messages =
@@ -1262,7 +1364,8 @@ const validate = (data) => {
       onlyFormFields,
       apiVersion,
       fieldOptions,
-      data.language_codes
+      data.language_codes,
+      existingForm
     );
   });
   return result;

package/package.json

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