@mastra/pg 0.12.0 → 0.12.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.12.0-alpha.3 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.12.1-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 10128ms
+TSC ⚡️ Build success in 11911ms
 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 11992ms
+DTS ⚡️ Build success in 12897ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 87.61 KB
-CJS ⚡️ Build success in 1941ms
-ESM dist/index.js 86.23 KB
-ESM ⚡️ Build success in 1945ms
+CJS dist/index.cjs 88.25 KB
+CJS ⚡️ Build success in 1549ms
+ESM dist/index.js 86.87 KB
+ESM ⚡️ Build success in 1554ms

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @mastra/pg
 
+## 0.12.1
+
+### Patch Changes
+
+- e0ad8e3: Exposes database connection objects as public fields in PostgresStore and PgVector classes to enable direct database operations and connection monitoring.
+- Updated dependencies [9dda1ac]
+- Updated dependencies [c984582]
+- Updated dependencies [7e801dd]
+- Updated dependencies [a606c75]
+- Updated dependencies [7aa70a4]
+- Updated dependencies [764f86a]
+- Updated dependencies [1760a1c]
+- Updated dependencies [038e5ae]
+- Updated dependencies [7dda16a]
+- Updated dependencies [5ebfcdd]
+- Updated dependencies [b2d0c91]
+- Updated dependencies [4e809ad]
+- Updated dependencies [57929df]
+- Updated dependencies [b7852ed]
+- Updated dependencies [6320a61]
+  - @mastra/core@0.10.9
+
+## 0.12.1-alpha.0
+
+### Patch Changes
+
+- e0ad8e3: Exposes database connection objects as public fields in PostgresStore and PgVector classes to enable direct database operations and connection monitoring.
+- Updated dependencies [9dda1ac]
+- Updated dependencies [c984582]
+- Updated dependencies [7e801dd]
+- Updated dependencies [a606c75]
+- Updated dependencies [7aa70a4]
+- Updated dependencies [764f86a]
+- Updated dependencies [1760a1c]
+- Updated dependencies [038e5ae]
+- Updated dependencies [7dda16a]
+- Updated dependencies [5ebfcdd]
+- Updated dependencies [b2d0c91]
+- Updated dependencies [4e809ad]
+- Updated dependencies [57929df]
+- Updated dependencies [b7852ed]
+- Updated dependencies [6320a61]
+  - @mastra/core@0.10.9-alpha.0
+
 ## 0.12.0
 
 ### Minor Changes
@@ -1577,7 +1621,6 @@
 ### Minor Changes
 
 - c87eb4e: Combine PostgreSQL packages into `@mastra/pg`.
-
   - Move and combine packages to `stores/pg`
   - Reorganize source files into `src/vector` and `src/store`
   - Add deprecation notices to old packages
@@ -1911,7 +1954,6 @@
 ### Minor Changes
 
 - c87eb4e: Combine PostgreSQL packages into `@mastra/pg`.
-
   - Move and combine packages to `stores/pg`
   - Reorganize source files into `src/vector` and `src/store`
   - Add deprecation notices to old packages

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

