@mastra/upstash 0.11.1-alpha.0 → 0.11.1-alpha.2

package/src/storage/upstash.test.ts

@@ -321,9 +321,9 @@ describe('UpstashStore', () => {
 
     it('should save and retrieve messages in order', async () => {
       const messages: MastraMessageV2[] = [
-        createSampleMessageV2({ threadId, content: 'First' }),
-        createSampleMessageV2({ threadId, content: 'Second' }),
-        createSampleMessageV2({ threadId, content: 'Third' }),
+        createSampleMessageV2({ threadId, content: { content: 'First' } }),
+        createSampleMessageV2({ threadId, content: { content: 'Second' } }),
+        createSampleMessageV2({ threadId, content: { content: 'Third' } }),
       ];
 
       await store.saveMessages({ messages, format: 'v2' });
@@ -344,16 +344,48 @@ describe('UpstashStore', () => {
       await store.saveThread({ thread: thread3 });
 
       const messages: MastraMessageV2[] = [
-        createSampleMessageV2({ threadId: 'thread-one', content: 'First', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-one', content: 'Second', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-one', content: 'Third', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { content: 'First' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { content: 'Second' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { content: 'Third' },
+          resourceId: 'cross-thread-resource',
+        }),
 
-        createSampleMessageV2({ threadId: 'thread-two', content: 'Fourth', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-two', content: 'Fifth', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-two', content: 'Sixth', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Fourth' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Fifth' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Sixth' },
+          resourceId: 'cross-thread-resource',
+        }),
 
-        createSampleMessageV2({ threadId: 'thread-three', content: 'Seventh', resourceId: 'other-resource' }),
-        createSampleMessageV2({ threadId: 'thread-three', content: 'Eighth', resourceId: 'other-resource' }),
+        createSampleMessageV2({
+          threadId: 'thread-three',
+          content: { content: 'Seventh' },
+          resourceId: 'other-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-three',
+          content: { content: 'Eighth' },
+          resourceId: 'other-resource',
+        }),
       ];
 
       await store.saveMessages({ messages: messages, format: 'v2' });
@@ -466,13 +498,88 @@ describe('UpstashStore', () => {
       expect(retrievedMessages[0].content).toEqual(messages[0].content);
     });
 
+    it('should upsert messages: duplicate id+threadId results in update, not duplicate row', async () => {
+      const thread = await createSampleThread();
+      await store.saveThread({ thread });
+      const baseMessage = createSampleMessageV2({
+        threadId: thread.id,
+        createdAt: new Date(),
+        content: { content: 'Original' },
+        resourceId: thread.resourceId,
+      });
+
+      // Insert the message for the first time
+      await store.saveMessages({ messages: [baseMessage], format: 'v2' });
+
+      // Insert again with the same id and threadId but different content
+      const updatedMessage = {
+        ...createSampleMessageV2({
+          threadId: thread.id,
+          createdAt: new Date(),
+          content: { content: 'Updated' },
+          resourceId: thread.resourceId,
+        }),
+        id: baseMessage.id,
+      };
+
+      await store.saveMessages({ messages: [updatedMessage], format: 'v2' });
+
+      // Retrieve messages for the thread
+      const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v2' });
+
+      // Only one message should exist for that id+threadId
+      expect(retrievedMessages.filter(m => m.id === baseMessage.id)).toHaveLength(1);
+
+      // The content should be the updated one
+      expect(retrievedMessages.find(m => m.id === baseMessage.id)?.content.content).toBe('Updated');
+    });
+
+    it('should upsert messages: duplicate id and different threadid', async () => {
+      const thread1 = await createSampleThread();
+      const thread2 = await createSampleThread();
+      await store.saveThread({ thread: thread1 });
+      await store.saveThread({ thread: thread2 });
+
+      const message = createSampleMessageV2({
+        threadId: thread1.id,
+        createdAt: new Date(),
+        content: { content: 'Thread1 Content' },
+        resourceId: thread1.resourceId,
+      });
+
+      // Insert message into thread1
+      await store.saveMessages({ messages: [message], format: 'v2' });
+
+      // Attempt to insert a message with the same id but different threadId
+      const conflictingMessage = {
+        ...createSampleMessageV2({
+          threadId: thread2.id, // different thread
+          content: { content: 'Thread2 Content' },
+          resourceId: thread2.resourceId,
+        }),
+        id: message.id,
+      };
+
+      // Save should move the message to the new thread
+      await store.saveMessages({ messages: [conflictingMessage], format: 'v2' });
+
+      // Retrieve messages for both threads
+      const thread1Messages = await store.getMessages({ threadId: thread1.id, format: 'v2' });
+      const thread2Messages = await store.getMessages({ threadId: thread2.id, format: 'v2' });
+
+      // Thread 1 should NOT have the message with that id
+      expect(thread1Messages.find(m => m.id === message.id)).toBeUndefined();
+
+      // Thread 2 should have the message with that id
+      expect(thread2Messages.find(m => m.id === message.id)?.content.content).toBe('Thread2 Content');
+    });
     describe('getMessagesPaginated', () => {
       it('should return paginated messages with total count', async () => {
         const thread = createSampleThread();
         await store.saveThread({ thread });
 
         const messages = Array.from({ length: 15 }, (_, i) =>
-          createSampleMessageV2({ threadId: thread.id, content: `Message ${i + 1}` }),
+          createSampleMessageV2({ threadId: thread.id, content: { content: `Message ${i + 1}` } }),
         );
 
         await store.saveMessages({ messages, format: 'v2' });
@@ -512,7 +619,7 @@ describe('UpstashStore', () => {
         await store.saveThread({ thread });
 
         const messages = Array.from({ length: 10 }, (_, i) => {
-          const message = createSampleMessageV2({ threadId: thread.id, content: `Message ${i + 1}` });
+          const message = createSampleMessageV2({ threadId: thread.id, content: { content: `Message ${i + 1}` } });
           // Ensure different timestamps
           message.createdAt = new Date(Date.now() + i * 1000);
           return message;
@@ -545,13 +652,13 @@ describe('UpstashStore', () => {
         const tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1000);
 
         const oldMessages = Array.from({ length: 3 }, (_, i) => {
-          const message = createSampleMessageV2({ threadId: thread.id, content: `Old Message ${i + 1}` });
+          const message = createSampleMessageV2({ threadId: thread.id, content: { content: `Old Message ${i + 1}` } });
           message.createdAt = yesterday;
           return message;
         });
 
         const newMessages = Array.from({ length: 4 }, (_, i) => {
-          const message = createSampleMessageV2({ threadId: thread.id, content: `New Message ${i + 1}` });
+          const message = createSampleMessageV2({ threadId: thread.id, content: { content: `New Message ${i + 1}` } });
           message.createdAt = tomorrow;
           return message;
         });

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { UpstashVectorFilter } from './filter';
 import { UpstashFilterTranslator } from './filter';
 
 describe('UpstashFilterTranslator', () => {
@@ -22,7 +23,7 @@ describe('UpstashFilterTranslator', () => {
 
   it('translates nested paths', () => {
     expect(translator.translate({ 'geography.continent': 'Asia' })).toBe("geography.continent = 'Asia'");
-    expect(translator.translate({ geography: { continent: 'Asia' } })).toBe("geography.continent = 'Asia'");
+    expect(translator.translate({ geography: { continent: 'Asia' } } as any)).toBe("geography.continent = 'Asia'");
   });
 
   it('translates comparison operators', () => {
@@ -65,7 +66,7 @@ describe('UpstashFilterTranslator', () => {
   });
 
   it('translates complex nested conditions', () => {
-    const filter = {
+    const filter: UpstashVectorFilter = {
       $and: [
         { population: { $gte: 1000000 } },
         { 'geography.continent': 'Asia' },
@@ -154,7 +155,7 @@ describe('UpstashFilterTranslator', () => {
 
   describe('complex scenarios', () => {
     it('deeply nested logical operators', () => {
-      const filter = {
+      const filter: UpstashVectorFilter = {
         $or: [
           {
             $and: [
@@ -214,7 +215,7 @@ describe('UpstashFilterTranslator', () => {
     });
 
     it('complex filtering with all operator types', () => {
-      const filter = {
+      const filter: UpstashVectorFilter = {
         $and: [
           {
             $or: [{ name: { $regex: 'San*' } }, { name: { $regex: 'New*' } }],
@@ -531,7 +532,7 @@ describe('UpstashFilterTranslator', () => {
     });
 
     it('throws error for invalid $not operator', () => {
-      expect(() => translator.translate({ field: { $not: true } })).toThrow();
+      expect(() => translator.translate({ field: { $not: true } } as any)).toThrow();
     });
 
     it('throws error for regex operators', () => {
@@ -539,7 +540,7 @@ describe('UpstashFilterTranslator', () => {
       expect(() => translator.translate(filter)).toThrow();
     });
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);

package/src/vector/filter.ts

@@ -1,7 +1,13 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, OperatorSupport, VectorFilter } from '@mastra/core/vector/filter';
+import type { OperatorSupport, VectorFilter, OperatorValueMap } from '@mastra/core/vector/filter';
 
-export class UpstashFilterTranslator extends BaseFilterTranslator {
+type UpstashOperatorValueMap = Omit<OperatorValueMap, '$options' | '$elemMatch'> & {
+  $contains: string;
+};
+
+export type UpstashVectorFilter = VectorFilter<keyof UpstashOperatorValueMap, UpstashOperatorValueMap>;
+
+export class UpstashFilterTranslator extends BaseFilterTranslator<UpstashVectorFilter, string | undefined> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -11,13 +17,13 @@ export class UpstashFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): string | undefined {
+  translate(filter?: UpstashVectorFilter): string | undefined {
     if (this.isEmpty(filter)) return undefined;
     this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition, path: string = ''): string {
+  private translateNode(node: UpstashVectorFilter, path: string = ''): string {
     if (this.isRegex(node)) {
       throw new Error('Direct regex pattern format is not supported in Upstash');
     }

package/src/vector/index.test.ts

@@ -1146,7 +1146,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
           vectorStore.query({
             indexName: filterIndexName,
             queryVector: createVector(0),
-            filter: { field: { $invalidOp: 'value' } },
+            filter: { field: { $invalidOp: 'value' } as any },
           }),
         ).rejects.toThrow();
       });
@@ -1196,7 +1196,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
         const results = await vectorStore.query({
           indexName: filterIndexName,
           queryVector: createVector(0),
-          filter: { $and: { not: 'an array' } },
+          filter: { $and: { not: 'an array' } as any },
         });
         expect(results.length).toBeGreaterThan(0);
       });

package/src/vector/index.ts

@@ -1,3 +1,4 @@
+import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import type {
   CreateIndexParams,
@@ -10,12 +11,14 @@ import type {
   UpdateVectorParams,
   UpsertVectorParams,
 } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { Index } from '@upstash/vector';
 
 import { UpstashFilterTranslator } from './filter';
+import type { UpstashVectorFilter } from './filter';
 
-export class UpstashVector extends MastraVector {
+type UpstashQueryVectorParams = QueryVectorParams<UpstashVectorFilter>;
+
+export class UpstashVector extends MastraVector<UpstashVectorFilter> {
   private client: Index;
 
   /**
@@ -46,18 +49,30 @@ export class UpstashVector extends MastraVector {
       metadata: metadata?.[index],
     }));
 
-    await this.client.upsert(points, {
-      namespace,
-    });
-    return generatedIds;
+    try {
+      await this.client.upsert(points, {
+        namespace,
+      });
+      return generatedIds;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_UPSERT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { namespace, vectorCount: vectors.length },
+        },
+        error,
+      );
+    }
   }
 
   /**
    * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-   * @param {VectorFilter} [filter] - The filter to transform.
+   * @param {UpstashVectorFilter} [filter] - The filter to transform.
    * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
    */
-  transformFilter(filter?: VectorFilter) {
+  transformFilter(filter?: UpstashVectorFilter) {
     const translator = new UpstashFilterTranslator();
     return translator.translate(filter);
   }
@@ -82,25 +97,37 @@ export class UpstashVector extends MastraVector {
     topK = 10,
     filter,
     includeVector = false,
-  }: QueryVectorParams): Promise<QueryResult[]> {
-    const ns = this.client.namespace(namespace);
-
-    const filterString = this.transformFilter(filter);
-    const results = await ns.query({
-      topK,
-      vector: queryVector,
-      includeVectors: includeVector,
-      includeMetadata: true,
-      ...(filterString ? { filter: filterString } : {}),
-    });
+  }: UpstashQueryVectorParams): Promise<QueryResult[]> {
+    try {
+      const ns = this.client.namespace(namespace);
 
-    // Map the results to our expected format
-    return (results || []).map(result => ({
-      id: `${result.id}`,
-      score: result.score,
-      metadata: result.metadata,
-      ...(includeVector && { vector: result.vector || [] }),
-    }));
+      const filterString = this.transformFilter(filter);
+      const results = await ns.query({
+        topK,
+        vector: queryVector,
+        includeVectors: includeVector,
+        includeMetadata: true,
+        ...(filterString ? { filter: filterString } : {}),
+      });
+
+      // Map the results to our expected format
+      return (results || []).map(result => ({
+        id: `${result.id}`,
+        score: result.score,
+        metadata: result.metadata,
+        ...(includeVector && { vector: result.vector || [] }),
+      }));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_QUERY_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { namespace, topK },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -108,8 +135,19 @@ export class UpstashVector extends MastraVector {
    * @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);
+    try {
+      const indexes = await this.client.listNamespaces();
+      return indexes.filter(Boolean);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_LIST_INDEXES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -119,13 +157,25 @@ export class UpstashVector extends MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName: namespace }: DescribeIndexParams): Promise<IndexStats> {
-    const info = await this.client.info();
+    try {
+      const info = await this.client.info();
 
-    return {
-      dimension: info.dimension,
-      count: info.namespaces?.[namespace]?.vectorCount || 0,
-      metric: info?.similarityFunction?.toLowerCase() as 'cosine' | 'euclidean' | 'dotproduct',
-    };
+      return {
+        dimension: info.dimension,
+        count: info.namespaces?.[namespace]?.vectorCount || 0,
+        metric: info?.similarityFunction?.toLowerCase() as 'cosine' | 'euclidean' | 'dotproduct',
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_DESCRIBE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { namespace },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -137,7 +187,15 @@ export class UpstashVector extends MastraVector {
     try {
       await this.client.deleteNamespace(namespace);
     } catch (error) {
-      this.logger.error('Failed to delete namespace:', error);
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_DELETE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { namespace },
+        },
+        error,
+      );
     }
   }
 
@@ -162,7 +220,19 @@ export class UpstashVector extends MastraVector {
       if (!update.vector && update.metadata) {
         throw new Error('Both vector and metadata must be provided for an update');
       }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { namespace, id },
+        },
+        error,
+      );
+    }
 
+    try {
       const updatePayload: any = { id: id };
       if (update.vector) {
         updatePayload.vector = update.vector;
@@ -180,8 +250,16 @@ export class UpstashVector extends MastraVector {
       await this.client.upsert(points, {
         namespace,
       });
-    } catch (error: any) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${namespace}: ${error.message}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_UPDATE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { namespace, id },
+        },
+        error,
+      );
     }
   }
 
@@ -198,7 +276,16 @@ export class UpstashVector extends MastraVector {
         namespace,
       });
     } catch (error) {
-      this.logger.error(`Failed to delete vector by id: ${id} for namespace: ${namespace}:`, error);
+      const mastraError = new MastraError(
+        {
+          id: 'STORAGE_UPSTASH_VECTOR_DELETE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { namespace, id },
+        },
+        error,
+      );
+      this.logger?.error(mastraError.toString());
     }
   }
 }