@mastra/pg 0.1.0-alpha.2 → 0.1.0-alpha.20

package/CHANGELOG.md

@@ -1,5 +1,163 @@
 # @mastra/pg
 
+## 0.1.0-alpha.20
+
+### Patch Changes
+
+- Updated dependencies [016493a]
+- Updated dependencies [382f4dc]
+- Updated dependencies [176bc42]
+- Updated dependencies [d68b532]
+- Updated dependencies [fe3dcb0]
+- Updated dependencies [e448a26]
+- Updated dependencies [fd75f3c]
+- Updated dependencies [ccf115c]
+- Updated dependencies [a221426]
+  - @mastra/core@0.2.0-alpha.110
+
+## 0.1.0-alpha.19
+
+### Patch Changes
+
+- Updated dependencies [d5fccfb]
+  - @mastra/core@0.2.0-alpha.109
+
+## 0.1.0-alpha.18
+
+### Patch Changes
+
+- Updated dependencies [5ee67d3]
+- Updated dependencies [95a4697]
+  - @mastra/core@0.2.0-alpha.108
+
+## 0.1.0-alpha.17
+
+### Patch Changes
+
+- Updated dependencies [66a5392]
+  - @mastra/core@0.2.0-alpha.107
+
+## 0.1.0-alpha.16
+
+### Patch Changes
+
+- Updated dependencies [6f2c0f5]
+- Updated dependencies [a8a459a]
+  - @mastra/core@0.2.0-alpha.106
+
+## 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
+
+- Updated dependencies [4534e77]
+  - @mastra/core@0.2.0-alpha.103
+
+## 0.1.0-alpha.12
+
+### Patch Changes
+
+- Updated dependencies [a9345f9]
+  - @mastra/core@0.2.0-alpha.102
+
+## 0.1.0-alpha.11
+
+### Patch Changes
+
+- 4f1d1a1: Enforce types ann cleanup package.json
+- Updated dependencies [66a03ec]
+- Updated dependencies [4f1d1a1]
+  - @mastra/core@0.2.0-alpha.101
+
+## 0.1.0-alpha.10
+
+### Patch Changes
+
+- Updated dependencies [9d1796d]
+  - @mastra/core@0.2.0-alpha.100
+
+## 0.1.0-alpha.9
+
+### Patch Changes
+
+- Updated dependencies [7d83b92]
+  - @mastra/core@0.2.0-alpha.99
+
+## 0.1.0-alpha.8
+
+### Patch Changes
+
+- 70dabd9: Fix broken publish
+- Updated dependencies [70dabd9]
+- Updated dependencies [202d404]
+  - @mastra/core@0.2.0-alpha.98
+
+## 0.1.0-alpha.7
+
+### Patch Changes
+
+- 07c069d: Update build script
+- Updated dependencies [07c069d]
+- Updated dependencies [7892533]
+- Updated dependencies [e6d8055]
+- Updated dependencies [5950de5]
+- Updated dependencies [df843d3]
+- Updated dependencies [a870123]
+  - @mastra/core@0.2.0-alpha.97
+
+## 0.1.0-alpha.6
+
+### Patch Changes
+
+- Updated dependencies [74b3078]
+  - @mastra/core@0.2.0-alpha.96
+
+## 0.1.0-alpha.5
+
+### Patch Changes
+
+- Updated dependencies [9fb59d6]
+  - @mastra/core@0.2.0-alpha.95
+
+## 0.1.0-alpha.4
+
+### Minor Changes
+
+- 8b416d9: Breaking changes
+
+### Patch Changes
+
+- 9c10484: update all packages
+- Updated dependencies [9c10484]
+- Updated dependencies [8b416d9]
+  - @mastra/core@0.2.0-alpha.94
+
+## 0.1.0-alpha.3
+
+### Patch Changes
+
+- Updated dependencies [5285356]
+  - @mastra/core@0.2.0-alpha.93
+
 ## 0.1.0-alpha.2
 
 ### Minor Changes

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

