@mastra/mongodb 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/index.js

@@ -11,7 +11,7 @@ import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // package.json
 var package_default = {
-  version: "1.0.0-beta.0"};
+  version: "1.0.0-beta.2"};
 var MongoDBFilterTranslator = class extends BaseFilterTranslator {
   getSupportedOperators() {
     return {
@@ -353,12 +353,17 @@ var MongoDBVector = class extends MastraVector {
         limit: topK
       };
       if (Object.keys(combinedFilter).length > 0) {
-        const candidateIds = await collection.aggregate([{ $match: combinedFilter }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
+        const filterWithExclusion = {
+          $and: [{ _id: { $ne: "__index_metadata__" } }, combinedFilter]
+        };
+        const candidateIds = await collection.aggregate([{ $match: filterWithExclusion }, { $project: { _id: 1 } }]).map((doc) => doc._id).toArray();
         if (candidateIds.length > 0) {
           vectorSearch.filter = { _id: { $in: candidateIds } };
         } else {
           return [];
         }
+      } else {
+        vectorSearch.filter = { _id: { $ne: "__index_metadata__" } };
       }
       const pipeline = [
         {
@@ -479,7 +484,26 @@ var MongoDBVector = class extends MastraVector {
    * @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 }) {
+  async updateVector(params) {
+    const { indexName, update } = params;
+    if ("id" in params && params.id && "filter" in params && params.filter) {
+      throw new MastraError({
+        id: "STORAGE_MONGODB_VECTOR_UPDATE_MUTUALLY_EXCLUSIVE_PARAMS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { indexName },
+        text: "id and filter are mutually exclusive - provide only one"
+      });
+    }
+    if (!("id" in params || "filter" in params) || !params.id && !params.filter) {
+      throw new MastraError({
+        id: "STORAGE_MONGODB_VECTOR_UPDATE_MISSING_PARAMS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "Either id or filter must be provided",
+        details: { indexName }
+      });
+    }
     try {
       if (!update.vector && !update.metadata) {
         throw new Error("No updates provided");
@@ -501,17 +525,49 @@ var MongoDBVector = class extends MastraVector {
         );
         updateDoc[this.metadataFieldName] = normalizedMeta;
       }
-      await collection.findOneAndUpdate({ _id: id }, { $set: updateDoc });
+      if ("id" in params && params.id) {
+        await collection.findOneAndUpdate({ _id: params.id }, { $set: updateDoc });
+      } else if ("filter" in params && params.filter) {
+        const filter = params.filter;
+        if (!filter || Object.keys(filter).length === 0) {
+          throw new MastraError({
+            id: "STORAGE_MONGODB_VECTOR_UPDATE_EMPTY_FILTER",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { indexName },
+            text: "Cannot update with empty filter"
+          });
+        }
+        const mongoFilter = this.transformFilter(filter);
+        const transformedFilter = this.transformMetadataFilter(mongoFilter);
+        if (!transformedFilter || Object.keys(transformedFilter).length === 0) {
+          throw new MastraError({
+            id: "STORAGE_MONGODB_VECTOR_UPDATE_INVALID_FILTER",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { indexName },
+            text: "Filter produced empty query"
+          });
+        }
+        await collection.updateMany(transformedFilter, { $set: updateDoc });
+      }
     } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      const errorDetails = { indexName };
+      if ("id" in params && params.id) {
+        errorDetails.id = params.id;
+      }
+      if ("filter" in params && params.filter) {
+        errorDetails.filter = JSON.stringify(params.filter);
+      }
       throw new MastraError(
         {
           id: "STORAGE_MONGODB_VECTOR_UPDATE_VECTOR_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            id
-          }
+          details: errorDetails
         },
         error
       );
@@ -543,6 +599,83 @@ var MongoDBVector = class extends MastraVector {
       );
     }
   }
+  async deleteVectors({ indexName, filter, ids }) {
+    if (!filter && !ids) {
+      throw new MastraError({
+        id: "STORAGE_MONGODB_VECTOR_DELETE_MISSING_PARAMS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { indexName },
+        text: "Either filter or ids must be provided"
+      });
+    }
+    if (filter && ids) {
+      throw new MastraError({
+        id: "STORAGE_MONGODB_VECTOR_DELETE_CONFLICTING_PARAMS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { indexName },
+        text: "Cannot provide both filter and ids - they are mutually exclusive"
+      });
+    }
+    try {
+      const collection = await this.getCollection(indexName, true);
+      if (ids) {
+        if (ids.length === 0) {
+          throw new MastraError({
+            id: "STORAGE_MONGODB_VECTOR_DELETE_EMPTY_IDS",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { indexName },
+            text: "Cannot delete with empty ids array"
+          });
+        }
+        await collection.deleteMany({ _id: { $in: ids } });
+      } else {
+        if (!filter || Object.keys(filter).length === 0) {
+          throw new MastraError({
+            id: "STORAGE_MONGODB_VECTOR_DELETE_EMPTY_FILTER",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { indexName },
+            text: "Cannot delete with empty filter"
+          });
+        }
+        const mongoFilter = this.transformFilter(filter);
+        const transformedFilter = this.transformMetadataFilter(mongoFilter);
+        if (!transformedFilter || Object.keys(transformedFilter).length === 0) {
+          throw new MastraError({
+            id: "STORAGE_MONGODB_VECTOR_DELETE_INVALID_FILTER",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { indexName },
+            text: "Filter produced empty query"
+          });
+        }
+        const finalFilter = {
+          $and: [{ _id: { $ne: "__index_metadata__" } }, transformedFilter]
+        };
+        await collection.deleteMany(finalFilter);
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: "STORAGE_MONGODB_VECTOR_DELETE_VECTORS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error
+      );
+    }
+  }
   // Private methods
   async getCollection(indexName, throwIfNotExists = true) {
     if (this.collections.has(indexName)) {
@@ -590,16 +723,26 @@ var MongoDBVector = class extends MastraVector {
    */
   transformMetadataFilter(filter) {
     if (!filter || typeof filter !== "object") return filter;
+    if (Array.isArray(filter)) {
+      return filter.map((item) => this.transformMetadataFilter(item));
+    }
     const transformed = {};
     for (const [key, value] of Object.entries(filter)) {
       if (key.startsWith("$")) {
         if (Array.isArray(value)) {
           transformed[key] = value.map((item) => this.transformMetadataFilter(item));
-        } else {
+        } else if (typeof value === "object" && value !== null) {
           transformed[key] = this.transformMetadataFilter(value);
+        } else {
+          transformed[key] = value;
         }
       } else if (key.startsWith("metadata.")) {
-        transformed[key] = value;
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          const hasOperator = Object.keys(value).some((k) => k.startsWith("$"));
+          transformed[key] = hasOperator ? value : value;
+        } else {
+          transformed[key] = value;
+        }
       } else if (this.isMetadataField(key)) {
         transformed[`metadata.${key}`] = value;
       } else {
@@ -2244,6 +2387,9 @@ var WorkflowsStorageMongoDB = class extends WorkflowsStorage {
       if (options.workflowName) {
         query["workflow_name"] = options.workflowName;
       }
+      if (options.status) {
+        query["snapshot.status"] = options.status;
+      }
       if (options.fromDate) {
         query["createdAt"] = { $gte: options.fromDate };
       }