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

package/src/storage/index.ts

@@ -1,5 +1,6 @@
 import { MessageList } from '@mastra/core/agent';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
+import { ErrorDomain, ErrorCategory, MastraError } from '@mastra/core/error';
 import type { MetricResult, TestInfo } from '@mastra/core/eval';
 import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
 import type {
@@ -48,15 +49,27 @@ export class MongoDBStore extends MastraStorage {
     super({ name: 'MongoDBStore' });
     this.#isConnected = false;
 
-    if (!config.url?.trim().length) {
-      throw new Error(
-        'MongoDBStore: url must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults.',
-      );
-    }
+    try {
+      if (!config.url?.trim().length) {
+        throw new Error(
+          'MongoDBStore: url must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults.',
+        );
+      }
 
-    if (!config.dbName?.trim().length) {
-      throw new Error(
-        'MongoDBStore: dbName must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults.',
+      if (!config.dbName?.trim().length) {
+        throw new Error(
+          'MongoDBStore: dbName must be provided and cannot be empty. Passing an empty string may cause fallback to local MongoDB defaults.',
+        );
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { url: config.url, dbName: config.dbName },
+        },
+        error,
       );
     }
 
@@ -104,7 +117,17 @@ export class MongoDBStore extends MastraStorage {
       await collection.deleteMany({});
     } catch (error) {
       if (error instanceof Error) {
-        this.logger.error(error.message);
+        const matstraError = new MastraError(
+          {
+            id: 'STORAGE_MONGODB_STORE_CLEAR_TABLE_FAILED',
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { tableName },
+          },
+          error,
+        );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
       }
     }
   }
@@ -114,8 +137,19 @@ export class MongoDBStore extends MastraStorage {
       const collection = await this.getCollection(tableName);
       await collection.insertOne(record);
     } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+      if (error instanceof Error) {
+        const matstraError = new MastraError(
+          {
+            id: 'STORAGE_MONGODB_STORE_INSERT_FAILED',
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { tableName },
+          },
+          error,
+        );
+        this.logger.error(matstraError.message);
+        this.logger?.trackException(matstraError);
+      }
     }
   }
 
@@ -128,8 +162,15 @@ export class MongoDBStore extends MastraStorage {
       const collection = await this.getCollection(tableName);
       await collection.insertMany(records);
     } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_BATCH_INSERT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName },
+        },
+        error,
+      );
     }
   }
 
@@ -139,8 +180,15 @@ export class MongoDBStore extends MastraStorage {
       const collection = await this.getCollection(tableName);
       return (await collection.find(keys).toArray()) as R;
     } catch (error) {
-      this.logger.error(`Error loading ${tableName} with keys ${JSON.stringify(keys)}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_LOAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName },
+        },
+        error,
+      );
     }
   }
 
@@ -157,8 +205,15 @@ export class MongoDBStore extends MastraStorage {
         metadata: typeof result.metadata === 'string' ? JSON.parse(result.metadata) : result.metadata,
       };
     } catch (error) {
-      this.logger.error(`Error loading thread with ID ${threadId}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_GET_THREAD_BY_ID_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId },
+        },
+        error,
+      );
     }
   }
 
@@ -175,8 +230,15 @@ export class MongoDBStore extends MastraStorage {
         metadata: typeof result.metadata === 'string' ? JSON.parse(result.metadata) : result.metadata,
       }));
     } catch (error) {
-      this.logger.error(`Error loading threads by resourceId ${resourceId}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId },
+        },
+        error,
+      );
     }
   }
 
@@ -195,8 +257,15 @@ export class MongoDBStore extends MastraStorage {
       );
       return thread;
     } catch (error) {
-      this.logger.error(`Error saving thread ${thread.id}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_SAVE_THREAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id },
+        },
+        error,
+      );
     }
   }
 
@@ -211,7 +280,13 @@ export class MongoDBStore extends MastraStorage {
   }): Promise<StorageThreadType> {
     const thread = await this.getThreadById({ threadId: id });
     if (!thread) {
-      throw new Error(`Thread ${id} not found`);
+      throw new MastraError({
+        id: 'STORAGE_MONGODB_STORE_UPDATE_THREAD_NOT_FOUND',
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { threadId: id },
+        text: `Thread ${id} not found`,
+      });
     }
 
     const updatedThread = {
@@ -235,8 +310,15 @@ export class MongoDBStore extends MastraStorage {
         },
       );
     } catch (error) {
-      this.logger.error(`Error updating thread ${id}:) ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_UPDATE_THREAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: id },
+        },
+        error,
+      );
     }
 
     return updatedThread;
@@ -251,8 +333,15 @@ export class MongoDBStore extends MastraStorage {
       const collectionThreads = await this.getCollection(TABLE_THREADS);
       await collectionThreads.deleteOne({ id: threadId });
     } catch (error) {
-      this.logger.error(`Error deleting thread ${threadId}: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_DELETE_THREAD_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId },
+        },
+        error,
+      );
     }
   }
 
