@mastra/pg 0.1.0-alpha.13 → 0.1.0-alpha.15

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @mastra/pg
 
+## 0.1.0-alpha.15
+
+### Patch Changes
+
+- Updated dependencies [1420ae2]
+- Updated dependencies [99f1847]
+  - @mastra/core@0.2.0-alpha.105
+
+## 0.1.0-alpha.14
+
+### Patch Changes
+
+- b97ca96: Tracing into default storage
+- Updated dependencies [5fdc87c]
+- Updated dependencies [b97ca96]
+- Updated dependencies [72d1990]
+- Updated dependencies [cf6d825]
+- Updated dependencies [10870bc]
+  - @mastra/core@0.2.0-alpha.104
+
 ## 0.1.0-alpha.13
 
 ### Patch Changes

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

@@ -2,6 +2,7 @@ import { ArrayOperator } from '@mastra/core/filter';
 import { BaseFilterTranslator } from '@mastra/core/filter';
 import { BasicOperator } from '@mastra/core/filter';
 import { ElementOperator } from '@mastra/core/filter';
+import { EvalRow } from '@mastra/core/storage';
 import { Filter } from '@mastra/core/filter';
 import { IndexStats } from '@mastra/core/vector';
 import { LogicalOperator } from '@mastra/core/filter';
@@ -88,6 +89,18 @@ declare class PostgresStore extends MastraStorage {
     private db;
     private pgp;
     constructor(config: PostgresConfig);
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    getTraces({ name, scope, page, perPage, attributes, }: {
+        name?: string;
+        scope?: string;
+        page: number;
+        perPage: number;
+        attributes?: Record<string, string>;
+    }): Promise<any[]>;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;

package/dist/index.js

@@ -516,6 +516,86 @@ var PostgresStore = class extends MastraStorage {
       }
     );
   }
+  getEvalsByAgentName(agentName, type) {
+    throw new Error("Method not implemented.");
+  }
+  async batchInsert({ tableName, records }) {
+    try {
+      await this.db.query("BEGIN");
+      for (const record of records) {
+        await this.insert({ tableName, record });
+      }
+      await this.db.query("COMMIT");
+    } catch (error) {
+      console.error(`Error inserting into ${tableName}:`, error);
+      await this.db.query("ROLLBACK");
+      throw error;
+    }
+  }
+  async getTraces({
+    name,
+    scope,
+    page,
+    perPage,
+    attributes
+  }) {
+    let idx = 1;
+    const limit = perPage;
+    const offset = page * perPage;
+    const args = [];
+    const conditions = [];
+    if (name) {
+      conditions.push(`name LIKE CONCAT($${idx++}, '%')`);
+    }
+    if (scope) {
+      conditions.push(`scope = $${idx++}`);
+    }
+    if (attributes) {
+      Object.keys(attributes).forEach((key) => {
+        conditions.push(`attributes->>'${key}' = $${idx++}`);
+      });
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    if (name) {
+      args.push(name);
+    }
+    if (scope) {
+      args.push(scope);
+    }
+    if (attributes) {
+      for (const [_key, value] of Object.entries(attributes)) {
+        args.push(value);
+      }
+    }
+    console.log(
+      "QUERY",
+      `SELECT * FROM ${MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      args
+    );
+    const result = await this.db.manyOrNone(
+      `SELECT * FROM ${MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      args
+    );
+    if (!result) {
+      return [];
+    }
+    return result.map((row) => ({
+      id: row.id,
+      parentSpanId: row.parentSpanId,
+      traceId: row.traceId,
+      name: row.name,
+      scope: row.scope,
+      kind: row.kind,
+      status: row.status,
+      events: row.events,
+      links: row.links,
+      attributes: row.attributes,
+      startTime: row.startTime,
+      endTime: row.endTime,
+      other: row.other,
+      createdAt: row.createdAt
+    }));
+  }
   async createTable({
     tableName,
     schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.1.0-alpha.13",
+  "version": "0.1.0-alpha.15",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
   "dependencies": {
     "pg": "^8.13.1",
     "pg-promise": "^11.5.4",
-    "@mastra/core": "^0.2.0-alpha.103"
+    "@mastra/core": "^0.2.0-alpha.105"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",

package/src/storage/index.ts

@@ -1,8 +1,22 @@
 import { type MessageType, type StorageThreadType } from '@mastra/core/memory';
-import { MastraStorage, type StorageColumn, type StorageGetMessagesArg, type TABLE_NAMES } from '@mastra/core/storage';
+import {
+  MastraStorage,
+  type EvalRow,
+  type StorageColumn,
+  type StorageGetMessagesArg,
+  type TABLE_NAMES,
+} from '@mastra/core/storage';
 import { type WorkflowRunState } from '@mastra/core/workflows';
 import pgPromise from 'pg-promise';
 
+function safelyParseJSON(json: string): any {
+  try {
+    return JSON.parse(json);
+  } catch (e) {
+    return {};
+  }
+}
+
 export type PostgresConfig =
   | {
       host: string;
@@ -35,6 +49,120 @@ export class PostgresStore extends MastraStorage {
     );
   }
 
+  getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
+    try {
+      await this.db.query('BEGIN');
+      for (const record of records) {
+        await this.insert({ tableName, record });
+      }
+      await this.db.query('COMMIT');
+    } catch (error) {
+      console.error(`Error inserting into ${tableName}:`, error);
+      await this.db.query('ROLLBACK');
+      throw error;
+    }
+  }
+
+  async getTraces({
+    name,
+    scope,
+    page,
+    perPage,
+    attributes,
+  }: {
+    name?: string;
+    scope?: string;
+    page: number;
+    perPage: number;
+    attributes?: Record<string, string>;
+  }): Promise<any[]> {
+    let idx = 1;
+    const limit = perPage;
+    const offset = page * perPage;
+
+    const args: (string | number)[] = [];
+
+    const conditions: string[] = [];
+    if (name) {
+      conditions.push(`name LIKE CONCAT(\$${idx++}, '%')`);
+    }
+    if (scope) {
+      conditions.push(`scope = \$${idx++}`);
+    }
+    if (attributes) {
+      Object.keys(attributes).forEach(key => {
+        conditions.push(`attributes->>'${key}' = \$${idx++}`);
+      });
+    }
+
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+    if (name) {
+      args.push(name);
+    }
+
+    if (scope) {
+      args.push(scope);
+    }
+
+    if (attributes) {
+      for (const [_key, value] of Object.entries(attributes)) {
+        args.push(value);
+      }
+    }
+
+    console.log(
+      'QUERY',
+      `SELECT * FROM ${MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      args,
+    );
+
+    const result = await this.db.manyOrNone<{
+      id: string;
+      parentSpanId: string;
+      traceId: string;
+      name: string;
+      scope: string;
+      kind: string;
+      events: any[];
+      links: any[];
+      status: any;
+      attributes: Record<string, any>;
+      startTime: string;
+      endTime: string;
+      other: any;
+      createdAt: string;
+    }>(
+      `SELECT * FROM ${MastraStorage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+      args,
+    );
+
+    if (!result) {
+      return [];
+    }
+
+    return result.map(row => ({
+      id: row.id,
+      parentSpanId: row.parentSpanId,
+      traceId: row.traceId,
+      name: row.name,
+      scope: row.scope,
+      kind: row.kind,
+      status: row.status,
+      events: row.events,
+      links: row.links,
+      attributes: row.attributes,
+      startTime: row.startTime,
+      endTime: row.endTime,
+      other: row.other,
+      createdAt: row.createdAt,
+    })) as any;
+  }
+
   async createTable({
     tableName,
     schema,