@mastra/astra 0.10.2 → 0.10.3-alpha.1

package/dist/index.js

@@ -1,4 +1,5 @@
 import { DataAPIClient, UUID } from '@datastax/astra-db-ts';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
@@ -68,15 +69,32 @@ var AstraVector = class extends MastraVector {
    */
   async createIndex({ indexName, dimension, metric = "cosine" }) {
     if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
+      throw new MastraError({
+        id: "ASTRA_VECTOR_CREATE_INDEX_INVALID_DIMENSION",
+        text: "Dimension must be a positive integer",
+        domain: ErrorDomain.MASTRA_VECTOR,
+        category: ErrorCategory.USER
+      });
+    }
+    try {
+      await this.#db.createCollection(indexName, {
+        vector: {
+          dimension,
+          metric: metricMap[metric]
+        },
+        checkExists: false
+      });
+    } catch (error) {
+      new MastraError(
+        {
+          id: "ASTRA_VECTOR_CREATE_INDEX_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
-    await this.#db.createCollection(indexName, {
-      vector: {
-        dimension,
-        metric: metricMap[metric]
-      },
-      checkExists: false
-    });
   }
   /**
    * Inserts or updates vectors in the specified collection.
@@ -95,7 +113,19 @@ var AstraVector = class extends MastraVector {
       $vector: vector,
       metadata: metadata?.[i] || {}
     }));
-    await collection.insertMany(records);
+    try {
+      await collection.insertMany(records);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_UPSERT_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
     return vectorIds;
   }
   transformFilter(filter) {
@@ -121,29 +151,52 @@ var AstraVector = class extends MastraVector {
   }) {
     const collection = this.#db.collection(indexName);
     const translatedFilter = this.transformFilter(filter);
-    const cursor = collection.find(translatedFilter ?? {}, {
-      sort: { $vector: queryVector },
-      limit: topK,
-      includeSimilarity: true,
-      projection: {
-        $vector: includeVector ? true : false
-      }
-    });
-    const results = await cursor.toArray();
-    return results.map((result) => ({
-      id: result.id,
-      score: result.$similarity,
-      metadata: result.metadata,
-      ...includeVector && { vector: result.$vector }
-    }));
+    try {
+      const cursor = collection.find(translatedFilter ?? {}, {
+        sort: { $vector: queryVector },
+        limit: topK,
+        includeSimilarity: true,
+        projection: {
+          $vector: includeVector ? true : false
+        }
+      });
+      const results = await cursor.toArray();
+      return results.map((result) => ({
+        id: result.id,
+        score: result.$similarity,
+        metadata: result.metadata,
+        ...includeVector && { vector: result.$vector }
+      }));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_QUERY_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Lists all collections in the database.
    *
    * @returns {Promise<string[]>} A promise that resolves to an array of collection names.
    */
