@objectstack/driver-memory 3.2.0 → 3.2.2

package/dist/index.mjs

@@ -161,9 +161,6 @@ import { Query, Aggregator } from "mingo";
 
 // src/memory-matcher.ts
 function getValueByPath(obj, path2) {
-  if (path2 === "_id" && obj._id === void 0 && obj.id !== void 0) {
-    return obj.id;
-  }
   if (!path2.includes(".")) return obj[path2];
   return path2.split(".").reduce((o, i) => o ? o[i] : void 0, obj);
 }
@@ -633,7 +630,7 @@ var _InMemoryDriver = class _InMemoryDriver {
         const op = filters.operator === "or" ? "$or" : "$and";
         return { [op]: conditions };
       }
-      return filters;
+      return this.normalizeFilterCondition(filters);
     }
     if (!Array.isArray(filters) || filters.length === 0) return {};
     const logicGroups = [
@@ -694,6 +691,9 @@ var _InMemoryDriver = class _InMemoryDriver {
       case "contains":
       case "like":
         return { [field]: { $regex: new RegExp(this.escapeRegex(value), "i") } };
+      case "notcontains":
+      case "not_contains":
+        return { [field]: { $not: { $regex: new RegExp(this.escapeRegex(value), "i") } } };
       case "startswith":
       case "starts_with":
         return { [field]: { $regex: new RegExp(`^${this.escapeRegex(value)}`, "i") } };
@@ -709,6 +709,104 @@ var _InMemoryDriver = class _InMemoryDriver {
         return null;
     }
   }
+  /**
+   * Normalize a FilterCondition object by converting non-standard $-prefixed
+   * operators ($contains, $notContains, $startsWith, $endsWith, $between, $null)
+   * to Mingo-compatible equivalents ($regex, $gte/$lte, null checks).
+   */
+  normalizeFilterCondition(filter) {
+    const result = {};
+    const extraAndConditions = [];
+    for (const key of Object.keys(filter)) {
+      const value = filter[key];
+      if (key === "$and" || key === "$or") {
+        result[key] = Array.isArray(value) ? value.map((child) => this.normalizeFilterCondition(child)) : value;
+        continue;
+      }
+      if (key === "$not") {
+        result[key] = value && typeof value === "object" ? this.normalizeFilterCondition(value) : value;
+        continue;
+      }
+      if (key.startsWith("$")) {
+        result[key] = value;
+        continue;
+      }
+      if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp)) {
+        const normalized = this.normalizeFieldOperators(value);
+        if (normalized._multiRegex) {
+          const regexConditions = normalized._multiRegex;
+          delete normalized._multiRegex;
+          for (const rc of regexConditions) {
+            extraAndConditions.push({ [key]: { ...normalized, ...rc } });
+          }
+        } else {
+          result[key] = normalized;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+    if (extraAndConditions.length > 0) {
+      const existing = result.$and;
+      const andArray = Array.isArray(existing) ? existing : [];
+      if (Object.keys(result).filter((k) => k !== "$and").length > 0) {
+        const rest = { ...result };
+        delete rest.$and;
+        andArray.push(rest);
+      }
+      andArray.push(...extraAndConditions);
+      return { $and: andArray };
+    }
+    return result;
+  }
+  /**
+   * Convert non-standard field operators to Mingo-compatible format.
+   * When multiple regex-producing operators appear on the same field
+   * (e.g. $startsWith + $endsWith), they are combined via $and.
+   */
+  normalizeFieldOperators(ops) {
+    const result = {};
+    const regexConditions = [];
+    for (const op of Object.keys(ops)) {
+      const val = ops[op];
+      switch (op) {
+        case "$contains":
+          regexConditions.push({ $regex: new RegExp(this.escapeRegex(val), "i") });
+          break;
+        case "$notContains":
+          result.$not = { $regex: new RegExp(this.escapeRegex(val), "i") };
+          break;
+        case "$startsWith":
+          regexConditions.push({ $regex: new RegExp(`^${this.escapeRegex(val)}`, "i") });
+          break;
+        case "$endsWith":
+          regexConditions.push({ $regex: new RegExp(`${this.escapeRegex(val)}$`, "i") });
+          break;
+        case "$between":
+          if (Array.isArray(val) && val.length === 2) {
+            result.$gte = val[0];
+            result.$lte = val[1];
+          }
+          break;
+        case "$null":
+          if (val === true) {
+            result.$eq = null;
+          } else {
+            result.$ne = null;
+          }
+          break;
+        default:
+          result[op] = val;
+          break;
+      }
+    }
+    if (regexConditions.length === 1) {
+      Object.assign(result, regexConditions[0]);
+    } else if (regexConditions.length > 1) {
+      result._multiRegex = regexConditions;
+    }
+    return result;
+  }
   /**
    * Escape special regex characters for safe literal matching.
    */