@mastra/pg 0.12.3 → 0.12.4-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.12.3-alpha.0 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.12.4-alpha.0 build /home/runner/work/mastra/mastra/stores/pg
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 12290ms
+TSC ⚡️ Build success in 18224ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 12231ms
+DTS ⚡️ Build success in 13124ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 86.90 KB
-ESM ⚡️ Build success in 1870ms
-CJS dist/index.cjs 88.28 KB
-CJS ⚡️ Build success in 1870ms
+ESM dist/index.js 102.98 KB
+ESM ⚡️ Build success in 2337ms
+CJS dist/index.cjs 104.50 KB
+CJS ⚡️ Build success in 2337ms

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @mastra/pg
 
+## 0.12.4-alpha.0
+
+### Patch Changes
+
+- 7ba91fa: Throw mastra errors methods not implemented yet
+- a74b8e3: Wrapped the query method logic inside of a transaction to ensure `SET LOCAL` works as expected -- properly sets the `hnsw.ef_search` value
+- Updated dependencies [f248d53]
+- Updated dependencies [2affc57]
+- Updated dependencies [66e13e3]
+- Updated dependencies [edd9482]
+- Updated dependencies [18344d7]
+- Updated dependencies [9d372c2]
+- Updated dependencies [40c2525]
+- Updated dependencies [e473f27]
+- Updated dependencies [032cb66]
+- Updated dependencies [703ac71]
+- Updated dependencies [a723d69]
+- Updated dependencies [5889a31]
+- Updated dependencies [65e3395]
+- Updated dependencies [4933192]
+- Updated dependencies [d1c77a4]
+- Updated dependencies [bea9dd1]
+- Updated dependencies [dcd4802]
+- Updated dependencies [7ba91fa]
+  - @mastra/core@0.11.0-alpha.2
+
 ## 0.12.3
 
 ### Patch Changes

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

@@ -5,34 +5,53 @@ import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
+import type { IDatabase } from 'pg-promise';
 import type { IndexStats } from '@mastra/core/vector';
 import type { ISSLConfig } from 'pg-promise/typescript/pg-subset';
