@mastra/mongodb 0.12.0 → 0.12.1

package/dist/_tsup-dts-rollup.d.ts

@@ -1,35 +1,166 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
+import { Collection } from 'mongodb';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
+import { Document } from 'mongodb';
 import type { EvalRow } from '@mastra/core/storage';
+import type { IMastraLogger } from '@mastra/core/logger';
 import type { IndexStats } from '@mastra/core/vector';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
 import type { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
+import { MemoryStorage } from '@mastra/core/storage';
+import { MongoClient } from 'mongodb';
 import type { MongoClientOptions } from 'mongodb';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
 import type { OperatorValueMap } from '@mastra/core/vector/filter';
+import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { ScoreRowData } from '@mastra/core/scores';
+import { ScoresStorage } from '@mastra/core/storage';
 import type { StorageColumn } from '@mastra/core/storage';
+import type { StorageDomains } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageGetTracesArg } from '@mastra/core/storage';
+import type { StorageGetTracesPaginatedArg } from '@mastra/core/storage';
+import type { StoragePagination } from '@mastra/core/storage';
+import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
+import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
+import { TracesStorage } from '@mastra/core/storage';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFieldValue } from '@mastra/core/vector/filter';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
+import { WorkflowsStorage } from '@mastra/core/storage';
+
+export declare interface ConnectorHandler {
+    getCollection(collectionName: string): Promise<Collection>;
+    close(): Promise<void>;
+}
+
+export declare interface ConnectorHandler_alias_1 {
+    getCollection(collectionName: string): Promise<Collection>;
+    close(): Promise<void>;
+}
+
+export declare function createExecuteOperationWithRetry({ logger, maxRetries, initialBackoffMs, }: {
+    logger: IMastraLogger;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+}): <T>(operationFn: () => Promise<T>, operationDescription: string) => Promise<T>;
+
+export declare type DatabaseConfig = {
+    url: string;
+    dbName: string;
+    options?: MongoClientOptions;
+};
+
+export declare function formatDateForMongoDB(date: Date | string): Date;
+
+export declare class LegacyEvalsMongoDB extends LegacyEvalsStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsMongoDB;
+    });
+    /** @deprecated use getEvals instead */
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
+export declare class MemoryStorageMongoDB extends MemoryStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsMongoDB;
+    });
+    private parseRow;
+    private _getIncludedMessages;
+    /**
+     * @deprecated use getMessagesPaginated instead for paginated results.
+     */
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2[]>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+}
 
 /**
  * Vector store specific prompt that details supported operators and examples.
@@ -41,13 +172,49 @@ export { MONGODB_PROMPT as MONGODB_PROMPT_alias_1 }
 
 declare type MongoDBBlacklisted = BlacklistedRootOperators | '$size';
 
-declare interface MongoDBConfig {
-    url: string;
-    dbName: string;
-    options?: MongoClientOptions;
+export declare type MongoDBConfig = DatabaseConfig | {
+    connectorHandler: ConnectorHandler_alias_1;
+};
+
+export declare class MongoDBConnector {
+    #private;
+    constructor(options: MongoDBConnectorOptions);
+    static fromDatabaseConfig(config: DatabaseConfig): MongoDBConnector;
+    static fromConnectionHandler(handler: ConnectorHandler): MongoDBConnector;
+    private getConnection;
+    getCollection(collectionName: string): Promise<Collection<Document>>;
+    close(): Promise<void>;
 }
-export { MongoDBConfig }
-export { MongoDBConfig as MongoDBConfig_alias_1 }
+
+export declare class MongoDBConnector_alias_1 {
+    #private;
+    constructor(options: MongoDBConnectorOptions_2);
+    static fromDatabaseConfig(config: DatabaseConfig): MongoDBConnector_alias_1;
+    static fromConnectionHandler(handler: ConnectorHandler_alias_1): MongoDBConnector_alias_1;
+    private getConnection;
+    getCollection(collectionName: string): Promise<Collection<Document>>;
+    close(): Promise<void>;
+}
+
+declare type MongoDBConnectorOptions = {
+    client: MongoClient;
+    dbName: string;
+    handler: undefined;
+} | {
+    client: undefined;
+    dbName: undefined;
+    handler: ConnectorHandler;
+};
+
+declare type MongoDBConnectorOptions_2 = {
+    client: MongoClient;
+    dbName: string;
+    handler: undefined;
+} | {
+    client: undefined;
+    dbName: undefined;
+    handler: ConnectorHandler_alias_1;
+};
 
 /**
  * Translator for MongoDB filter queries.
@@ -70,6 +237,10 @@ declare interface MongoDBIndexReadyParams {
 export { MongoDBIndexReadyParams }
 export { MongoDBIndexReadyParams as MongoDBIndexReadyParams_alias_1 }
 
+export declare interface MongoDBOperationsConfig {
+    connector: ConnectorHandler_alias_1;
+}
+
 declare type MongoDBOperatorValueMap = Omit<OperatorValueMap, '$options'> & {
     $size: number;
 };
@@ -80,21 +251,26 @@ declare interface MongoDBQueryVectorParams extends QueryVectorParams<MongoDBVect
 
 declare class MongoDBStore extends MastraStorage {
     #private;
+    stores: StorageDomains;
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
+    };
     constructor(config: MongoDBConfig);
-    private getConnection;
-    private getCollection;
-    createTable(): Promise<void>;
-    /**
-     * 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
-     */
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
     alterTable(_args: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
         ifNotExists: string[];
     }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
