nox-validation 1.7.1 → 1.7.3

package/index.js

@@ -5,19 +5,34 @@ const {
   buildNestedStructure,
   getValue,
   setValue,
-  getDefaultValues
+  getDefaultValues,
 } = require("./lib/helpers");
 
+const optimizedValidate = require("./lib/validate.optimized");
+const helpersOptimized = require("./lib/helpers.optimized");
+
 module.exports = {
   validate,
   CONSTANTS: constants,
   helpers: {
     validateSingleField: validateField,
     validateType: typeChecks,
-    fieldsMapping:getFieldsGroupBySchemaId,
-    convertTree:buildNestedStructure,
-    getValueByDynamicKey:getValue,
-    setValueByDynamicKey:setValue,
-    getTreeDefaultValues:getDefaultValues
+    fieldsMapping: getFieldsGroupBySchemaId,
+    convertTree: buildNestedStructure,
+    getValueByDynamicKey: getValue,
+    setValueByDynamicKey: setValue,
+    getTreeDefaultValues: getDefaultValues,
+  },
+  optimized: {
+    validate: optimizedValidate.validate,
+    helpers: {
+      validateSingleField: helpersOptimized.validateField,
+      validateType: helpersOptimized.typeChecks,
+      fieldsMapping: helpersOptimized.getFieldsGroupBySchemaId,
+      convertTree: helpersOptimized.buildNestedStructure,
+      getValueByDynamicKey: helpersOptimized.getValue,
+      setValueByDynamicKey: helpersOptimized.setValue,
+      getTreeDefaultValues: helpersOptimized.getDefaultValues,
+    },
   },
 };

package/lib/helpers.optimized.js