@@ -0,0 +1,154 @@
+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';
+import { MastraStorage } from '@mastra/core/storage';
+import { MastraVector } from '@mastra/core/vector';
+import { MessageType } from '@mastra/core/memory';
+import { NumericOperator } from '@mastra/core/filter';
+import { OperatorSupport } from '@mastra/core/filter';
+import { QueryResult } from '@mastra/core/vector';
+import { RegexOperator } from '@mastra/core/filter';
+import { StorageColumn } from '@mastra/core/storage';
+import { StorageGetMessagesArg } from '@mastra/core/storage';
+import { StorageThreadType } from '@mastra/core/memory';
+import { TABLE_NAMES } from '@mastra/core/storage';
+import { WorkflowRunState } from '@mastra/core/workflows';
+
+export declare function buildFilterQuery(filter: Filter, minScore: number): FilterResult;
+
+export declare const FILTER_OPERATORS: Record<string, OperatorFn>;
+
+declare type FilterOperator = {
+    sql: string;
+    needsValue: boolean;
+    transformValue?: (value: any) => any;
+};
+
+export declare interface FilterResult {
+    sql: string;
+    values: any[];
+}
+
+export declare const handleKey: (key: string) => string;
+
+declare type OperatorFn = (key: string, paramIndex: number, value?: any) => FilterOperator;
+
+export declare type OperatorType = BasicOperator | NumericOperator | ArrayOperator | ElementOperator | LogicalOperator | '$contains' | Exclude<RegexOperator, '$options'>;
+
+/**
+ * Translates MongoDB-style filters to PG compatible filters.
+ *
+ * Key differences from MongoDB:
+ *
+ * Logical Operators ($and, $or, $nor):
+ * - Can be used at the top level or nested within fields
+ * - Can take either a single condition or an array of conditions
+ *
+ */
+export declare class PGFilterTranslator extends BaseFilterTranslator {
+    protected getSupportedOperators(): OperatorSupport;
+    translate(filter: Filter): Filter;
+    private translateNode;
+    private translateRegexPattern;
+}
+
+declare class PgVector extends MastraVector {
+    private pool;
+    constructor(connectionString: string);
+    transformFilter(filter?: Filter): Filter;
+    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean, minScore?: number): Promise<QueryResult[]>;
+    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
+    createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    deleteIndex(indexName: string): Promise<void>;
+    truncateIndex(indexName: string): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export { PgVector }
+export { PgVector as PgVector_alias_1 }
+
+declare type PostgresConfig = {
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+} | {
+    connectionString: string;
+};
+export { PostgresConfig }
+export { PostgresConfig as PostgresConfig_alias_1 }
+
+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>;
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<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>;
+    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T>;
+    saveMessages({ messages }: {
+        messages: MessageType[];
+    }): Promise<MessageType[]>;
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    close(): Promise<void>;
+}
+export { PostgresStore }
+export { PostgresStore as PostgresStore_alias_1 }
+
+export { }

package/dist/index.d.ts

