@mastra/mongodb 0.0.0-working-memory-per-user-20250620163010 → 0.0.0-zod-v4-compat-part-2-20250820135355

package/src/storage/types.ts

@@ -0,0 +1,14 @@
+import type { MongoClientOptions } from 'mongodb';
+import type { ConnectorHandler } from './connectors/base';
+
+export type MongoDBConfig =
+  | DatabaseConfig
+  | {
+      connectorHandler: ConnectorHandler;
+    };
+
+export type DatabaseConfig = {
+  url: string;
+  dbName: string;
+  options?: MongoClientOptions;
+};

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { MongoDBVectorFilter } from './filter';
 import { MongoDBFilterTranslator } from './filter';
 
 describe('MongoDBFilterTranslator', () => {
@@ -12,12 +13,12 @@ describe('MongoDBFilterTranslator', () => {
   // Basic Filter Operations
   describe('basic operations', () => {
     it('handles simple equality', () => {
-      const filter = { field: 'value' };
+      const filter: MongoDBVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles comparison operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         age: { $gt: 25 },
         score: { $lte: 100 },
       };
@@ -25,7 +26,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles valid multiple operators on same field', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         price: { $gt: 100, $lt: 200 },
         quantity: { $gte: 10, $lte: 20 },
       };
@@ -33,7 +34,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles null values correctly', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         field: null,
         other: { $eq: null },
       };
@@ -41,7 +42,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles boolean values correctly', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         active: true,
         deleted: false,
         status: { $eq: true },
@@ -53,7 +54,7 @@ describe('MongoDBFilterTranslator', () => {
   // Array Operations
   describe('array operations', () => {
     it('handles array operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         tags: { $all: ['tag1', 'tag2'] },
         categories: { $in: ['A', 'B'] },
         items: { $nin: ['item1', 'item2'] },
@@ -63,7 +64,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles empty array values', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         tags: { $in: [] },
         categories: { $all: [] },
       };
@@ -71,14 +72,14 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles nested array operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $and: [{ tags: { $all: ['tag1', 'tag2'] } }, { 'nested.array': { $in: [1, 2, 3] } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles $size operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         tags: { $size: 3 },
       };
       expect(translator.translate(filter)).toEqual(filter);
@@ -88,14 +89,14 @@ describe('MongoDBFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('handles logical operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $or: [{ status: 'active' }, { age: { $gt: 25 } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles $not operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         field: { $not: { $eq: 'value' } },
         $not: { field: 'value' },
       };
@@ -103,14 +104,14 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles $nor operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $nor: [{ status: 'deleted' }, { active: false }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $and: [
           { status: 'active' },
           { $or: [{ category: { $in: ['A', 'B'] } }, { $and: [{ price: { $gt: 100 } }, { stock: { $lt: 50 } }] }] },
@@ -120,7 +121,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles empty conditions in logical operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $and: [],
         $or: [{}],
         field: 'value',
@@ -175,7 +176,7 @@ describe('MongoDBFilterTranslator', () => {
       expect(() =>
         translator.translate({
           $or: [{ $in: ['value1', 'value2'] }],
-        }),
+        } as any),
       ).toThrow(/Logical operators must contain field conditions/);
     });
 
@@ -187,7 +188,7 @@ describe('MongoDBFilterTranslator', () => {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
             },
           },
-        }),
+        } as any),
       ).toThrow();
 
       expect(() =>
@@ -196,7 +197,7 @@ describe('MongoDBFilterTranslator', () => {
             $in: [
               {
                 $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-              },
+              } as any,
             ],
           },
         }),
@@ -211,7 +212,7 @@ describe('MongoDBFilterTranslator', () => {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
             },
           },
-        }),
+        } as any),
       ).toThrow();
 
       expect(() =>
@@ -227,7 +228,7 @@ describe('MongoDBFilterTranslator', () => {
 
     it('throws error for $not if not an object', () => {
       expect(() => translator.translate({ $not: 'value' })).toThrow();
-      expect(() => translator.translate({ $not: [{ field: 'value' }] })).toThrow();
+      expect(() => translator.translate({ $not: [{ field: 'value' }] } as any)).toThrow();
     });
 
     it('throws error for $not if empty', () => {
@@ -238,7 +239,7 @@ describe('MongoDBFilterTranslator', () => {
   // Nested Objects and Fields
   describe('nested objects and fields', () => {
     it('handles nested objects', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         'user.profile.age': { $gt: 25 },
         'user.status': 'active',
       };
@@ -246,7 +247,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles deeply nested field paths', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         'user.profile.address.city': { $eq: 'New York' },
         'deep.nested.field': { $gt: 100 },
       };
@@ -295,13 +296,13 @@ describe('MongoDBFilterTranslator', () => {
   describe('special cases', () => {
     it('handles empty filters', () => {
       expect(translator.translate({})).toEqual({});
-      expect(translator.translate(null as any)).toEqual(null);
-      expect(translator.translate(undefined as any)).toEqual(undefined);
+      expect(translator.translate(null)).toEqual(null);
+      expect(translator.translate(undefined)).toEqual(undefined);
     });
 
     it('normalizes dates', () => {
       const date = new Date('2024-01-01');
-      const filter = { timestamp: { $gt: date } };
+      const filter: MongoDBVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({
         timestamp: { $gt: date.toISOString() },
       });
@@ -321,14 +322,14 @@ describe('MongoDBFilterTranslator', () => {
   // Regex Support
   describe('regex support', () => {
     it('handles $regex operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         name: { $regex: '^test' },
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles RegExp objects', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         name: /^test/i,
       };
       // RegExp objects should be preserved
@@ -338,7 +339,7 @@ describe('MongoDBFilterTranslator', () => {
 
   describe('operator validation', () => {
     it('ensures all supported operator filters are accepted', () => {
-      const supportedFilters = [
+      const supportedFilters: MongoDBVectorFilter[] = [
         // Basic comparison operators
         { field: { $eq: 'value' } },
         { field: { $ne: 'value' } },
@@ -382,12 +383,21 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('throws on unsupported operators', () => {
-      expect(() => translator.translate({ field: { $unknown: 'value' } })).toThrow('Unsupported operator: $unknown');
-      expect(() => translator.translate({ $unknown: [{ field: 'value' }] })).toThrow('Unsupported operator: $unknown');
+      expect(() => translator.translate({ field: { $unknown: 'value' } } as any)).toThrow(
+        'Unsupported operator: $unknown',
+      );
+      expect(() => translator.translate({ $unknown: [{ field: 'value' }] } as any)).toThrow(
+        'Unsupported operator: $unknown',
+      );
     });
 
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $exists: true }, { $regex: 'pattern' }];
+      const invalidFilters: any = [
+        { $gt: 100 },
+        { $in: ['value1', 'value2'] },
+        { $exists: true },
+        { $regex: 'pattern' },
+      ];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);

package/src/vector/filter.ts

@@ -1,12 +1,33 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, VectorFilter, OperatorSupport, QueryOperator } from '@mastra/core/vector/filter';
+import type {
+  VectorFilter,
+  OperatorSupport,
+  QueryOperator,
+  OperatorValueMap,
+  LogicalOperatorValueMap,
+  BlacklistedRootOperators,
+  VectorFieldValue,
+} from '@mastra/core/vector/filter';
+
+type MongoDBOperatorValueMap = Omit<OperatorValueMap, '$options'> & {
+  $size: number;
+};
+type MongoDBBlacklisted = BlacklistedRootOperators | '$size';
+
+export type MongoDBVectorFilter = VectorFilter<
+  keyof MongoDBOperatorValueMap,
+  MongoDBOperatorValueMap,
+  LogicalOperatorValueMap,
+  MongoDBBlacklisted,
+  VectorFieldValue | RegExp
+>;
 
 /**
  * Translator for MongoDB filter queries.
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class MongoDBFilterTranslator extends BaseFilterTranslator {
+export class MongoDBFilterTranslator extends BaseFilterTranslator<MongoDBVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -15,14 +36,14 @@ export class MongoDBFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): any {
+  translate(filter?: MongoDBVectorFilter): any {
     if (this.isEmpty(filter)) return filter;
     this.validateFilter(filter);
 
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition): any {
+  private translateNode(node: MongoDBVectorFilter): any {
     // Handle primitive values and arrays
     if (this.isRegex(node)) {
       return node; // Return regex values as-is

package/src/vector/index.test.ts

@@ -1,4 +1,3 @@
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { vi, describe, it, expect, beforeAll, afterAll, test } from 'vitest';
 import { MongoDBVector } from './';
 
@@ -94,6 +93,7 @@ describe('MongoDBVector Integration Tests', () => {
   let vectorDB: MongoDBVector;
   const testIndexName = 'my_vectors';
   const testIndexName2 = 'my_vectors_2';
+  const emptyIndexName = 'empty-index';
 
   beforeAll(async () => {
     vectorDB = new MongoDBVector({ uri, dbName });
@@ -115,6 +115,7 @@ describe('MongoDBVector Integration Tests', () => {
 
     await createIndexAndWait(vectorDB, testIndexName, 4, 'cosine');
     await createIndexAndWait(vectorDB, testIndexName2, 4, 'cosine');
+    await createIndexAndWait(vectorDB, emptyIndexName, 4, 'cosine');
   }, 500000);
 
   afterAll(async () => {
@@ -128,6 +129,11 @@ describe('MongoDBVector Integration Tests', () => {
     } catch (error) {
       console.error('Failed to delete test collection:', error);
     }
+    try {
+      await vectorDB.deleteIndex({ indexName: emptyIndexName });
+    } catch (error) {
+      console.error('Failed to delete test collection:', error);
+    }
     await vectorDB.disconnect();
   });
 
@@ -264,7 +270,10 @@ describe('MongoDBVector Integration Tests', () => {
     beforeAll(async () => {
       // Ensure testIndexName2 has at least one document
       const testVector = [1, 0, 0, 0];
-      const testMetadata = { label: 'test_filter_validation' };
+      const testMetadata = {
+        label: 'test_filter_validation',
+        timestamp: new Date('2024-01-01T00:00:00Z'),
+      };
 
       // First check if there are already documents
       const existingResults = await vectorDB.query({
@@ -329,7 +338,7 @@ describe('MongoDBVector Integration Tests', () => {
       const results = await retryQuery({
         indexName: testIndexName2,
         queryVector: [1, 0, 0, 0],
-        filter: null as unknown as VectorFilter,
+        filter: null,
       });
       const results2 = await retryQuery({
         indexName: testIndexName2,
@@ -339,6 +348,18 @@ describe('MongoDBVector Integration Tests', () => {
       expect(results.length).toBeGreaterThan(0);
     });
 
+    it('handles filters with multiple properties', async () => {
+      const results = await retryQuery({
+        indexName: testIndexName2,
+        queryVector: [1, 0, 0, 0],
+        filter: {
+          'metadata.label': 'test_filter_validation',
+          'metadata.timestamp': { $gt: new Date('2023-01-01T00:00:00Z') },
+        },
+      });
+      expect(results.length).toBeGreaterThan(0);
+    });
+
     it('normalizes date values in filter using filter.ts', async () => {
       const vector = [1, 0, 0, 0];
       const timestampDate = new Date('2024-01-01T00:00:00Z');
@@ -468,5 +489,29 @@ describe('MongoDBVector Integration Tests', () => {
       const invalidVector = [1, 2, 3]; // 3D vector for 4D index
       await expect(vectorDB.upsert({ indexName: testIndexName, vectors: [invalidVector] })).rejects.toThrow();
     });
+    it('should return empty results and not throw when semantic search filter matches zero documents', async () => {
+      // Use a valid embedding vector matching your test index dimension
+      const testEmbedding = [0.1, 0.2, 0.3, 0.4]; // Adjust dimension as needed
+
+      // Should not throw, should return an empty array
+      let error: unknown = null;
+      let results: any[] = [];
+      try {
+        results = await vectorDB.query({
+          indexName: emptyIndexName,
+          queryVector: testEmbedding,
+          topK: 2,
+          filter: {
+            'metadata.label': 'test_filter_validation',
+          },
+        });
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).toBeNull();
+      expect(Array.isArray(results)).toBe(true);
+      expect(results.length).toBe(0);
+    });
   });
 });