@mastra/upstash 0.10.3 → 0.11.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.10.3",
+  "version": "0.11.0-alpha.1",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -25,15 +25,15 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
-    "@types/node": "^20.17.57",
+    "@types/node": "^20.19.0",
     "dotenv": "^16.5.0",
     "eslint": "^9.28.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "@internal/storage-test-utils": "0.0.7",
-    "@internal/lint": "0.0.11",
-    "@mastra/core": "0.10.4"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@internal/storage-test-utils": "0.0.8",
+    "@internal/lint": "0.0.12",
+    "@mastra/core": "0.10.6-alpha.1"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/storage/index.ts

@@ -628,10 +628,15 @@ export class UpstashStore extends MastraStorage {
       _index: index,
     }));
 
+    // Get current thread data once (all messages belong to same thread)
+    const threadKey = this.getKey(TABLE_THREADS, { id: threadId });
+    const existingThread = await this.redis.get<StorageThreadType>(threadKey);
+
     const batchSize = 1000;
     for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
       const batch = messagesWithIndex.slice(i, i + batchSize);
       const pipeline = this.redis.pipeline();
+
       for (const message of batch) {
         const key = this.getMessageKey(message.threadId!, message.id);
         const createdAtScore = new Date(message.createdAt).getTime();
@@ -647,6 +652,15 @@ export class UpstashStore extends MastraStorage {
         });
       }
 
+      // Update the thread's updatedAt field (only in the first batch)
+      if (i === 0 && existingThread) {
+        const updatedThread = {
+          ...existingThread,
+          updatedAt: new Date(),
+        };
+        pipeline.set(threadKey, this.processRecord(TABLE_THREADS, updatedThread).processedRecord);
+      }
+
       await pipeline.exec();
     }
 

package/src/storage/upstash.test.ts

@@ -187,6 +187,29 @@ describe('UpstashStore', () => {
         updated: 'value',
       });
     });