@@ -1105,21 +1105,53 @@ const buildNestedStructure = ({
   const root = {};
   const nodeMap = new Map();
 
-  // Sort fields by path depth once
   const sortedFields = [...schemaFields].sort(
     (a, b) => a.path.split(".").length - b.path.split(".").length
   );
 
-  // Pre-compute interface checks
-  const isV2FileInterface = (interface) =>
+  const isV2FileInterface = (interfaceName) =>
     apiVersion === constants.API_VERSION.V2 &&
     [
       constants.interfaces.FILES,
       constants.interfaces.FILE,
       constants.interfaces.FILE_IMAGE,
-    ].includes(interface);
+    ].includes(interfaceName);
+
+  // utility to adjust children keys as required
+  function adjustChildKeys(
+    children,
+    parentType,
+    parentKey,
+    parentMetaInterface
+  ) {
+    if (!Array.isArray(children) || children.length === 0) return children;
+    // For array parent type
+    if (parentType === constants.types.ARRAY) {
+      // If translation
+      if (parentMetaInterface === constants.interfaces.TRANSLATIONS) {
+        // e.g., parent.key[lang_code].child.key
+        return children.map((child) => ({
+          ...child,
+          key: `${parentKey}[lang_code].${child.key.split(".").pop()}`,
+          value: `${parentKey}[lang_code].${child.key.split(".").pop()}`,
+        }));
+      } else {
+        // e.g., parent.key[idx].child.key
+        return children.map((child) => ({
+          ...child,
+          key: `${parentKey}[idx].${child.key.split(".").pop()}`,
+          value: `${parentKey}[idx].${child.key.split(".").pop()}`,
+        }));
+      }
+    }
+    // For normal object type, just parent.key.child.key
+    return children.map((child) => ({
+      ...child,
+      key: `${parentKey}.${child.key.split(".").pop()}`,
+      value: `${parentKey}.${child.key.split(".").pop()}`,
+    }));
+  }
 
-  // Process each field in a single pass
   for (const item of sortedFields) {
     const pathParts = item.path.split(".");
     const key = pathParts.join(".");
@@ -1215,6 +1247,13 @@ const buildNestedStructure = ({
       } else {
         children = childFields;
       }
+      // Now, adjust children keys as required
+      children = adjustChildKeys(
+        children,
+        definedType.type,
+        key,
+        item.meta?.interface
+      );
     }
 
     // Add _id field for arrays
@@ -1382,7 +1421,7 @@ const RULE_TRANSFORM_MAP = {
     case: constants.rulesTypes.REGEX,
     options: (rule) => ({
       type: constants.regexTypes.CONTAINS,
-      case_sensitive: !rule[rule.type].insensitive,
+      case_sensitive: !rule[rule.type]?.insensitive,
       multiline: false,
       global: false,
     }),
@@ -1391,7 +1430,7 @@ const RULE_TRANSFORM_MAP = {
     case: constants.rulesTypes.REGEX,
     options: (rule) => ({
       type: constants.regexTypes.NOT_CONTAINS,
-      case_sensitive: !rule[rule.type].insensitive,
+      case_sensitive: !rule[rule.type]?.insensitive,
       multiline: false,
       global: false,
     }),
@@ -1400,28 +1439,28 @@ const RULE_TRANSFORM_MAP = {
     case: constants.rulesTypes.REGEX,
     options: (rule) => ({
       type: constants.regexTypes.START_WITH,
-      case_sensitive: !rule[rule.type].insensitive,
+      case_sensitive: !rule[rule.type]?.insensitive,
     }),
   },
   doesNotStartWith: {
     case: constants.rulesTypes.REGEX,
     options: (rule) => ({
       type: constants.regexTypes.NOT_START_WITH,
-      case_sensitive: !rule[rule.type].insensitive,
+      case_sensitive: !rule[rule.type]?.insensitive,
     }),
   },
   endsWith: {
     case: constants.rulesTypes.REGEX,
     options: (rule) => ({
       type: constants.regexTypes.ENDS_WITH,
-      case_sensitive: !rule[rule.type].insensitive,
+      case_sensitive: !rule[rule.type]?.insensitive,
     }),
   },
   doesNotEndWith: {
     case: constants.rulesTypes.REGEX,
     options: (rule) => ({
       type: constants.regexTypes.NOT_ENDS_WITH,
-      case_sensitive: !rule[rule.type].insensitive,
+      case_sensitive: !rule[rule.type]?.insensitive,
     }),
   },
   matchesRegExp: {
@@ -1465,12 +1504,12 @@ const RULE_TRANSFORM_MAP = {
   isOneOf: {
     case: constants.rulesTypes.ONE_OF,
     options: () => ({}),
-    value: (rule) => rule[rule.type].value,
+    value: (rule) => rule[rule.type]?.value,
   },
   isNotOneOf: {
     case: constants.rulesTypes.NOT_ONE_OF,
     options: () => ({}),
-    value: (rule) => [rule[rule.type].value],
+    value: (rule) => [rule[rule.type]?.value],
   },
 };
 

package/lib/validate.js

@@ -224,7 +224,18 @@ const isEmptyRelational = ({
     }
   } else if (api_version === constants.API_VERSION.V2) {
     if (isEmpty(existingValue)) return true;
-
+    let all = Array.isArray(existingValue)
+      ? existingValue.length === 0
+        ? []
+        : typeof existingValue[0] === "string"
+          ? existingValue
+          : existingValue.map((item) => item._id)
+      : typeof existingValue === "string"
+        ? [existingValue]
+        : existingValue && typeof existingValue === "object"
+          ? [existingValue._id]
+          : [];
+    all = Array.isArray(all) ? all?.filter(Boolean) : all;
     switch (interface) {
       case constants.interfaces.FILE:
       case constants.interfaces.FILE_IMAGE:
@@ -232,30 +243,17 @@ const isEmptyRelational = ({
       case constants.interfaces.MANY_TO_MANY:
       case constants.interfaces.ONE_TO_MANY:
       case constants.interfaces.MANY_TO_ONE:
-      case constants.interfaces.SEO:
+      case constants.interfaces.MANY_TO_ANY:
         return remainingItems({
-          all: Array.isArray(existingValue)
-            ? existingValue.length === 0
-              ? []
-              : typeof existingValue[0] === "string"
-              ? existingValue
-              : existingValue.map((item) => item._id)
-            : typeof existingValue === "string"
-            ? [existingValue]
-            : existingValue && typeof existingValue === "object"
-            ? [existingValue._id]
-            : [],
+          all: all,
           obj: value,
+          isM2A: interface === constants.interfaces.MANY_TO_ANY,
         });
-      case constants.interfaces.MANY_TO_ANY:
+      case constants.interfaces.SEO:
         return remainingItems({
-          all: Array.isArray(existingValue)
-            ? existingValue?.map((item) => item.item)
-            : [],
+          all: all,
           obj: value,
-          isM2A: true,
         });
-
       // constants.interfaces.TRANSLATIONS,
       default:
         return true;
@@ -361,12 +359,21 @@ const validateMetaRules = (
   const isValidRelational =
     required && isRelational
       ? isEmptyRelational({
-          api_version: apiVersion,
-          value: fieldValue,
-          interface: field?.meta?.interface,
-          onlyFormFields,
-          existingValue: getValue(existingForm, currentPath),
-        })
+        api_version: apiVersion,
+        value: fieldValue,
+        interface: field?.meta?.interface,
+        onlyFormFields,
+        existingValue:
+          getValue(existingForm, currentPath) ||
+          getValue(
+            existingForm,
+            currentPath
+              ?.replace(".create", "")
+              ?.replace(".update", "")
+              ?.replace(".existing", "")
+              ?.replace(".delete", "")
+          ), // TODO: Need to Generate Form Path Without create, update, existing, delete
+      })
       : true;
 
   const isEmptyVal = is_m2a_item ? !fieldValue : isEmpty(fieldValue);
@@ -385,29 +392,29 @@ const validateMetaRules = (
   if (invalidRequire || !isValidRelational) {
     const message = field?.meta?.required
       ? error_messages.REQUIRED.replace(
-          `{field}`,
-          formatLabel(field.display_label)
-        )
+        `{field}`,
+        formatLabel(field.display_label)
+      )
       : error_messages.NOT_EMPTY.replace(
-          `{field}`,
-          formatLabel(field.display_label)
-        );
+        `{field}`,
+        formatLabel(field.display_label)
+      );
     addError(
       currentPath,
       translatedPath
         ? {
-            label: formatLabel(field.display_label),
-            fieldPath: currentPath,
-            description: "",
-            translation_path: translatedPath,
-            message,
-          }
+          label: formatLabel(field.display_label),
+          fieldPath: currentPath,
+          description: "",
+          translation_path: translatedPath,
+          message,
+        }
         : {
-            label: formatLabel(field.display_label),
-            fieldPath: currentPath,
-            description: "",
-            message,
-          },
+          label: formatLabel(field.display_label),
+          fieldPath: currentPath,
+          description: "",
+          message,
+        },
       field
     );
   }
@@ -463,8 +470,19 @@ 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) => ({
@@ -475,6 +493,7 @@ const validateMetaRules = (
         const isTranslationNode =
           node?.meta?.parentInterface === constants.interfaces.TRANSLATIONS ||
           field?.meta?.interface === constants.interfaces.TRANSLATIONS;
+
         let fPath = node.key?.replace("[0][0]", "[0]");
         const types = ["update", "delete", "existing", "create"];
         const extractFirstType = (key) => {
@@ -587,8 +606,8 @@ const validateMetaRules = (
   const validType =
     field?.alternateType?.length > 0
       ? [field.type, ...field?.alternateType].some((type) =>
-          typeChecks[type](fieldValue)
-        )
+        typeChecks[type](fieldValue)
+      )
       : typeChecks[field.type](fieldValue, { key: currentPath, updateValue });
 
   if (!isEmpty(fieldValue) && !validType) {
@@ -626,9 +645,8 @@ const handleRegexValidation = (
   const fieldLabel = formatLabel(field.display_label);
 
   // Determine regex flags
-  const flags = `${rule.options?.case_sensitive ? "" : "i"}${
-    rule.options?.multiline ? "m" : ""
-  }${rule.options?.global ? "g" : ""}`;
+  const flags = `${rule.options?.case_sensitive ? "" : "i"}${rule.options?.multiline ? "m" : ""
+    }${rule.options?.global ? "g" : ""}`;
 
   // Build regex for MATCH/CONTAINS/NOT_CONTAINS
   let regex;
@@ -1203,10 +1221,12 @@ const validateField = (
     if (itemType) {
       value.forEach((item, index) => {
         const itemPath = `${currentPath}[${index}]`;
-
         if (
           (choices.includes(field?.meta?.interface) && !isEmpty(item)) ||
-          (["tags", "array_of_values"].includes(field?.meta?.interface) &&
+          ([
+            constants.interfaces.TAGS,
+            constants.interfaces.ARRAY_OF_VALUES,
+          ].includes(field?.meta?.interface) &&
             !isEmpty(item))
         ) {
           applyValidations(
@@ -1404,11 +1424,14 @@ const validate = (data) => {
   };
 
   const addError = (fieldPath, obj, field) => {
-    fieldPath = [...choices, "tags", "array_of_values"].includes(
-      field?.meta?.interface
-    )
-      ? fieldPath?.replace(/\[\d+\].*$/, "")
-      : fieldPath;
+    // fieldPath = [
+    //   ...choices,
+    //   constants.interfaces.TAGS,
+    //   constants.interfaces.ARRAY_OF_VALUES,
+    // ].includes(field?.meta?.interface)
+    //   ? fieldPath?.replace(/\[\d+\].*$/, "")
+    //   : fieldPath;
+    // TODO: Path is Sometimes Become Wrong (Like Unflatten) if we uncomment this
 
     const fieldKey = getLastChildKey(fieldPath);
     const isBypass = byPassKeys?.some((key) => key === fieldKey);
@@ -1422,7 +1445,7 @@ const validate = (data) => {
         if (
           secondParentField &&
           secondParentField?.meta?.interface ===
-            constants.interfaces.TRANSLATIONS
+          constants.interfaces.TRANSLATIONS
         ) {
           const languageKey = secondParentField?.meta?.options?.language_field;
           const firstParentValue = getValue(formData, firstParent);

package/package.json

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