@mastra/mongodb 0.13.3 → 0.13.6-alpha.0

package/src/storage/domains/utils.ts

@@ -1,43 +0,0 @@
-import type { IMastraLogger } from '@mastra/core/logger';
-
-export function formatDateForMongoDB(date: Date | string): Date {
-  return typeof date === 'string' ? new Date(date) : date;
-}
-
-export function createExecuteOperationWithRetry({
-  logger,
-  maxRetries = 3,
-  initialBackoffMs = 100,
-}: {
-  logger: IMastraLogger;
-  maxRetries?: number;
-  initialBackoffMs?: number;
-}) {
-  return async function executeOperationWithRetry<T>(
-    operationFn: () => Promise<T>,
-    operationDescription: string,
-  ): Promise<T> {
-    let retries = 0;
-
-    while (true) {
-      try {
-        return await operationFn();
-      } catch (error: any) {
-        if (
-          ((error.message && error.message.includes('connection')) || error.code === 'ECONNRESET') &&
-          retries < maxRetries
-        ) {
-          retries++;
-          const backoffTime = initialBackoffMs * Math.pow(2, retries - 1);
-          logger.warn(
-            `MongoDBStore: Encountered connection error during ${operationDescription}. Retrying (${retries}/${maxRetries}) in ${backoffTime}ms...`,
-          );
-          await new Promise(resolve => setTimeout(resolve, backoffTime));
-        } else {
-          logger.error(`MongoDBStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
-          throw error;
-        }
-      }
-    }
-  };
-}

package/src/storage/domains/workflows/index.ts

@@ -1,196 +0,0 @@
-import { ErrorDomain, ErrorCategory, MastraError } from '@mastra/core/error';
-import { WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, safelyParseJSON } from '@mastra/core/storage';
-import type { WorkflowRun, WorkflowRuns } from '@mastra/core/storage';
-import type { WorkflowRunState } from '@mastra/core/workflows';
-import type { StoreOperationsMongoDB } from '../operations';
-
-export class WorkflowsStorageMongoDB extends WorkflowsStorage {
-  private operations: StoreOperationsMongoDB;
-
-  constructor({ operations }: { operations: StoreOperationsMongoDB }) {
-    super();
-    this.operations = operations;
-  }
-
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    snapshot,
-  }: {
-    workflowName: string;
-    runId: string;
-    snapshot: WorkflowRunState;
-  }): Promise<void> {
-    try {
-      const collection = await this.operations.getCollection(TABLE_WORKFLOW_SNAPSHOT);
-      await collection.updateOne(
-        { workflow_name: workflowName, run_id: runId },
-        {
-          $set: {
-            workflow_name: workflowName,
-            run_id: runId,
-            snapshot,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-          },
-        },
-        { upsert: true },
-      );
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_MONGODB_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { workflowName, runId },
-        },
-        error,
-      );
-    }
-  }
-
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId,
-  }: {
-    workflowName: string;
-    runId: string;
-  }): Promise<WorkflowRunState | null> {
-    try {
-      const result = await this.operations.load<any[]>({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId,
-        },
-      });
-
-      if (!result?.length) {
-        return null;
-      }
-
-      return typeof result[0].snapshot === 'string' ? safelyParseJSON(result[0].snapshot) : result[0].snapshot;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_MONGODB_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { workflowName, runId },
-        },
-        error,
-      );
-    }
-  }
-
-  async getWorkflowRuns(args?: {
-    workflowName?: string;
-    fromDate?: Date;
-    toDate?: Date;
-    limit?: number;
-    offset?: number;
-    resourceId?: string;
-  }): Promise<WorkflowRuns> {
-    const options = args || {};
-    try {
-      const query: any = {};
-      if (options.workflowName) {
-        query['workflow_name'] = options.workflowName;
-      }
-      if (options.fromDate) {
-        query['createdAt'] = { $gte: options.fromDate };
-      }
-      if (options.toDate) {
-        if (query['createdAt']) {
-          query['createdAt'].$lte = options.toDate;
-        } else {
-          query['createdAt'] = { $lte: options.toDate };
-        }
-      }
-      if (options.resourceId) {
-        query['resourceId'] = options.resourceId;
-      }
-
-      const collection = await this.operations.getCollection(TABLE_WORKFLOW_SNAPSHOT);
-      const total = await collection.countDocuments(query);
-
-      let cursor = collection.find(query).sort({ createdAt: -1 });
-      if (options.offset) {
-        cursor = cursor.skip(options.offset);
-      }
-      if (options.limit) {
-        cursor = cursor.limit(options.limit);
-      }
-
-      const results = await cursor.toArray();
-
-      const runs = results.map(row => this.parseWorkflowRun(row));
-
-      return {
-        runs,
-        total,
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_MONGODB_STORE_GET_WORKFLOW_RUNS_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { workflowName: options.workflowName || 'unknown' },
-        },
-        error,
-      );
-    }
-  }
-
-  async getWorkflowRunById(args: { runId: string; workflowName?: string }): Promise<WorkflowRun | null> {
-    try {
-      const query: any = {};
-      if (args.runId) {
-        query['run_id'] = args.runId;
-      }
-      if (args.workflowName) {
-        query['workflow_name'] = args.workflowName;
-      }
-
-      const collection = await this.operations.getCollection(TABLE_WORKFLOW_SNAPSHOT);
-      const result = await collection.findOne(query);
-      if (!result) {
-        return null;
-      }
-
-      return this.parseWorkflowRun(result);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_MONGODB_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { runId: args.runId },
-        },
-        error,
-      );
-    }
-  }
-
-  private parseWorkflowRun(row: any): WorkflowRun {
-    let parsedSnapshot: WorkflowRunState | string = row.snapshot as string;
-    if (typeof parsedSnapshot === 'string') {
-      try {
-        parsedSnapshot = typeof row.snapshot === 'string' ? safelyParseJSON(row.snapshot as string) : row.snapshot;
-      } 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: row.resourceId,
-    };
-  }
-}

package/src/storage/index.test.ts

@@ -1,62 +0,0 @@
-import { createTestSuite } from '@internal/storage-test-utils';
-import { describe, expect, it } from 'vitest';
-import type { ConnectorHandler } from './connectors/base';
-import type { MongoDBConfig } from './types';
-import { MongoDBStore } from './index';
-
-const TEST_CONFIG: MongoDBConfig = {
-  url: process.env.MONGODB_URL || 'mongodb://localhost:27017',
-  dbName: process.env.MONGODB_DB_NAME || 'mastra-test-db',
-};
-
-describe('Validation', () => {
-  describe('with database options', () => {
-    const validConfig = TEST_CONFIG;
-    it('throws if url is empty', () => {
-      expect(() => new MongoDBStore({ ...validConfig, url: '' })).toThrow(/url must be provided and cannot be empty/);
-    });
-
-    it('throws if dbName is missing or empty', () => {
-      expect(() => new MongoDBStore({ ...validConfig, dbName: '' })).toThrow(
-        /dbName must be provided and cannot be empty/,
-      );
-      const { dbName, ...rest } = validConfig;
-      expect(() => new MongoDBStore(rest as any)).toThrow(/dbName must be provided and cannot be empty/);
-    });
-
-    it('does not throw on valid config (host-based)', () => {
-      expect(() => new MongoDBStore(validConfig)).not.toThrow();
-    });
-  });
-
-  describe('with connection handler', () => {
-    const validWithConnectionHandlerConfig = {
-      connectorHandler: {} as ConnectorHandler,
-    };
-
-    it('not throws if url is empty', () => {
-      expect(() => new MongoDBStore({ ...validWithConnectionHandlerConfig, url: '' })).not.toThrow(
-        /url must be provided and cannot be empty/,
-      );
-    });
-
-    it('not throws if dbName is missing or empty', () => {
-      expect(() => new MongoDBStore({ ...validWithConnectionHandlerConfig, dbName: '' })).not.toThrow(
-        /dbName must be provided and cannot be empty/,
-      );
-      const { dbName, ...rest } = validWithConnectionHandlerConfig as any;
-      expect(() => new MongoDBStore(rest as any)).not.toThrow(/dbName must be provided and cannot be empty/);
-    });
-
-    it('does not throw on valid config', () => {
-      expect(() => new MongoDBStore(validWithConnectionHandlerConfig)).not.toThrow();
-    });
-
-    it('should initialize the stores correctly', () => {
-      const store = new MongoDBStore(validWithConnectionHandlerConfig);
-      expect(Object.keys(store.stores)).not.toHaveLength(0);
-    });
-  });
-});
-
-createTestSuite(new MongoDBStore(TEST_CONFIG));

package/src/storage/index.ts

@@ -1,406 +0,0 @@
-import type { MastraMessageContentV2 } from '@mastra/core/agent';
-import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
-import type { ScoreRowData, ScoringSource } 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 } from '@mastra/core/storage';
-import type { Trace } from '@mastra/core/telemetry';
-import type { WorkflowRunState } from '@mastra/core/workflows';
-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 {
-    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,
-    );
-  }
-
-  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 {
-  #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.stores = {} as StorageDomains;
-
-    this.#connector = loadConnector(config);
-
-    const operations = new StoreOperationsMongoDB({
-      connector: this.#connector,
-    });
-
-    const memory = new MemoryStorageMongoDB({
-      operations,
-    });
-
-    const traces = new TracesStorageMongoDB({
-      operations,
-    });
-
-    const legacyEvals = new LegacyEvalsMongoDB({
-      operations,
-    });
-
-    const scores = new ScoresStorageMongoDB({
-      operations,
-    });
-
-    const workflows = new WorkflowsStorageMongoDB({
-      operations,
-    });
-
-    this.stores = {
-      operations,
-      memory,
-      traces,
-      legacyEvals,
-      scores,
-      workflows,
-    };
-  }
-
-  async createTable({
-    tableName,
-    schema,
-  }: {
-    tableName: TABLE_NAMES;
-    schema: Record<string, StorageColumn>;
-  }): Promise<void> {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-
-  async alterTable(_args: {
-    tableName: TABLE_NAMES;
-    schema: Record<string, StorageColumn>;
-    ifNotExists: string[];
-  }): Promise<void> {
-    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> {
-    return this.stores.operations.clearTable({ tableName });
-  }
-
-  async insert({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
-    return this.stores.operations.insert({ tableName, record });
-  }
-
-  async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-
-  async load<R>({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, string> }): Promise<R | null> {
-    return this.stores.operations.load({ tableName, keys });
-  }
-
-  async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-
-  async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
-    return this.stores.memory.getThreadsByResourceId({ resourceId });
-  }
-
-  async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
-    return this.stores.memory.saveThread({ thread });
-  }
-
-  async updateThread({
-    id,
-    title,
-    metadata,
-  }: {
-    id: string;
-    title: string;
-    metadata: Record<string, unknown>;
-  }): Promise<StorageThreadType> {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-
-  async deleteThread({ threadId }: { threadId: string }): Promise<void> {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-
-  public async getMessages(args: StorageGetMessagesArg & { format?: 'v1' }): Promise<MastraMessageV1[]>;
-  public async getMessages(args: StorageGetMessagesArg & { format: 'v2' }): Promise<MastraMessageV2[]>;
-  public async getMessages({
-    threadId,
-    selectBy,
-    format,
-  }: StorageGetMessagesArg & {
-    format?: 'v1' | 'v2';
-  }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
-    return this.stores.memory.getMessages({ threadId, selectBy, format });
-  }
-
-  async getMessagesById({ messageIds, format }: { messageIds: string[]; format: 'v1' }): Promise<MastraMessageV1[]>;
-  async getMessagesById({ messageIds, format }: { messageIds: string[]; format?: 'v2' }): Promise<MastraMessageV2[]>;
-  async getMessagesById({
-    messageIds,
-    format,
-  }: {
-    messageIds: string[];
-    format?: 'v1' | 'v2';
-  }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
-    return this.stores.memory.getMessagesById({ messageIds, format });
-  }
-
-  async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
-  async saveMessages(args: { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[]>;
-  async saveMessages(
-    args: { messages: MastraMessageV1[]; format?: undefined | 'v1' } | { messages: MastraMessageV2[]; format: 'v2' },
-  ): Promise<MastraMessageV2[] | MastraMessageV1[]> {
-    return this.stores.memory.saveMessages(args);
-  }
-
-  async getThreadsByResourceIdPaginated(_args: {
-    resourceId: string;
-    page: number;
-    perPage: number;
-  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
-    return this.stores.memory.getThreadsByResourceIdPaginated(_args);
-  }
-
-  async getMessagesPaginated(
-    _args: StorageGetMessagesArg,
-  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
-    return this.stores.memory.getMessagesPaginated(_args);
-  }
-
-  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);
-  }
-
-  async getTraces(args: StorageGetTracesArg): Promise<Trace[]> {
-    return this.stores.traces.getTraces(args);
-  }
-
-  async getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & { traces: Trace[] }> {
-    return this.stores.traces.getTracesPaginated(args);
-  }
-
-  async getWorkflowRuns(args?: {
-    workflowName?: string;
-    fromDate?: Date;
-    toDate?: Date;
-    limit?: number;
-    offset?: number;
-    resourceId?: string;
-  }): Promise<WorkflowRuns> {
-    return this.stores.workflows.getWorkflowRuns(args);
-  }
-
-  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[]> {
-    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
-  }
-
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    snapshot,
-  }: {
-    workflowName: string;
-    runId: string;
-    snapshot: WorkflowRunState;
-  }): Promise<void> {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
-  }
-
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId,
-  }: {
-    workflowName: string;
-    runId: string;
-  }): Promise<WorkflowRunState | null> {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-
-  async getWorkflowRunById({
-    runId,
-    workflowName,
-  }: {
-    runId: string;
-    workflowName?: string;
-  }): Promise<WorkflowRun | null> {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-
-  async close(): Promise<void> {
-    try {
-      await this.#connector.close();
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_MONGODB_STORE_CLOSE_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-        },
-        error,
-      );
-    }
-  }
-
-  /**
-   * SCORERS
-   */
-  async getScoreById({ id }: { id: string }): Promise<ScoreRowData | null> {
-    return this.stores.scores.getScoreById({ id });
-  }
-
-  async saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{ score: ScoreRowData }> {
-    return this.stores.scores.saveScore(score);
-  }
-
-  async getScoresByRunId({
-    runId,
-    pagination,
-  }: {
-    runId: string;
-    pagination: StoragePagination;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    return this.stores.scores.getScoresByRunId({ runId, pagination });
-  }
-
-  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 getScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source,
-  }: {
-    scorerId: string;
-    pagination: StoragePagination;
-    entityId?: string;
-    entityType?: string;
-    source?: ScoringSource;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
-  }
-
-  /**
-   * RESOURCES
-   */
-  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-
-  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
-    return this.stores.memory.saveResource({ resource });
-  }
-
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata,
-  }: {
-    resourceId: string;
-    workingMemory?: string;
-    metadata?: Record<string, unknown>;
-  }): Promise<StorageResourceType> {
-    return this.stores.memory.updateResource({
-      resourceId,
-      workingMemory,
-      metadata,
-    });
-  }
-}