@mastra/mongodb 0.0.0-working-memory-per-user-20250620163010 → 0.0.0-zod-v4-compat-part-2-20250822105954

package/src/storage/index.ts

@@ -1,203 +1,180 @@
-import { MessageList } from '@mastra/core/agent';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
-import type { MetricResult, TestInfo } from '@mastra/core/eval';
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
+import type { ScoreRowData } from '@mastra/core/scores';
 import type {
   EvalRow,
+  PaginationArgs,
   PaginationInfo,
   StorageColumn,
+  StorageDomains,
   StorageGetMessagesArg,
   StorageGetTracesArg,
+  StorageGetTracesPaginatedArg,
+  StoragePagination,
+  StorageResourceType,
   TABLE_NAMES,
   WorkflowRun,
+  WorkflowRuns,
 } from '@mastra/core/storage';
-import {
-  MastraStorage,
-  TABLE_EVALS,
-  TABLE_MESSAGES,
-  TABLE_THREADS,
-  TABLE_TRACES,
-  TABLE_WORKFLOW_SNAPSHOT,
-} from '@mastra/core/storage';
+import { MastraStorage } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
 import type { WorkflowRunState } from '@mastra/core/workflows';
-import type { Db, MongoClientOptions } from 'mongodb';
-import { MongoClient } from 'mongodb';
-
-function safelyParseJSON(jsonString: string): any {
+import { MongoDBConnector } from './connectors/MongoDBConnector';
+import { LegacyEvalsMongoDB } from './domains/legacy-evals';
+import { MemoryStorageMongoDB } from './domains/memory';
+import { StoreOperationsMongoDB } from './domains/operations';
+import { ScoresStorageMongoDB } from './domains/scores';
+import { TracesStorageMongoDB } from './domains/traces';
+import { WorkflowsStorageMongoDB } from './domains/workflows';
+import type { MongoDBConfig } from './types';
+
+const loadConnector = (config: MongoDBConfig): MongoDBConnector => {
   try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
+    if ('connectorHandler' in config) {
+      return MongoDBConnector.fromConnectionHandler(config.connectorHandler);
+    }
+  } catch (error) {
+    throw new MastraError(
+      {
+        id: 'STORAGE_MONGODB_STORE_CONSTRUCTOR_FAILED',
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { connectionHandler: true },
+      },
+      error,
+    );
   }
-}
 
-export interface MongoDBConfig {
-  url: string;
-  dbName: string;
-  options?: MongoClientOptions;
-}
+  try {
+    return MongoDBConnector.fromDatabaseConfig({
+      options: config.options,
+      url: config.url,
+      dbName: config.dbName,
+    });
+  } 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,
+    );
+  }
+};
 
 export class MongoDBStore extends MastraStorage {
-  #isConnected = false;
-  #client: MongoClient;
-  #db: Db | undefined;
-  readonly #dbName: string;
+  #connector: MongoDBConnector;
+
+  stores: StorageDomains;
+
+  public get supports(): {
+    selectByIncludeResourceScope: boolean;
+    resourceWorkingMemory: boolean;
+    hasColumn: boolean;
+    createTable: boolean;
+    deleteMessages: boolean;
+  } {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: false,
+      createTable: false,
+      deleteMessages: false,
+    };
+  }
 
   constructor(config: MongoDBConfig) {
     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.',
-      );
-    }
+    this.stores = {} as StorageDomains;
 
-    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.',
-      );
-    }
+    this.#connector = loadConnector(config);
 
-    this.#dbName = config.dbName;
-    this.#client = new MongoClient(config.url, config.options);
-  }
+    const operations = new StoreOperationsMongoDB({
+      connector: this.#connector,
+    });
 
-  private async getConnection(): Promise<Db> {
-    if (this.#isConnected) {
-      return this.#db!;
-    }
+    const memory = new MemoryStorageMongoDB({
+      operations,
+    });
 
-    await this.#client.connect();
-    this.#db = this.#client.db(this.#dbName);
-    this.#isConnected = true;
-    return this.#db;
-  }
+    const traces = new TracesStorageMongoDB({
+      operations,
+    });
+
+    const legacyEvals = new LegacyEvalsMongoDB({
+      operations,
+    });
+
+    const scores = new ScoresStorageMongoDB({
+      operations,
+    });
+
+    const workflows = new WorkflowsStorageMongoDB({
+      operations,
+    });
 
-  private async getCollection(collectionName: string) {
-    const db = await this.getConnection();
-    return db.collection(collectionName);
+    this.stores = {
+      operations,
+      memory,
+      traces,
+      legacyEvals,
+      scores,
+      workflows,
+    };
   }
 