@@ -141,29 +317,42 @@ declare class MongoDBStore extends MastraStorage {
         messages: MastraMessageV2[];
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
-    getTraces({ name, scope, page, perPage, attributes, filters, }?: {
-        name?: string;
-        scope?: string;
+    getThreadsByResourceIdPaginated(_args: {
+        resourceId: string;
         page: number;
         perPage: number;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-    }): Promise<any[]>;
-    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, }?: {
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+    updateMessages(_args: {
+        messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        }[];
+    }): Promise<MastraMessageV2[]>;
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    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;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
     }>;
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
     persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
@@ -179,32 +368,54 @@ declare class MongoDBStore extends MastraStorage {
         runId: string;
         workflowName?: string;
     }): Promise<WorkflowRun | null>;
-    private parseWorkflowRun;
-    private parseRow;
-    private transformEvalRow;
-    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
-        traces: Trace[];
+    close(): Promise<void>;
+    /**
+     * SCORERS
+     */
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
     }>;
-    getThreadsByResourceIdPaginated(_args: {
-        resourceId: string;
-        page?: number;
-        perPage?: number;
-    }): Promise<PaginationInfo & {
-        threads: StorageThreadType[];
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
     }>;
-    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
-        messages: MastraMessageV1[] | MastraMessageV2[];
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
     }>;
-    close(): Promise<void>;
-    updateMessages(_args: {
-        messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
-            id: string;
-            content?: {
-                metadata?: MastraMessageContentV2['metadata'];
-                content?: MastraMessageContentV2['content'];
-            };
-        }[];
-    }): Promise<MastraMessageV2[]>;
+    getScoresByScorerId({ scorerId, pagination, entityId, entityType, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+        entityId?: string;
+        entityType?: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    /**
+     * RESOURCES
+     */
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
 }
 export { MongoDBStore }
 export { MongoDBStore as MongoDBStore_alias_1 }
@@ -281,4 +492,115 @@ export { MongoDBVector as MongoDBVector_alias_1 }
 
 export declare type MongoDBVectorFilter = VectorFilter<keyof MongoDBOperatorValueMap, MongoDBOperatorValueMap, LogicalOperatorValueMap, MongoDBBlacklisted, VectorFieldValue | RegExp>;
 
+export declare class ScoresStorageMongoDB extends ScoresStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsMongoDB;
+    });
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByScorerId({ scorerId, pagination, entityId, entityType, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+        entityId?: string;
+        entityType?: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+}
+
+export declare class StoreOperationsMongoDB extends StoreOperations {
+    #private;
+    constructor(config: MongoDBOperationsConfig);
+    getCollection(collectionName: string): Promise<Collection<Document>>;
+    hasColumn(_table: string, _column: string): Promise<boolean>;
+    createTable(): Promise<void>;
+    alterTable(_args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+}
+
+export declare class TracesStorageMongoDB extends TracesStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsMongoDB;
+    });
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
+export declare class WorkflowsStorageMongoDB extends WorkflowsStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsMongoDB;
+    });
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    getWorkflowRuns(args?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById(args: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+    private parseWorkflowRun;
+}
+
 export { }