@mastra/upstash 0.1.13-alpha.0 → 0.2.0-alpha.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/upstash@0.1.13-alpha.0 build /home/runner/work/mastra/mastra/stores/upstash
+> @mastra/upstash@0.2.0-alpha.1 build /home/runner/work/mastra/mastra/stores/upstash
 > 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.4.0
 TSC Build start
-TSC ⚡️ Build success in 9737ms
+TSC ⚡️ Build success in 9696ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.2
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 10952ms
+DTS ⚡️ Build success in 10580ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 16.31 KB
-CJS ⚡️ Build success in 711ms
-ESM dist/index.js 16.19 KB
-ESM ⚡️ Build success in 717ms
+ESM dist/index.js 17.07 KB
+ESM ⚡️ Build success in 746ms
+CJS dist/index.cjs 17.20 KB
+CJS ⚡️ Build success in 747ms

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/upstash
 
+## 0.2.0-alpha.1
+
+### Minor Changes
+
+- c0b2496: Added new operations implementations for MastraVector methods in upstash store
+
+### Patch Changes
+
+- Updated dependencies [6794797]
+  - @mastra/core@0.6.4-alpha.1
+
 ## 0.1.13-alpha.0
 
 ### Patch Changes

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

@@ -126,6 +126,11 @@ declare class UpstashVector extends MastraVector {
         metric: "cosine" | "euclidean" | "dotproduct";
     }>;
     deleteIndex(indexName: string): Promise<void>;
+    updateIndexById(indexName: string, id: string, update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    deleteIndexById(indexName: string, id: string): Promise<void>;
 }
 export { UpstashVector }
 export { UpstashVector as UpstashVector_alias_1 }

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

@@ -126,6 +126,11 @@ declare class UpstashVector extends MastraVector {
         metric: "cosine" | "euclidean" | "dotproduct";
     }>;
     deleteIndex(indexName: string): Promise<void>;
+    updateIndexById(indexName: string, id: string, update: {
+        vector?: number[];
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    deleteIndexById(indexName: string, id: string): Promise<void>;
 }
 export { UpstashVector }
 export { UpstashVector as UpstashVector_alias_1 }

package/dist/index.cjs

@@ -474,6 +474,38 @@ var UpstashVector = class extends vector.MastraVector {
       console.error("Failed to delete namespace:", error);
     }
   }
+  async updateIndexById(indexName, id, update) {
+    if (!update.vector && !update.metadata) {
+      throw new Error("No update data provided");
+    }
+    if (!update.vector && update.metadata) {
+      throw new Error("Both vector and metadata must be provided for an update");
+    }
+    const updatePayload = { id };
+    if (update.vector) {
+      updatePayload.vector = update.vector;
+    }
+    if (update.metadata) {
+      updatePayload.metadata = update.metadata;
+    }
+    const points = {
+      id: updatePayload.id,
+      vector: updatePayload.vector,
+      metadata: updatePayload.metadata
+    };
+    await this.client.upsert(points, {
+      namespace: indexName
+    });
+  }
+  async deleteIndexById(indexName, id) {
+    try {
+      await this.client.delete(id, {
+        namespace: indexName
+      });
+    } catch (error) {
+      console.error("Failed to delete index by ID:", error);
+    }
+  }
 };
 
 exports.UpstashStore = UpstashStore;

package/dist/index.js

@@ -472,6 +472,38 @@ var UpstashVector = class extends MastraVector {
       console.error("Failed to delete namespace:", error);
     }
   }