+
+    it('should update thread updatedAt when a message is saved to it', async () => {
+      const thread = createSampleThread();
+      await store.saveThread({ thread });
+
+      // Get the initial thread to capture the original updatedAt
+      const initialThread = await store.getThreadById({ threadId: thread.id });
+      expect(initialThread).toBeDefined();
+      const originalUpdatedAt = initialThread!.updatedAt;
+
+      // Wait a small amount to ensure different timestamp
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      // Create and save a message to the thread
+      const message = createSampleMessageV2({ threadId: thread.id });
+      await store.saveMessages({ messages: [message], format: 'v2' });
+
+      // Retrieve the thread again and check that updatedAt was updated
+      const updatedThread = await store.getThreadById({ threadId: thread.id });
+      expect(updatedThread).toBeDefined();
+      expect(updatedThread!.updatedAt.getTime()).toBeGreaterThan(originalUpdatedAt.getTime());
+    });
+
     it('should fetch >100000 threads by resource ID', async () => {
       const resourceId = `resource-${randomUUID()}`;
       const total = 100_000;
@@ -669,13 +692,14 @@ describe('UpstashStore', () => {
         activePaths: [],
         suspendedPaths: {},
         timestamp: Date.now(),
+        status: 'success',
       };
 
       await store.persistWorkflowSnapshot({
         namespace: testNamespace,
         workflowName: testWorkflow,
         runId: testRunId,
-        snapshot: mockSnapshot,
+        snapshot: mockSnapshot as WorkflowRunState,
       });
 
       const loadedSnapshot = await store.loadWorkflowSnapshot({

package/src/vector/index.ts

@@ -18,6 +18,12 @@ import { UpstashFilterTranslator } from './filter';
 export class UpstashVector extends MastraVector {
   private client: Index;
 
+  /**
+   * Creates a new UpstashVector instance.
+   * @param {object} params - The parameters for the UpstashVector.
+   * @param {string} params.url - The URL of the Upstash vector index.
+   * @param {string} params.token - The token for the Upstash vector index.
+   */
   constructor({ url, token }: { url: string; token: string }) {
     super();
     this.client = new Index({
@@ -26,7 +32,12 @@ export class UpstashVector extends MastraVector {
     });
   }
 
-  async upsert({ indexName, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]> {
+  /**
+   * Upserts vectors into the index.
+   * @param {UpsertVectorParams} params - The parameters for the upsert operation.
+   * @returns {Promise<string[]>} A promise that resolves to the IDs of the upserted vectors.
+   */
+  async upsert({ indexName: namespace, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]> {
     const generatedIds = ids || vectors.map(() => crypto.randomUUID());
 
     const points = vectors.map((vector, index) => ({
@@ -36,28 +47,43 @@ export class UpstashVector extends MastraVector {
     }));
 
     await this.client.upsert(points, {
-      namespace: indexName,
+      namespace,
     });
     return generatedIds;
   }
 
+  /**
+   * Transforms a Mastra vector filter into an Upstash-compatible filter string.
+   * @param {VectorFilter} [filter] - The filter to transform.
+   * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
+   */
   transformFilter(filter?: VectorFilter) {
     const translator = new UpstashFilterTranslator();
     return translator.translate(filter);
   }
 
+  /**
+   * Creates a new index. For Upstash, this is a no-op as indexes (known as namespaces in Upstash) are created on-the-fly.
+   * @param {CreateIndexParams} _params - The parameters for creating the index (ignored).
+   * @returns {Promise<void>} A promise that resolves when the operation is complete.
+   */
   async createIndex(_params: CreateIndexParams): Promise<void> {
-    console.log('No need to call createIndex for Upstash');
+    this.logger.debug('No need to call createIndex for Upstash');
   }
 
+  /**
+   * Queries the vector index.
+   * @param {QueryVectorParams} params - The parameters for the query operation. indexName is the namespace in Upstash.
+   * @returns {Promise<QueryResult[]>} A promise that resolves to the query results.
+   */
   async query({
-    indexName,
+    indexName: namespace,
     queryVector,
     topK = 10,
     filter,
     includeVector = false,
   }: QueryVectorParams): Promise<QueryResult[]> {
-    const ns = this.client.namespace(indexName);
+    const ns = this.client.namespace(namespace);
 
     const filterString = this.transformFilter(filter);
     const results = await ns.query({
@@ -77,6 +103,10 @@ export class UpstashVector extends MastraVector {
     }));
   }
 
+  /**
+   * Lists all namespaces in the Upstash vector index, which correspond to indexes.
+   * @returns {Promise<string[]>} A promise that resolves to a list of index names.
+   */
   async listIndexes(): Promise<string[]> {
     const indexes = await this.client.listNamespaces();
     return indexes.filter(Boolean);
@@ -85,30 +115,35 @@ export class UpstashVector extends MastraVector {
   /**
    * Retrieves statistics about a vector index.
    *
-   * @param {string} indexName - The name of the index to describe
+   * @param {string} indexName - The name of the namespace to describe
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
-  async describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats> {
+  async describeIndex({ indexName: namespace }: DescribeIndexParams): Promise<IndexStats> {
     const info = await this.client.info();
 
     return {
       dimension: info.dimension,
-      count: info.namespaces?.[indexName]?.vectorCount || 0,
+      count: info.namespaces?.[namespace]?.vectorCount || 0,
       metric: info?.similarityFunction?.toLowerCase() as 'cosine' | 'euclidean' | 'dotproduct',
     };
   }
 
-  async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
+  /**
+   * Deletes an index (namespace).
+   * @param {DeleteIndexParams} params - The parameters for the delete operation.
+   * @returns {Promise<void>} A promise that resolves when the deletion is complete.
+   */
+  async deleteIndex({ indexName: namespace }: DeleteIndexParams): Promise<void> {
     try {
-      await this.client.deleteNamespace(indexName);
+      await this.client.deleteNamespace(namespace);
     } catch (error) {
-      console.error('Failed to delete namespace:', error);
+      this.logger.error('Failed to delete namespace:', error);
     }
   }
 
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
-   * @param indexName - The name of the index containing the vector.
+   * @param indexName - The name of the namespace containing the vector.
    * @param id - The ID of the vector to update.
    * @param update - An object containing the vector and/or metadata to update.
    * @param update.vector - An optional array of numbers representing the new vector.
@@ -116,7 +151,7 @@ export class UpstashVector extends MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void> {
+  async updateVector({ indexName: namespace, id, update }: UpdateVectorParams): Promise<void> {
     try {
       if (!update.vector && !update.metadata) {
         throw new Error('No update data provided');
@@ -143,27 +178,27 @@ export class UpstashVector extends MastraVector {
       };
 
       await this.client.upsert(points, {
-        namespace: indexName,
+        namespace,
       });
     } catch (error: any) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new Error(`Failed to update vector by id: ${id} for index name: ${namespace}: ${error.message}`);
     }
   }
 
   /**
    * Deletes a vector by its ID.
-   * @param indexName - The name of the index containing the vector.
+   * @param indexName - The name of the namespace containing the vector.
    * @param id - The ID of the vector to delete.
    * @returns A promise that resolves when the deletion is complete.
    * @throws Will throw an error if the deletion operation fails.
    */
-  async deleteVector({ indexName, id }: DeleteVectorParams): Promise<void> {
+  async deleteVector({ indexName: namespace, id }: DeleteVectorParams): Promise<void> {
     try {
       await this.client.delete(id, {
-        namespace: indexName,
+        namespace,
       });
     } catch (error) {
-      console.error(`Failed to delete vector by id: ${id} for index name: ${indexName}:`, error);
+      this.logger.error(`Failed to delete vector by id: ${id} for namespace: ${namespace}:`, error);
     }
   }
 }