@@ -1,82 +1,3 @@
-import { Filter } from '@mastra/core/filter';
-import { MastraVector, QueryResult, IndexStats } from '@mastra/core/vector';
-import { StorageThreadType, MessageType } from '@mastra/core/memory';
-import { MastraStorage, TABLE_NAMES, StorageColumn, StorageGetMessagesArg } from '@mastra/core/storage';
-import { WorkflowRunState } from '@mastra/core/workflows';
-
-declare class PgVector extends MastraVector {
-    private pool;
-    constructor(connectionString: string);
-    transformFilter(filter?: Filter): Filter;
-    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean, minScore?: number): Promise<QueryResult[]>;
-    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
-    createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
-    listIndexes(): Promise<string[]>;
-    describeIndex(indexName: string): Promise<IndexStats>;
-    deleteIndex(indexName: string): Promise<void>;
-    truncateIndex(indexName: string): Promise<void>;
-    disconnect(): Promise<void>;
-}
-
-type PostgresConfig = {
-    host: string;
-    port: number;
-    database: string;
-    user: string;
-    password: string;
-} | {
-    connectionString: string;
-};
-declare class PostgresStore extends MastraStorage {
-    private db;
-    private pgp;
-    constructor(config: PostgresConfig);
-    createTable({ tableName, schema, }: {
-        tableName: TABLE_NAMES;
-        schema: Record<string, StorageColumn>;
-    }): Promise<void>;
-    clearTable({ tableName }: {
-        tableName: TABLE_NAMES;
-    }): Promise<void>;
-    insert({ tableName, record }: {
-        tableName: TABLE_NAMES;
-        record: Record<string, any>;
-    }): Promise<void>;
-    load<R>({ tableName, keys }: {
-        tableName: TABLE_NAMES;
-        keys: Record<string, string>;
-    }): Promise<R | null>;
-    getThreadById({ threadId }: {
-        threadId: string;
-    }): Promise<StorageThreadType | null>;
-    getThreadsByResourceId({ resourceId }: {
-        resourceId: string;
-    }): Promise<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>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T>;
-    saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
-    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
-        workflowName: string;
-        runId: string;
-        snapshot: WorkflowRunState;
-    }): Promise<void>;
-    loadWorkflowSnapshot({ workflowName, runId, }: {
-        workflowName: string;
-        runId: string;
-    }): Promise<WorkflowRunState | null>;
-    close(): Promise<void>;
-}
-
-export { PgVector, type PostgresConfig, PostgresStore };
+export { PgVector } from './_tsup-dts-rollup.js';
+export { PostgresConfig } from './_tsup-dts-rollup.js';
+export { PostgresStore } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -285,6 +285,7 @@ function buildFilterQuery(filter, minScore) {
 
 // src/vector/index.ts
 var PgVector = class extends MastraVector {
+  pool;
   constructor(connectionString) {
     super();
     const basePool = new pg.Pool({
@@ -500,6 +501,8 @@ var PgVector = class extends MastraVector {
   }
 };
 var PostgresStore = class extends MastraStorage {
+  db;
+  pgp;
   constructor(config) {
     super({ name: "PostgresStore" });
     this.pgp = pgPromise();
@@ -513,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.2",
+  "version": "0.1.0-alpha.20",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -17,18 +17,19 @@
   "dependencies": {
     "pg": "^8.13.1",
     "pg-promise": "^11.5.4",
-    "@mastra/core": "^0.2.0-alpha.92"
+    "@mastra/core": "^0.2.0-alpha.110"
   },
   "devDependencies": {
-    "@tsconfig/recommended": "^1.0.7",
-    "@types/node": "^22.9.0",
+    "@microsoft/api-extractor": "^7.49.2",
+    "@types/node": "^22.13.1",
     "@types/pg": "^8.11.10",
     "tsup": "^8.0.1",
+    "typescript": "^5.7.3",
     "vitest": "^3.0.4"
   },
   "scripts": {
-    "build": "tsup-node src/index.ts --format esm --dts --clean --treeshake",
-    "dev": "tsup-node src/index.ts --format esm --dts --clean --treeshake --watch",
+    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
+    "build:watch": "pnpm build --watch",
     "pretest": "docker compose up -d && (for i in $(seq 1 30); do docker compose exec -T db pg_isready -U postgres && break || (sleep 1; [ $i -eq 30 ] && exit 1); done)",
     "test": "vitest run",
     "posttest": "docker compose down -v",

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,

package/src/vector/filter.ts

@@ -1,4 +1,4 @@
-import { BaseFilterTranslator, FieldCondition, Filter, OperatorSupport } from '@mastra/core/filter';
+import { BaseFilterTranslator, type FieldCondition, type Filter, type OperatorSupport } from '@mastra/core/filter';
 
 /**
  * Translates MongoDB-style filters to PG compatible filters.

package/src/vector/sql-builder.ts

@@ -1,11 +1,11 @@
 import {
-  BasicOperator,
-  NumericOperator,
-  ArrayOperator,
-  ElementOperator,
-  LogicalOperator,
-  RegexOperator,
-  Filter,
+  type BasicOperator,
+  type NumericOperator,
+  type ArrayOperator,
+  type ElementOperator,
+  type LogicalOperator,
+  type RegexOperator,
+  type Filter,
 } from '@mastra/core/filter';
 
 export type OperatorType =

package/tsconfig.json

@@ -1,15 +1,5 @@
 {
   "extends": "../../tsconfig.node.json",
-  "compilerOptions": {
-    "moduleResolution": "bundler",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "module": "ES2022",
-    "target": "ES2020",
-    "declaration": true,
-    "declarationMap": true,
-    "noEmit": false
-  },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "**/*.test.ts"]
 }