@mastra/dynamodb 0.12.0 → 0.13.0-alpha.1

package/dist/index.cjs

@@ -974,7 +974,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
       metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
     };
     try {
-      await this.service.entities.thread.create(threadData).go();
+      await this.service.entities.thread.upsert(threadData).go();
       return {
         id: thread.id,
         resourceId: thread.resourceId,

package/dist/index.js

@@ -972,7 +972,7 @@ var DynamoDBStore = class extends MastraStorage {
       metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
     };
     try {
-      await this.service.entities.thread.create(threadData).go();
+      await this.service.entities.thread.upsert(threadData).go();
       return {
         id: thread.id,
         resourceId: thread.resourceId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dynamodb",
-  "version": "0.12.0",
+  "version": "0.13.0-alpha.1",
   "description": "DynamoDB storage adapter for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -23,8 +23,8 @@
     "src"
   ],
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.828.0",
-    "@aws-sdk/lib-dynamodb": "^3.830.0",
+    "@aws-sdk/client-dynamodb": "^3.840.0",
+    "@aws-sdk/lib-dynamodb": "^3.840.0",
     "electrodb": "^3.4.3"
   },
   "peerDependencies": {
@@ -39,10 +39,10 @@
     "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3",
-    "@internal/lint": "0.0.14",
-    "@internal/storage-test-utils": "0.0.10",
-    "@mastra/core": "0.10.7"
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.17",
+    "@internal/storage-test-utils": "0.0.13",
+    "@mastra/core": "0.10.11-alpha.2"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.test.ts

@@ -481,6 +481,123 @@ describe('DynamoDBStore Integration Tests', () => {
         expect(updatedThread).toBeDefined();
         expect(updatedThread!.updatedAt.getTime()).toBeGreaterThan(originalUpdatedAt.getTime());
       });
+
+      test('saveThread upsert: should create new thread when thread does not exist', async () => {
+        const threadId = `upsert-new-${randomUUID()}`;
+        const now = new Date();
+        const thread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-upsert-new',
+          title: 'New Thread via Upsert',
+          createdAt: now,
+          updatedAt: now,
+          metadata: { operation: 'create', test: true },
+        };
+
+        // Save the thread (should create new)
+        await expect(store.saveThread({ thread })).resolves.not.toThrow();
+
+        // Verify the thread was created
+        const retrieved = await store.getThreadById({ threadId });
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.id).toBe(threadId);
+        expect(retrieved?.title).toBe('New Thread via Upsert');
+        expect(retrieved?.resourceId).toBe('resource-upsert-new');
+        expect(retrieved?.metadata).toEqual({ operation: 'create', test: true });
+      });
+
+      test('saveThread upsert: should update existing thread when thread already exists', async () => {
+        const threadId = `upsert-update-${randomUUID()}`;
+        const initialCreatedAt = new Date();
+
+        // Create initial thread
+        const initialThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-upsert-initial',
+          title: 'Initial Thread Title',
+          createdAt: initialCreatedAt,
+          updatedAt: initialCreatedAt,
+          metadata: { operation: 'initial', version: 1 },
+        };
+        await store.saveThread({ thread: initialThread });
+
+        // Wait a small amount to ensure different timestamp
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Update the thread with same ID but different data
+        const updatedThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-upsert-updated',
+          title: 'Updated Thread Title',
+          createdAt: initialCreatedAt, // Keep original creation time
+          updatedAt: new Date(), // New update time
+          metadata: { operation: 'update', version: 2 },
+        };
+        await expect(store.saveThread({ thread: updatedThread })).resolves.not.toThrow();
+
+        // Verify the thread was updated
+        const retrieved = await store.getThreadById({ threadId });
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.id).toBe(threadId);
+        expect(retrieved?.title).toBe('Updated Thread Title');
+        expect(retrieved?.resourceId).toBe('resource-upsert-updated');
+        expect(retrieved?.metadata).toEqual({ operation: 'update', version: 2 });
+
+        // updatedAt should be newer than the initial creation time
+        expect(retrieved?.updatedAt.getTime()).toBeGreaterThan(initialCreatedAt.getTime());
+        // createdAt should remain exactly equal to the initial creation time
+        expect(retrieved?.createdAt.getTime()).toBe(initialCreatedAt.getTime());
+      });
+
+      test('saveThread upsert: should handle complex metadata updates', async () => {
+        const threadId = `upsert-metadata-${randomUUID()}`;
+        const initialMetadata = {
+          user: 'initial-user',
+          tags: ['initial', 'test'],
+          count: 1,
+        };
+
+        // Create initial thread with complex metadata
+        const initialThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-metadata-test',
+          title: 'Metadata Test Thread',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          metadata: initialMetadata,
+        };
+        await store.saveThread({ thread: initialThread });
+
+        // Wait a small amount to ensure different timestamp
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        // Update with completely different metadata structure
+        const updatedMetadata = {
+          user: 'updated-user',
+          settings: { theme: 'light', language: 'ja', notifications: true },
+          tags: ['updated', 'upsert', 'complex'],
+          count: 5,
+          newField: { nested: { deeply: 'value' } },
+        };
+
+        const updatedThread: StorageThreadType = {
+          id: threadId,
+          resourceId: 'resource-metadata-test',
+          title: 'Updated Metadata Thread',
+          createdAt: initialThread.createdAt,
+          updatedAt: new Date(),
+          metadata: updatedMetadata,
+        };
+        await expect(store.saveThread({ thread: updatedThread })).resolves.not.toThrow();
+
+        // Verify the metadata was completely replaced
+        const retrieved = await store.getThreadById({ threadId });
+        expect(retrieved).toBeDefined();
+        expect(retrieved?.metadata).toEqual(updatedMetadata);
+        expect(retrieved?.metadata?.user).toBe('updated-user');
+        expect(retrieved?.metadata?.tags).toEqual(['updated', 'upsert', 'complex']);
+        expect(retrieved?.title).toBe('Updated Metadata Thread');
+      });
     });
 
     describe('Batch Operations', () => {
@@ -1363,4 +1480,4 @@ describe('DynamoDBStore Integration Tests', () => {
       ).toBeNull();
     });
   }); // End Generic Storage Methods describe
-}); // End Main Describe
+});

package/src/storage/index.ts

@@ -598,7 +598,7 @@ export class DynamoDBStore extends MastraStorage {
     };
 
     try {
-      await this.service.entities.thread.create(threadData).go();
+      await this.service.entities.thread.upsert(threadData).go();
 
       return {
         id: thread.id,