@@ -18,6 +18,7 @@ import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 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 { StorageColumn } from '@mastra/core/storage';
@@ -200,7 +201,7 @@ declare interface PgQueryVectorParams extends QueryVectorParams<PGVectorFilter>
 }
 
 declare class PgVector extends MastraVector<PGVectorFilter> {
-    private pool;
+    pool: pg.Pool;
     private describeIndexCache;
     private createdIndexes;
     private mutexesByName;
@@ -289,8 +290,8 @@ export { PostgresConfig }
 export { PostgresConfig as PostgresConfig_alias_1 }
 
 declare class PostgresStore extends MastraStorage {
-    private db;
-    private pgp;
+    db: pgPromise.IDatabase<{}>;
+    pgp: pgPromise.IMain;
     private schema?;
     private setupSchemaPromise;
     private schemaSetupComplete;

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

@@ -18,6 +18,7 @@ import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 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 { StorageColumn } from '@mastra/core/storage';
@@ -200,7 +201,7 @@ declare interface PgQueryVectorParams extends QueryVectorParams<PGVectorFilter>
 }
 
 declare class PgVector extends MastraVector<PGVectorFilter> {
-    private pool;
+    pool: pg.Pool;
     private describeIndexCache;
     private createdIndexes;
     private mutexesByName;
@@ -289,8 +290,8 @@ export { PostgresConfig }
 export { PostgresConfig as PostgresConfig_alias_1 }
 
 declare class PostgresStore extends MastraStorage {
-    private db;
-    private pgp;
+    db: pgPromise.IDatabase<{}>;
+    pgp: pgPromise.IMain;
     private schema?;
     private setupSchemaPromise;
     private schemaSetupComplete;

package/dist/index.cjs

@@ -1954,7 +1954,17 @@ var PostgresStore = class extends storage.MastraStorage {
       )} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
       const rows = await this.db.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
       messages.push(...rows || []);
-      const list = new agent.MessageList().add(messages, "memory");
+      const messagesWithParsedContent = messages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            return message;
+          }
+        }
+        return message;
+      });
+      const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
       const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
       return {
         messages: messagesToReturn,
@@ -2048,7 +2058,17 @@ var PostgresStore = class extends storage.MastraStorage {
         );
         await Promise.all([...messageInserts, threadUpdate]);
       });
-      const list = new agent.MessageList().add(messages, "memory");
+      const messagesWithParsedContent = messages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            return message;
+          }
+        }
+        return message;
+      });
+      const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
       if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
     } catch (error$1) {

package/dist/index.js

@@ -1946,7 +1946,17 @@ var PostgresStore = class extends MastraStorage {
       )} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
       const rows = await this.db.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
       messages.push(...rows || []);
-      const list = new MessageList().add(messages, "memory");
+      const messagesWithParsedContent = messages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            return message;
+          }
+        }
+        return message;
+      });
+      const list = new MessageList().add(messagesWithParsedContent, "memory");
       const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
       return {
         messages: messagesToReturn,
@@ -2040,7 +2050,17 @@ var PostgresStore = class extends MastraStorage {
         );
         await Promise.all([...messageInserts, threadUpdate]);
       });
-      const list = new MessageList().add(messages, "memory");
+      const messagesWithParsedContent = messages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            return message;
+          }
+        }
+        return message;
+      });
+      const list = new MessageList().add(messagesWithParsedContent, "memory");
       if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
     } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -32,10 +32,10 @@
     "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3",
-    "@internal/lint": "0.0.14",
-    "@mastra/core": "0.10.7",
-    "@internal/storage-test-utils": "0.0.10"
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.16",
+    "@internal/storage-test-utils": "0.0.12",
+    "@mastra/core": "0.10.9"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.7-0 <0.11.0-0"

package/src/storage/index.test.ts

@@ -46,6 +46,61 @@ describe('PostgresStore', () => {
     await store.init();
   });
 