@@ -266,7 +355,7 @@ export class MongoDBStore extends MastraStorage {
     format?: 'v1' | 'v2';
   }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
     try {
-      const limit = typeof selectBy?.last === 'number' ? selectBy.last : 40;
+      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
       const include = selectBy?.include || [];
       let messages: MastraMessageV2[] = [];
       let allMessages: MastraMessageV2[] = [];
@@ -323,8 +412,15 @@ export class MongoDBStore extends MastraStorage {
       if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
     } catch (error) {
-      this.logger.error('Error getting messages:', error as Error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_GET_MESSAGES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId },
+        },
+        error,
+      );
     }
   }
 
@@ -366,7 +462,15 @@ export class MongoDBStore extends MastraStorage {
       const threadsCollection = await this.getCollection(TABLE_THREADS);
 
       await Promise.all([
-        collection.insertMany(messagesToInsert),
+        collection.bulkWrite(
+          messagesToInsert.map(msg => ({
+            updateOne: {
+              filter: { id: msg.id },
+              update: { $set: msg },
+              upsert: true,
+            },
+          })),
+        ),
         threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: new Date() } }),
       ]);
 
@@ -404,7 +508,7 @@ export class MongoDBStore extends MastraStorage {
 
     const query: any = {};
     if (name) {
-      query['name'] = `%${name}%`;
+      query['name'] = new RegExp(name);
     }
 
     if (scope) {
@@ -412,9 +516,9 @@ export class MongoDBStore extends MastraStorage {
     }
 
     if (attributes) {
-      Object.keys(attributes).forEach(key => {
-        query[`attributes.${key}`] = attributes[key];
-      });
+      query['$and'] = Object.entries(attributes).map(([key, value]) => ({
+        attributes: new RegExp(`\"${key}\":\"${value}\"`),
+      }));
     }
 
     if (filters) {
@@ -423,31 +527,42 @@ export class MongoDBStore extends MastraStorage {
       });
     }
 
-    const collection = await this.getCollection(TABLE_TRACES);
-    const result = await collection
-      .find(query, {
-        sort: { startTime: -1 },
-      })
-      .limit(limit)
-      .skip(offset)
-      .toArray();
-
-    return result.map(row => ({
-      id: row.id,
-      parentSpanId: row.parentSpanId,
-      traceId: row.traceId,
-      name: row.name,
-      scope: row.scope,
-      kind: row.kind,
-      status: safelyParseJSON(row.status as string),
-      events: safelyParseJSON(row.events as string),
-      links: safelyParseJSON(row.links as string),
-      attributes: safelyParseJSON(row.attributes as string),
-      startTime: row.startTime,
-      endTime: row.endTime,
-      other: safelyParseJSON(row.other as string),
-      createdAt: row.createdAt,
-    })) as any;
+    try {
+      const collection = await this.getCollection(TABLE_TRACES);
+      const result = await collection
+        .find(query, {
+          sort: { startTime: -1 },
+        })
+        .limit(limit)
+        .skip(offset)
+        .toArray();
+
+      return result.map(row => ({
+        id: row.id,
+        parentSpanId: row.parentSpanId,
+        traceId: row.traceId,
+        name: row.name,
+        scope: row.scope,
+        kind: row.kind,
+        status: safelyParseJSON(row.status as string),
+        events: safelyParseJSON(row.events as string),
+        links: safelyParseJSON(row.links as string),
+        attributes: safelyParseJSON(row.attributes as string),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: safelyParseJSON(row.other as string),
+        createdAt: row.createdAt,
+      })) as any;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_GET_TRACES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
+    }
   }
 
   async getWorkflowRuns({
@@ -487,46 +602,57 @@ export class MongoDBStore extends MastraStorage {
       }
     }
 
-    const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
-    let total = 0;
-    // Only get total count when using pagination
-    if (limit !== undefined && offset !== undefined) {
-      total = await collection.countDocuments(query);
-    }
+    try {
+      const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
+      let total = 0;
+      // Only get total count when using pagination
+      if (limit !== undefined && offset !== undefined) {
+        total = await collection.countDocuments(query);
+      }
 
-    // Get results
-    const request = collection.find(query).sort({ createdAt: 'desc' });
-    if (limit) {
-      request.limit(limit);
-    }
+      // Get results
+      const request = collection.find(query).sort({ createdAt: 'desc' });
+      if (limit) {
+        request.limit(limit);
+      }
 
-    if (offset) {
-      request.skip(offset);
-    }
+      if (offset) {
+        request.skip(offset);
+      }
 
-    const result = await request.toArray();
-    const runs = result.map(row => {
-      let parsedSnapshot: WorkflowRunState | string = row.snapshot;
-      if (typeof parsedSnapshot === 'string') {
-        try {
-          parsedSnapshot = JSON.parse(row.snapshot as string) as WorkflowRunState;
-        } catch (e) {
-          // If parsing fails, return the raw snapshot string
-          console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      const result = await request.toArray();
+      const runs = result.map(row => {
+        let parsedSnapshot: WorkflowRunState | string = row.snapshot;
+        if (typeof parsedSnapshot === 'string') {
+          try {
+            parsedSnapshot = JSON.parse(row.snapshot as string) as WorkflowRunState;
+          } catch (e) {
+            // If parsing fails, return the raw snapshot string
+            console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+          }
         }
-      }
 
-      return {
-        workflowName: row.workflow_name as string,
-        runId: row.run_id as string,
-        snapshot: parsedSnapshot,
-        createdAt: new Date(row.createdAt as string),
-        updatedAt: new Date(row.updatedAt as string),
-      };
-    });
+        return {
+          workflowName: row.workflow_name as string,
+          runId: row.run_id as string,
+          snapshot: parsedSnapshot,
+          createdAt: new Date(row.createdAt as string),
+          updatedAt: new Date(row.updatedAt as string),
+        };
+      });
 
-    // Use runs.length as total when not paginating
-    return { runs, total: total || runs.length };
+      // Use runs.length as total when not paginating
+      return { runs, total: total || runs.length };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_GET_WORKFLOW_RUNS_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
+    }
   }
 
   async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
@@ -565,8 +691,15 @@ export class MongoDBStore extends MastraStorage {
       if (error instanceof Error && error.message.includes('no such table')) {
         return [];
       }
-      this.logger.error('Failed to get evals for the specified agent: ' + (error as any)?.message);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName },
+        },
+        error,
+      );
     }
   }
 