-  listIndexes() {
-    return this.#db.listCollections({ nameOnly: true });
+  async listIndexes() {
+    try {
+      return await this.#db.listCollections({ nameOnly: true });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_LIST_INDEXES_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -153,16 +206,29 @@ var AstraVector = class extends MastraVector {
    */
   async describeIndex({ indexName }) {
     const collection = this.#db.collection(indexName);
-    const optionsPromise = collection.options();
-    const countPromise = collection.countDocuments({}, 100);
-    const [options, count] = await Promise.all([optionsPromise, countPromise]);
-    const keys = Object.keys(metricMap);
-    const metric = keys.find((key) => metricMap[key] === options.vector?.metric);
-    return {
-      dimension: options.vector?.dimension,
-      metric,
-      count
-    };
+    try {
+      const optionsPromise = collection.options();
+      const countPromise = collection.countDocuments({}, 100);
+      const [options, count] = await Promise.all([optionsPromise, countPromise]);
+      const keys = Object.keys(metricMap);
+      const metric = keys.find((key) => metricMap[key] === options.vector?.metric);
+      return {
+        dimension: options.vector?.dimension,
+        metric,
+        count
+      };
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_DESCRIBE_INDEX_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Deletes the specified collection.
@@ -172,7 +238,19 @@ var AstraVector = class extends MastraVector {
    */
   async deleteIndex({ indexName }) {
     const collection = this.#db.collection(indexName);
-    await collection.drop();
+    try {
+      await collection.drop();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_DELETE_INDEX_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -185,10 +263,16 @@ var AstraVector = class extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: "ASTRA_VECTOR_UPDATE_NO_PAYLOAD",
+        text: "No updates provided for vector",
+        domain: ErrorDomain.MASTRA_VECTOR,
+        category: ErrorCategory.USER,
+        details: { indexName, id }
+      });
+    }
     try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No updates provided");
-      }
       const collection = this.#db.collection(indexName);
       const updateDoc = {};
       if (update.vector) {
@@ -199,7 +283,16 @@ var AstraVector = class extends MastraVector {
       }
       await collection.findOneAndUpdate({ id }, { $set: updateDoc });
     } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_UPDATE_FAILED_UNHANDLED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
   /**
@@ -214,7 +307,16 @@ var AstraVector = class extends MastraVector {
       const collection = this.#db.collection(indexName);
       await collection.deleteOne({ id });
     } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_DELETE_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/astra",
-  "version": "0.10.2",
+  "version": "0.10.3-alpha.1",
   "description": "Astra DB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -24,13 +24,13 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
-    "@types/node": "^20.17.57",
-    "eslint": "^9.28.0",
+    "@types/node": "^20.19.0",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "@internal/lint": "0.0.11",
-    "@mastra/core": "0.10.4"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@mastra/core": "0.10.7-alpha.2",
+    "@internal/lint": "0.0.13"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { AstraVectorFilter } from './filter';
 import { AstraFilterTranslator } from './filter';
 
 describe('AstraFilterTranslator', () => {
@@ -12,12 +13,12 @@ describe('AstraFilterTranslator', () => {
   // Basic Filter Operations
   describe('basic operations', () => {
     it('handles simple equality', () => {
-      const filter = { field: 'value' };
+      const filter: AstraVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles comparison operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         age: { $gt: 25 },
         score: { $lte: 100 },
       };
@@ -25,7 +26,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles valid multiple operators on same field', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         price: { $gt: 100, $lt: 200 },
         quantity: { $gte: 10, $lte: 20 },
       };
@@ -33,7 +34,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles null values correctly', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         field: null,
         other: { $eq: null },
       };
@@ -41,7 +42,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('throws on unsupported combinations', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         field: { $gt: 100, $lt: 200 },
       };
       expect(translator.translate(filter)).toEqual(filter);
@@ -51,14 +52,14 @@ describe('AstraFilterTranslator', () => {
   // Array Operations
   describe('array operations', () => {
     it('handles array operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         tags: { $all: ['tag1', 'tag2'] },
         categories: { $in: ['A', 'B'] },
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
     it('handles empty array values', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         tags: { $in: [] },
         categories: { $all: [] },
       };
@@ -66,7 +67,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles nested array operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $and: [{ tags: { $all: ['tag1', 'tag2'] } }, { 'nested.array': { $in: [1, 2, 3] } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
@@ -76,14 +77,14 @@ describe('AstraFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('handles logical operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $or: [{ status: 'active' }, { age: { $gt: 25 } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $and: [
           { status: 'active' },
           { $or: [{ category: { $in: ['A', 'B'] } }, { $and: [{ price: { $gt: 100 } }, { stock: { $lt: 50 } }] }] },
@@ -93,7 +94,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles empty conditions in logical operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $and: [],
         $or: [{}],
         field: 'value',
@@ -147,7 +148,7 @@ describe('AstraFilterTranslator', () => {
 
       expect(() =>
         translator.translate({
-          $or: [{ $in: ['value1', 'value2'] }],
+          $or: [{ $in: ['value1', 'value2'] as any }],
         }),
       ).toThrow(/Logical operators must contain field conditions/);
     });
@@ -158,7 +159,7 @@ describe('AstraFilterTranslator', () => {
           field: {
             $gt: {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            },
+            } as any,
           },
         }),
       ).toThrow();
@@ -169,7 +170,7 @@ describe('AstraFilterTranslator', () => {
             $in: [
               {
                 $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-              },
+              } as any,
             ],
           },
         }),
@@ -182,7 +183,7 @@ describe('AstraFilterTranslator', () => {
           field: {
             $gt: {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            },
+            } as any,
           },
         }),
       ).toThrow();
@@ -200,7 +201,7 @@ describe('AstraFilterTranslator', () => {
 
     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', () => {
@@ -211,7 +212,7 @@ describe('AstraFilterTranslator', () => {
   // Nested Objects and Fields
   describe('nested objects and fields', () => {
     it('handles nested objects', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         'user.profile.age': { $gt: 25 },
         'user.status': 'active',
       };
@@ -219,7 +220,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles deeply nested field paths', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         'user.profile.address.city': { $eq: 'New York' },
         'deep.nested.field': { $gt: 100 },
       };
@@ -227,38 +228,28 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('preserves nested empty objects', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         status: 'active',
         metadata: {},
-        user: {
-          profile: {},
-          settings: { theme: null },
-        },
+        'user.profile': {},
+        'usersettings.theme': null,
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles mix of operators and empty objects', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         tags: { $in: ['a', 'b'] },
         metadata: {},
-        nested: {
-          field: { $eq: 'value' },
-          empty: {},
-        },
+        'nested.field': { $eq: 'value' },
+        'nested.empty': {},
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles deeply nested operators', () => {
-      const filter = {
-        user: {
-          profile: {
-            preferences: {
-              theme: { $in: ['dark', 'light'] },
-            },
-          },
-        },
+      const filter: AstraVectorFilter = {
+        'user.profile.preferences.theme': { $in: ['dark', 'light'] },
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
@@ -268,13 +259,13 @@ describe('AstraFilterTranslator', () => {
   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: AstraVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({
         timestamp: { $gt: date.toISOString() },
       });
@@ -293,7 +284,7 @@ describe('AstraFilterTranslator', () => {
 
   describe('operator validation', () => {
     it('ensure all operator filters are supported', () => {
-      const supportedFilters = [
+      const supportedFilters: AstraVectorFilter[] = [
         // Basic comparison operators
         { field: { $eq: 'value' } },
         { field: { $ne: 'value' } },
@@ -313,11 +304,9 @@ describe('AstraFilterTranslator', () => {
         { $and: [{ field1: 'value1' }, { field2: 'value2' }] },
         { $or: [{ field1: 'value1' }, { field2: 'value2' }] },
 
-        { $and: { field: 'value' } },
-        { $or: { field: 'value' } },
         { $not: { field: 'value' } },
 
-        { $or: [{ $and: { field1: 'value1' } }, { $not: { field2: 'value2' } }] },
+        { $or: [{ $and: [{ field1: 'value1' }] }, { $not: { field2: 'value2' } }] },
 
         { field: { $not: { $eq: 'value' } } },
         { field: { $not: { $in: ['value1', 'value2'] } } },
@@ -333,16 +322,16 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('throws on unsupported operators', () => {
-      expect(() => translator.translate({ field: { $regex: 'value' } })).toThrow('Unsupported operator: $regex');
-      const filter = { field: /pattern/i };
+      expect(() => translator.translate({ field: { $regex: 'value' } as any })).toThrow('Unsupported operator: $regex');
+      const filter: any = { field: /pattern/i };
       expect(() => translator.translate(filter)).toThrow();
-      expect(() => translator.translate({ $nor: [{ field: 'value' }] })).toThrow('Unsupported operator: $nor');
-      expect(() => translator.translate({ field: { $elemMatch: { $gt: 5 } } })).toThrow(
+      expect(() => translator.translate({ $nor: [{ field: 'value' }] } as any)).toThrow('Unsupported operator: $nor');
+      expect(() => translator.translate({ field: { $elemMatch: { $gt: 5 } } } as any)).toThrow(
         'Unsupported operator: $elemMatch',
       );
     });
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $exists: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $exists: true }];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);
@@ -350,7 +339,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('allows logical operators at top level', () => {
-      const validFilters = [
+      const validFilters: AstraVectorFilter[] = [
         { $and: [{ field: 'value' }] },
         { $or: [{ field: 'value' }] },
         { $not: { field: 'value' } },

package/src/vector/filter.ts

@@ -1,12 +1,34 @@
 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,
+} from '@mastra/core/vector/filter';
+
+type AstraOperatorValueMap = Omit<OperatorValueMap, '$elemMatch' | '$regex' | '$options'> & {
+  $size: number; // Astra-specific
+};
+
+type AstraLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+type AstraBlacklisted = BlacklistedRootOperators | '$nor' | '$size';
+
+export type AstraVectorFilter = VectorFilter<
+  keyof AstraOperatorValueMap,
+  AstraOperatorValueMap,
+  AstraLogicalOperatorValueMap,
+  AstraBlacklisted
+>;
 
 /**
  * Translator for Astra DB filter queries.
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class AstraFilterTranslator extends BaseFilterTranslator {
+export class AstraFilterTranslator extends BaseFilterTranslator<AstraVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -17,14 +39,14 @@ export class AstraFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: AstraVectorFilter): AstraVectorFilter {
     if (this.isEmpty(filter)) return filter;
     this.validateFilter(filter);
 
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition): any {
+  private translateNode(node: AstraVectorFilter): any {
     // Handle primitive values and arrays
     if (this.isRegex(node)) {
       throw new Error('Regex is not supported in Astra DB');

package/src/vector/index.test.ts

@@ -297,7 +297,7 @@ describe.skip('AstraVector Integration Tests', () => {
         vectorDB.query({
           indexName: testIndexName2,
           queryVector: [1, 0, 0, 0],
-          filter: { tags: { $all: 'not-an-array' } },
+          filter: { tags: { $all: 'not-an-array' as any } },
         }),
       ).rejects.toThrow();
     });
@@ -307,15 +307,7 @@ describe.skip('AstraVector Integration Tests', () => {
         vectorDB.query({
           indexName: testIndexName2,
           queryVector: [1, 0, 0, 0],
-          filter: { tags: { $in: null } },
-        }),
-      ).rejects.toThrow();
-
-      await expect(
-        vectorDB.query({
-          indexName: testIndexName2,
-          queryVector: [1, 0, 0, 0],
-          filter: { tags: { $all: 'not-an-array' } },
+          filter: { tags: { $in: null as any } },
         }),
       ).rejects.toThrow();
     });
@@ -327,7 +319,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $in: val } },
+            filter: { field: { $in: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -340,7 +332,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $nin: val } },
+            filter: { field: { $nin: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -353,7 +345,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $all: val } },
+            filter: { field: { $all: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -366,7 +358,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $exists: val } },
+            filter: { field: { $exists: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -395,9 +387,9 @@ describe.skip('AstraVector Integration Tests', () => {
           indexName: testIndexName2,
           queryVector: [1, 0, 0, 0],
           filter: {
-            field1: { $in: 'not-array' },
-            field2: { $exists: 'not-boolean' },
-            field3: { $gt: 'not-number' },
+            field1: { $in: 'not-array' as any },
+            field2: { $exists: 'not-boolean' as any },
+            field3: { $gt: 'not-number' as any },
           },
         }),
       ).rejects.toThrow();