-  async createTable(): Promise<void> {
-    // Nothing to do here, MongoDB is schemaless
+  async createTable({
+    tableName,
+    schema,
+  }: {
+    tableName: TABLE_NAMES;
+    schema: Record<string, StorageColumn>;
+  }): Promise<void> {
+    return this.stores.operations.createTable({ tableName, schema });
   }
 
-  /**
-   * No-op: This backend is schemaless and does not require schema changes.
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
   async alterTable(_args: {
     tableName: TABLE_NAMES;
     schema: Record<string, StorageColumn>;
     ifNotExists: string[];
   }): Promise<void> {
-    // Nothing to do here, MongoDB is schemaless
+    return this.stores.operations.alterTable(_args);
+  }
+
+  async dropTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
+    return this.stores.operations.dropTable({ tableName });
   }
 
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.deleteMany({});
-    } catch (error) {
-      if (error instanceof Error) {
-        this.logger.error(error.message);
-      }
-    }
+    return this.stores.operations.clearTable({ tableName });
   }
 
   async insert({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.insertOne(record);
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
+    return this.stores.operations.insert({ tableName, record });
   }
 
   async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
-    if (!records.length) {
-      return;
-    }
-
-    try {
-      const collection = await this.getCollection(tableName);
-      await collection.insertMany(records);
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
+    return this.stores.operations.batchInsert({ tableName, records });
   }
 
   async load<R>({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, string> }): Promise<R | null> {
-    this.logger.info(`Loading ${tableName} with keys ${JSON.stringify(keys)}`);
-    try {
-      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;
-    }
+    return this.stores.operations.load({ tableName, keys });
   }
 
   async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
-    try {
-      const collection = await this.getCollection(TABLE_THREADS);
-      const result = await collection.findOne<any>({ id: threadId });
-      if (!result) {
-        return null;
-      }
-
-      return {
-        ...result,
-        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;
-    }
+    return this.stores.memory.getThreadById({ threadId });
   }
 
   async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
-    try {
-      const collection = await this.getCollection(TABLE_THREADS);
-      const results = await collection.find<any>({ resourceId }).toArray();
-      if (!results.length) {
-        return [];
-      }
-
-      return results.map(result => ({
-        ...result,
-        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;
-    }
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
   }
 
   async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
-    try {
-      const collection = await this.getCollection(TABLE_THREADS);
-      await collection.updateOne(
-        { id: thread.id },
-        {
-          $set: {
-            ...thread,
-            metadata: JSON.stringify(thread.metadata),
-          },
-        },
-        { upsert: true },
-      );
-      return thread;
-    } catch (error) {
-      this.logger.error(`Error saving thread ${thread.id}: ${error}`);
-      throw error;
-    }
+    return this.stores.memory.saveThread({ thread });
   }
 
   async updateThread({
@@ -209,51 +186,11 @@ export class MongoDBStore extends MastraStorage {
     title: string;
     metadata: Record<string, unknown>;
   }): Promise<StorageThreadType> {
-    const thread = await this.getThreadById({ threadId: id });
-    if (!thread) {
-      throw new Error(`Thread ${id} not found`);
-    }
-
-    const updatedThread = {
-      ...thread,
-      title,
-      metadata: {
-        ...thread.metadata,
-        ...metadata,
-      },
-    };
-
-    try {
-      const collection = await this.getCollection(TABLE_THREADS);
-      await collection.updateOne(
-        { id },
-        {
-          $set: {
-            title,
-            metadata: JSON.stringify(updatedThread.metadata),
-          },
-        },
-      );
-    } catch (error) {
-      this.logger.error(`Error updating thread ${id}:) ${error}`);
-      throw error;
-    }
-
-    return updatedThread;
+    return this.stores.memory.updateThread({ id, title, metadata });
   }
 
   async deleteThread({ threadId }: { threadId: string }): Promise<void> {
-    try {
-      // First, delete all messages associated with the thread
-      const collectionMessages = await this.getCollection(TABLE_MESSAGES);
-      await collectionMessages.deleteMany({ thread_id: threadId });
-      // Then delete the thread itself
-      const collectionThreads = await this.getCollection(TABLE_THREADS);
-      await collectionThreads.deleteOne({ id: threadId });
-    } catch (error) {
-      this.logger.error(`Error deleting thread ${threadId}: ${error}`);
-      throw error;
-    }
+    return this.stores.memory.deleteThread({ threadId });
   }
 
   public async getMessages(args: StorageGetMessagesArg & { format?: 'v1' }): Promise<MastraMessageV1[]>;
@@ -265,309 +202,71 @@ export class MongoDBStore extends MastraStorage {
   }: StorageGetMessagesArg & {
     format?: 'v1' | 'v2';
   }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
-    try {
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      const include = selectBy?.include || [];
-      let messages: MastraMessageV2[] = [];
-      let allMessages: MastraMessageV2[] = [];
-      const collection = await this.getCollection(TABLE_MESSAGES);
-      // Get all messages from the thread ordered by creation date descending
-      allMessages = (await collection.find({ thread_id: threadId }).sort({ createdAt: -1 }).toArray()).map((row: any) =>
-        this.parseRow(row),
-      );
-
-      // If there are messages to include, select the messages around the included IDs
-      if (include.length) {
-        // Map IDs to their position in the ordered array
-        const idToIndex = new Map<string, number>();
-        allMessages.forEach((msg, idx) => {
-          idToIndex.set(msg.id, idx);
-        });
-
-        const selectedIndexes = new Set<number>();
-        for (const inc of include) {
-          const idx = idToIndex.get(inc.id);
-          if (idx === undefined) continue;
-          // Previous messages
-          for (let i = 1; i <= (inc.withPreviousMessages || 0); i++) {
-            if (idx + i < allMessages.length) selectedIndexes.add(idx + i);
-          }
-          // Included message
-          selectedIndexes.add(idx);
-          // Next messages
-          for (let i = 1; i <= (inc.withNextMessages || 0); i++) {
-            if (idx - i >= 0) selectedIndexes.add(idx - i);
-          }
-        }
-        // Add the selected messages, filtering out undefined
-        messages.push(
-          ...Array.from(selectedIndexes)
-            .map(i => allMessages[i])
-            .filter((m): m is MastraMessageV2 => !!m),
-        );
-      }
-
-      // Get the remaining messages, excluding those already selected
-      const excludeIds = new Set(messages.map(m => m.id));
-      for (const msg of allMessages) {
-        if (messages.length >= limit) break;
-        if (!excludeIds.has(msg.id)) {
-          messages.push(msg);
-        }
-      }
-
-      // Sort all messages by creation date ascending
-      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-
-      const list = new MessageList().add(messages.slice(0, limit), 'memory');
-      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;
-    }
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
   }
 
   async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
   async saveMessages(args: { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[]>;
-  async saveMessages({
-    messages,
-    format,
-  }:
-    | { messages: MastraMessageV1[]; format?: undefined | 'v1' }
-    | { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[] | MastraMessageV1[]> {
-    if (!messages.length) {
-      return messages;
-    }
-
-    const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      this.logger.error('Thread ID is required to save messages');
-      throw new Error('Thread ID is required');
-    }
+  async saveMessages(
+    args: { messages: MastraMessageV1[]; format?: undefined | 'v1' } | { messages: MastraMessageV2[]; format: 'v2' },
+  ): Promise<MastraMessageV2[] | MastraMessageV1[]> {
+    return this.stores.memory.saveMessages(args);
+  }
 
-    try {
-      // Prepare batch statements for all messages
-      const messagesToInsert = messages.map(message => {
-        const time = message.createdAt || new Date();
-        return {
-          id: message.id,
-          thread_id: threadId,
-          content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content),
-          role: message.role,
-          type: message.type,
-          resourceId: message.resourceId,
-          createdAt: time instanceof Date ? time.toISOString() : time,
-        };
-      });
-
-      // Execute message inserts and thread update in parallel for better performance
-      const collection = await this.getCollection(TABLE_MESSAGES);
-      const threadsCollection = await this.getCollection(TABLE_THREADS);
-
-      await Promise.all([
-        collection.insertMany(messagesToInsert),
-        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: new Date() } }),
-      ]);
-
-      const list = new MessageList().add(messages, 'memory');
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      this.logger.error('Failed to save messages in database: ' + (error as { message: string })?.message);
-      throw error;
-    }
+  async getThreadsByResourceIdPaginated(_args: {
+    resourceId: string;
+    page: number;
+    perPage: number;
+  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+    return this.stores.memory.getThreadsByResourceIdPaginated(_args);
   }
 
-  async getTraces(
-    {
-      name,
-      scope,
-      page,
-      perPage,
-      attributes,
-      filters,
-    }: {
-      name?: string;
-      scope?: string;
-      page: number;
-      perPage: number;
-      attributes?: Record<string, string>;
-      filters?: Record<string, any>;
-    } = {
-      page: 0,
-      perPage: 100,
-    },
-  ): Promise<any[]> {
-    const limit = perPage;
-    const offset = page * perPage;
-
-    const query: any = {};
-    if (name) {
-      query['name'] = `%${name}%`;
-    }
+  async getMessagesPaginated(
+    _args: StorageGetMessagesArg,
+  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
+    return this.stores.memory.getMessagesPaginated(_args);
+  }
 
-    if (scope) {
-      query['scope'] = scope;
-    }
+  async updateMessages(_args: {
+    messages: Partial<Omit<MastraMessageV2, 'createdAt'>> &
+      {
+        id: string;
+        content?: { metadata?: MastraMessageContentV2['metadata']; content?: MastraMessageContentV2['content'] };
+      }[];
+  }): Promise<MastraMessageV2[]> {
+    return this.stores.memory.updateMessages(_args);
+  }
 
-    if (attributes) {
-      Object.keys(attributes).forEach(key => {
-        query[`attributes.${key}`] = attributes[key];
-      });
-    }
+  async getTraces(args: StorageGetTracesArg): Promise<Trace[]> {
+    return this.stores.traces.getTraces(args);
+  }
 
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        query[key] = value;
-      });
-    }
+  async getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & { traces: Trace[] }> {
+    return this.stores.traces.getTracesPaginated(args);
+  }
 
-    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;
-  }
-
-  async getWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    limit,
-    offset,
-  }: {
+  async getWorkflowRuns(args?: {
     workflowName?: string;
     fromDate?: Date;
     toDate?: Date;
     limit?: number;
     offset?: number;
-  } = {}): Promise<{
-    runs: Array<{
-      workflowName: string;
-      runId: string;
-      snapshot: WorkflowRunState | string;
-      createdAt: Date;
-      updatedAt: Date;
-    }>;
-    total: number;
-  }> {
-    const query: any = {};
-    if (workflowName) {
-      query['workflow_name'] = workflowName;
-    }
-
-    if (fromDate || toDate) {
-      query['createdAt'] = {};
-      if (fromDate) {
-        query['createdAt']['$gte'] = fromDate;
-      }
-      if (toDate) {
-        query['createdAt']['$lte'] = toDate;
-      }
-    }
-
-    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);
-    }
-
-    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}`);
-        }
-      }
-
-      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),
-      };
-    });
+    resourceId?: string;
+  }): Promise<WorkflowRuns> {
+    return this.stores.workflows.getWorkflowRuns(args);
+  }
 
-    // Use runs.length as total when not paginating
-    return { runs, total: total || runs.length };
+  async getEvals(
+    options: {
+      agentName?: string;
+      type?: 'test' | 'live';
+    } & PaginationArgs = {},
+  ): Promise<PaginationInfo & { evals: EvalRow[] }> {
+    return this.stores.legacyEvals.getEvals(options);
   }
 
   async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
-    try {
-      const query: any = {
-        agent_name: agentName,
-      };
-
-      if (type === 'test') {
-        query['test_info'] = { $ne: null };
-        // is not possible to filter by test_info.testPath because it is not a json field
-        // query['test_info.testPath'] = { $ne: null };
-      }
-
-      if (type === 'live') {
-        // is not possible to filter by test_info.testPath because it is not a json field
-        query['test_info'] = null;
-      }
-
-      const collection = await this.getCollection(TABLE_EVALS);
-      const documents = await collection.find(query).sort({ created_at: 'desc' }).toArray();
-      const result = documents.map(row => this.transformEvalRow(row));
-      // Post filter to remove if test_info.testPath is null
-      return result.filter(row => {
-        if (type === 'live') {
-          return !Boolean(row.testInfo?.testPath);
-        }
-
-        if (type === 'test') {
-          return row.testInfo?.testPath !== null;
-        }
-        return true;
-      });
-    } catch (error) {
-      // Handle case where table doesn't exist yet
-      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;
-    }
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
   }
 
   async persistWorkflowSnapshot({
@@ -579,26 +278,7 @@ export class MongoDBStore extends MastraStorage {
     runId: string;
     snapshot: WorkflowRunState;
   }): Promise<void> {
-    try {
-      const now = new Date().toISOString();
-      const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
-      await collection.updateOne(
-        { workflow_name: workflowName, run_id: runId },
-        {
-          $set: {
-            snapshot: JSON.stringify(snapshot),
-            updatedAt: now,
-          },
-          $setOnInsert: {
-            createdAt: now,
-          },
-        },
-        { upsert: true },
-      );
-    } catch (error) {
-      this.logger.error(`Error persisting workflow snapshot: ${error}`);
-      throw error;
-    }
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
   }
 
   async loadWorkflowSnapshot({
@@ -608,24 +288,7 @@ export class MongoDBStore extends MastraStorage {
     workflowName: string;
     runId: string;
   }): Promise<WorkflowRunState | null> {
-    try {
-      const result = await this.load<any[]>({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId,
-        },
-      });
-
-      if (!result?.length) {
-        return null;
-      }
-
-      return JSON.parse(result[0].snapshot);
-    } catch (error) {
-      console.error('Error loading workflow snapshot:', error);
-      throw error;
-    }
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
   }
 
   async getWorkflowRunById({
@@ -635,122 +298,95 @@ export class MongoDBStore extends MastraStorage {
     runId: string;
     workflowName?: string;
   }): Promise<WorkflowRun | null> {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+
+  async close(): Promise<void> {
     try {
-      const query: any = {};
-      if (runId) {
-        query['run_id'] = runId;
-      }
-
-      if (workflowName) {
-        query['workflow_name'] = workflowName;
-      }
-
-      const collection = await this.getCollection(TABLE_WORKFLOW_SNAPSHOT);
-      const result = await collection.findOne(query);
-      if (!result) {
-        return null;
-      }
-
-      return this.parseWorkflowRun(result);
+      await this.#connector.close();
     } catch (error) {
-      console.error('Error getting workflow run by ID:', error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_MONGODB_STORE_CLOSE_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+        },
+        error,
+      );
     }
   }
 
-  private parseWorkflowRun(row: any): WorkflowRun {
-    let parsedSnapshot: WorkflowRunState | string = row.snapshot as string;
-    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,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      resourceId: row.resourceId,
-    };
+  /**
+   * SCORERS
+   */
+  async getScoreById({ id }: { id: string }): Promise<ScoreRowData | null> {
+    return this.stores.scores.getScoreById({ id });
   }
 
-  private parseRow(row: any): MastraMessageV2 {
-    let content = row.content;
-    try {
-      content = JSON.parse(row.content);
-    } catch {
-      // use content as is if it's not JSON
-    }
-    return {
-      id: row.id,
-      content,
-      role: row.role,
-      type: row.type,
-      createdAt: new Date(row.createdAt as string),
-      threadId: row.thread_id,
-      resourceId: row.resourceId,
-    } as MastraMessageV2;
-  }
-
-  private transformEvalRow(row: Record<string, any>): EvalRow {
-    let testInfoValue = null;
-    if (row.test_info) {
-      try {
-        testInfoValue = typeof row.test_info === 'string' ? JSON.parse(row.test_info) : row.test_info;
-      } catch (e) {
-        console.warn('Failed to parse test_info:', e);
-      }
-    }
+  async saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{ score: ScoreRowData }> {
+    return this.stores.scores.saveScore(score);
+  }
 
-    return {
-      input: row.input as string,
-      output: row.output as string,
-      result: row.result as MetricResult,
-      agentName: row.agent_name as string,
-      metricName: row.metric_name as string,
-      instructions: row.instructions as string,
-      testInfo: testInfoValue as TestInfo,
-      globalRunId: row.global_run_id as string,
-      runId: row.run_id as string,
-      createdAt: row.created_at as string,
-    };
+  async getScoresByRunId({
+    runId,
+    pagination,
+  }: {
+    runId: string;
+    pagination: StoragePagination;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
   }
 
-  async getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & { traces: Trace[] }> {
-    throw new Error('Method not implemented.');
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination,
+  }: {
+    pagination: StoragePagination;
+    entityId: string;
+    entityType: string;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
   }
 
-  async getThreadsByResourceIdPaginated(_args: {
-    resourceId: string;
-    page?: number;
-    perPage?: number;
-  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
-    throw new Error('Method not implemented.');
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+  }: {
+    scorerId: string;
+    pagination: StoragePagination;
+    entityId?: string;
+    entityType?: string;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType });
   }
 
-  async getMessagesPaginated(
-    _args: StorageGetMessagesArg,
-  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
-    throw new Error('Method not implemented.');
+  /**
+   * RESOURCES
+   */
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    return this.stores.memory.getResourceById({ resourceId });
   }
 
-  async close(): Promise<void> {
-    await this.#client.close();
+  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    return this.stores.memory.saveResource({ resource });
   }
 
-  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');
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    return this.stores.memory.updateResource({
+      resourceId,
+      workingMemory,
+      metadata,
+    });
   }
 }