nox-validation 1.0.7 → 1.0.8

package/lib/helpers.js

@@ -157,6 +157,117 @@ const isEmpty = (val) => {
   return false;
 };
 
+// field?.field_type (Possible Values => Single, Object, Array)
+// 1. Single => Root Field Then Its Single
+// 2. Object => Nested Field Like Inside Array Or Object
+// 3. Array => Any Kind Of Array Array Of String, Object etc
+
+// field?.type (Possible Values)
+// 1. String
+// 2. Number
+// 3. Date
+// 4. Buffer
+// 5. Boolean
+// 6. Mixed
+// 7. ObjectId
+// 8. Object
+// 9. Array
+// 10. Alias
+
+// field?.schema_definition?.type
+// it is used for specially when field?.type is Array, but some times both are Array Then We Have to check
+
+// field?.meta?.interface
+
+const generateType = (field, api) => {
+  let { type, schema_definition, meta } = field;
+  let interfaceType = meta?.interface;
+  let array_type = schema_definition?.type;
+  let fieldType = type;
+  let find_relations = false;
+
+
+  // When type and Array Type Are Same
+  if (type === schema_definition?.type) {
+    // Type And Array Type Both is Array
+    if (type === constants.types.ARRAY) {
+      array_type = constants.types.OBJECT;
+    }
+    // Todo: when both is Alias type === constants.types.ALIAS
+  }
+
+  switch (api) {
+    case "v1":
+      // is Relational Field
+      if (interfaceType && interfaceType !== "none") {
+        // We Need to find Relation
+        if (
+          [constants.interfaces.MANY_TO_ANY, constants.interfaces.TRANSLATIONS].includes(
+            interfaceType
+          )
+        ) {
+          find_relations = true;
+          // update type and array type accordingly interface
+          if ([constants.interfaces.MANY_TO_ANY].includes(interfaceType)) {
+            fieldType = constants.types.ARRAY;
+            array_type = constants.types.OBJECT;
+          } else {
+            fieldType = constants.types.OBJECT;
+          }
+        } else {
+          // It is Relational Field, so we have to update type and array type accordingly interface
+          if ([constants.interfaces.MANY_TO_ONE].includes(interfaceType)) {
+            fieldType = constants.types.OBJECT_ID;
+          }
+
+          if (
+            [
+              constants.interfaces.ONE_TO_MANY,
+              constants.interfaces.MANY_TO_MANY,
+              constants.interfaces.FILES,
+            ].includes(interfaceType)
+          ) {
+            fieldType = constants.types.ARRAY;
+            array_type = constants.types.OBJECT_ID;
+          }
+        }
+      }
+
+      return {
+        type: fieldType,
+        array_type,
+        find_relations,
+      };
+
+    default:
+      // API V2
+      if (
+        [
+          constants.interfaces.ONE_TO_MANY,
+          constants.interfaces.MANY_TO_MANY,
+          constants.interfaces.MANY_TO_ANY,
+          constants.interfaces.MANY_TO_ONE,
+          constants.interfaces.TRANSLATIONS,
+        ].includes(interfaceType)
+      ) {
+        fieldType = constants.types.OBJECT;
+        array_type = null;
+        find_relations = true;
+      }
+
+      if (interfaceType === constants.interfaces.FILES) {
+        fieldType = constants.types.ARRAY;
+        array_type = constants.types.OBJECT_ID;
+        find_relations = false;
+      }
+      return {
+        type: fieldType,
+        array_type,
+        find_relations,
+      };
+  }
+};
+
 const convertTypes = (field) => {
   let { type, schema_definition, meta } = field;
   let array_type = schema_definition?.type ?? null;
@@ -559,15 +670,18 @@ const default_fields = [
   "_id",
 ];
 
-const buildNestedStructure = (
+const buildNestedStructure = ({
   schemaFields,
   allFields,
   relations,
-  formData,
   relational_fields,
   isSeparatedFields,
-  apiVersion
-) => {
+  apiVersion,
+  maxLevel,
+  currentDepthMap,
+  rootPath,
+  isRoot,
+}) => {
   const root = {};
   const nodeMap = new Map();
 
@@ -577,17 +691,17 @@ const buildNestedStructure = (
     const pathParts = item.path.split(".");
     const key = pathParts.join(".");
 
+    const currentDepth = currentDepthMap.get(isRoot ? item.path : rootPath) || 0;
+
+    if (currentDepth >= maxLevel) return;
+
     let childFields;
 
-    const definedType =
-      apiVersion === constants.API_VERSION.V1 ? convertTypesV1(item) : convertTypes(item);
+    const definedType = generateType(item, apiVersion);
+    // apiVersion === constants.API_VERSION.V1 ? convertTypesV1(item) : convertTypes(item);
     // const isUserKey = default_fields.some((field) => item?.path?.includes(field));
 
-    if (
-      definedType.find_relations &&
-      (item?.type === constants.types.ALIAS ||
-        item?.schema_definition?.type === constants.types.ALIAS)
-    ) {
+    if (definedType.find_relations) {
       const relationDetail = getForeignCollectionDetails({
         relations: relations,
         collection: item?.schema_id,
@@ -609,15 +723,20 @@ const buildNestedStructure = (
       }
 
       if (childFields) {
-        childFields = buildNestedStructure(
-          childFields,
-          allFields,
-          relations,
-          formData,
-          relational_fields,
-          isSeparatedFields
-        );
- 
+        if (!isRoot) currentDepthMap.set(rootPath, currentDepth + 1);
+
+        childFields = buildNestedStructure({
+          schemaFields: childFields,
+          allFields: allFields,
+          relations: relations,
+          relational_fields: relational_fields,
+          isSeparatedFields,
+          apiVersion,
+          maxLevel,
+          currentDepthMap,
+          rootPath: isRoot ? item.path : rootPath,
+          isRoot: false,
+        });
       }
     }
 
@@ -689,12 +808,17 @@ const getAllKeys = (structure) => {
 
 const normalizeKey = (key) => key.replace(/\[\d+\]/g, "");
 
-const findDisallowedKeys = (formData, structure) => {
+const findDisallowedKeys = (formData, structure, maxLevel) => {
   const formKeys = [];
   generateDynamicKeys(formData, formKeys);
 
   const validKeys = getAllKeys(structure);
-  return formKeys.filter((key) => !validKeys.has(normalizeKey(key)));
+  return formKeys.filter((key) => {
+    const keyParts = normalizeKey(key).split(".");
+    const keyLevel = keyParts.length;
+    const levelParent = keyParts.slice(maxLevel - 1).join(".");
+    return !validKeys.has(normalizeKey(keyLevel > maxLevel ? levelParent : key));
+  });
 };
 
 const generateFieldCompareRules = (rule) => {

package/lib/validate.js

@@ -7,6 +7,7 @@ const {
   getValue,
   setValue,
   isEmpty,
+  getParentKey,
 } = require("./helpers");
 
 const typeChecks = {
@@ -663,6 +664,7 @@ const schema = {
   },
   apiVersion: { type: constants.types.STRING, array_type: null },
   language: { type: constants.types.STRING, array_type: null },
+  maxLevel: { type: constants.types.NUMBER, array_type: null },
 };
 
 const validate = (data) => {
@@ -677,12 +679,12 @@ const validate = (data) => {
     byPassKeys,
     apiVersion,
     language,
+    maxLevel,
   } = 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) => {
@@ -833,18 +835,23 @@ const validate = (data) => {
     schemaFields = fields.filter((field) => field?.schema_id?.toString() === formId?.toString());
   }
 
+  let currentDepthMap = new Map();
+
   const fieldOptions =
-    buildNestedStructure(
-      schemaFields || [],
-      allFields,
-      relations,
-      formData,
-      relationalFields,
+    buildNestedStructure({
+      schemaFields: schemaFields || [],
+      allFields: allFields,
+      relations: relations,
+      relational_fields: relationalFields,
       isSeparatedFields,
-      apiVersion
-    ) || [];
-
-  findDisallowedKeys(formData, fieldOptions).forEach((fieldPath) => {
+      apiVersion,
+      maxLevel,
+      currentDepthMap,
+      rootPath: "",
+      isRoot: true,
+    }) || [];
+
+  findDisallowedKeys(formData, fieldOptions,maxLevel).forEach((fieldPath) => {
     if (abortEarly && !result.status) return result;
     const fieldKey = getLastChildKey(fieldPath);
     if (fieldKey && !result.errors[fieldPath]) {

package/package.json

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