nox-validation 1.0.1

package/lib/helpers.js

@@ -0,0 +1,1011 @@
+const constants = require("./constant");
+
+const getAllFields = (obj, parentPath = "") => {
+  return Object.keys(obj).flatMap((key) => {
+    const path = parentPath ? `${parentPath}.${key}` : key;
+    if (Array.isArray(obj[key])) {
+      return obj[key].flatMap((item, index) =>
+        typeof item === "object" && item !== null
+          ? getAllFields(item, `${path}[${index}]`)
+          : `${path}[${index}]`
+      );
+    }
+    return typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key])
+      ? getAllFields(obj[key], path)
+      : path;
+  });
+};
+
+const getValue = (obj, key, separator = ".") => {
+  if (!key) return undefined;
+  const fieldPathParts = key.replace(/\[(\d+)\]/g, ".$1").split(separator);
+  return fieldPathParts.reduce((acc, part) => acc && acc[part], obj);
+};
+
+const setValue = (obj, key, value, separator = ".") => {
+  if (!key) return;
+
+  const keys = key.replace(/\[(\d+)\]/g, ".$1").split(separator);
+  const lastKey = keys.pop();
+
+  let deepObj = obj;
+
+  for (const part of keys) {
+    if (typeof deepObj[part] !== "object" || deepObj[part] === null) {
+      deepObj[part] = {};
+    }
+    deepObj = deepObj[part];
+  }
+
+  if (typeof deepObj[lastKey] === "object" && deepObj[lastKey] !== null) {
+    Object.assign(deepObj[lastKey], value);
+  } else {
+    deepObj[lastKey] = value;
+  }
+};
+
+const keyExists = (obj, key, separator = ".") => {
+  if (!key) return false;
+
+  const keys = key.replace(/\[(\d+)\]/g, ".$1").split(separator);
+  return keys.every((part) => {
+    if (obj && Object.prototype.hasOwnProperty.call(obj, part)) {
+      obj = obj[part];
+      return true;
+    }
+    return false;
+  });
+};
+
+const formatLabel = (str) => {
+  return str
+    ?.replace(/_/g, " ")
+    ?.toLowerCase()
+    ?.replace(/^./, (char) => char?.toUpperCase());
+};
+
+const getLastChildKey = (key) => {
+  if (!key) return "";
+  return key
+    .replace(/\[\d+\]/g, "")
+    .split(".")
+    .pop();
+};
+
+const getParentKey = (key) => {
+  if (!key) return "";
+
+  const cleanedKey = key.replace(/\[\d+\]/g, "").split(".");
+  cleanedKey.pop();
+  return cleanedKey.join(".");
+};
+
+const generateDynamicKeys = (data, keys, parentKey = "") => {
+  const addKey = (key) => {
+    if (key) {
+      keys.push(key);
+    }
+  };
+
+  if (Array.isArray(data)) {
+    addKey(parentKey);
+    data.forEach((item, index) => {
+      const key = `${parentKey}[${index}]`;
+      generateDynamicKeys(item, keys, key);
+    });
+  } else if (typeof data === "object" && data !== null) {
+    addKey(parentKey);
+    for (const key in data) {
+      if (Object.prototype.hasOwnProperty.call(data, key)) {
+        const newKey = parentKey ? `${parentKey}.${key}` : key;
+        generateDynamicKeys(data[key], keys, newKey);
+      }
+    }
+  } else {
+    addKey(parentKey);
+  }
+};
+
+const checkIsArrayKey = (key) => {
+  const match = key.match(/\[\d+\]/g);
+  const cleanedKey = key
+    .replace(/\[\d+\]/g, "")
+    .split(".")
+    .join(".");
+  return match
+    ? {
+        status: true,
+        fieldPath: cleanedKey,
+        formPath: key,
+        parentKey: getParentKey(key),
+      }
+    : { status: false, fieldPath: key, formPath: key, parentKey: key };
+};
+
+const getFormPath = (inputFields, fieldPath) => {
+  if (!fieldPath) return "";
+
+  const pathParts = fieldPath.split(".");
+  let formPath = "";
+
+  for (let i = 0; i < pathParts.length; i++) {
+    const currentPath = pathParts.slice(0, i + 1).join(".");
+    const field = inputFields.find((f) => f.path === currentPath);
+
+    if (field) {
+      formPath += field.type === constants.types.ARRAY ? `${field.field}[0]` : field.field;
+    } else {
+      formPath += `.${pathParts[i]}`;
+    }
+
+    if (i < pathParts.length - 1) formPath += ".";
+  }
+
+  const cleanedFormPath = formPath.replace(/\.\[/g, "[");
+  return cleanedFormPath.endsWith("[0]") ? cleanedFormPath.split("[0]")[0] : cleanedFormPath;
+};
+
+const isEmpty = (val) => {
+  if (val === undefined) return true;
+  if (val == null) return true;
+  if (typeof val === "boolean") return false;
+  if (typeof val === "number") return false;
+  if (typeof val === "string") return val.length === 0;
+  if (Array.isArray(val)) return val.length === 0;
+  if (typeof val === "object") return Object.keys(val).length === 0;
+
+  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
+
+  let { type, schema_definition, meta } = field;
+  let array_type = schema_definition?.type ?? null;
+  let interfaceType = meta?.interface;
+  let find_relations = false;
+
+  if (
+    [
+      constants.interfaces.ONE_TO_MANY,
+      constants.interfaces.MANY_TO_MANY,
+      constants.interfaces.MANY_TO_ANY,
+      constants.interfaces.TRANSLATIONS,
+    ].includes(interfaceType)
+  ) {
+    return {
+      type: constants.types.OBJECT,
+      array_type: null,
+      find_relations: true,
+    };
+  }
+
+  if (interfaceType === constants.interfaces.FILES) {
+    return {
+      type: constants.types.ARRAY,
+      array_type: constants.types.OBJECT_ID,
+      find_relations: true,
+    };
+  }
+
+  if (type !== schema_definition?.type && schema_definition?.type !== constants.types.ALIAS) {
+    array_type = schema_definition.type;
+  }
+
+  return { type, array_type, find_relations };
+};
+
+const convertTypesV1 = (field) => {
+  let { type, schema_definition, meta } = field;
+  let array_type = schema_definition?.type ?? null;
+  let interfaceType = meta?.interface;
+  let find_relations = false;
+
+  if ([constants.interfaces.TRANSLATIONS].includes(interfaceType)) {
+    return {
+      type: constants.types.OBJECT,
+      array_type: null,
+      find_relations: true,
+    };
+  }
+
+  if ([constants.interfaces.MANY_TO_ANY].includes(interfaceType)) {
+    return {
+      type: constants.types.ARRAY,
+      array_type: constants.types.OBJECT,
+      find_relations: true,
+    };
+  }
+
+  if ([constants.interfaces.MANY_TO_ONE].includes(interfaceType)) {
+    return {
+      type: constants.types.OBJECT_ID,
+      array_type: null,
+      find_relations: false,
+    };
+  }
+
+  if (
+    [
+      constants.interfaces.ONE_TO_MANY,
+      constants.interfaces.MANY_TO_MANY,
+      constants.interfaces.FILES,
+    ].includes(interfaceType)
+  ) {
+    return {
+      type: constants.types.ARRAY,
+      array_type: constants.types.OBJECT_ID,
+      find_relations: false,
+    };
+  }
+
+  if (type !== schema_definition?.type && schema_definition?.type !== constants.types.ALIAS) {
+    array_type = schema_definition.type;
+    find_relations = false;
+  }
+
+  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;
+
+    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) {
+    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,
+      ),
+    ];
+  } else {
+    return [];
+  }
+};
+
+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",
+      constants.types.OBJECT,
+      constants.types.ARRAY
+    );
+    existingField.children = [
+      generateField(
+        "collection",
+        "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),
+    ];
+    const deleteField = generateField(
+      "delete",
+      "delete",
+      constants.types.OBJECT_ID,
+      constants.types.ARRAY
+    );
+    const createField = generateField(
+      "create",
+      "create",
+      constants.types.OBJECT,
+      constants.types.ARRAY,
+      collectionFields
+    );
+    createField.children = [
+      generateField(
+        "collection",
+        "create.collection",
+        constants.types.STRING,
+        constants.types.STRING
+      ),
+      generateField("sort", "create.sort", constants.types.NUMBER, constants.types.NUMBER),
+      generateField(
+        "item",
+        "create.item",
+        constants.types.OBJECT,
+        constants.types.OBJECT,
+        collectionFields
+      ),
+    ];
+    const updateField = generateField(
+      "update",
+      "update",
+      constants.types.OBJECT,
+      constants.types.ARRAY,
+      collectionFields
+    );
+    updateField.children = [
+      generateField(
+        "collection",
+        "update.collection",
+        constants.types.STRING,
+        constants.types.STRING
+      ),
+      generateField("sort", "update.sort", constants.types.NUMBER, constants.types.NUMBER),
+      generateField(
+        "item",
+        "update.item",
+        constants.types.OBJECT,
+        constants.types.OBJECT,
+        collectionFields
+      ),
+    ];
+    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(
+        "create",
+        "create",
+        constants.types.OBJECT,
+        constants.types.ARRAY,
+        collectionFields
+      ),
+      generateField(
+        "update",
+        "update",
+        constants.types.OBJECT,
+        constants.types.ARRAY,
+        collectionFields
+      ),
+    ];
+  }
+};
+
+const getForeignCollectionDetails = ({
+  relations,
+  collection,
+  field,
+  iFace,
+  findJunction = true,
+  getRelationshipDetails = true,
+}) => {
+  if (!relations.length > 0) return {};
+
+  const isListInterface = [
+    constants.interfaces.ONE_TO_MANY,
+    constants.interfaces.MANY_TO_MANY,
+    constants.interfaces.TRANSLATIONS,
+    constants.interfaces.FILES,
+    constants.interfaces.MANY_TO_ANY,
+  ].includes(iFace);
+
+  const isSingleRelation = [
+    constants.interfaces.MANY_TO_ONE,
+    constants.interfaces.FILE,
+    constants.interfaces.FILE_IMAGE,
+  ].includes(iFace);
+
+  if (isListInterface) {
+    const mainTable = relations.find(
+      (d) => d.one_collection_id === collection && d.one_field_id === field
+    );
+    if (!mainTable) return {};
+
+    const isJunction = mainTable.junction_field && findJunction;
+    const relational = isJunction
+      ? relations.find(
+          (d) =>
+            d.many_collection === mainTable.many_collection &&
+            d.junction_field === mainTable.many_field
+        )
+      : [];
+
+    if (getRelationshipDetails) {
+      return {
+        this_collection: mainTable.one_collection_id,
+        this_field: "_id",
+        foreign_collection:
+          iFace === constants.interfaces.MANY_TO_MANY || iFace === constants.interfaces.TRANSLATIONS
+            ? relational?.one_collection_id
+            : iFace === constants.interfaces.MANY_TO_ANY
+            ? relational?.one_allowed_collections_id
+            : mainTable.many_collection_id,
+        foreign_field:
+          iFace === constants.interfaces.MANY_TO_MANY || iFace === constants.interfaces.TRANSLATIONS
+            ? "_id"
+            : iFace === constants.interfaces.MANY_TO_ANY
+            ? "Primary Key"
+            : mainTable.many_field_id,
+        ...(isJunction && {
+          junction_collection: relational?.many_collection_id,
+          junction_field_this: relational?.junction_field,
+          junction_field_foreign:
+            iFace === constants.interfaces.MANY_TO_ANY ? "item" : relational?.many_field,
+        }),
+        ...(iFace === constants.interfaces.MANY_TO_ANY && {
+          junction_field_ref: "collection",
+          foreign_collection_ref: relational?.one_allowed_collections?.join(", "),
+        }),
+      };
+    }
+
+    return {
+      foreign_collection_id: isJunction
+        ? iFace === constants.interfaces.MANY_TO_ANY
+          ? relational?.one_allowed_collections_id
+          : relational?.one_collection_id
+        : mainTable.many_collection_id,
+      ...(isJunction && {
+        junction_collection_id: relational?.many_collection_id,
+        junction_field: mainTable.junction_field,
+        junction_field_local: mainTable.many_field,
+      }),
+    };
+  }
+
+  if (isSingleRelation) {
+    const mainTable = relations.find(
+      (d) => d.many_collection_id === collection && d.many_field === field
+    );
+    if (!mainTable) return {};
+
+    return getRelationshipDetails
+      ? {
+          this_collection: mainTable.many_collection_id,
+          this_field: mainTable.many_field,
+          foreign_collection: mainTable.one_collection_id,
+          foreign_field: "_id",
+        }
+      : {
+          foreign_collection_id: mainTable.one_collection_id,
+        };
+  }
+
+  return {};
+};
+
+const getCachedFields = (relationDetail, relational_fields) => {
+  const isMultiple = Array.isArray(relationDetail.foreign_collection);
+  const getField = (schemaId) => {
+    if (relational_fields[schemaId]) {
+      return relational_fields[schemaId]; // Return cached fields if available
+    } else {
+      return [];
+    }
+  };
+
+  if (!isMultiple) {
+    return getField(relationDetail.foreign_collection);
+  } else {
+    return relationDetail.foreign_collection.flatMap((schemaId) => getField(schemaId));
+  }
+};
+
+const getCachedOrFetchFields = (schemaId, allFields, relational_fields) => {
+  if (relational_fields[schemaId]) {
+    return relational_fields[schemaId]; // Return cached fields if available
+  }
+
+  const fields = allFields?.filter((field) => field.schema_id === schemaId) || [];
+  relational_fields[schemaId] = fields; // Cache the fields
+  return fields;
+};
+
+const getChildFields = (relationDetail, allFields, relational_fields, isTranslation) => {
+  let key = isTranslation
+  ? [
+      ...(Array.isArray(relationDetail.junction_collection)
+        ? relationDetail.junction_collection
+        : [relationDetail.junction_collection]),
+      ...(Array.isArray(relationDetail.foreign_collection)
+        ? relationDetail.foreign_collection
+        : [relationDetail.foreign_collection])
+    ]
+  : relationDetail.foreign_collection;
+
+
+  const isMultiple = Array.isArray(key);
+
+  if (!isMultiple) {
+    return getCachedOrFetchFields(key, allFields, relational_fields);
+  } else {
+    return key.flatMap((schemaId) =>
+      getCachedOrFetchFields(schemaId, allFields, relational_fields)
+    );
+  }
+};
+
+const buildNestedStructure = (
+  schemaFields,
+  allFields,
+  relations,
+  formData,
+  relational_fields,
+  isSeparatedFields,
+  apiVersion
+) => {
+  const root = {};
+  const nodeMap = new Map();
+
+  schemaFields.sort((a, b) => a.path.split(".").length - b.path.split(".").length);
+
+  schemaFields.forEach((item) => {
+    let childFields;
+
+    const definedType =
+      apiVersion === constants.API_VERSION.V1 ? convertTypesV1(item) : convertTypes(item);
+
+    if (definedType.find_relations) {
+      const relationDetail = getForeignCollectionDetails({
+        relations: relations,
+        collection: item?.schema_id,
+        field: item._id,
+        iFace: item?.meta?.interface,
+        findJunction: true,
+        getRelationshipDetails: true,
+      });
+
+      if (!isSeparatedFields) {
+        childFields = getChildFields(
+          relationDetail,
+          allFields,
+          relational_fields,
+          item?.meta?.interface === constants.interfaces.TRANSLATIONS
+        );
+      } else {
+        childFields = getCachedFields(relationDetail, relational_fields);
+      }
+
+      if (childFields) {
+        childFields = buildNestedStructure(
+          childFields,
+          allFields,
+          relations,
+          formData,
+          relational_fields,
+          isSeparatedFields
+        );
+      }
+    }
+
+    const pathParts = item.path.split(".");
+    const key = pathParts.join(".");
+
+    const node = {
+      field_id: item?._id,
+      display_label: pathParts[pathParts.length - 1],
+      key,
+      value: key,
+      meta: {
+        interface: item.meta?.interface || "none",
+        required: item.meta?.required || false,
+        nullable: item.meta?.nullable || false,
+        hidden: item.meta?.hidden || false,
+      },
+      validations:
+        item?.meta?.validations?.rules?.length > 0
+          ? generateModifiedRules(item?.meta, formData)
+          : [],
+      children:
+        childFields?.length > 0
+          ? apiVersion === constants.API_VERSION.V1 &&
+            item.meta?.interface !== constants.interfaces.TRANSLATIONS
+            ? generateRelationalFieldV1(key, childFields, item.meta?.interface)
+            : generateRelationalField(key, childFields, item.meta?.interface)
+          : [],
+      type: definedType.type,
+      array_type: definedType.array_type,
+      default_value: item?.schema_definition?.default,
+    };
+
+    nodeMap.set(key, node);
+
+    if (pathParts.length === 1) {
+      root[key] = node;
+    } else {
+      const parentPath = pathParts.slice(0, -1).join(".");
+
+      if (nodeMap.has(parentPath)) {
+        nodeMap.get(parentPath).children.push(node);
+      }
+    }
+  });
+
+  const removeEmptyChildren = (nodes) => {
+    return nodes.map(({ children, ...node }) =>
+      children && children?.length ? { ...node, children: removeEmptyChildren(children) } : node
+    );
+  };
+
+  return removeEmptyChildren(Object.values(root));
+};
+
+const getAllKeys = (structure) => {
+  const keys = new Set();
+
+  const traverse = (nodes) => {
+    nodes.forEach((node) => {
+      keys.add(node.key);
+      if (node.children && node.children.length) {
+        traverse(node.children);
+      }
+    });
+  };
+
+  traverse(structure);
+  return keys;
+};
+
+const normalizeKey = (key) => key.replace(/\[\d+\]/g, "");
+
+const findDisallowedKeys = (formData, structure) => {
+  const formKeys = [];
+  generateDynamicKeys(formData, formKeys);
+
+  const validKeys = getAllKeys(structure);
+  return formKeys.filter((key) => !validKeys.has(normalizeKey(key)));
+};
+
+const generateFieldCompareRules = (rule) => {
+  const modifiedRule = {
+    identifier: 1,
+    case: constants.rulesTypes.FIELD_COMPARE,
+    value: [],
+    options: {},
+  };
+
+  switch (rule.type) {
+    case "contains":
+      modifiedRule.case = constants.rulesTypes.REGEX;
+      modifiedRule.value = [rule[rule.type].value];
+      modifiedRule.options = {
+        type: constants.regexTypes.CONTAINS,
+        case_sensitive: !rule[rule.type].insensitive,
+        multiline: false,
+        global: false,
+      };
+      break;
+    case "doesNotContain":
+      modifiedRule.case = constants.rulesTypes.REGEX;
+      modifiedRule.value = [rule[rule.type].value];
+      modifiedRule.options = {
+        type: constants.regexTypes.NOT_CONTAINS,
+        case_sensitive: !rule[rule.type].insensitive,
+        multiline: false,
+        global: false,
+      };
+      break;
+    case "startsWith":
+      modifiedRule.case = constants.rulesTypes.REGEX;
+      modifiedRule.value = [rule[rule.type].value];
+      modifiedRule.options = {
+        type: constants.regexTypes.START_WITH,
+        case_sensitive: !rule[rule.type].insensitive,
+      };
+      break;
+    case "doesNotStartWith":
+      modifiedRule.case = constants.rulesTypes.REGEX;
+      modifiedRule.value = [rule[rule.type].value];
+      modifiedRule.options = {
+        type: constants.regexTypes.NOT_START_WITH,
+        case_sensitive: !rule[rule.type].insensitive,
+      };
+      break;
+    case "endsWith":
+      modifiedRule.case = constants.rulesTypes.REGEX;
+      modifiedRule.value = [rule[rule.type].value];
+      modifiedRule.options = {
+        type: constants.regexTypes.ENDS_WITH,
+        case_sensitive: !rule[rule.type].insensitive,
+      };
+      break;
+    case "doesNotEndWith":
+      modifiedRule.case = constants.rulesTypes.REGEX;
+      modifiedRule.value = [rule[rule.type].value];
+      modifiedRule.options = {
+        type: constants.regexTypes.NOT_ENDS_WITH,
+        case_sensitive: !rule[rule.type].insensitive,
+      };
+      break;
+    case "matchesRegExp":
+      modifiedRule.case = constants.rulesTypes.REGEX;
+      modifiedRule.value = [rule.matchesRegExp.value];
+      modifiedRule.options.type = constants.regexTypes.MATCH;
+      break;
+    case "equals":
+      modifiedRule.case = constants.rulesTypes.OPERATOR;
+      modifiedRule.options.operator = constants.operatorTypes.EQUAL;
+      modifiedRule.value = [rule[rule.type].value];
+      break;
+    case "doesNotEqual":
+      modifiedRule.case = constants.rulesTypes.OPERATOR;
+      modifiedRule.options.operator = constants.operatorTypes.NOT_EQUAL;
+      modifiedRule.value = [rule[rule.type].value];
+      break;
+    case "lessThan":
+      modifiedRule.case = constants.rulesTypes.OPERATOR;
+      modifiedRule.options.operator = constants.operatorTypes.LESS_THAN;
+      modifiedRule.value = [rule[rule.type].value];
+      break;
+    case "lessThanOrEqualTo":
+      modifiedRule.case = constants.rulesTypes.OPERATOR;
+      modifiedRule.options.operator = constants.operatorTypes.LESS_THAN_EQUAL;
+      modifiedRule.value = [rule[rule.type].value];
+      break;
+    case "greaterThan":
+      modifiedRule.case = constants.rulesTypes.OPERATOR;
+      modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN;
+      modifiedRule.value = [rule[rule.type].value];
+      break;
+    case "greaterThanOrEqualTo":
+      modifiedRule.case = constants.rulesTypes.OPERATOR;
+      modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN_EQUAL;
+      modifiedRule.value = [rule[rule.type].value];
+      break;
+    case "isEmpty":
+      modifiedRule.case = constants.rulesTypes.EMPTY;
+      modifiedRule.value = [];
+      break;
+    case "isNotEmpty":
+      modifiedRule.case = constants.rulesTypes.NOT_EMPTY;
+      modifiedRule.value = [];
+      break;
+    case "isOneOf":
+      modifiedRule.case = constants.rulesTypes.ONE_OF;
+      modifiedRule.value = rule[rule.type].value;
+      break;
+    case "isNotOneOf":
+      modifiedRule.case = constants.rulesTypes.NOT_ONE_OF;
+      modifiedRule.value = [rule[rule.type].value];
+      break;
+  }
+  modifiedRule.options.isFieldCompare = true;
+  return modifiedRule;
+};
+
+const generateModifiedRules = (meta) => {
+  return meta?.validations?.rules?.map((rule, index) => {
+    let modifiedRule = {
+      identifier: String(index),
+      case: constants.rulesTypes.RULES_COMPARE,
+      value: [],
+      options: {},
+    };
+    switch (rule.rule) {
+      case "contains":
+        modifiedRule.case = constants.rulesTypes.REGEX;
+        modifiedRule.value = [rule[rule.rule].value];
+        modifiedRule.options = {
+          type: constants.regexTypes.CONTAINS,
+          case_sensitive: !rule[rule.rule].insensitive,
+          multiline: false,
+          global: false,
+        };
+        break;
+      case "doesNotContain":
+        modifiedRule.case = constants.rulesTypes.REGEX;
+        modifiedRule.value = [rule[rule.rule].value];
+        modifiedRule.options = {
+          type: constants.regexTypes.NOT_CONTAINS,
+          case_sensitive: !rule[rule.rule].insensitive,
+          multiline: false,
+          global: false,
+        };
+        break;
+      case "startsWith":
+        modifiedRule.case = constants.rulesTypes.REGEX;
+        modifiedRule.value = [rule[rule.rule].value];
+        modifiedRule.options = {
+          type: constants.regexTypes.START_WITH,
+          case_sensitive: !rule[rule.rule].insensitive,
+        };
+        break;
+      case "doesNotStartWith":
+        modifiedRule.case = constants.rulesTypes.REGEX;
+        modifiedRule.value = [rule[rule.rule].value];
+        modifiedRule.options = {
+          type: constants.regexTypes.NOT_START_WITH,
+          case_sensitive: !rule[rule.rule].insensitive,
+        };
+        break;
+      case "endsWith":
+        modifiedRule.case = constants.rulesTypes.REGEX;
+        modifiedRule.value = [rule[rule.rule].value];
+        modifiedRule.options = {
+          type: constants.regexTypes.ENDS_WITH,
+          case_sensitive: !rule[rule.rule].insensitive,
+        };
+        break;
+      case "doesNotEndWith":
+        modifiedRule.case = constants.rulesTypes.REGEX;
+        modifiedRule.value = [rule[rule.rule].value];
+        modifiedRule.options = {
+          type: constants.regexTypes.NOT_ENDS_WITH,
+          case_sensitive: !rule[rule.rule].insensitive,
+        };
+        break;
+      case "matchesRegExp":
+        modifiedRule.case = constants.rulesTypes.REGEX;
+        modifiedRule.value = [rule.matchesRegExp.value];
+        modifiedRule.options.type = constants.regexTypes.MATCH;
+        break;
+      case "equals":
+        modifiedRule.case = constants.rulesTypes.OPERATOR;
+        modifiedRule.options.operator = constants.operatorTypes.EQUAL;
+        modifiedRule.value = [rule[rule.rule].value];
+        break;
+      case "doesNotEqual":
+        modifiedRule.case = constants.rulesTypes.OPERATOR;
+        modifiedRule.options.operator = constants.operatorTypes.NOT_EQUAL;
+        modifiedRule.value = [rule[rule.rule].value];
+        break;
+      case "lessThan":
+        modifiedRule.case = constants.rulesTypes.OPERATOR;
+        modifiedRule.options.operator = constants.operatorTypes.LESS_THAN;
+        modifiedRule.value = [rule[rule.rule].value];
+        break;
+      case "lessThanOrEqualTo":
+        modifiedRule.case = constants.rulesTypes.OPERATOR;
+        modifiedRule.options.operator = constants.operatorTypes.LESS_THAN_EQUAL;
+        modifiedRule.value = [rule[rule.rule].value];
+        break;
+      case "greaterThan":
+        modifiedRule.case = constants.rulesTypes.OPERATOR;
+        modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN;
+        modifiedRule.value = [rule[rule.rule].value];
+        break;
+      case "greaterThanOrEqualTo":
+        modifiedRule.case = constants.rulesTypes.OPERATOR;
+        modifiedRule.options.operator = constants.operatorTypes.GREATER_THAN_EQUAL;
+        modifiedRule.value = [rule[rule.rule].value];
+        break;
+      case "isEmpty":
+        modifiedRule.case = constants.rulesTypes.EMPTY;
+        modifiedRule.value = [];
+        break;
+      case "isNotEmpty":
+        modifiedRule.case = constants.rulesTypes.NOT_EMPTY;
+        modifiedRule.value = [];
+        break;
+      case "isOneOf":
+        modifiedRule.case = constants.rulesTypes.ONE_OF;
+        modifiedRule.value = rule[rule.rule].value;
+        break;
+      case "isNotOneOf":
+        modifiedRule.case = constants.rulesTypes.NOT_ONE_OF;
+        modifiedRule.value = [rule[rule.rule].value];
+        break;
+      case constants.rulesTypes.FIELD_COMPARE: {
+        const fieldRule = generateFieldCompareRules(rule);
+        modifiedRule.case = fieldRule.case;
+        modifiedRule.options = fieldRule.options;
+        modifiedRule.value = fieldRule.value;
+        break;
+      }
+    }
+
+    return modifiedRule;
+  });
+};
+
+const getFieldsGroupBySchemaId = (arr) => {
+  return arr.reduce((acc, item) => {
+    const key = item.schema_id;
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push(item);
+    return acc;
+  }, {});
+};
+
+const getDefaultValues = (tree) => {
+  const defaultValues = {};
+
+  tree?.forEach((field) => {
+    let { key, type, array_type, children, default_value } = field;
+    let defaultValue = default_value !== undefined ? default_value : null;
+
+    // Extract last part of the key (remove parent references)
+    const keyParts = key.split(".");
+    const cleanKey = keyParts[keyParts.length - 1];
+
+    if (type === "Object") {
+      setValue(defaultValues, cleanKey, children?.length ? getDefaultValues(children) : {});
+    } else if (type === "Array") {
+      if (array_type === "String" || array_type === "Number") {
+        setValue(defaultValues, cleanKey, []);
+      } else {
+        // Prevent extra nesting by ensuring the array contains objects, not arrays
+        setValue(defaultValues, cleanKey, children?.length ? [getDefaultValues(children)] : []);
+      }
+    } else {
+      setValue(defaultValues, cleanKey, defaultValue);
+    }
+  });
+
+  return defaultValues;
+};
+
+module.exports = {
+  generateModifiedRules,
+  getFieldsGroupBySchemaId,
+  buildNestedStructure,
+  getValue,
+  setValue,
+  keyExists,
+  formatLabel,
+  generateDynamicKeys,
+  getLastChildKey,
+  checkIsArrayKey,
+  isEmpty,
+  getParentKey,
+  getFormPath,
+  findDisallowedKeys,
+  getAllFields,
+  getForeignCollectionDetails,
+  getDefaultValues,
+};