@mastra/mongodb 0.11.0 → 0.11.1-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mongodb",
-  "version": "0.11.0",
+  "version": "0.11.1-alpha.1",
   "description": "MongoDB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -31,9 +31,9 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "@internal/lint": "0.0.13",
     "@internal/storage-test-utils": "0.0.9",
-    "@mastra/core": "0.10.6"
+    "@mastra/core": "0.10.7-alpha.1",
+    "@internal/lint": "0.0.13"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/storage/index.ts

@@ -1,4 +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 {
@@ -47,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,
       );
     }
 
@@ -103,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);
       }
     }
   }
@@ -113,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);
+      }
     }
   }
 
@@ -127,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,
+      );
     }
   }
 
@@ -138,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,
+      );
     }
   }
 
@@ -156,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,
+      );
     }
   }
 
@@ -174,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,
+      );
     }
   }
 
@@ -194,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,
+      );
     }
   }
 
@@ -210,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 = {
@@ -234,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;
@@ -250,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,
+      );
     }
   }
 
@@ -265,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[] = [];
@@ -322,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,
+      );
     }
   }
 
@@ -422,31 +519,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({
@@ -486,46 +594,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[]> {
@@ -564,8 +683,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,
+      );
     }
   }
 
@@ -595,8 +721,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,
+      );
     }
   }
 
@@ -622,8 +755,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,
+      );
     }
   }
 
@@ -652,8 +792,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,
+      );
     }
   }
 
@@ -721,7 +868,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: {
@@ -729,16 +881,48 @@ 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: {
+    messages: Partial<Omit<MastraMessageV2, 'createdAt'>> &
+      {
+        id: string;
+        content?: { metadata?: MastraMessageContentV2['metadata']; content?: MastraMessageContentV2['content'] };
+      }[];
+  }): Promise<MastraMessageV2[]> {
+    this.logger.error('updateMessages is not yet implemented in MongoDBStore');
+    throw new Error('Method not implemented');
   }
 }