nox-validation 1.0.6 → 1.0.8

package/lib/helpers.js

@@ -157,31 +157,118 @@ const isEmpty = (val) => {
   return false;
 };
 
-const convertTypes = (field) => {
-  // array_type:
-  // item.type !== item.schema_definition.type &&
-  // item.schema_definition.type !== constants.types.ALIAS
-  //   ? item.schema_definition.type
-  //   : item.type === item.schema_definition.type &&
-  //       item.type === constants.types.ARRAY
-  //     ? constants.types.OBJECT
-  //     : null,
-
-  // type:
-  // item.type === constants.types.ALIAS ||
-  // item.schema_definition.type === constants.types.ALIAS
-  //   ? constants.types.OBJECT
-  //   : item.type,
-
-  //   'list-o2m', // alias
-  //   'list-m2o', // objectid
-  //   'list-m2m', // alias
-  //   'file', // objectid
-  //   'file-image', // objectid
-  //   'files', // alias
-  //   'list-m2a', // alias
-  //   'translations', // alias
+// 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;
   let interfaceType = meta?.interface;
@@ -207,7 +294,7 @@ const convertTypes = (field) => {
     return {
       type: constants.types.ARRAY,
       array_type: constants.types.OBJECT_ID,
-      find_relations: true,
+      find_relations: false,
     };
   }
 
@@ -270,90 +357,83 @@ const convertTypesV1 = (field) => {
   return { type, array_type, find_relations };
 };
 
-const generateRelationalFieldV1 = (key = "", collectionFields = [], relationType) => {
-  const generateField = (name, path, schema_definition_type, type, childrenFields = []) => {
-    const relationalPath = key ? `${key}.${path}` : path;
-
+const generateField = (name, path, schema_definition_type, type, childrenFields = []) => {
+  childrenFields = childrenFields?.map((child) => {
     return {
-      display_label: name,
-      key: relationalPath,
-      value: relationalPath,
-      children: childrenFields,
-      type: type,
-      meta: {
-        required: false,
-        nullable: false,
-        hidden: false,
-      },
-      validations: [],
-      array_type: schema_definition_type,
+      ...child,
+      value: `${path}.${child.value}`,
+      key: `${path}.${child.key}`,
     };
+  });
+
+  return {
+    display_label: name,
+    // field: name,
+    key: path,
+    value: path,
+    children: childrenFields,
+    type: type,
+    meta: {
+      required: false,
+      nullable: false,
+      hidden: false,
+    },
+    validations: [],
+    schema_definition: {
+      type: schema_definition_type,
+    },
   };
+};
 
+const generateRelationalFieldV1 = (key = "", collectionFields = [], relationType) => {
   if (relationType === constants.interfaces.MANY_TO_ANY) {
     return [
-      generateField("collection", "collection", constants.types.STRING, constants.types.STRING),
-      generateField("sort", "sort", constants.types.NUMBER, constants.types.NUMBER),
-      generateField("item", "item", constants.types.OBJECT_ID, constants.types.OBJECT_ID),
+      generateField(
+        "collection",
+        `${key}.collection`,
+        constants.types.STRING,
+        constants.types.STRING
+      ),
+      generateField("sort", `${key}.sort`, constants.types.NUMBER, constants.types.NUMBER),
+      generateField("item", `${key}.item`, constants.types.OBJECT_ID, constants.types.OBJECT_ID),
     ];
   } else {
-    return [];
+    return null;
   }
 };
 
 const generateRelationalField = (key = "", collectionFields = [], relationType) => {
-  const generateField = (name, path, schema_definition_type, type, childrenFields = []) => {
-    const relationalPath = key ? `${key}.${path}` : path;
-    childrenFields = childrenFields?.map((child) => {
-      return {
-        ...child,
-        key: `${relationalPath}.${child.key}`,
-        value: `${relationalPath}.${child.value}`,
-      };
-    });
-
-    return {
-      display_label: name,
-      key: relationalPath,
-      value: relationalPath,
-      children: childrenFields,
-      type: type,
-      meta: {
-        required: false,
-        nullable: false,
-        hidden: false,
-      },
-      validations: [],
-      array_type: schema_definition_type,
-    };
-  };
-
   if (relationType === constants.interfaces.MANY_TO_ANY) {
     const existingField = generateField(
-      `${key}.existing`,
       "existing",
+      `${key}.existing`,
       constants.types.OBJECT,
       constants.types.ARRAY
     );
     existingField.children = [
       generateField(
         "collection",
-        "existing.collection",
+        `${key}.existing.collection`,
         constants.types.STRING,
         constants.types.STRING
       ),
-      generateField("sort", "existing.sort", constants.types.NUMBER, constants.types.NUMBER),
-      generateField("item", "existing.item", constants.types.OBJECT_ID, constants.types.OBJECT_ID),
+      generateField("sort", `${key}.existing.sort`, constants.types.NUMBER, constants.types.NUMBER),
+      generateField(
+        "item",
+        `${key}.existing.item`,
+        constants.types.OBJECT_ID,
+        constants.types.OBJECT_ID
+      ),
     ];
     const deleteField = generateField(
       "delete",
-      "delete",
+      `${key}.delete`,
       constants.types.OBJECT_ID,
       constants.types.ARRAY
     );
     const createField = generateField(
       "create",
-      "create",
+      `${key}.create`,
       constants.types.OBJECT,
       constants.types.ARRAY,
       collectionFields
@@ -361,14 +441,14 @@ const generateRelationalField = (key = "", collectionFields = [], relationType)
     createField.children = [
       generateField(
         "collection",
-        "create.collection",
+        `${key}.create.collection`,
         constants.types.STRING,
         constants.types.STRING
       ),
-      generateField("sort", "create.sort", constants.types.NUMBER, constants.types.NUMBER),
+      generateField("sort", `${key}.create.sort`, constants.types.NUMBER, constants.types.NUMBER),
       generateField(
         "item",
-        "create.item",
+        `${key}.create.item`,
         constants.types.OBJECT,
         constants.types.OBJECT,
         collectionFields
@@ -376,7 +456,7 @@ const generateRelationalField = (key = "", collectionFields = [], relationType)
     ];
     const updateField = generateField(
       "update",
-      "update",
+      `${key}.update`,
       constants.types.OBJECT,
       constants.types.ARRAY,
       collectionFields
@@ -384,14 +464,14 @@ const generateRelationalField = (key = "", collectionFields = [], relationType)
     updateField.children = [
       generateField(
         "collection",
-        "update.collection",
+        `${key}.update.collection`,
         constants.types.STRING,
         constants.types.STRING
       ),
-      generateField("sort", "update.sort", constants.types.NUMBER, constants.types.NUMBER),
+      generateField("sort", `${key}.update.sort`, constants.types.NUMBER, constants.types.NUMBER),
       generateField(
         "item",
-        "update.item",
+        `${key}.update.item`,
         constants.types.OBJECT,
         constants.types.OBJECT,
         collectionFields
@@ -400,18 +480,23 @@ const generateRelationalField = (key = "", collectionFields = [], relationType)
     return [existingField, deleteField, createField, updateField];
   } else {
     return [
-      generateField("existing", "existing", constants.types.OBJECT_ID, constants.types.ARRAY),
-      generateField("delete", "delete", constants.types.OBJECT_ID, constants.types.ARRAY),
+      generateField(
+        "existing",
+        `${key}.existing`,
+        constants.types.OBJECT_ID,
+        constants.types.ARRAY
+      ),
+      generateField("delete", `${key}.delete`, constants.types.OBJECT_ID, constants.types.ARRAY),
       generateField(
         "create",
-        "create",
+        `${key}.create`,
         constants.types.OBJECT,
         constants.types.ARRAY,
         collectionFields
       ),
       generateField(
         "update",
-        "update",
+        `${key}.update`,
         constants.types.OBJECT,
         constants.types.ARRAY,
         collectionFields
@@ -573,28 +658,50 @@ const getChildFields = (relationDetail, allFields, relational_fields, isTranslat
   }
 };
 
-const buildNestedStructure = (
+const default_fields = [
+  "updated_by",
+  "created_by",
+  "created_at",
+  "updated_at",
+  "nox_created_at",
+  "nox_updated_at",
+  "nox_created_by",
+  "nox_updated_by",
+  "_id",
+];
+
+const buildNestedStructure = ({
   schemaFields,
   allFields,
   relations,
-  formData,
   relational_fields,
   isSeparatedFields,
-  apiVersion
-) => {
+  apiVersion,
+  maxLevel,
+  currentDepthMap,
+  rootPath,
+  isRoot,
+}) => {
   const root = {};
   const nodeMap = new Map();
 
   schemaFields.sort((a, b) => a.path.split(".").length - b.path.split(".").length);
 
   schemaFields.forEach((item) => {
+    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 isUserKey = item?.path?.includes("updated_by") || item?.path?.includes("created_by");
+    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 && !isUserKey) {
+    if (definedType.find_relations) {
       const relationDetail = getForeignCollectionDetails({
         relations: relations,
         collection: item?.schema_id,
@@ -616,20 +723,23 @@ 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,
+        });
       }
     }
 
-    const pathParts = item.path.split(".");
-    const key = pathParts.join(".");
-
     const node = {
       field_id: item?._id,
       display_label: pathParts[pathParts.length - 1],
@@ -698,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.6",
+  "version": "1.0.8",
   "description": "validate dynamic schema",
   "main": "index.js",
   "scripts": {