@mastra/pg 0.1.8-alpha.9 → 0.2.0-alpha.10

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.1.8-alpha.9 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.2.0-alpha.10 build /home/runner/work/mastra/mastra/stores/pg
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.3.6
 TSC Build start
-TSC ⚡️ Build success in 9376ms
+TSC ⚡️ Build success in 10654ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.7.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.7.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 10054ms
+DTS ⚡️ Build success in 11401ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 33.26 KB
-ESM ⚡️ Build success in 1131ms
-CJS dist/index.cjs 33.66 KB
-CJS ⚡️ Build success in 1131ms
+ESM dist/index.js 34.40 KB
+ESM ⚡️ Build success in 1309ms
+CJS dist/index.cjs 34.80 KB
+CJS ⚡️ Build success in 1311ms

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/pg
 
+## 0.2.0-alpha.10
+
+### Minor Changes
+
+- 3de7e06: Added new operations implementations for MastraVector interface methods in pg vector store
+
+### Patch Changes
+
+- Updated dependencies [a910463]
+  - @mastra/core@0.5.0-alpha.10
+
 ## 0.1.8-alpha.9
 
 ### Patch Changes

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

@@ -216,6 +216,11 @@ declare class PgVector extends MastraVector {
     deleteIndex(indexName: string): Promise<void>;
     truncateIndex(indexName: string): Promise<void>;
     disconnect(): Promise<void>;
+    updateIndexById(indexName: string, id: string, update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    deleteIndexById(indexName: string, id: string): Promise<void>;
 }
 export { PgVector }
 export { PgVector as PgVector_alias_1 }

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

@@ -216,6 +216,11 @@ declare class PgVector extends MastraVector {
     deleteIndex(indexName: string): Promise<void>;
     truncateIndex(indexName: string): Promise<void>;
     disconnect(): Promise<void>;
+    updateIndexById(indexName: string, id: string, update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    deleteIndexById(indexName: string, id: string): Promise<void>;
 }
 export { PgVector }
 export { PgVector as PgVector_alias_1 }

package/dist/index.cjs

@@ -589,6 +589,49 @@ var PgVector = class extends vector.MastraVector {
   async disconnect() {
     await this.pool.end();
   }
+  async updateIndexById(indexName, id, update) {
+    if (!update.vector && !update.metadata) {
+      throw new Error("No updates provided");
+    }
+    const client = await this.pool.connect();
+    try {
+      let updateParts = [];
+      let values = [id];
+      let valueIndex = 2;
+      if (update.vector) {
+        updateParts.push(`embedding = $${valueIndex}::vector`);
+        values.push(`[${update.vector.join(",")}]`);
+        valueIndex++;
+      }
+      if (update.metadata) {
+        updateParts.push(`metadata = $${valueIndex}::jsonb`);
+        values.push(JSON.stringify(update.metadata));
+      }
+      if (updateParts.length === 0) {
+        return;
+      }
+      const query = `
+        UPDATE ${indexName}
+        SET ${updateParts.join(", ")}
+        WHERE vector_id = $1
+      `;
+      await client.query(query, values);
+    } finally {
+      client.release();
+    }
+  }
+  async deleteIndexById(indexName, id) {
+    const client = await this.pool.connect();
+    try {
+      const query = `
+        DELETE FROM ${indexName}
+        WHERE vector_id = $1
+      `;
+      await client.query(query, [id]);
+    } finally {
+      client.release();
+    }
+  }
 };
 var PostgresStore = class extends storage.MastraStorage {
   db;

package/dist/index.js

@@ -582,6 +582,49 @@ var PgVector = class extends MastraVector {
   async disconnect() {
     await this.pool.end();
   }
+  async updateIndexById(indexName, id, update) {
+    if (!update.vector && !update.metadata) {
+      throw new Error("No updates provided");
+    }
+    const client = await this.pool.connect();
+    try {
+      let updateParts = [];
+      let values = [id];
+      let valueIndex = 2;
+      if (update.vector) {
+        updateParts.push(`embedding = $${valueIndex}::vector`);
+        values.push(`[${update.vector.join(",")}]`);
+        valueIndex++;
+      }
+      if (update.metadata) {
+        updateParts.push(`metadata = $${valueIndex}::jsonb`);
+        values.push(JSON.stringify(update.metadata));
+      }
+      if (updateParts.length === 0) {
+        return;
+      }
+      const query = `
+        UPDATE ${indexName}
+        SET ${updateParts.join(", ")}
+        WHERE vector_id = $1
+      `;
+      await client.query(query, values);
+    } finally {
+      client.release();
+    }
+  }
+  async deleteIndexById(indexName, id) {
+    const client = await this.pool.connect();
+    try {
+      const query = `
+        DELETE FROM ${indexName}
+        WHERE vector_id = $1
+      `;
+      await client.query(query, [id]);
+    } finally {
+      client.release();
+    }
+  }
 };
 var PostgresStore = class extends MastraStorage {
   db;

package/package.json

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

package/src/vector/index.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';
 
 import { PgVector } from '.';
+import { type QueryResult } from '@mastra/core';
 
 describe('PgVector', () => {
   let vectorDB: PgVector;
@@ -232,6 +233,136 @@ describe('PgVector', () => {
       });
     });
 
+    describe('updates', () => {
+      const testVectors = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+      ];
+
+      beforeEach(async () => {
+        await vectorDB.createIndex({ indexName: testIndexName, dimension: 3 });
+      });
+
+      afterEach(async () => {
+        await vectorDB.deleteIndex(testIndexName);
+      });
+
+      it('should update the vector by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newVector = [1, 2, 3];
+        const newMetaData = {
+          test: 'updates',
+        };
+
+        const update = {
+          vector: newVector,
+          metadata: newMetaData,
+        };
+
+        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: newVector,
+          topK: 2,
+          includeVector: true,
+        });
+        expect(results[0]?.id).toBe(idToBeUpdated);
+        expect(results[0]?.vector).toEqual(newVector);
+        expect(results[0]?.metadata).toEqual(newMetaData);
+      });
+
+      it('should only update the metadata by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newMetaData = {
+          test: 'updates',
+        };
+
+        const update = {
+          metadata: newMetaData,
+        };
+
+        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: testVectors[0],
+          topK: 2,
+          includeVector: true,
+        });
+        expect(results[0]?.id).toBe(idToBeUpdated);
+        expect(results[0]?.vector).toEqual(testVectors[0]);
+        expect(results[0]?.metadata).toEqual(newMetaData);
+      });
+
+      it('should only update vector embeddings by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newVector = [1, 2, 3];
+
+        const update = {
+          vector: newVector,
+        };
+
+        await vectorDB.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: newVector,
+          topK: 2,
+          includeVector: true,
+        });
+        expect(results[0]?.id).toBe(idToBeUpdated);
+        expect(results[0]?.vector).toEqual(newVector);
+      });
+
+      it('should throw exception when no updates are given', () => {
+        expect(vectorDB.updateIndexById(testIndexName, 'id', {})).rejects.toThrow('No updates provided');
+      });
+    });
+
+    describe('deletes', () => {
+      const testVectors = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+      ];
+
+      beforeEach(async () => {
+        await vectorDB.createIndex({ indexName: testIndexName, dimension: 3 });
+      });
+
+      afterEach(async () => {
+        await vectorDB.deleteIndex(testIndexName);
+      });
+
+      it('should delete the vector by id', async () => {
+        const ids = await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+        const idToBeDeleted = ids[0];
+
+        await vectorDB.deleteIndexById(testIndexName, idToBeDeleted);
+
+        const results: QueryResult[] = await vectorDB.query({
+          indexName: testIndexName,
+          queryVector: [1.0, 0.0, 0.0],
+          topK: 2,
+        });
+
+        expect(results).toHaveLength(2);
+        expect(results.map(res => res.id)).not.toContain(idToBeDeleted);
+      });
+    });
+
     describe('Basic Query Operations', () => {
       ['flat', 'hnsw', 'ivfflat'].forEach(indexType => {
         const indexName = `test_query_2_${indexType}`;

package/src/vector/index.ts

@@ -426,4 +426,64 @@ export class PgVector extends MastraVector {
   async disconnect() {
     await this.pool.end();
   }
+
+  async updateIndexById(
+    indexName: string,
+    id: string,
+    update: {
+      vector?: number[];
+      metadata?: Record<string, any>;
+    },
+  ): Promise<void> {
+    if (!update.vector && !update.metadata) {
+      throw new Error('No updates provided');
+    }
+
+    const client = await this.pool.connect();
+    try {
+      let updateParts = [];
+      let values = [id];
+      let valueIndex = 2;
+
+      if (update.vector) {
+        updateParts.push(`embedding = $${valueIndex}::vector`);
+        values.push(`[${update.vector.join(',')}]`);
+        valueIndex++;
+      }
+
+      if (update.metadata) {
+        updateParts.push(`metadata = $${valueIndex}::jsonb`);
+        values.push(JSON.stringify(update.metadata));
+      }
+
+      if (updateParts.length === 0) {
+        return;
+      }
+
+      // query looks like this:
+      // UPDATE table SET embedding = $2::vector, metadata = $3::jsonb WHERE id = $1
+      const query = `
+        UPDATE ${indexName}
+        SET ${updateParts.join(', ')}
+        WHERE vector_id = $1
+      `;
+
+      await client.query(query, values);
+    } finally {
+      client.release();
+    }
+  }
+
+  async deleteIndexById(indexName: string, id: string): Promise<void> {
+    const client = await this.pool.connect();
+    try {
+      const query = `
+        DELETE FROM ${indexName}
+        WHERE vector_id = $1
+      `;
+      await client.query(query, [id]);
+    } finally {
+      client.release();
+    }
+  }
 }