@mastra/pg 0.11.1-alpha.0 → 0.11.1-alpha.2

package/src/vector/filter.test.ts

@@ -54,7 +54,7 @@ describe('PGFilterTranslator', () => {
         translator.translate({
           nested: {
             field: 'value',
-          },
+          } as any,
         }),
       ).toEqual({
         'nested.field': { $eq: 'value' },
@@ -634,7 +634,7 @@ describe('PGFilterTranslator', () => {
 
     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', () => {
       expect(() => translator.translate({ $not: {} })).toThrow();
@@ -645,21 +645,21 @@ describe('PGFilterTranslator', () => {
       // $and cannot be used in field conditions
       expect(() =>
         translator.translate({
-          field: { $and: [{ $eq: 'value1' }, { $eq: 'value2' }] },
+          field: { $and: [{ $eq: 'value1' }, { $eq: 'value2' }] } as any,
         }),
       ).toThrow();
 
       // $or cannot be used in field conditions
       expect(() =>
         translator.translate({
-          field: { $or: [{ $eq: 'value1' }, { $eq: 'value2' }] },
+          field: { $or: [{ $eq: 'value1' }, { $eq: 'value2' }] } as any,
         }),
       ).toThrow();
 
       // $nor cannot be used in field conditions
       expect(() =>
         translator.translate({
-          field: { $nor: [{ $eq: 'value1' }, { $eq: 'value2' }] },
+          field: { $nor: [{ $eq: 'value1' }, { $eq: 'value2' }] } as any,
         }),
       ).toThrow();
     });
@@ -710,7 +710,7 @@ describe('PGFilterTranslator', () => {
             $gt: {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
             },
-          },
+          } as any,
         }),
       ).toThrow();
 
@@ -721,7 +721,7 @@ describe('PGFilterTranslator', () => {
             $in: [
               {
                 $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-              },
+              } as any,
             ],
           },
         }),
@@ -730,7 +730,7 @@ describe('PGFilterTranslator', () => {
 
     it('validates $not operator structure', () => {
       // $not must be an object
-      expect(() => translator.translate({ field: { $not: 'value' } })).toThrow();
+      expect(() => translator.translate({ field: { $not: 'value' } } as any)).toThrow();
       expect(() => translator.translate({ field: { $not: ['value'] } })).toThrow();
       expect(() => translator.translate({ $not: 'value' })).toThrow();
       expect(() => translator.translate({ $not: ['value'] })).toThrow();
@@ -790,7 +790,7 @@ describe('PGFilterTranslator', () => {
     });
 
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);
@@ -808,13 +808,13 @@ describe('PGFilterTranslator', () => {
       // Should throw for non-object values
       expect(() =>
         translator.translate({
-          field: { $elemMatch: 'value' },
+          field: { $elemMatch: 'value' } as any,
         }),
       ).toThrow('$elemMatch requires an object with conditions');
 
       expect(() =>
         translator.translate({
-          field: { $elemMatch: ['value'] },
+          field: { $elemMatch: ['value'] } as any,
         }),
       ).toThrow('$elemMatch requires an object with conditions');
     });
@@ -917,7 +917,7 @@ describe('PGFilterTranslator', () => {
         translator.translate({
           nested: {
             field: { $regex: 'pattern', $options: 'i' },
-          },
+          } as any,
         }),
       ).toEqual({
         'nested.field': { $regex: '(?i)pattern' },

package/src/vector/filter.ts

@@ -1,5 +1,34 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, VectorFilter, OperatorSupport } from '@mastra/core/vector/filter';
+import type {
+  VectorFilter,
+  OperatorSupport,
+  OperatorValueMap,
+  LogicalOperatorValueMap,
+  BlacklistedRootOperators,
+  VectorFieldValue,
+} from '@mastra/core/vector/filter';
+
+type PGOperatorValueMap = Omit<OperatorValueMap, '$in' | '$all' | '$nin' | '$eq' | '$ne'> & {
+  $size: number;
+  $contains: VectorFieldValue | Record<string, unknown>;
+  $all: VectorFieldValue;
+  $in: VectorFieldValue;
+  $nin: VectorFieldValue;
+  $eq: VectorFieldValue;
+  $ne: VectorFieldValue;
+};
+
+type PGBlacklisted = BlacklistedRootOperators | '$contains' | '$size';
+
+type PGFilterValue = VectorFieldValue | RegExp;
+
+export type PGVectorFilter = VectorFilter<
+  keyof PGOperatorValueMap,
+  PGOperatorValueMap,
+  LogicalOperatorValueMap,
+  PGBlacklisted,
+  PGFilterValue
+>;
 
 /**
  * Translates MongoDB-style filters to PG compatible filters.
@@ -11,7 +40,7 @@ import type { FieldCondition, VectorFilter, OperatorSupport } from '@mastra/core
  * - Can take either a single condition or an array of conditions
  *
  */
-export class PGFilterTranslator extends BaseFilterTranslator {
+export class PGFilterTranslator extends BaseFilterTranslator<PGVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -19,7 +48,7 @@ export class PGFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: PGVectorFilter): PGVectorFilter {
     if (this.isEmpty(filter)) {
       return filter;
     }
@@ -27,7 +56,7 @@ export class PGFilterTranslator extends BaseFilterTranslator {
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition, currentPath: string = ''): any {
+  private translateNode(node: PGVectorFilter, currentPath: string = ''): any {
     // Helper to wrap result with path if needed
     const withPath = (result: any) => (currentPath ? { [currentPath]: result } : result);
 
@@ -49,14 +78,14 @@ export class PGFilterTranslator extends BaseFilterTranslator {
     const entries = Object.entries(node as Record<string, any>);
     const result: Record<string, any> = {};
 
-    if ('$options' in node && !('$regex' in node)) {
+    if (node && '$options' in node && !('$regex' in node)) {
       throw new Error('$options is not valid without $regex');
     }
 
     // Handle special regex object format
-    if ('$regex' in node) {
+    if (node && '$regex' in node) {
       const options = (node as any).$options || '';
-      return withPath(this.translateRegexPattern(node.$regex, options));
+      return withPath(this.translateRegexPattern((node as any).$regex, options));
     }
 
     // Process remaining entries

package/src/vector/index.test.ts

@@ -1288,7 +1288,7 @@ describe('PgVector', () => {
           vectorDB.query({
             indexName,
             queryVector: [1, 0, 0],
-            filter: { price: { $invalid: 100 } },
+            filter: { price: { $invalid: 100 } } as any,
           }),
         ).rejects.toThrow('Unsupported operator: $invalid');
       });
@@ -1567,7 +1567,7 @@ describe('PgVector', () => {
           vectorDB.query({
             indexName,
             queryVector: [1, 0, 0],
-            filter: { price: { $invalid: 100 } },
+            filter: { price: { $invalid: 100 } } as any,
           }),
         ).rejects.toThrow('Unsupported operator: $invalid');
       });