@mastra/mongodb 0.0.0-vnext-inngest-20250508122351 → 0.0.0-vnextAgentNetwork-20250527091247

package/src/vector/index.test.ts

@@ -60,7 +60,7 @@ async function createIndexAndWait(
   metric: 'cosine' | 'euclidean' | 'dotproduct',
 ) {
   await vectorDB.createIndex({ indexName, dimension, metric });
-  await vectorDB.waitForIndexReady(indexName);
+  await vectorDB.waitForIndexReady({ indexName });
   const created = await waitForCondition(
     async () => {
       const cols = await vectorDB.listIndexes();
@@ -75,7 +75,7 @@ async function createIndexAndWait(
 // Delete index (collection) and wait until it is removed
 async function deleteIndexAndWait(vectorDB: MongoDBVector, indexName: string) {
   try {
-    await vectorDB.deleteIndex(indexName);
+    await vectorDB.deleteIndex({ indexName });
     const deleted = await waitForCondition(
       async () => {
         const cols = await vectorDB.listIndexes();
@@ -105,7 +105,7 @@ describe('MongoDBVector Integration Tests', () => {
     // Cleanup any existing collections
     try {
       const cols = await vectorDB.listIndexes();
-      await Promise.all(cols.map(c => vectorDB.deleteIndex(c)));
+      await Promise.all(cols.map(c => vectorDB.deleteIndex({ indexName: c })));
       const deleted = await waitForCondition(async () => (await vectorDB.listIndexes()).length === 0, 30000, 2000);
       if (!deleted) throw new Error('Timed out waiting for collections to be deleted');
     } catch (error) {
@@ -119,12 +119,12 @@ describe('MongoDBVector Integration Tests', () => {
 
   afterAll(async () => {
     try {
-      await vectorDB.deleteIndex(testIndexName);
+      await vectorDB.deleteIndex({ indexName: testIndexName });
     } catch (error) {
       console.error('Failed to delete test collection:', error);
     }
     try {
-      await vectorDB.deleteIndex(testIndexName2);
+      await vectorDB.deleteIndex({ indexName: testIndexName2 });
     } catch (error) {
       console.error('Failed to delete test collection:', error);
     }
@@ -137,7 +137,7 @@ describe('MongoDBVector Integration Tests', () => {
     expect(cols).toContain(testIndexName);
 
     // Check stats (should be zero docs initially)
-    const initialStats = await vectorDB.describeIndex(testIndexName);
+    const initialStats = await vectorDB.describeIndex({ indexName: testIndexName });
     expect(initialStats).toEqual({ dimension: 4, metric: 'cosine', count: 0 });
 
     // Upsert 4 vectors with metadata
@@ -153,7 +153,7 @@ describe('MongoDBVector Integration Tests', () => {
 
     // Wait for the document count to update (increased delay to 5000ms)
     await new Promise(resolve => setTimeout(resolve, 5000));
-    const updatedStats = await vectorDB.describeIndex(testIndexName);
+    const updatedStats = await vectorDB.describeIndex({ indexName: testIndexName });
     expect(updatedStats.count).toEqual(4);
 
     // Query for similar vectors (delay again to allow for index update)
@@ -175,7 +175,7 @@ describe('MongoDBVector Integration Tests', () => {
     expect(filteredResults[0]?.metadata).toEqual({ label: 'vector2' });
 
     // Final stats should show > 0 documents
-    const finalStats = await vectorDB.describeIndex(testIndexName);
+    const finalStats = await vectorDB.describeIndex({ indexName: testIndexName });
     expect(finalStats.count).toBeGreaterThan(0);
   });
 
@@ -379,7 +379,11 @@ describe('MongoDBVector Integration Tests', () => {
       const idToBeUpdated = ids[0];
       const newVector = [1, 2, 3, 4];
       const newMetaData = { test: 'updates' };
-      await vectorDB.updateIndexById(indexName, idToBeUpdated, { vector: newVector, metadata: newMetaData });
+      await vectorDB.updateVector({
+        indexName,
+        id: idToBeUpdated,
+        update: { vector: newVector, metadata: newMetaData },
+      });
       await new Promise(resolve => setTimeout(resolve, 5000));
       const results = await vectorDB.query({
         indexName,
@@ -399,7 +403,7 @@ describe('MongoDBVector Integration Tests', () => {
       expect(ids).toHaveLength(4);
       const idToBeUpdated = ids[0];
       const newMetaData = { test: 'metadata only update' };
-      await vectorDB.updateIndexById(indexName, idToBeUpdated, { metadata: newMetaData });
+      await vectorDB.updateVector({ indexName, id: idToBeUpdated, update: { metadata: newMetaData } });
       await new Promise(resolve => setTimeout(resolve, 5000));
       const results = await vectorDB.query({
         indexName,
@@ -419,7 +423,7 @@ describe('MongoDBVector Integration Tests', () => {
       expect(ids).toHaveLength(4);
       const idToBeUpdated = ids[0];
       const newVector = [1, 2, 3, 4];
-      await vectorDB.updateIndexById(indexName, idToBeUpdated, { vector: newVector });
+      await vectorDB.updateVector({ indexName, id: idToBeUpdated, update: { vector: newVector } });
       await new Promise(resolve => setTimeout(resolve, 5000));
       const results = await vectorDB.query({
         indexName,
@@ -434,15 +438,24 @@ describe('MongoDBVector Integration Tests', () => {
       expect(updatedResult?.vector).toEqual(newVector);
     });
     it('should throw exception when no updates are given', async () => {
-      await expect(vectorDB.updateIndexById(indexName, 'nonexistent-id', {})).rejects.toThrow('No updates provided');
+      await expect(vectorDB.updateVector({ indexName, id: 'nonexistent-id', update: {} })).rejects.toThrow(
+        'No updates provided',
+      );
     });
     it('should delete the vector by id', async () => {
       const ids = await vectorDB.upsert({ indexName, vectors: testVectors });
       expect(ids).toHaveLength(4);
       const idToBeDeleted = ids[0];
-      await vectorDB.deleteIndexById(indexName, idToBeDeleted);
+
+      const initialStats = await vectorDB.describeIndex({ indexName });
+
+      await vectorDB.deleteVector({ indexName, id: idToBeDeleted });
       const results = await vectorDB.query({ indexName, queryVector: [1, 0, 0, 0], topK: 2 });
       expect(results.map(res => res.id)).not.toContain(idToBeDeleted);
+
+      await new Promise(resolve => setTimeout(resolve, 5000)); // Wait for count to update
+      const finalStats = await vectorDB.describeIndex({ indexName });
+      expect(finalStats.count).toBe(initialStats.count - 1);
     });
   });
 

package/src/vector/index.ts

@@ -5,9 +5,10 @@ import type {
   CreateIndexParams,
   UpsertVectorParams,
   QueryVectorParams,
-  ParamsToArgs,
-  QueryVectorArgs,
-  UpsertVectorArgs,
+  DescribeIndexParams,
+  DeleteIndexParams,
+  DeleteVectorParams,
+  UpdateVectorParams,
 } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import { MongoClient } from 'mongodb';
@@ -17,10 +18,6 @@ import { v4 as uuidv4 } from 'uuid';
 import { MongoDBFilterTranslator } from './filter';
 
 // Define necessary types and interfaces
-export type MongoDBUpsertArgs = [...UpsertVectorArgs, string[]?];
-export type MongoDBQueryArgs = [...QueryVectorArgs, string?];
-export type MongoDBUpsertParams = ParamsToArgs<MongoDBUpsertArgs>;
-
 export interface MongoDBUpsertVectorParams extends UpsertVectorParams {
   documents?: string[];
 }
@@ -29,6 +26,12 @@ export interface MongoDBQueryVectorParams extends QueryVectorParams {
   documentFilter?: VectorFilter;
 }
 
+export interface MongoDBIndexReadyParams {
+  indexName: string;
+  timeoutMs?: number;
+  checkIntervalMs?: number;
+}
+
 // Define the document interface
 interface MongoDBDocument extends Document {
   _id: string; // Explicitly declare '_id' as string
@@ -68,9 +71,7 @@ export class MongoDBVector extends MastraVector {
     await this.client.close();
   }
 
-  async createIndex(params: CreateIndexParams): Promise<void> {
-    const { indexName, dimension, metric = 'cosine' } = params;
-
+  async createIndex({ indexName, dimension, metric = 'cosine' }: CreateIndexParams): Promise<void> {
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error('Dimension must be a positive integer');
     }
@@ -118,7 +119,19 @@ export class MongoDBVector extends MastraVector {
     await collection.updateOne({ _id: '__index_metadata__' }, { $set: { dimension, metric } }, { upsert: true });
   }
 
-  async waitForIndexReady(indexName: string, timeoutMs: number = 60000, checkIntervalMs: number = 2000): Promise<void> {
+  /**
+   * Waits for the index to be ready.
+   *
+   * @param {string} indexName - The name of the index to wait for
+   * @param {number} timeoutMs - The maximum time in milliseconds to wait for the index to be ready (default: 60000)
+   * @param {number} checkIntervalMs - The interval in milliseconds at which to check if the index is ready (default: 2000)
+   * @returns A promise that resolves when the index is ready
+   */
+  async waitForIndexReady({
+    indexName,
+    timeoutMs = 60000,
+    checkIntervalMs = 2000,
+  }: MongoDBIndexReadyParams): Promise<void> {
     const collection = await this.getCollection(indexName, true);
     const indexNameInternal = `${indexName}_vector_index`;
 
@@ -135,15 +148,13 @@ export class MongoDBVector extends MastraVector {
     throw new Error(`Index "${indexNameInternal}" did not become ready within timeout`);
   }
 
-  async upsert(params: MongoDBUpsertVectorParams): Promise<string[]> {
-    const { indexName, vectors, metadata, ids, documents } = params;
-
+  async upsert({ indexName, vectors, metadata, ids, documents }: MongoDBUpsertVectorParams): Promise<string[]> {
     const collection = await this.getCollection(indexName);
 
     this.collectionForValidation = collection;
 
     // Get index stats to check dimension
-    const stats = await this.describeIndex(indexName);
+    const stats = await this.describeIndex({ indexName });
 
     // Validate vector dimensions
     await this.validateVectorDimensions(vectors, stats.dimension);
@@ -187,9 +198,14 @@ export class MongoDBVector extends MastraVector {
     return generatedIds;
   }
 
-  async query(params: MongoDBQueryVectorParams): Promise<QueryResult[]> {
-    const { indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter } = params;
-
+  async query({
+    indexName,
+    queryVector,
+    topK = 10,
+    filter,
+    includeVector = false,
+    documentFilter,
+  }: MongoDBQueryVectorParams): Promise<QueryResult[]> {
     const collection = await this.getCollection(indexName, true);
     const indexNameInternal = `${indexName}_vector_index`;
 
@@ -255,7 +271,13 @@ export class MongoDBVector extends MastraVector {
     return collections.map(col => col.name);
   }
 
-  async describeIndex(indexName: string): Promise<IndexStats> {
+  /**
+   * Retrieves statistics about a vector index.
+   *
+   * @param {string} indexName - The name of the index to describe
+   * @returns A promise that resolves to the index statistics including dimension, count and metric
+   */
+  async describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats> {
     const collection = await this.getCollection(indexName, true);
 
     // Get the count of documents, excluding the metadata document
@@ -273,7 +295,7 @@ export class MongoDBVector extends MastraVector {
     };
   }
 
-  async deleteIndex(indexName: string): Promise<void> {
+  async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
     const collection = await this.getCollection(indexName, false); // Do not throw error if collection doesn't exist
     if (collection) {
       await collection.drop();
@@ -284,45 +306,64 @@ export class MongoDBVector extends MastraVector {
     }
   }
 
-  async updateIndexById(
-    indexName: string,
-    id: string,
-    update: { vector?: number[]; metadata?: Record<string, any> },
-  ): Promise<void> {
-    if (!update.vector && !update.metadata) {
-      throw new Error('No updates provided');
-    }
+  /**
+   * Updates a vector by its ID with the provided vector and/or metadata.
+   * @param indexName - The name of the index containing the vector.
+   * @param id - The ID of the vector to update.
+   * @param update - An object containing the vector and/or metadata to update.
+   * @param update.vector - An optional array of numbers representing the new vector.
+   * @param update.metadata - An optional record containing the new metadata.
+   * @returns A promise that resolves when the update is complete.
+   * @throws Will throw an error if no updates are provided or if the update operation fails.
+   */
+  async updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void> {
+    try {
+      if (!update.vector && !update.metadata) {
+        throw new Error('No updates provided');
+      }
 
-    const collection = await this.getCollection(indexName, true);
-    const updateDoc: Record<string, any> = {};
+      const collection = await this.getCollection(indexName, true);
+      const updateDoc: Record<string, any> = {};
 
-    if (update.vector) {
-      updateDoc[this.embeddingFieldName] = update.vector;
-    }
+      if (update.vector) {
+        const stats = await this.describeIndex({ indexName });
+        await this.validateVectorDimensions([update.vector], stats.dimension);
+        updateDoc[this.embeddingFieldName] = update.vector;
+      }
 
-    if (update.metadata) {
-      // Normalize metadata in updates too
-      const normalizedMeta = Object.keys(update.metadata).reduce(
-        (acc, key) => {
-          acc[key] =
-            update.metadata![key] instanceof Date ? update.metadata![key].toISOString() : update.metadata![key];
-          return acc;
-        },
-        {} as Record<string, any>,
-      );
+      if (update.metadata) {
+        // Normalize metadata in updates too
+        const normalizedMeta = Object.keys(update.metadata).reduce(
+          (acc, key) => {
+            acc[key] =
+              update.metadata![key] instanceof Date ? update.metadata![key].toISOString() : update.metadata![key];
+            return acc;
+          },
+          {} as Record<string, any>,
+        );
+
+        updateDoc[this.metadataFieldName] = normalizedMeta;
+      }
 
-      updateDoc[this.metadataFieldName] = normalizedMeta;
+      await collection.findOneAndUpdate({ _id: id }, { $set: updateDoc });
+    } catch (error: any) {
+      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
     }
-
-    await collection.findOneAndUpdate({ _id: id }, { $set: updateDoc });
   }
 
-  async deleteIndexById(indexName: string, id: string): Promise<void> {
+  /**
+   * Deletes a vector by its ID.
+   * @param indexName - The name of the index containing the vector.
+   * @param id - The ID of the vector to delete.
+   * @returns A promise that resolves when the deletion is complete.
+   * @throws Will throw an error if the deletion operation fails.
+   */
+  async deleteVector({ indexName, id }: DeleteVectorParams): Promise<void> {
     try {
       const collection = await this.getCollection(indexName, true);
       await collection.deleteOne({ _id: id });
     } catch (error: any) {
-      throw new Error(`Failed to delete index by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
     }
   }
 

package/docker-compose.yml

@@ -1,8 +0,0 @@
-services:
-  mongodb:
-    image: mongodb/mongodb-atlas-local
-    environment:
-      MONGODB_INITDB_ROOT_USERNAME: mongodb
-      MONGODB_INITDB_ROOT_PASSWORD: mongodb
-    ports:
-      - 27018:27017