+  async updateIndexById(indexName, id, update) {
+    if (!update.vector && !update.metadata) {
+      throw new Error("No update data provided");
+    }
+    if (!update.vector && update.metadata) {
+      throw new Error("Both vector and metadata must be provided for an update");
+    }
+    const updatePayload = { id };
+    if (update.vector) {
+      updatePayload.vector = update.vector;
+    }
+    if (update.metadata) {
+      updatePayload.metadata = update.metadata;
+    }
+    const points = {
+      id: updatePayload.id,
+      vector: updatePayload.vector,
+      metadata: updatePayload.metadata
+    };
+    await this.client.upsert(points, {
+      namespace: indexName
+    });
+  }
+  async deleteIndexById(indexName, id) {
+    try {
+      await this.client.delete(id, {
+        namespace: indexName
+      });
+    } catch (error) {
+      console.error("Failed to delete index by ID:", error);
+    }
+  }
 };
 
 export { UpstashStore, UpstashVector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.1.13-alpha.0",
+  "version": "0.2.0-alpha.1",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -21,11 +21,12 @@
   "dependencies": {
     "@upstash/redis": "^1.34.5",
     "@upstash/vector": "^1.2.1",
-    "@mastra/core": "^0.6.4-alpha.0"
+    "@mastra/core": "^0.6.4-alpha.1"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.1",
     "@types/node": "^22.13.10",
+    "dotenv": "^16.4.7",
     "eslint": "^9.22.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",

package/src/vector/index.test.ts

@@ -1,6 +1,11 @@
+import dotenv from 'dotenv';
+
 import { describe, it, expect, beforeAll, afterAll, beforeEach, vi, afterEach } from 'vitest';
 
 import { UpstashVector } from './';
+import type { QueryResult } from '@mastra/core';
+
+dotenv.config();
 
 function waitUntilVectorsIndexed(vector: UpstashVector, indexName: string, expectedCount: number) {
   return new Promise((resolve, reject) => {
@@ -98,19 +103,145 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
     }, 5000000);
 
     it('should query vectors and return vector in results', async () => {
-      const results = await vectorStore.query({ indexName: testIndexName, queryVector: createVector(0, 0.9), topK: 3 });
+      const results = await vectorStore.query({
+        indexName: testIndexName,
+        queryVector: createVector(0, 0.9),
+        topK: 3,
+        includeVector: true,
+      });
       expect(results).toHaveLength(3);
-      expect(results?.[0]?.vector).toBeDefined();
-      expect(results?.[0]?.vector).toHaveLength(VECTOR_DIMENSION);
-      expect(results?.[1]?.vector).toBeDefined();
-      expect(results?.[1]?.vector).toHaveLength(VECTOR_DIMENSION);
-      expect(results?.[2]?.vector).toBeDefined();
-      expect(results?.[2]?.vector).toHaveLength(VECTOR_DIMENSION);
+      results.forEach(result => {
+        expect(result.vector).toBeDefined();
+        expect(result.vector).toHaveLength(VECTOR_DIMENSION);
+      });
+    });
+
+    describe('Vector update operations', () => {
+      const testVectors = [createVector(0, 1.0), createVector(1, 1.0), createVector(2, 1.0)];
+
+      const testIndexName = 'test-index';
+
+      afterEach(async () => {
+        await vectorStore.deleteIndex(testIndexName);
+      });
+
+      it('should update the vector by id', async () => {
+        const ids = await vectorStore.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newVector = createVector(0, 4.0);
+        const newMetaData = {
+          test: 'updates',
+        };
+
+        const update = {
+          vector: newVector,
+          metadata: newMetaData,
+        };
+
+        await vectorStore.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        await waitUntilVectorsIndexed(vectorStore, testIndexName, 3);
+
+        const results: QueryResult[] = await vectorStore.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);
+      }, 500000);
+
+      it('should only update the metadata by id', async () => {
+        const ids = await vectorStore.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newMetaData = {
+          test: 'updates',
+        };
+
+        const update = {
+          metadata: newMetaData,
+        };
+
+        await expect(vectorStore.updateIndexById(testIndexName, 'id', update)).rejects.toThrow(
+          'Both vector and metadata must be provided for an update',
+        );
+      });
+
+      it('should only update vector embeddings by id', async () => {
+        const ids = await vectorStore.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+
+        const idToBeUpdated = ids[0];
+        const newVector = createVector(0, 4.0);
+
+        const update = {
+          vector: newVector,
+        };
+
+        await vectorStore.updateIndexById(testIndexName, idToBeUpdated, update);
+
+        await waitUntilVectorsIndexed(vectorStore, testIndexName, 3);
+
+        const results: QueryResult[] = await vectorStore.query({
+          indexName: testIndexName,
+          queryVector: newVector,
+          topK: 2,
+          includeVector: true,
+        });
+        expect(results[0]?.id).toBe(idToBeUpdated);
+        expect(results[0]?.vector).toEqual(newVector);
+      }, 500000);
+
+      it('should throw exception when no updates are given', async () => {
+        await expect(vectorStore.updateIndexById(testIndexName, 'id', {})).rejects.toThrow('No update data provided');
+      });
+    });
+
+    describe('Vector delete operations', () => {
+      const testVectors = [createVector(0, 1.0), createVector(1, 1.0), createVector(2, 1.0)];
+
+      afterEach(async () => {
+        await vectorStore.deleteIndex(testIndexName);
+      });
+
+      it('should delete the vector by id', async () => {
+        const ids = await vectorStore.upsert({ indexName: testIndexName, vectors: testVectors });
+        expect(ids).toHaveLength(3);
+        const idToBeDeleted = ids[0];
+
+        await vectorStore.deleteIndexById(testIndexName, idToBeDeleted);
+
+        const results: QueryResult[] = await vectorStore.query({
+          indexName: testIndexName,
+          queryVector: createVector(0, 1.0),
+          topK: 2,
+        });
+
+        expect(results).toHaveLength(2);
+        expect(results.map(res => res.id)).not.toContain(idToBeDeleted);
+      });
     });
   });
   describe('Index Operations', () => {
+    const createVector = (primaryDimension: number, value: number = 1.0): number[] => {
+      const vector = new Array(VECTOR_DIMENSION).fill(0);
+      vector[primaryDimension] = value;
+      // Normalize the vector for cosine similarity
+      const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+      return vector.map(val => val / magnitude);
+    };
     it('should create and list an index', async () => {
-      await vectorStore.createIndex({ indexName: testIndexName, dimension: 3, metric: 'cosine' });
+      // since, we do not have to create index explictly in case of upstash. Upserts are enough
+      // for testing the listIndexes() function
+      // await vectorStore.createIndex({ indexName: testIndexName, dimension: 3, metric: 'cosine' });
+      const ids = await vectorStore.upsert({ indexName: testIndexName, vectors: [createVector(0, 1.0)] });
+      expect(ids).toHaveLength(1);
       const indexes = await vectorStore.listIndexes();
       expect(indexes).toEqual([testIndexName]);
     });
@@ -1068,10 +1199,6 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
 
     let warnSpy;
 
-    beforeAll(async () => {
-      await vectorStore.createIndex({ indexName: indexName, dimension: 3 });
-    });
-
     afterAll(async () => {
       await vectorStore.deleteIndex(indexName);
       await vectorStore.deleteIndex(indexName2);
@@ -1086,16 +1213,16 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
       await vectorStore.deleteIndex(indexName2);
     });
 
-    it('should show deprecation warning when using individual args for createIndex', async () => {
-      await vectorStore.createIndex(indexName2, 3, 'cosine');
-
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Deprecation Warning: Passing individual arguments to createIndex() is deprecated'),
-      );
-    });
+    const createVector = (primaryDimension: number, value: number = 1.0): number[] => {
+      const vector = new Array(VECTOR_DIMENSION).fill(0);
+      vector[primaryDimension] = value;
+      // Normalize the vector for cosine similarity
+      const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+      return vector.map(val => val / magnitude);
+    };
 
     it('should show deprecation warning when using individual args for upsert', async () => {
-      await vectorStore.upsert(indexName, [[1, 2, 3]], [{ test: 'data' }]);
+      await vectorStore.upsert(indexName, [createVector(0, 2)], [{ test: 'data' }]);
 
       expect(warnSpy).toHaveBeenCalledWith(
         expect.stringContaining('Deprecation Warning: Passing individual arguments to upsert() is deprecated'),
@@ -1103,7 +1230,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
     });
 
     it('should show deprecation warning when using individual args for query', async () => {
-      await vectorStore.query(indexName, [1, 2, 3], 5);
+      await vectorStore.query(indexName, createVector(0, 2), 5);
 
       expect(warnSpy).toHaveBeenCalledWith(
         expect.stringContaining('Deprecation Warning: Passing individual arguments to query() is deprecated'),
@@ -1113,7 +1240,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
     it('should not show deprecation warning when using object param for query', async () => {
       await vectorStore.query({
         indexName,
-        queryVector: [1, 2, 3],
+        queryVector: createVector(0, 2),
         topK: 5,
       });
 
@@ -1133,7 +1260,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
     it('should not show deprecation warning when using object param for upsert', async () => {
       await vectorStore.upsert({
         indexName,
-        vectors: [[1, 2, 3]],
+        vectors: [createVector(0, 2)],
         metadata: [{ test: 'data' }],
       });
 
@@ -1142,7 +1269,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
 
     it('should maintain backward compatibility with individual args', async () => {
       // Query
-      const queryResults = await vectorStore.query(indexName, [1, 2, 3], 5);
+      const queryResults = await vectorStore.query(indexName, createVector(0, 2), 5);
       expect(Array.isArray(queryResults)).toBe(true);
 
       // CreateIndex
@@ -1151,7 +1278,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
       // Upsert
       const upsertResults = await vectorStore.upsert({
         indexName,
-        vectors: [[1, 2, 3]],
+        vectors: [createVector(0, 2)],
         metadata: [{ test: 'data' }],
       });
       expect(Array.isArray(upsertResults)).toBe(true);

package/src/vector/index.ts

@@ -97,4 +97,51 @@ export class UpstashVector extends MastraVector {
       console.error('Failed to delete namespace:', error);
     }
   }
+
+  async updateIndexById(
+    indexName: string,
+    id: string,
+    update: {
+      vector?: number[];
+      metadata?: Record<string, any>;
+    },
+  ): Promise<void> {
+    if (!update.vector && !update.metadata) {
+      throw new Error('No update data provided');
+    }
+
+    // The upstash client throws an exception as: 'This index requires dense vectors' when
+    // only metadata is present in the update object.
+    if (!update.vector && update.metadata) {
+      throw new Error('Both vector and metadata must be provided for an update');
+    }
+
+    const updatePayload: any = { id: id };
+    if (update.vector) {
+      updatePayload.vector = update.vector;
+    }
+    if (update.metadata) {
+      updatePayload.metadata = update.metadata;
+    }
+
+    const points = {
+      id: updatePayload.id,
+      vector: updatePayload.vector,
+      metadata: updatePayload.metadata,
+    };
+
+    await this.client.upsert(points, {
+      namespace: indexName,
+    });
+  }
+
+  async deleteIndexById(indexName: string, id: string): Promise<void> {
+    try {
+      await this.client.delete(id, {
+        namespace: indexName,
+      });
+    } catch (error) {
+      console.error('Failed to delete index by ID:', error);
+    }
+  }
 }