+  describe('Public Fields Access', () => {
+    let testDB: PostgresStore;
+    beforeAll(async () => {
+      testDB = new PostgresStore(TEST_CONFIG);
+    });
+    afterAll(async () => {
+      try {
+        await testDB.close();
+      } catch {}
+      store = new PostgresStore(TEST_CONFIG);
+      await store.init();
+    });
+
+    it('should expose db field as public', () => {
+      expect(testDB.db).toBeDefined();
+      expect(typeof testDB.db).toBe('object');
+      expect(testDB.db.query).toBeDefined();
+      expect(typeof testDB.db.query).toBe('function');
+    });
+
+    it('should expose pgp field as public', () => {
+      expect(testDB.pgp).toBeDefined();
+      expect(typeof testDB.pgp).toBe('function');
+      expect(testDB.pgp.end).toBeDefined();
+      expect(typeof testDB.pgp.end).toBe('function');
+    });
+
+    it('should allow direct database queries via public db field', async () => {
+      const result = await testDB.db.one('SELECT 1 as test');
+      expect(result.test).toBe(1);
+    });
+
+    it('should allow access to pgp utilities via public pgp field', () => {
+      const helpers = testDB.pgp.helpers;
+      expect(helpers).toBeDefined();
+      expect(helpers.insert).toBeDefined();
+      expect(helpers.update).toBeDefined();
+    });
+
+    it('should maintain connection state through public db field', async () => {
+      // Test multiple queries to ensure connection state
+      const result1 = await testDB.db.one('SELECT NOW() as timestamp1');
+      const result2 = await testDB.db.one('SELECT NOW() as timestamp2');
+
+      expect(result1.timestamp1).toBeDefined();
+      expect(result2.timestamp2).toBeDefined();
+      expect(new Date(result2.timestamp2).getTime()).toBeGreaterThanOrEqual(new Date(result1.timestamp1).getTime());
+    });
+
+    it('should throw error when pool is used after disconnect', async () => {
+      await testDB.close();
+      expect(testDB.db.connect()).rejects.toThrow();
+    });
+  });
+
   beforeEach(async () => {
     // Only clear tables if store is initialized
     try {

package/src/storage/index.ts

@@ -45,8 +45,8 @@ export type PostgresConfig = {
 );
 
 export class PostgresStore extends MastraStorage {
-  private db: pgPromise.IDatabase<{}>;
-  private pgp: pgPromise.IMain;
+  public db: pgPromise.IDatabase<{}>;
+  public pgp: pgPromise.IMain;
   private schema?: string;
   private setupSchemaPromise: Promise<void> | null = null;
   private schemaSetupComplete: boolean | undefined = undefined;
@@ -1072,7 +1072,20 @@ export class PostgresStore extends MastraStorage {
       const rows = await this.db.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
       messages.push(...(rows || []));
 
-      const list = new MessageList().add(messages, 'memory');
+      // Parse content back to objects if they were stringified during storage
+      const messagesWithParsedContent = messages.map(message => {
+        if (typeof message.content === 'string') {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            // If parsing fails, leave as string (V1 message)
+            return message;
+          }
+        }
+        return message;
+      });
+
+      const list = new MessageList().add(messagesWithParsedContent, 'memory');
       const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
 
       return {
@@ -1180,7 +1193,20 @@ export class PostgresStore extends MastraStorage {
         await Promise.all([...messageInserts, threadUpdate]);
       });
 
-      const list = new MessageList().add(messages, 'memory');
+      // Parse content back to objects if they were stringified during storage
+      const messagesWithParsedContent = messages.map(message => {
+        if (typeof message.content === 'string') {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            // If parsing fails, leave as string (V1 message)
+            return message;
+          }
+        }
+        return message;
+      });
+
+      const list = new MessageList().add(messagesWithParsedContent, 'memory');
       if (format === `v2`) return list.get.all.v2();
       return list.get.all.v1();
     } catch (error) {

package/src/vector/index.test.ts

@@ -15,6 +15,139 @@ describe('PgVector', () => {
     vectorDB = new PgVector({ connectionString });
   });
 
+  describe('Public Fields Access', () => {
+    let testDB: PgVector;
+    beforeAll(async () => {
+      testDB = new PgVector({ connectionString });
+    });
+    afterAll(async () => {
+      try {
+        await testDB.disconnect();
+      } catch {}
+    });
+    it('should expose pool field as public', () => {
+      expect(testDB.pool).toBeDefined();
+      expect(typeof testDB.pool).toBe('object');
+      expect(testDB.pool.connect).toBeDefined();
+      expect(typeof testDB.pool.connect).toBe('function');
+      expect(testDB.pool).toBeInstanceOf(pg.Pool);
+    });
+
+    it('pool provides a working client connection', async () => {
+      const pool = testDB.pool;
+      const client = await pool.connect();
+      expect(typeof client.query).toBe('function');
+      expect(typeof client.release).toBe('function');
+      client.release();
+    });
+
+    it('should allow direct database connections via public pool field', async () => {
+      const client = await testDB.pool.connect();
+      try {
+        const result = await client.query('SELECT 1 as test');
+        expect(result.rows[0].test).toBe(1);
+      } finally {
+        client.release();
+      }
+    });
+
+    it('should provide access to pool configuration via public pool field', () => {
+      expect(testDB.pool.options).toBeDefined();
+      expect(testDB.pool.options.connectionString).toBe(connectionString);
+      expect(testDB.pool.options.max).toBeDefined();
+      expect(testDB.pool.options.idleTimeoutMillis).toBeDefined();
+    });
+
+    it('should allow pool monitoring via public pool field', () => {
+      expect(testDB.pool.totalCount).toBeDefined();
+      expect(testDB.pool.idleCount).toBeDefined();
+      expect(testDB.pool.waitingCount).toBeDefined();
+      expect(typeof testDB.pool.totalCount).toBe('number');
+      expect(typeof testDB.pool.idleCount).toBe('number');
+      expect(typeof testDB.pool.waitingCount).toBe('number');
+    });
+
+    it('should allow executing raw SQL via public pool field', async () => {
+      const client = await testDB.pool.connect();
+      try {
+        // Test a simple vector-related query
+        const result = await client.query('SELECT version()');
+        expect(result.rows[0].version).toBeDefined();
+        expect(typeof result.rows[0].version).toBe('string');
+      } finally {
+        client.release();
+      }
+    });
+
+    it('should maintain proper connection lifecycle via public pool field', async () => {
+      const initialIdleCount = testDB.pool.idleCount;
+      const initialTotalCount = testDB.pool.totalCount;
+
+      const client = await testDB.pool.connect();
+
+      // After connecting, total count should be >= initial, idle count should be less
+      expect(testDB.pool.totalCount).toBeGreaterThanOrEqual(initialTotalCount);
+      expect(testDB.pool.idleCount).toBeLessThanOrEqual(initialIdleCount);
+
+      client.release();
+
+      // After releasing, idle count should return to at least initial value
+      expect(testDB.pool.idleCount).toBeGreaterThanOrEqual(initialIdleCount);
+    });
+
+    it('allows performing a transaction', async () => {
+      const client = await testDB.pool.connect();
+      try {
+        await client.query('BEGIN');
+        const { rows } = await client.query('SELECT 2 as value');
+        expect(rows[0].value).toBe(2);
+        await client.query('COMMIT');
+      } finally {
+        client.release();
+      }
+    });
+    it('releases client on query error', async () => {
+      const client = await testDB.pool.connect();
+      try {
+        await expect(client.query('SELECT * FROM not_a_real_table')).rejects.toThrow();
+      } finally {
+        client.release();
+      }
+    });
+
+    it('can use getPool() to query metadata for filter options (user scenario)', async () => {
+      // Insert vectors with metadata
+      await testDB.createIndex({ indexName: 'filter_test', dimension: 2 });
+      await testDB.upsert({
+        indexName: 'filter_test',
+        vectors: [
+          [0.1, 0.2],
+          [0.3, 0.4],
+          [0.5, 0.6],
+        ],
+        metadata: [
+          { category: 'A', color: 'red' },
+          { category: 'B', color: 'blue' },
+          { category: 'A', color: 'green' },
+        ],
+        ids: ['id1', 'id2', 'id3'],
+      });
+      // Use the pool to query unique categories
+      const { tableName } = testDB['getTableName']('filter_test');
+      const res = await testDB.pool.query(
+        `SELECT DISTINCT metadata->>'category' AS category FROM ${tableName} ORDER BY category`,
+      );
+      expect(res.rows.map(r => r.category).sort()).toEqual(['A', 'B']);
+      // Clean up
+      await testDB.deleteIndex({ indexName: 'filter_test' });
+    });
+
+    it('should throw error when pool is used after disconnect', async () => {
+      await testDB.disconnect();
+      expect(testDB.pool.connect()).rejects.toThrow();
+    });
+  });
+
   afterAll(async () => {
     // Clean up test tables
     await vectorDB.deleteIndex({ indexName: testIndexName });

package/src/vector/index.ts

@@ -57,7 +57,7 @@ interface PgDefineIndexParams {
 }
 
 export class PgVector extends MastraVector<PGVectorFilter> {
-  private pool: pg.Pool;
+  public pool: pg.Pool;
   private describeIndexCache: Map<string, PGIndexStats> = new Map();
   private createdIndexes = new Map<string, number>();
   private mutexesByName = new Map<string, Mutex>();