@mastra/opensearch 0.10.3 → 0.10.4-alpha.1

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 
+import type { OpenSearchVectorFilter } from './filter';
 import { OpenSearchFilterTranslator } from './filter';
 
 describe('OpenSearchFilterTranslator', () => {
@@ -13,19 +14,19 @@ describe('OpenSearchFilterTranslator', () => {
   describe('basic operations', () => {
     it('handles empty filters', () => {
       expect(translator.translate({})).toEqual(undefined);
-      expect(translator.translate(null as any)).toEqual(undefined);
-      expect(translator.translate(undefined as any)).toEqual(undefined);
+      expect(translator.translate(null)).toEqual(undefined);
+      expect(translator.translate(undefined)).toEqual(undefined);
     });
 
     it('translates simple field equality to term query', () => {
-      const filter = { field: 'value' };
+      const filter: OpenSearchVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field.keyword': 'value' },
       });
     });
 
     it('translates multiple top-level fields to bool must', () => {
-      const filter = { field1: 'value1', field2: 'value2' };
+      const filter: OpenSearchVectorFilter = { field1: 'value1', field2: 'value2' };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ term: { 'metadata.field1.keyword': 'value1' } }, { term: { 'metadata.field2.keyword': 'value2' } }],
@@ -62,14 +63,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Comparison Operators
   describe('comparison operators', () => {
     it('translates $eq operator', () => {
-      const filter = { field: { $eq: 'value' } };
+      const filter: OpenSearchVectorFilter = { field: { $eq: 'value' } };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field.keyword': 'value' },
       });
     });
 
     it('translates $ne operator', () => {
-      const filter = { field: { $ne: 'value' } };
+      const filter: OpenSearchVectorFilter = { field: { $ne: 'value' } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ term: { 'metadata.field.keyword': 'value' } }],
@@ -79,7 +80,7 @@ describe('OpenSearchFilterTranslator', () => {
 
     it('handles date values', () => {
       const date = new Date('2024-01-01');
-      const filter = { timestamp: { $gt: date } };
+      const filter: OpenSearchVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.timestamp': { gt: date.toISOString() } },
       });
@@ -89,7 +90,7 @@ describe('OpenSearchFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('translates $and operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [{ field1: 'value1' }, { field2: 'value2' }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -100,7 +101,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $or operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $or: [{ field1: 'value1' }, { field2: 'value2' }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -114,7 +115,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $not: { field: 'value' },
       };
       expect(translator.translate(filter)).toEqual({
@@ -125,7 +126,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with $eq operator', () => {
-      const filter = { field: { $not: { $eq: 'value' } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $eq: 'value' } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ term: { 'metadata.field.keyword': 'value' } }],
@@ -134,7 +135,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with $ne operator', () => {
-      const filter = { field: { $not: { $ne: 'value' } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $ne: 'value' } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -149,14 +150,14 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with $eq null', () => {
-      const filter = { field: { $not: { $eq: null } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $eq: null } } };
       expect(translator.translate(filter)).toEqual({
         exists: { field: 'metadata.field' },
       });
     });
 
     it('translates $not with $ne null', () => {
-      const filter = { field: { $not: { $ne: null } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $ne: null } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ exists: { field: 'metadata.field' } }],
@@ -165,7 +166,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with nested fields', () => {
-      const filter = { 'user.profile.age': { $not: { $gt: 25 } } };
+      const filter: OpenSearchVectorFilter = { 'user.profile.age': { $not: { $gt: 25 } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -178,7 +179,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with multiple operators', () => {
-      const filter = { price: { $not: { $gte: 30, $lte: 70 } } };
+      const filter: OpenSearchVectorFilter = { price: { $not: { $gte: 30, $lte: 70 } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -191,7 +192,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $and array', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [],
       };
       // Empty $and should match everything
@@ -199,7 +200,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $or array', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $or: [],
       };
       // Empty $or should match nothing
@@ -218,7 +219,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with comparison operators', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         price: { $not: { $gt: 100 } },
       };
       expect(translator.translate(filter)).toEqual({
@@ -229,7 +230,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles nested $not with $or', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $not: { $or: [{ category: 'electronics' }, { category: 'books' }] },
       };
       expect(translator.translate(filter)).toEqual({
@@ -249,7 +250,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with $not operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $not: { $not: { category: 'electronics' } },
       };
       expect(translator.translate(filter)).toEqual({
@@ -266,7 +267,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [
           { field1: 'value1' },
           {
@@ -295,14 +296,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Array Operators
   describe('array operators', () => {
     it('translates $in operator', () => {
-      const filter = { field: { $in: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field.keyword': ['value1', 'value2'] },
       });
     });
 
     it('translates $nin operator', () => {
-      const filter = { field: { $nin: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $nin: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ terms: { 'metadata.field.keyword': ['value1', 'value2'] } }],
@@ -311,7 +312,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $all operator', () => {
-      const filter = { field: { $all: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $all: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ term: { 'metadata.field.keyword': 'value1' } }, { term: { 'metadata.field.keyword': 'value2' } }],
@@ -320,7 +321,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $in array', () => {
-      const filter = { field: { $in: [] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: [] } };
       // Empty $in should match nothing (empty terms)
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field.keyword': [] },
@@ -328,7 +329,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $nin array', () => {
-      const filter = { field: { $nin: [] } };
+      const filter: OpenSearchVectorFilter = { field: { $nin: [] } };
       // Empty $nin should match everything
       expect(translator.translate(filter)).toEqual({
         match_all: {},
@@ -336,7 +337,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $all array', () => {
-      const filter = { field: { $all: [] } };
+      const filter: OpenSearchVectorFilter = { field: { $all: [] } };
       // Empty $all should match nothing
       expect(translator.translate(filter)).toEqual({
         bool: {
@@ -346,7 +347,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with array operators', () => {
-      const filter = { tags: { $not: { $in: ['premium', 'new'] } } };
+      const filter: OpenSearchVectorFilter = { tags: { $not: { $in: ['premium', 'new'] } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -359,7 +360,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with empty array operators', () => {
-      const filter = { tags: { $not: { $in: [] } } };
+      const filter: OpenSearchVectorFilter = { tags: { $not: { $in: [] } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -375,14 +376,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Element Operators
   describe('element operators', () => {
     it('translates $exists operator', () => {
-      const filter = { field: { $exists: true } };
+      const filter: OpenSearchVectorFilter = { field: { $exists: true } };
       expect(translator.translate(filter)).toEqual({
         exists: { field: 'metadata.field' },
       });
     });
 
     it('translates $exists operator with false', () => {
-      const filter = { field: { $exists: false } };
+      const filter: OpenSearchVectorFilter = { field: { $exists: false } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ exists: { field: 'metadata.field' } }],
@@ -394,14 +395,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Regex Operators
   describe('regex operators', () => {
     it('translates $regex operator', () => {
-      const filter = { field: { $regex: 'pattern' } };
+      const filter: OpenSearchVectorFilter = { field: { $regex: 'pattern' } };
       expect(translator.translate(filter)).toEqual({
         regexp: { 'metadata.field': 'pattern' },
       });
     });
 
     it('handles $regex with start anchor', () => {
-      const filter = { category: { $regex: '^elect' } };
+      const filter: OpenSearchVectorFilter = { category: { $regex: '^elect' } };
       // Should use wildcard for better anchor handling
       expect(translator.translate(filter)).toEqual({
         wildcard: { 'metadata.category': 'elect*' },
@@ -409,7 +410,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $regex with end anchor', () => {
-      const filter = { category: { $regex: 'nics$' } };
+      const filter: OpenSearchVectorFilter = { category: { $regex: 'nics$' } };
       // Should use wildcard for better anchor handling
       expect(translator.translate(filter)).toEqual({
         wildcard: { 'metadata.category': '*nics' },
@@ -417,7 +418,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $regex with both anchors', () => {
-      const filter = { category: { $regex: '^electronics$' } };
+      const filter: OpenSearchVectorFilter = { category: { $regex: '^electronics$' } };
       // Should use exact match for both anchors
       expect(translator.translate(filter)).toEqual({
         wildcard: { 'metadata.category': 'electronics' },
@@ -425,7 +426,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with $regex operator', () => {
-      const filter = { category: { $not: { $regex: '^elect' } } };
+      const filter: OpenSearchVectorFilter = { category: { $not: { $regex: '^elect' } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -441,14 +442,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Complex Queries
   describe('complex queries', () => {
     it('translates numeric operators', () => {
-      const filter = { price: { $gt: 70, $lte: 100 } };
+      const filter: OpenSearchVectorFilter = { price: { $gt: 70, $lte: 100 } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.price': { gt: 70, lte: 100 } },
       });
     });
 
     it('translates multiple range operators on the same field', () => {
-      const filter = { price: { $gte: 50, $lt: 200 } };
+      const filter: OpenSearchVectorFilter = { price: { $gte: 50, $lt: 200 } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.price': { gte: 50, lt: 200 } },
       });
@@ -456,14 +457,14 @@ describe('OpenSearchFilterTranslator', () => {
 
     it('translates all four range operators combined', () => {
       // This is an edge case that would never occur in practice, but tests the implementation
-      const filter = { value: { $gt: 10, $gte: 20, $lt: 100, $lte: 90 } };
+      const filter: OpenSearchVectorFilter = { value: { $gt: 10, $gte: 20, $lt: 100, $lte: 90 } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.value': { gt: 10, gte: 20, lt: 100, lte: 90 } },
       });
     });
 
     it('translates mixed numeric and non-numeric operators', () => {
-      const filter = { price: { $gt: 50, $exists: true } };
+      const filter: OpenSearchVectorFilter = { price: { $gt: 50, $exists: true } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ range: { 'metadata.price': { gt: 50 } } }, { exists: { field: 'metadata.price' } }],
@@ -471,7 +472,7 @@ describe('OpenSearchFilterTranslator', () => {
       });
     });
     it('translates mixed operators', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [{ field1: { $gt: 10 } }, { field2: { $in: ['value1', 'value2'] } }, { field3: { $exists: true } }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -486,7 +487,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates complex nested queries', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [
           { status: 'active' },
           {
@@ -542,7 +543,7 @@ describe('OpenSearchFilterTranslator', () => {
 
     it('throws error for invalid array operator values', () => {
       const filter = { field: { $in: 'not-an-array' } };
-      expect(() => translator.translate(filter)).toThrow();
+      expect(() => translator.translate(filter as any)).toThrow();
     });
 
     it('throws error for nested invalid operators', () => {
@@ -553,7 +554,7 @@ describe('OpenSearchFilterTranslator', () => {
 
   describe('special values', () => {
     it('handles boolean values', () => {
-      const filter = { active: true, disabled: false };
+      const filter: OpenSearchVectorFilter = { active: true, disabled: false };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ term: { 'metadata.active': true } }, { term: { 'metadata.disabled': false } }],
@@ -562,7 +563,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles null values', () => {
-      const filter = { field: null };
+      const filter: OpenSearchVectorFilter = { field: null };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field': null },
       });
@@ -571,21 +572,21 @@ describe('OpenSearchFilterTranslator', () => {
 
   describe('array handling', () => {
     it('translates array values to terms query', () => {
-      const filter = { tags: ['premium', 'new'] };
+      const filter: OpenSearchVectorFilter = { tags: ['premium', 'new'] };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.tags.keyword': ['premium', 'new'] },
       });
     });
 
     it('translates numeric array values to terms query', () => {
-      const filter = { scores: [90, 95, 100] };
+      const filter: OpenSearchVectorFilter = { scores: [90, 95, 100] };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.scores': [90, 95, 100] },
       });
     });
 
     it('translates empty array values to empty terms query', () => {
-      const filter = { tags: [] };
+      const filter: OpenSearchVectorFilter = { tags: [] };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.tags.keyword': [] },
       });
@@ -609,35 +610,35 @@ describe('OpenSearchFilterTranslator', () => {
 
   describe('field type handling', () => {
     it('adds .keyword suffix for string fields', () => {
-      const filter = { field: 'value' };
+      const filter: OpenSearchVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field.keyword': 'value' },
       });
     });
 
     it('adds .keyword suffix for string array fields', () => {
-      const filter = { field: { $in: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field.keyword': ['value1', 'value2'] },
       });
     });
 
     it('does not add .keyword suffix for numeric fields', () => {
-      const filter = { field: 123 };
+      const filter: OpenSearchVectorFilter = { field: 123 };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field': 123 },
       });
     });
 
     it('does not add .keyword suffix for numeric array fields', () => {
-      const filter = { field: { $in: [1, 2, 3] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: [1, 2, 3] } };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field': [1, 2, 3] },
       });
     });
 
     it('handles mixed field types in complex queries', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [
           { textField: 'value' },
           { numericField: 123 },

package/src/vector/filter.ts

@@ -1,30 +1,48 @@
-import type { FieldCondition, OperatorSupport, QueryOperator, VectorFilter } from '@mastra/core/vector/filter';
+import type {
+  BlacklistedRootOperators,
+  LogicalOperatorValueMap,
+  OperatorSupport,
+  OperatorValueMap,
+  QueryOperator,
+  VectorFilter,
+} from '@mastra/core/vector/filter';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
+type OpenSearchOperatorValueMap = Omit<OperatorValueMap, '$options' | '$nor' | '$elemMatch'>;
+
+type OpenSearchLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+type OpenSearchBlacklisted = BlacklistedRootOperators | '$nor';
+
+export type OpenSearchVectorFilter = VectorFilter<
+  keyof OpenSearchOperatorValueMap,
+  OpenSearchOperatorValueMap,
+  OpenSearchLogicalOperatorValueMap,
+  OpenSearchBlacklisted
+>;
 /**
  * Translator for OpenSearch filter queries.
  * Maintains OpenSearch-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class OpenSearchFilterTranslator extends BaseFilterTranslator {
+export class OpenSearchFilterTranslator extends BaseFilterTranslator<OpenSearchVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
       logical: ['$and', '$or', '$not'],
       array: ['$in', '$nin', '$all'],
-      element: ['$exists'],
       regex: ['$regex'],
       custom: [],
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: OpenSearchVectorFilter): OpenSearchVectorFilter {
     if (this.isEmpty(filter)) return undefined;
     this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition): any {
+  private translateNode(node: OpenSearchVectorFilter): any {
     // Handle primitive values and arrays
     if (this.isPrimitive(node) || Array.isArray(node)) {
       return node;

package/src/vector/index.test.ts

@@ -1,5 +1,5 @@
 // To setup a Opensearch server, run the docker compose file in the opensearch directory
-import type { QueryResult, QueryVectorParams } from '@mastra/core';
+import type { QueryResult } from '@mastra/core';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { OpenSearchVector } from './index';
@@ -215,12 +215,11 @@ describe('OpenSearchVector', () => {
 
         await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata });
 
-        const queryParams: QueryVectorParams = {
+        const results = await vectorDB.query({
           indexName: testIndexName,
           queryVector: [1.0, 0.1, 0.1],
           topK: 3,
-        };
-        const results = await vectorDB.query(queryParams);
+        });
 
         expect(results).toHaveLength(3);
         expect(results[0]?.score).toBeGreaterThan(0);
@@ -1197,7 +1196,7 @@ describe('OpenSearchVector', () => {
           vectorDB.query({
             indexName,
             queryVector: [1, 0, 0],
-            filter: { price: { $invalid: 100 } },
+            filter: { price: { $invalid: 100 } as any },
           }),
         ).rejects.toThrow('Unsupported operator: $invalid');
       });