fix: address review feedback — multi-regex overwrite, $null guard, test name

1. normalizeFieldOperators: collect regex-producing operators ($contains,
   $startsWith, $endsWith) into an array; when multiple exist on the same
   field, promote to $and so no regex silently overwrites another.

2. memory-matcher checkCondition: exclude $null from the undefined early-
   return guard so $null: true correctly matches missing fields.

3. Rename test from "$contains inside $or" to "$startsWith inside $or"
   to match actual test body.

4. Add tests: combined $startsWith + $endsWith on same field, $null: true
   on records with missing fields.

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/plugins/driver-memory/src/memory-driver.test.ts

@@ -677,7 +677,7 @@ describe('InMemoryDriver', () => {
       expect(results.map((r: any) => r.name).sort()).toEqual(['Alice Johnson', 'Charlie Brown']);
     });
 
-    it('should handle $contains inside $or', async () => {
+    it('should handle $startsWith inside $or', async () => {
       const results = await driver.find(testTable, {
         object: testTable,
         where: { $or: [{ name: { $startsWith: 'Al' } }, { name: { $startsWith: 'Ev' } }] },
@@ -693,5 +693,28 @@ describe('InMemoryDriver', () => {
       });
       expect(results).toHaveLength(3);
     });
+
+    it('should handle combined $startsWith + $endsWith on same field', async () => {
+      const results = await driver.find(testTable, {
+        object: testTable,
+        where: { name: { $startsWith: 'A', $endsWith: 'son' } },
+      });
+      expect(results).toHaveLength(1);
+      expect(results[0].name).toBe('Alice Johnson');
+    });
+
+    it('should filter with $null: true on missing fields', async () => {
+      // bio is null for Alice Johnson — should match
+      // Records without bio field at all should also match $null: true
+      await driver.create(testTable, { id: '5', name: 'Frank', age: 40, email: 'frank@test.com' });
+      const results = await driver.find(testTable, {
+        object: testTable,
+        where: { bio: { $null: true } },
+      });
+      // Alice (bio: null), Frank (bio: missing)
+      expect(results.length).toBeGreaterThanOrEqual(2);
+      expect(results.map((r: any) => r.name)).toContain('Alice Johnson');
+      expect(results.map((r: any) => r.name)).toContain('Frank');
+    });
   });
 });

packages/plugins/driver-memory/src/memory-driver.ts

@@ -718,6 +718,8 @@ export class InMemoryDriver implements DriverInterface {
    */
   private normalizeFilterCondition(filter: Record<string, any>): Record<string, any> {
     const result: Record<string, any> = {};
+    const extraAndConditions: Record<string, any>[] = [];
+
     for (const key of Object.keys(filter)) {
       const value = filter[key];
       // Recurse into logical operators
@@ -740,33 +742,63 @@ export class InMemoryDriver implements DriverInterface {
       }
       // Field-level: value may be primitive (implicit eq) or operator object
       if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp)) {
-        result[key] = this.normalizeFieldOperators(value);
+        const normalized = this.normalizeFieldOperators(value);
+        // Handle multiple regex conditions on the same field (e.g. $startsWith + $endsWith)
+        if (normalized.__$andRegex) {
+          const regexConditions: Record<string, any>[] = normalized.__$andRegex;
+          delete normalized.__$andRegex;
+          // Each regex becomes its own { field: { $regex: ... } } inside $and
+          for (const rc of regexConditions) {
+            extraAndConditions.push({ [key]: { ...normalized, ...rc } });
+          }
+        } else {
+          result[key] = normalized;
+        }
       } else {
         result[key] = value;
       }
     }
+
+    // Merge extra $and conditions from multi-regex fields
+    if (extraAndConditions.length > 0) {
+      const existing = result.$and;
+      const andArray = Array.isArray(existing) ? existing : [];
+      // Include the rest of result as a condition too
+      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.
    */
   private normalizeFieldOperators(ops: Record<string, any>): Record<string, any> {
     const result: Record<string, any> = {};
+    const regexConditions: Record<string, any>[] = [];
+
     for (const op of Object.keys(ops)) {
       const val = ops[op];
       switch (op) {
         case '$contains':
-          result.$regex = new RegExp(this.escapeRegex(val), 'i');
+          regexConditions.push({ $regex: new RegExp(this.escapeRegex(val), 'i') });
           break;
         case '$notContains':
           result.$not = { $regex: new RegExp(this.escapeRegex(val), 'i') };
           break;
         case '$startsWith':
-          result.$regex = new RegExp(`^${this.escapeRegex(val)}`, 'i');
+          regexConditions.push({ $regex: new RegExp(`^${this.escapeRegex(val)}`, 'i') });
           break;
         case '$endsWith':
-          result.$regex = new RegExp(`${this.escapeRegex(val)}$`, 'i');
+          regexConditions.push({ $regex: new RegExp(`${this.escapeRegex(val)}$`, 'i') });
           break;
         case '$between':
           if (Array.isArray(val) && val.length === 2) {
@@ -788,6 +820,19 @@ export class InMemoryDriver implements DriverInterface {
           break;
       }
     }
+
+    // Merge regex conditions: single → inline, multiple → wrap with $and
+    if (regexConditions.length === 1) {
+      Object.assign(result, regexConditions[0]);
+    } else if (regexConditions.length > 1) {
+      // Cannot have multiple $regex on one object; promote to top-level $and
+      // The caller (normalizeFilterCondition) handles field-level objects,
+      // so we return a sentinel that the caller will need to unwrap.
+      // Simpler approach: just assign the first and use $and for the rest isn't
+      // possible in flat Mingo format. Use __$and sentinel for the caller.
+      result.__$andRegex = regexConditions;
+    }
+
     return result;
   }
 

packages/plugins/driver-memory/src/memory-matcher.ts

@@ -103,7 +103,7 @@ function checkCondition(value: any, condition: any): boolean {
         const target = condition[op];
 
         // Handle undefined values
-        if (value === undefined && op !== '$exists' && op !== '$ne') {
+        if (value === undefined && op !== '$exists' && op !== '$ne' && op !== '$null') {
             return false; 
         }