+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/agent';
+import type { MastraMessageV2 as MastraMessageV2_2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
+import { MemoryStorage } from '@mastra/core/storage';
 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 { PaginationInfo as PaginationInfo_2 } from '@mastra/core';
 import pg from 'pg';
 import pgPromise from 'pg-promise';
 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 { StoragePagination as StoragePagination_2 } from '@mastra/core';
 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 { WorkflowRun as WorkflowRun_2 } from '@mastra/core';
 import type { WorkflowRuns } from '@mastra/core/storage';
+import type { WorkflowRuns as WorkflowRuns_2 } from '@mastra/core';
 import type { WorkflowRunState } from '@mastra/core/workflows';
+import type { WorkflowRunState as WorkflowRunState_2 } from '@mastra/core';
+import { WorkflowsStorage } from '@mastra/core/storage';
 
 export declare const baseTestConfigs: {
     smokeTests: {
@@ -73,6 +92,8 @@ export declare const calculateRecall: (actual: number[], expected: number[], k:
 
 export declare const calculateTimeout: (dimension: number, size: number, k: number) => number;
 
+export declare const connectionString: string;
+
 export declare function cosineSimilarity(a: number[], b: number[]): number;
 
 declare interface FilterResult {
@@ -105,12 +126,19 @@ export declare function getIndexDescription({ type, hnsw, }: {
 
 export declare const getListCount: (indexConfig: IndexConfig, size: number) => number | undefined;
 
+export declare function getSchemaName(schema?: string): string | undefined;
+
 export declare function getSearchEf(k: number, m: number): {
     default: number;
     lower: number;
     higher: number;
 };
 
+export declare function getTableName({ indexName, schemaName }: {
+    indexName: string;
+    schemaName?: string;
+}): string;
+
 export declare const groupBy: <T, K extends keyof T>(array: T[], key: K | ((item: T) => string), reducer?: (group: T[]) => any) => Record<string, any>;
 
 declare interface HNSWConfig {
@@ -130,8 +158,106 @@ declare interface IVFConfig {
     lists?: number;
 }
 
+export declare class LegacyEvalsPG extends LegacyEvalsStorage {
+    private client;
+    private schema;
+    constructor({ client, schema }: {
+        client: IDatabase<{}>;
+        schema: string;
+    });
+    /** @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 function measureLatency<T>(fn: () => Promise<T>): Promise<[number, T]>;
 
+export declare class MemoryPG extends MemoryStorage {
+    private client;
+    private schema;
+    private operations;
+    constructor({ client, schema, operations, }: {
+        client: IDatabase<{}>;
+        schema: string;
+        operations: StoreOperationsPG;
+    });
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    /**
+     * @deprecated use getThreadsByResourceIdPaginated instead
+     */
+    getThreadsByResourceId(args: {
+        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>;
+    private _getIncludedMessages;
+    /**
+     * @deprecated use getMessagesPaginated instead
+     */
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2_2[];
+    }>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2_2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2_2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2_2[]>;
+    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>;
+}
+
 declare type PGBlacklisted = BlacklistedRootOperators | '$contains' | '$size';
 
 declare interface PgCreateIndexParams extends CreateIndexParams {
@@ -200,6 +326,8 @@ declare interface PgQueryVectorParams extends QueryVectorParams<PGVectorFilter>
     probes?: number;
 }
 
+export declare function pgTests(): void;
+
 declare class PgVector extends MastraVector<PGVectorFilter> {
     pool: pg.Pool;
     private describeIndexCache;
@@ -292,56 +420,38 @@ export { PostgresConfig as PostgresConfig_alias_1 }
 declare class PostgresStore extends MastraStorage {
     db: pgPromise.IDatabase<{}>;
     pgp: pgPromise.IMain;
+    private client;
     private schema?;
-    private setupSchemaPromise;
-    private schemaSetupComplete;
+    stores: StorageDomains;
     constructor(config: PostgresConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
         resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
     };
-    private getTableName;
-    private getSchemaName;
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
-    private transformEvalRow;
-    batchInsert({ tableName, records }: {
-        tableName: TABLE_NAMES;
-        records: Record<string, any>[];
-    }): Promise<void>;
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
     /**
      * @deprecated use getTracesPaginated instead
      */
-    getTraces(args: {
-        name?: string;
-        scope?: string;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-        page: number;
-        perPage?: number;
-        fromDate?: Date;
-        toDate?: Date;
-    }): Promise<any[]>;
-    getTracesPaginated(args: {
-        name?: string;
-        scope?: string;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-    } & PaginationArgs): Promise<PaginationInfo & {
-        traces: any[];
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
     }>;
-    private setupSchema;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
-    protected getDefaultValue(type: StorageColumn['type']): string;
-    /**
-     * Alters table schema to add columns if they don't exist
-     * @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
-     */
     alterTable({ tableName, schema, ifNotExists, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
@@ -350,14 +460,24 @@ declare class PostgresStore extends MastraStorage {
     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>;
+    /**
+     * Memory
+     */
     getThreadById({ threadId }: {
         threadId: string;
     }): Promise<StorageThreadType | null>;
@@ -369,7 +489,9 @@ declare class PostgresStore extends MastraStorage {
     }): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
-    } & PaginationArgs): Promise<PaginationInfo & {
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -383,7 +505,6 @@ declare class PostgresStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    private _getIncludedMessages;
     /**
      * @deprecated use getMessagesPaginated instead
      */
@@ -406,6 +527,29 @@ declare class PostgresStore extends MastraStorage {
         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>;
+    /**
+     * Workflows
+     */
     persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
         workflowName: string;
         runId: string;
@@ -415,8 +559,6 @@ declare class PostgresStore extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
-    private hasColumn;
-    private parseWorkflowRun;
     getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         workflowName?: string;
         fromDate?: Date;
@@ -430,36 +572,127 @@ declare class PostgresStore extends MastraStorage {
         workflowName?: string;
     }): Promise<WorkflowRun | null>;
     close(): Promise<void>;
-    getEvals(options?: {
-        agentName?: string;
-        type?: 'test' | 'live';
-    } & PaginationArgs): Promise<PaginationInfo & {
-        evals: EvalRow[];
+    /**
+     * Scorers
+     */
+    getScoreById({ id: _id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    saveScore(_score: ScoreRowData): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByRunId({ runId: _runId, pagination: _pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId: _entityId, entityType: _entityType, pagination: _pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
     }>;
-    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>;
 }
 export { PostgresStore }
 export { PostgresStore as PostgresStore_alias_1 }
 
+export declare class ScoresPG extends ScoresStorage {
+    client: IDatabase<{}>;
+    private operations;
+    constructor({ client, operations }: {
+        client: IDatabase<{}>;
+        operations: StoreOperationsPG;
+    });
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination_2;
+    }): Promise<{
+        pagination: PaginationInfo_2;
+        scores: ScoreRowData[];
+    }>;
+    saveScore(score: Omit<ScoreRowData, 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination_2;
+    }): Promise<{
+        pagination: PaginationInfo_2;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination_2;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo_2;
+        scores: ScoreRowData[];
+    }>;
+}
+
+export declare class StoreOperationsPG extends StoreOperations {
+    client: IDatabase<{}>;
+    schemaName?: string;
+    private setupSchemaPromise;
+    private schemaSetupComplete;
+    constructor({ client, schemaName }: {
+        client: IDatabase<{}>;
+        schemaName?: string;
+    });
+    hasColumn(table: string, column: string): Promise<boolean>;
+    private setupSchema;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    protected getDefaultValue(type: StorageColumn['type']): string;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    /**
+     * Alters table schema to add columns if they don't exist
+     * @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
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+}
+
+export declare const TEST_CONFIG: PostgresConfig;
+
 export declare interface TestConfig {
     dimension: number;
     size: number;
@@ -494,6 +727,56 @@ export declare interface TestResult {
     };
 }
 
+export declare class TracesPG extends TracesStorage {
+    client: IDatabase<{}>;
+    private operations;
+    private schema?;
+    constructor({ client, operations, schema, }: {
+        client: IDatabase<{}>;
+        operations: StoreOperationsPG;
+        schema?: string;
+    });
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
 export declare function warmupQuery(vectorDB: PgVector, indexName: string, dimension: number, k: number): Promise<void>;
 
+export declare class WorkflowsPG extends WorkflowsStorage {
+    client: IDatabase<{}>;
+    private operations;
+    private schema;
+    constructor({ client, operations, schema, }: {
+        client: IDatabase<{}>;
+        operations: StoreOperationsPG;
+        schema: string;
+    });
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState_2;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState_2 | null>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun_2 | null>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns_2>;
+}
+
 export { }