@@ -596,8 +729,15 @@ export class MongoDBStore extends MastraStorage {
         { upsert: true },
       );
     } catch (error) {
-      this.logger.error(`Error persisting workflow snapshot: ${error}`);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId },
+        },
+        error,
+      );
     }
   }
 
@@ -623,8 +763,15 @@ export class MongoDBStore extends MastraStorage {
 
       return JSON.parse(result[0].snapshot);
     } catch (error) {
-      console.error('Error loading workflow snapshot:', error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId },
+        },
+        error,
+      );
     }
   }
 
@@ -653,8 +800,15 @@ export class MongoDBStore extends MastraStorage {
 
       return this.parseWorkflowRun(result);
     } catch (error) {
-      console.error('Error getting workflow run by ID:', error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { runId },
+        },
+        error,
+      );
     }
   }
 
@@ -706,11 +860,20 @@ export class MongoDBStore extends MastraStorage {
         console.warn('Failed to parse test_info:', e);
       }
     }
+    const resultValue = JSON.parse(row.result as string);
+    if (!resultValue || typeof resultValue !== 'object' || !('score' in resultValue)) {
+      throw new MastraError({
+        id: 'STORAGE_MONGODB_STORE_INVALID_METRIC_FORMAT',
+        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+      });
+    }
 
     return {
       input: row.input as string,
       output: row.output as string,
-      result: row.result as MetricResult,
+      result: resultValue as MetricResult,
       agentName: row.agent_name as string,
       metricName: row.metric_name as string,
       instructions: row.instructions as string,
@@ -722,7 +885,12 @@ export class MongoDBStore extends MastraStorage {
   }
 
   async getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & { traces: Trace[] }> {
-    throw new Error('Method not implemented.');
+    throw new MastraError({
+      id: 'STORAGE_MONGODB_STORE_GET_TRACES_PAGINATED_FAILED',
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.THIRD_PARTY,
+      text: 'Method not implemented.',
+    });
   }
 
   async getThreadsByResourceIdPaginated(_args: {
@@ -730,17 +898,38 @@ export class MongoDBStore extends MastraStorage {
     page?: number;
     perPage?: number;
   }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
-    throw new Error('Method not implemented.');
+    throw new MastraError({
+      id: 'STORAGE_MONGODB_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED',
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.THIRD_PARTY,
+      text: 'Method not implemented.',
+    });
   }
 
   async getMessagesPaginated(
     _args: StorageGetMessagesArg,
   ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
-    throw new Error('Method not implemented.');
+    throw new MastraError({
+      id: 'STORAGE_MONGODB_STORE_GET_MESSAGES_PAGINATED_FAILED',
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.THIRD_PARTY,
+      text: 'Method not implemented.',
+    });
   }
 
   async close(): Promise<void> {
-    await this.#client.close();
+    try {
+      await this.#client.close();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_CLOSE_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+        },
+        error,
+      );
+    }
   }
 
   async updateMessages(_args: {