@objectstack/driver-memory 3.2.1 → 3.2.2

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @objectstack/driver-memory@3.2.1 build /home/runner/work/spec/spec/packages/plugins/driver-memory
+> @objectstack/driver-memory@3.2.2 build /home/runner/work/spec/spec/packages/plugins/driver-memory
 > tsup --config ../../../tsup.config.ts
 
 CLI Building entry: src/index.ts
@@ -10,13 +10,13 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.js     50.91 KB
-CJS dist/index.js.map 97.27 KB
-CJS ⚡️ Build success in 96ms
-ESM dist/index.mjs     49.23 KB
-ESM dist/index.mjs.map 97.21 KB
-ESM ⚡️ Build success in 101ms
+ESM dist/index.mjs     52.62 KB
+ESM dist/index.mjs.map 104.48 KB
+ESM ⚡️ Build success in 129ms
+CJS dist/index.js     54.30 KB
+CJS dist/index.js.map 104.53 KB
+CJS ⚡️ Build success in 143ms
 DTS Build start
-DTS ⚡️ Build success in 16128ms
-DTS dist/index.d.mts 13.73 KB
-DTS dist/index.d.ts  13.73 KB
+DTS ⚡️ Build success in 17127ms
+DTS dist/index.d.mts 14.27 KB
+DTS dist/index.d.ts  14.27 KB

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @objectstack/driver-memory
 
+## 3.2.2
+
+### Patch Changes
+
+- 46defbb: Fix filter operators (contains, notContains, startsWith, endsWith, between, null) broken across spec and memory driver
+
+  - Add `$notContains` to `StringOperatorSchema`, `FieldOperatorsSchema`, `FILTER_OPERATORS`, and `Filter` type
+  - Add `notcontains` / `not_contains` to `VALID_AST_OPERATORS` and `AST_OPERATOR_MAP`
+  - Fix memory driver `convertToMongoQuery()` passthrough to normalize non-standard operators to Mingo-compatible format
+  - Add `$notContains` and `$null` operators to memory matcher
+  - Fix undefined value guard in memory matcher to exclude `$exists`, `$ne`, and `$null`
+
+- Updated dependencies [46defbb]
+  - @objectstack/spec@3.2.2
+  - @objectstack/core@3.2.2
+
 ## 3.2.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -181,6 +181,18 @@ declare class InMemoryDriver implements DriverInterface {
      * Convert a single ObjectQL condition to MongoDB operator format.
      */
     private convertConditionToMongo;
+    /**
+     * 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).
+     */
+    private normalizeFilterCondition;
+    /**
+     * 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.
+     */
+    private normalizeFieldOperators;
     /**
      * Escape special regex characters for safe literal matching.
      */

package/dist/index.d.ts

@@ -181,6 +181,18 @@ declare class InMemoryDriver implements DriverInterface {
      * Convert a single ObjectQL condition to MongoDB operator format.
      */
     private convertConditionToMongo;
+    /**
+     * 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).
+     */
+    private normalizeFilterCondition;
+    /**
+     * 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.
+     */
+    private normalizeFieldOperators;
     /**
      * Escape special regex characters for safe literal matching.
      */

package/dist/index.js

@@ -194,9 +194,6 @@ var import_mingo = require("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);
 }
@@ -666,7 +663,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 = [
@@ -727,6 +724,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") } };
@@ -742,6 +742,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.
    */