@applicaster/zapp-react-native-ui-components 14.0.0-rc.9 → 15.0.0-rc.1

package/Decorators/ZappPipesDataConnector/utils/mongoFilter.ts

@@ -0,0 +1,738 @@
+import { createLogger } from "@applicaster/zapp-react-native-utils/logger";
+
+const { log_error } = createLogger({
+  subsystem: "General",
+  category: "MongoSyntaxFilter",
+});
+
+// types.ts (or at the top of your file)
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+interface JsonObject {
+  [key: string]: JsonValue;
+}
+interface JsonArray extends Array<JsonValue> {}
+
+type MongoQuery = {
+  [key: string]: any; // Values can be direct matches or operator objects
+};
+
+// --- Helper Functions ---
+
+/**
+ * Retrieves a value from an object using a dot-notation path.
+ * @param obj The object to traverse.
+ * @param path The dot-notation path (e.g., "a.b.c").
+ * @returns The value at the specified path, or undefined if the path doesn't exist.
+ */
+function getValueByPath(obj: JsonObject, path: string): any {
+  if (path === "" || path === undefined) return undefined;
+  const keys = path.split(".");
+  let current: any = obj;
+
+  for (const key of keys) {
+    if (
+      current &&
+      typeof current === "object" &&
+      Object.prototype.hasOwnProperty.call(current, key)
+    ) {
+      current = (current as JsonObject)[key];
+    } else {
+      return undefined; // Path does not fully resolve or encounters non-object/missing key
+    }
+  }
+
+  return current;
+}
+
+/**
+ * Checks if a dot-notation path exists within an object.
+ * @param obj The object to check.
+ * @param path The dot-notation path.
+ * @returns True if the path exists, false otherwise.
+ */
+function pathExists(obj: JsonObject, path: string): boolean {
+  if (path === "" || path === undefined) return false;
+  const keys = path.split(".");
+  let current: any = obj;
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+
+    if (
+      typeof current === "object" &&
+      current !== null &&
+      Object.prototype.hasOwnProperty.call(current, key)
+    ) {
+      if (i === keys.length - 1) {
+        return true; // Full path exists
+      }
+
+      current = (current as JsonObject)[key];
+    } else {
+      return false; // Path does not exist
+    }
+  }
+
+  return false; // Should be covered by loop logic
+}
+
+/**
+ * Performs a basic deep equality check between two values.
+ * Handles primitives, arrays, and objects.
+ * @param val1 First value.
+ * @param val2 Second value.
+ * @returns True if values are deeply equal, false otherwise.
+ */
+function isEqual(val1: any, val2: any): boolean {
+  if (val1 === val2) return true; // Handles primitives and same object/array references
+
+  if (typeof val1 !== typeof val2) return false;
+  if (val1 === null || val2 === null) return false; // Already covered by val1 === val2 if both are null
+
+  if (typeof val1 === "object") {
+    if (Array.isArray(val1)) {
+      if (!Array.isArray(val2) || val1.length !== val2.length) return false;
+
+      for (let i = 0; i < val1.length; i++) {
+        if (!isEqual(val1[i], val2[i])) return false;
+      }
+
+      return true;
+    } else {
+      // Both are objects
+      if (Array.isArray(val2)) return false;
+      const keys1 = Object.keys(val1);
+      const keys2 = Object.keys(val2);
+      if (keys1.length !== keys2.length) return false;
+
+      for (const key of keys1) {
+        if (
+          !Object.prototype.hasOwnProperty.call(val2, key) ||
+          !isEqual(val1[key], val2[key])
+        ) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+
+  return false; // Mismatch for other types or conditions
+}
+
+/**
+ * Evaluates if a value matches a specific condition object (e.g., { $gt: 10, $lt: 20 }).
+ * This is used by the $not operator.
+ * @param value The actual value from the document field.
+ * @param conditionObject The condition object (e.g., { $gt: 10 }).
+ * @returns True if the value satisfies all conditions in conditionObject.
+ */
+function checkValueAgainstOperatorObject(
+  value: any,
+  conditionObject: JsonObject
+): boolean {
+  for (const operator in conditionObject) {
+    if (Object.prototype.hasOwnProperty.call(conditionObject, operator)) {
+      const operand = conditionObject[operator];
+
+      // This is a simplified version of evaluateFieldCondition's operator switch,
+      // applied directly to 'value'. $exists is not applicable here.
+      switch (operator) {
+        case "$eq":
+          if (!isEqual(value, operand)) return false;
+          break;
+        case "$ne":
+          if (isEqual(value, operand)) return false;
+          break;
+        case "$gt":
+          if (value === undefined || value === null || !(value > operand)) {
+            return false;
+          }
+
+          break;
+        case "$gte":
+          if (value === undefined || value === null || !(value >= operand)) {
+            return false;
+          }
+
+          break;
+        case "$lt":
+          if (value === undefined || value === null || !(value < operand)) {
+            return false;
+          }
+
+          break;
+        case "$lte":
+          if (value === undefined || value === null || !(value <= operand)) {
+            return false;
+          }
+
+          break;
+        case "$in":
+          if (!Array.isArray(operand)) {
+            throw new Error("$in requires an array operand.");
+          }
+
+          if (Array.isArray(value)) {
+            // If field value is an array
+            if (!value.some((item) => operand.includes(item))) return false;
+          } else {
+            if (!operand.includes(value)) return false;
+          }
+
+          break;
+        case "$nin":
+          if (!Array.isArray(operand)) {
+            throw new Error("$nin requires an array operand.");
+          }
+
+          if (Array.isArray(value)) {
+            // If field value is an array
+            if (value.some((item) => operand.includes(item))) return false;
+          } else {
+            if (operand.includes(value)) return false;
+          }
+
+          break;
+        // Regex and other relevant operators can be added here if needed for $not's operand
+        default:
+          log_error(
+            `Unsupported operator '${operator}' inside $not's operand object.`
+          );
+
+          return false;
+      }
+    }
+  }
+
+  return true; // All conditions in conditionObject passed for 'value'
+}
+
+/**
+ * Checks if a given object matches a MongoDB-style query.
+ * @param obj The object to check.
+ * @param query The MongoDB-style query.
+ * @returns True if the object matches the query, false otherwise.
+ */
+function matchesQuery(obj: JsonObject, query: MongoQuery): boolean {
+  for (const key in query) {
+    if (Object.prototype.hasOwnProperty.call(query, key)) {
+      const condition = query[key];
+
+      if (key.startsWith("$")) {
+        // Top-level logical operators ($and, $or, $not, $nor)
+        switch (key) {
+          case "$and":
+            if (!Array.isArray(condition)) {
+              throw new Error(
+                "$and operator requires an array of query objects."
+              );
+            }
+
+            if (
+              !condition.every((subQuery: MongoQuery) =>
+                matchesQuery(obj, subQuery)
+              )
+            ) {
+              return false;
+            }
+
+            break;
+          case "$or":
+            if (!Array.isArray(condition)) {
+              throw new Error(
+                "$or operator requires an array of query objects."
+              );
+            }
+
+            if (
+              !condition.some((subQuery: MongoQuery) =>
+                matchesQuery(obj, subQuery)
+              )
+            ) {
+              return false;
+            }
+
+            break;
+          case "$not": // Top-level $not
+            if (typeof condition !== "object" || condition === null) {
+              throw new Error("Top-level $not requires a query object.");
+            }
+
+            if (matchesQuery(obj, condition as MongoQuery)) {
+              return false; // If inner query matches, $not fails
+            }
+
+            break;
+          case "$nor":
+            if (!Array.isArray(condition)) {
+              throw new Error(
+                "$nor operator requires an array of query objects."
+              );
+            }
+
+            if (
+              condition.some((subQuery: MongoQuery) =>
+                matchesQuery(obj, subQuery)
+              )
+            ) {
+              return false; // If any subQuery matches, $nor fails
+            }
+
+            break;
+          default:
+            log_error(`Unsupported top-level logical operator: ${key}`);
+
+            return false;
+        }
+      } else {
+        // Field-specific query
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        if (!evaluateFieldCondition(obj, key, condition)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  return true; // All conditions in the query passed
+}
+
+/**
+ * Evaluates if a document's field satisfies a given condition.
+ * @param obj The document being checked.
+ * @param fieldPath The path to the field in the document (e.g., "age" or "address.city").
+ * @param fieldCondition The condition for the field (e.g., 30, { $gte: 30 }, /pattern/).
+ * @returns True if the field satisfies the condition, false otherwise.
+ */
+function evaluateFieldCondition(
+  obj: JsonObject,
+  fieldPath: string,
+  fieldCondition: any
+): boolean {
+  const actualValue = getValueByPath(obj, fieldPath);
+  const fieldActuallyExists = pathExists(obj, fieldPath);
+
+  // Case 1: fieldCondition is an operator object (e.g., { $gt: 10, $lt: 20 })
+  if (
+    typeof fieldCondition === "object" &&
+    fieldCondition !== null &&
+    !Array.isArray(fieldCondition) &&
+    !(fieldCondition instanceof RegExp)
+  ) {
+    const operatorKeys = Object.keys(fieldCondition).filter((k) =>
+      k.startsWith("$")
+    );
+
+    if (operatorKeys.length > 0) {
+      for (const operator in fieldCondition) {
+        if (!Object.prototype.hasOwnProperty.call(fieldCondition, operator)) {
+          continue;
+        }
+
+        if (
+          operator === "$options" &&
+          Object.prototype.hasOwnProperty.call(fieldCondition, "$regex")
+        ) {
+          continue;
+        } // Handled by $regex
+
+        const operand = fieldCondition[operator];
+
+        switch (operator) {
+          case "$eq":
+            if (operand === null) {
+              // MongoDB's special null equality
+              if (actualValue !== null && fieldActuallyExists) return false; // Matches if value is null or field doesn't exist
+            } else {
+              if (!isEqual(actualValue, operand)) return false;
+            }
+
+            break;
+          case "$ne":
+            // For $ne, null is treated literally. { field: { $ne: null } } means field must exist and not be null.
+            if (operand === null) {
+              if (actualValue === null || !fieldActuallyExists) return false;
+            } else {
+              if (isEqual(actualValue, operand)) return false;
+            }
+
+            break;
+          case "$gt":
+            if (
+              actualValue === undefined ||
+              actualValue === null ||
+              !(actualValue > operand)
+            ) {
+              return false;
+            }
+
+            break;
+          case "$gte":
+            if (
+              actualValue === undefined ||
+              actualValue === null ||
+              !(actualValue >= operand)
+            ) {
+              return false;
+            }
+
+            break;
+          case "$lt":
+            if (
+              actualValue === undefined ||
+              actualValue === null ||
+              !(actualValue < operand)
+            ) {
+              return false;
+            }
+
+            break;
+          case "$lte":
+            if (
+              actualValue === undefined ||
+              actualValue === null ||
+              !(actualValue <= operand)
+            ) {
+              return false;
+            }
+
+            break;
+          case "$in":
+            if (!Array.isArray(operand)) {
+              throw new Error("$in operator requires an array operand.");
+            }
+
+            if (!fieldActuallyExists) {
+              // Field does not exist
+              if (!operand.includes(null)) return false; // Matches if null is in operand array
+            } else if (Array.isArray(actualValue)) {
+              // Field is an array
+              if (!actualValue.some((item) => operand.includes(item))) {
+                return false;
+              }
+            } else {
+              // Field is a single value
+              if (!operand.includes(actualValue)) return false;
+            }
+
+            break;
+          case "$nin":
+            if (!Array.isArray(operand)) {
+              throw new Error("$nin operator requires an array operand.");
+            }
+
+            if (!fieldActuallyExists) {
+              // Field does not exist
+              if (operand.includes(null)) return false; // Does NOT match if null is in operand array
+            } else if (Array.isArray(actualValue)) {
+              // Field is an array
+              if (actualValue.some((item) => operand.includes(item))) {
+                return false;
+              }
+            } else {
+              // Field is a single value
+              if (operand.includes(actualValue)) return false;
+            }
+
+            break;
+          case "$exists":
+            if (typeof operand !== "boolean") {
+              throw new Error("$exists operator requires a boolean operand.");
+            }
+
+            if (operand === true && !fieldActuallyExists) return false;
+            if (operand === false && fieldActuallyExists) return false;
+            break;
+
+          case "$type": {
+            if (typeof operand !== "string") {
+              throw new Error("$type requires a string operand.");
+            }
+
+            const jsType = typeof actualValue;
+
+            let matchesType = false;
+
+            if (
+              !fieldActuallyExists &&
+              operand !==
+                "null" /* and other types that could match non-existence if we were super strict */
+            ) {
+              // Generally, $type checks existing fields. If field doesn't exist, it won't match most types.
+              // Exception: $type: "null" could match if we consider missing field as null for $type.
+              // MongoDB: $type matches BSON types. For non-existent fields, it depends.
+              // For simplicity, if field doesn't exist, it only matches $type: "null" if actualValue is undefined and operand is "null" (which is not how it works)
+              // Let's be strict: if field doesn't exist, it doesn't have a type other than "undefined" (which isn't a Mongo type string).
+              // If operand is 'null', it checks if actualValue is null. If field is missing, actualValue is undefined.
+              if (operand === "null") {
+                // $type: 'null'
+                matchesType = actualValue === null; // Only if value is literally null
+              } else {
+                matchesType = false;
+              }
+            } else {
+              switch (operand) {
+                case "string":
+                  matchesType = jsType === "string";
+                  break;
+                case "number":
+                  matchesType =
+                    jsType === "number" &&
+                    Number.isFinite(actualValue as number);
+
+                  break;
+                case "boolean":
+                  matchesType = jsType === "boolean";
+                  break;
+                case "object":
+                  matchesType =
+                    jsType === "object" &&
+                    actualValue !== null &&
+                    !Array.isArray(actualValue);
+
+                  break;
+                case "array":
+                  matchesType = Array.isArray(actualValue);
+                  break;
+                case "null":
+                  matchesType = actualValue === null;
+                  break;
+                default:
+                  throw new Error(
+                    `Unsupported type string for $type: ${operand}`
+                  );
+              }
+            }
+
+            if (!matchesType) return false;
+            break;
+          }
+
+          case "$all": {
+            if (!Array.isArray(operand)) {
+              throw new Error("$all requires an array operand.");
+            }
+
+            if (!fieldActuallyExists || !Array.isArray(actualValue)) {
+              return false;
+            } // Field must exist and be an array
+
+            // Assumes operand contains literal values for $all
+            const allPresent = operand.every((itemInOperand) =>
+              actualValue.some((valInArray) =>
+                isEqual(valInArray, itemInOperand)
+              )
+            );
+
+            if (!allPresent) return false;
+            break;
+          }
+
+          case "$elemMatch": {
+            if (typeof operand !== "object" || operand === null) {
+              throw new Error("$elemMatch requires a query object.");
+            }
+
+            if (!fieldActuallyExists || !Array.isArray(actualValue)) {
+              return false;
+            } // Field must exist and be an array
+
+            const foundElemMatch = actualValue.some((element) => {
+              if (typeof element !== "object" || element === null) return false; // Elements must be objects for sub-query
+
+              return matchesQuery(element as JsonObject, operand as MongoQuery);
+            });
+
+            if (!foundElemMatch) return false;
+            break;
+          }
+
+          case "$size":
+            if (
+              typeof operand !== "number" ||
+              !Number.isInteger(operand) ||
+              operand < 0
+            ) {
+              throw new Error("$size requires a non-negative integer.");
+            }
+
+            if (!fieldActuallyExists || !Array.isArray(actualValue)) {
+              return false;
+            } // Field must exist and be an array
+
+            if (actualValue.length !== operand) return false;
+            break;
+
+          case "$regex": {
+            const pattern = operand;
+            const options = fieldCondition.$options || "";
+            let regexInstance: RegExp;
+
+            if (pattern instanceof RegExp) {
+              regexInstance = new RegExp(
+                pattern.source,
+                options || pattern.flags
+              );
+            } else if (typeof pattern === "string") {
+              regexInstance = new RegExp(pattern, options);
+            } else {
+              throw new Error(
+                "$regex pattern must be a string or RegExp instance."
+              );
+            }
+
+            if (
+              typeof actualValue !== "string" ||
+              !regexInstance.test(actualValue)
+            ) {
+              return false;
+            }
+
+            break;
+          }
+
+          case "$not":
+            // Operand for $not is an operator expression object (e.g., { $gt: 10 }) or a RegExp
+            if (operand instanceof RegExp) {
+              if (
+                typeof actualValue === "string" &&
+                operand.test(actualValue)
+              ) {
+                return false;
+              } // If regex matches, $not fails
+            } else if (typeof operand === "object" && operand !== null) {
+              if (
+                checkValueAgainstOperatorObject(
+                  actualValue,
+                  operand as JsonObject
+                )
+              ) {
+                return false;
+              } // If inner condition matches, $not fails
+            } else {
+              throw new Error(
+                "$not requires an operator expression or RegExp."
+              );
+            }
+
+            break;
+          default:
+            log_error(`Unsupported field operator: ${operator}`);
+
+            return false;
+        }
+      }
+
+      return true; // All operator conditions for this field passed
+    } else {
+      // Case 2: fieldCondition is an object for sub-document matching (e.g., { subField: "value" })
+      if (typeof actualValue !== "object" || actualValue === null) return false; // actualValue must be an object for sub-query
+
+      return matchesQuery(
+        actualValue as JsonObject,
+        fieldCondition as MongoQuery
+      );
+    }
+  } else {
+    // Case 3: fieldCondition is a primitive, RegExp, or null (implicit $eq)
+    if (fieldCondition instanceof RegExp) {
+      return (
+        typeof actualValue === "string" && fieldCondition.test(actualValue)
+      );
+    }
+
+    // MongoDB's special null equality for implicit { field: null }
+    if (fieldCondition === null) {
+      return actualValue === null || !fieldActuallyExists; // Matches if value is null or field doesn't exist
+    }
+
+    return isEqual(actualValue, fieldCondition);
+  }
+}
+
+// --- Main Exported Function ---
+
+/**
+ * Filters an array of JSON objects based on a MongoDB-style query filter.
+ * @param data Array of JSON objects to filter.
+ * @param query The MongoDB-style query filter object.
+ * @returns A new array containing only the objects that match the query.
+ *
+ * @example
+ * const data = [
+ * { name: "Alice", age: 30, city: "New York", tags: ["dev", "js"] },
+ * { name: "Bob", age: 24, city: "London", tags: ["dev", "python"] },
+ * { name: "Charlie", age: 30, city: "Paris", tags: ["qa", "js"] },
+ * { name: "David", age: null, city: "Berlin" }
+ * ];
+ *
+ * // Find users older than 25
+ * filterObjects(data, { age: { $gt: 25 } });
+ * // Result: Alice, Charlie
+ *
+ * // Find users in New York or London
+ * filterObjects(data, { $or: [{ city: "New York" }, { city: "London" }] });
+ * // Result: Alice, Bob
+ *
+ * // Find users with the "dev" tag
+ * filterObjects(data, { tags: "dev" }); // or { tags: { $in: ["dev"] } } or { tags: { $all: ["dev"] } }
+ * // Result: Alice, Bob
+ *
+ * // Find users where age is null or missing
+ * filterObjects(data, { age: null });
+ * // Result: David
+ */
+export function filterObjects(
+  data: JsonObject[],
+  query: MongoQuery
+): JsonObject[] {
+  if (!data || data.length === 0) return [];
+  if (Object.keys(query).length === 0) return [...data]; // Return all if query is empty
+
+  return data.filter((obj) => matchesQuery(obj, query));
+}
+
+// Example Usage (can be removed or commented out in final library code)
+/*
+const sampleData: JsonObject[] = [
+  { _id: 1, item: { name: "ab", code: "123" }, qty: 15, tags: ["A", "B", "C"], scores: [ { s: 10, c:5 }, {s: 7, c: 8} ], status: "Active" },
+  { _id: 2, item: { name: "cd", code: "123" }, qty: 20, tags: ["B"], scores: [ { s: 8, c:5 } ], status: "Inactive" },
+  { _id: 3, item: { name: "ij", code: "456" }, qty: 25, tags: ["A", "B"], scores: [], status: "Active", meta: null },
+  { _id: 4, item: { name: "xy", code: "456" }, qty: 30, tags: ["B", "C"], status: "Pending" },
+  { _id: 5, item: { name: "mn", code: "000" }, qty: 20, tags: [["A", "B"], "C"] , meta: { info: "details" }, size: { w: 10, h: 5, uom: "cm"} },
+  { _id: 6, item: { name: "ab", code: "123" }, qty: 10, tags: ["A"], description: "A blue pen." },
+  { _id: 7, item: { name: "zz", code: "789" }, qty: null, tags: ["D"] }, // qty is null
+  { _id: 8, item: { name: "yy", code: "000" } , tags: ["E"], status: "Active"} // qty is missing
+];
+
+console.log("--- Test Cases ---");
+
+console.log("1. Equality (qty: 15):", filterObjects(sampleData, { qty: 15 }));
+console.log("2. Comparison (qty > 20):", filterObjects(sampleData, { qty: { $gt: 20 } }));
+console.log("3. $in (tags: 'A' or 'D'):", filterObjects(sampleData, { tags: { $in: ["A", "D"] } }));
+console.log("4. $all (tags: 'A' and 'B'):", filterObjects(sampleData, { tags: { $all: ["A", "B"] } }));
+console.log("5. $exists (description exists):", filterObjects(sampleData, { description: { $exists: true } }));
+console.log("6. $exists (description does not exist):", filterObjects(sampleData, { description: { $exists: false } }));
+console.log("7. Nested field (item.name: 'ab'):", filterObjects(sampleData, { "item.name": "ab" }));
+console.log("8. $and (status: 'Active', qty > 10):", filterObjects(sampleData, { $and: [{ status: "Active" }, { qty: { $gt: 10 } }] }));
+console.log("9. $or (qty < 15 or item.code: '456'):", filterObjects(sampleData, { $or: [{ qty: { $lt: 15 } }, { "item.code": "456" }] }));
+console.log("10. Regex (description contains 'pen'):", filterObjects(sampleData, { description: /pen/i }));
+console.log("11. $regex (description starts with 'A'):", filterObjects(sampleData, { description: { $regex: "^A", $options: "i" } }));
+console.log("12. Sub-document match (item: { name: 'ab', code: '123' }):", filterObjects(sampleData, { item: { name: "ab", code: "123" } }));
+console.log("13. $elemMatch (scores has s >= 8):", filterObjects(sampleData, { scores: { $elemMatch: { s: { $gte: 8 } } } }));
+console.log("14. $size (tags array size 1):", filterObjects(sampleData, { tags: { $size: 1 } }));
+console.log("15. $not field level (qty not > 20):", filterObjects(sampleData, { qty: { $not: { $gt: 20 } } }));
+console.log("16. Top-level $not (not status Active):", filterObjects(sampleData, { $not: { status: "Active" } }));
+console.log("17. $type (qty is number):", filterObjects(sampleData, { qty: { $type: "number" } }));
+console.log("18. $type (meta is object):", filterObjects(sampleData, { meta: { $type: "object" } }));
+console.log("19. $type (tags is array):", filterObjects(sampleData, { tags: { $type: "array" } }));
+console.log("20. Query for null value (qty: null - matches null or missing):", filterObjects(sampleData, { qty: null }));
+console.log("21. Query for $ne null (qty: { $ne: null } - matches existing and not null):", filterObjects(sampleData, { qty: { $ne: null } }));
+console.log("22. Query for $in including null (qty: { $in: [15, null] }):", filterObjects(sampleData, { qty: { $in: [15, null] } }));
+console.log("23. Query for $nin including null (qty: { $nin: [20, null] }):", filterObjects(sampleData, { qty: { $nin: [20, null] } }));
+console.log("24. Empty query:", filterObjects(sampleData, {}));
+console.log("25. $nor (neither status Active nor qty < 20):", filterObjects(sampleData, { $nor: [{status: "Active"}, {qty: {$lt: 20}}]}));
+*/