@mastra/dynamodb 0.10.1 → 0.10.3

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

@@ -70,6 +70,11 @@ declare class DynamoDBStore extends MastraStorage {
      * Handles resetting the stored promise on failure to allow retries.
      */
     private _performInitializationAndStore;
+    /**
+     * Pre-processes a record to ensure Date objects are converted to ISO strings
+     * This is necessary because ElectroDB validation happens before setters are applied
+     */
+    private preprocessRecord;
     /**
      * Clear all items from a logical "table" (entity type)
      */

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

@@ -70,6 +70,11 @@ declare class DynamoDBStore extends MastraStorage {
      * Handles resetting the stored promise on failure to allow retries.
      */
     private _performInitializationAndStore;
+    /**
+     * Pre-processes a record to ensure Date objects are converted to ISO strings
+     * This is necessary because ElectroDB validation happens before setters are applied
+     */
+    private preprocessRecord;
     /**
      * Clear all items from a logical "table" (entity type)
      */

package/dist/index.cjs

@@ -659,6 +659,23 @@ var DynamoDBStore = class extends storage.MastraStorage {
       throw err;
     });
   }
+  /**
+   * Pre-processes a record to ensure Date objects are converted to ISO strings
+   * This is necessary because ElectroDB validation happens before setters are applied
+   */
+  preprocessRecord(record) {
+    const processed = { ...record };
+    if (processed.createdAt instanceof Date) {
+      processed.createdAt = processed.createdAt.toISOString();
+    }
+    if (processed.updatedAt instanceof Date) {
+      processed.updatedAt = processed.updatedAt.toISOString();
+    }
+    if (processed.created_at instanceof Date) {
+      processed.created_at = processed.created_at.toISOString();
+    }
+    return processed;
+  }
   /**
    * Clear all items from a logical "table" (entity type)
    */
@@ -728,7 +745,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
       throw new Error(`No entity defined for ${tableName}`);
     }
     try {
-      const dataToSave = { entity: entityName, ...record };
+      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
       await this.service.entities[entityName].create(dataToSave).go();
     } catch (error) {
       this.logger.error("Failed to insert record", { tableName, error });
@@ -744,7 +761,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
     if (!entityName || !this.service.entities[entityName]) {
       throw new Error(`No entity defined for ${tableName}`);
     }
-    const recordsToSave = records.map((rec) => ({ entity: entityName, ...rec }));
+    const recordsToSave = records.map((rec) => ({ entity: entityName, ...this.preprocessRecord(rec) }));
     const batchSize = 25;
     const batches = [];
     for (let i = 0; i < recordsToSave.length; i += batchSize) {
@@ -904,7 +921,7 @@ var DynamoDBStore = class extends storage.MastraStorage {
     try {
       const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
       if (selectBy?.last && typeof selectBy.last === "number") {
-        const results2 = await query.go({ limit: selectBy.last, reverse: true });
+        const results2 = await query.go({ limit: selectBy.last, order: "desc" });
         const list2 = new agent.MessageList({ threadId, resourceId }).add(
           results2.data.map((data) => this.parseMessageData(data)),
           "memory"

package/dist/index.js

@@ -657,6 +657,23 @@ var DynamoDBStore = class extends MastraStorage {
       throw err;
     });
   }
+  /**
+   * Pre-processes a record to ensure Date objects are converted to ISO strings
+   * This is necessary because ElectroDB validation happens before setters are applied
+   */
+  preprocessRecord(record) {
+    const processed = { ...record };
+    if (processed.createdAt instanceof Date) {
+      processed.createdAt = processed.createdAt.toISOString();
+    }
+    if (processed.updatedAt instanceof Date) {
+      processed.updatedAt = processed.updatedAt.toISOString();
+    }
+    if (processed.created_at instanceof Date) {
+      processed.created_at = processed.created_at.toISOString();
+    }
+    return processed;
+  }
   /**
    * Clear all items from a logical "table" (entity type)
    */
@@ -726,7 +743,7 @@ var DynamoDBStore = class extends MastraStorage {
       throw new Error(`No entity defined for ${tableName}`);
     }
     try {
-      const dataToSave = { entity: entityName, ...record };
+      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
       await this.service.entities[entityName].create(dataToSave).go();
     } catch (error) {
       this.logger.error("Failed to insert record", { tableName, error });
@@ -742,7 +759,7 @@ var DynamoDBStore = class extends MastraStorage {
     if (!entityName || !this.service.entities[entityName]) {
       throw new Error(`No entity defined for ${tableName}`);
     }
-    const recordsToSave = records.map((rec) => ({ entity: entityName, ...rec }));
+    const recordsToSave = records.map((rec) => ({ entity: entityName, ...this.preprocessRecord(rec) }));
     const batchSize = 25;
     const batches = [];
     for (let i = 0; i < recordsToSave.length; i += batchSize) {
@@ -902,7 +919,7 @@ var DynamoDBStore = class extends MastraStorage {
     try {
       const query = this.service.entities.message.query.byThread({ entity: "message", threadId });
       if (selectBy?.last && typeof selectBy.last === "number") {
-        const results2 = await query.go({ limit: selectBy.last, reverse: true });
+        const results2 = await query.go({ limit: selectBy.last, order: "desc" });
         const list2 = new MessageList({ threadId, resourceId }).add(
           results2.data.map((data) => this.parseMessageData(data)),
           "memory"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dynamodb",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "DynamoDB storage adapter for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -40,8 +40,8 @@
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
     "vitest": "^3.0.9",
-    "@internal/lint": "0.0.8",
-    "@mastra/core": "0.10.2"
+    "@internal/lint": "0.0.10",
+    "@mastra/core": "0.10.3"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.test.ts

@@ -387,6 +387,61 @@ describe('DynamoDBStore Integration Tests', () => {
         expect(retrieved?.title).toBe('Updated Thread 2');
         expect(retrieved?.metadata?.update).toBe(2);
       });
+
+      test('getMessages should return the N most recent messages [v2 storage]', async () => {
+        const threadId = 'last-selector-thread';
+        const start = Date.now();
+
+        // Insert 10 messages with increasing timestamps
+        const messages: MastraMessageV2[] = Array.from({ length: 10 }, (_, i) => ({
+          id: `m-${i}`,
+          threadId,
+          resourceId: 'r',
+          content: { format: 2, parts: [{ type: 'text', text: `msg-${i}` }] },
+          createdAt: new Date(start + i), // 0..9 ms apart
+          role: 'user',
+          type: 'text',
+        }));
+        await store.saveMessages({ messages, format: 'v2' });
+
+        const last3 = await store.getMessages({
+          format: 'v2',
+          threadId,
+          selectBy: { last: 3 },
+        });
+
+        expect(last3).toHaveLength(3);
+        expect(last3.map(m => (m.content.parts[0] as { type: string; text: string }).text)).toEqual([
+          'msg-7',
+          'msg-8',
+          'msg-9',
+        ]);
+      });
+
+      test('getMessages should return the N most recent messages [v1 storage]', async () => {
+        const threadId = 'last-selector-thread';
+        const start = Date.now();
+
+        // Insert 10 messages with increasing timestamps
+        const messages: MastraMessageV1[] = Array.from({ length: 10 }, (_, i) => ({
+          id: `m-${i}`,
+          threadId,
+          resourceId: 'r',
+          content: `msg-${i}`,
+          createdAt: new Date(start + i), // 0..9 ms apart
+          role: 'user',
+          type: 'text',
+        }));
+        await store.saveMessages({ messages });
+
+        const last3 = await store.getMessages({
+          threadId,
+          selectBy: { last: 3 },
+        });
+
+        expect(last3).toHaveLength(3);
+        expect(last3.map(m => m.content)).toEqual(['msg-7', 'msg-8', 'msg-9']);
+      });
     });
 
     describe('Batch Operations', () => {
@@ -589,6 +644,37 @@ describe('DynamoDBStore Integration Tests', () => {
       expect(allTraces.length).toBe(3);
     });
 
+    test('should handle Date objects for createdAt/updatedAt fields in batchTraceInsert', async () => {
+      // This test specifically verifies the bug from the issue where Date objects
+      // were passed instead of ISO strings and ElectroDB validation failed
+      const now = new Date();
+      const traceWithDateObjects = {
+        id: `trace-${randomUUID()}`,
+        parentSpanId: `span-${randomUUID()}`,
+        traceId: `traceid-${randomUUID()}`,
+        name: 'test-trace-with-dates',
+        scope: 'default-tracer',
+        kind: 1,
+        startTime: now.getTime(),
+        endTime: now.getTime() + 100,
+        status: JSON.stringify({ code: 0 }),
+        attributes: JSON.stringify({ key: 'value' }),
+        events: JSON.stringify([]),
+        links: JSON.stringify([]),
+        // These are Date objects, not ISO strings - this should be handled by ElectroDB attribute setters
+        createdAt: now,
+        updatedAt: now,
+      };
+
+      // This should not throw a validation error due to Date object type
+      await expect(store.batchTraceInsert({ records: [traceWithDateObjects] })).resolves.not.toThrow();
+
+      // Verify the trace was saved correctly
+      const allTraces = await store.getTraces({ name: 'test-trace-with-dates', page: 1, perPage: 10 });
+      expect(allTraces.length).toBe(1);
+      expect(allTraces[0].name).toBe('test-trace-with-dates');
+    });
+
     test('should retrieve traces filtered by name using GSI', async () => {
       const trace1 = sampleTrace('trace-filter-name', 'scope-X');
       const trace2 = sampleTrace('trace-filter-name', 'scope-Y', Date.now() + 10);
@@ -670,6 +756,40 @@ describe('DynamoDBStore Integration Tests', () => {
       };
     };
 
+    test('should handle Date objects for createdAt/updatedAt fields in eval batchInsert', async () => {
+      // Test that eval entity properly handles Date objects in createdAt/updatedAt fields
+      const now = new Date();
+      const evalWithDateObjects = {
+        entity: 'eval',
+        agent_name: 'test-agent-dates',
+        input: 'Test input',
+        output: 'Test output',
+        result: JSON.stringify({ score: 0.95 }),
+        metric_name: 'test-metric',
+        instructions: 'Test instructions',
+        global_run_id: `global-${randomUUID()}`,
+        run_id: `run-${randomUUID()}`,
+        created_at: now, // Date object instead of ISO string
+        // These are Date objects, not ISO strings - should be handled by ElectroDB attribute setters
+        createdAt: now,
+        updatedAt: now,
+        metadata: JSON.stringify({ test: 'meta' }),
+      };
+
+      // This should not throw a validation error due to Date object type
+      await expect(
+        store.batchInsert({
+          tableName: TABLE_EVALS,
+          records: [evalWithDateObjects],
+        }),
+      ).resolves.not.toThrow();
+
+      // Verify the eval was saved correctly
+      const evals = await store.getEvalsByAgentName('test-agent-dates');
+      expect(evals.length).toBe(1);
+      expect(evals[0].agentName).toBe('test-agent-dates');
+    });
+
     test('should retrieve evals by agent name using GSI and filter by type', async () => {
       const agent1 = 'eval-agent-1';
       const agent2 = 'eval-agent-2';
@@ -1012,6 +1132,32 @@ describe('DynamoDBStore Integration Tests', () => {
       }
     });
 
+    test('insert() should handle Date objects for createdAt/updatedAt fields', async () => {
+      // Test that individual insert method properly handles Date objects in date fields
+      const now = new Date();
+      const recordWithDates = {
+        id: `thread-${randomUUID()}`,
+        resourceId: `resource-${randomUUID()}`,
+        title: 'Thread with Date Objects',
+        // These are Date objects, not ISO strings - should be handled by preprocessing
+        createdAt: now,
+        updatedAt: now,
+        metadata: JSON.stringify({ test: 'with-dates' }),
+      };
+
+      // This should not throw a validation error due to Date object type
+      await expect(genericStore.insert({ tableName: TABLE_THREADS, record: recordWithDates })).resolves.not.toThrow();
+
+      // Verify the record was saved correctly
+      const loaded = await genericStore.load<StorageThreadType>({
+        tableName: TABLE_THREADS,
+        keys: { id: recordWithDates.id },
+      });
+      expect(loaded).not.toBeNull();
+      expect(loaded?.id).toBe(recordWithDates.id);
+      expect(loaded?.title).toBe('Thread with Date Objects');
+    });
+
     test('load() should return null for non-existent record', async () => {
       // Use the genericStore instance
       const loaded = await genericStore.load({ tableName: TABLE_THREADS, keys: { id: 'non-existent-generic' } });

package/src/storage/index.ts

@@ -180,6 +180,29 @@ export class DynamoDBStore extends MastraStorage {
       });
   }
 
+  /**
+   * Pre-processes a record to ensure Date objects are converted to ISO strings
+   * This is necessary because ElectroDB validation happens before setters are applied
+   */
+  private preprocessRecord(record: Record<string, any>): Record<string, any> {
+    const processed = { ...record };
+
+    // Convert Date objects to ISO strings for date fields
+    // This prevents ElectroDB validation errors that occur when Date objects are passed
+    // to string-typed attributes, even when the attribute has a setter that converts dates
+    if (processed.createdAt instanceof Date) {
+      processed.createdAt = processed.createdAt.toISOString();
+    }
+    if (processed.updatedAt instanceof Date) {
+      processed.updatedAt = processed.updatedAt.toISOString();
+    }
+    if (processed.created_at instanceof Date) {
+      processed.created_at = processed.created_at.toISOString();
+    }
+
+    return processed;
+  }
+
   /**
    * Clear all items from a logical "table" (entity type)
    */
@@ -275,8 +298,8 @@ export class DynamoDBStore extends MastraStorage {
     }
 
     try {
-      // Add the entity type to the record before creating
-      const dataToSave = { entity: entityName, ...record };
+      // Add the entity type to the record and preprocess before creating
+      const dataToSave = { entity: entityName, ...this.preprocessRecord(record) };
       await this.service.entities[entityName].create(dataToSave).go();
     } catch (error) {
       this.logger.error('Failed to insert record', { tableName, error });
@@ -295,8 +318,8 @@ export class DynamoDBStore extends MastraStorage {
       throw new Error(`No entity defined for ${tableName}`);
     }
 
-    // Add entity type to each record
-    const recordsToSave = records.map(rec => ({ entity: entityName, ...rec }));
+    // Add entity type and preprocess each record
+    const recordsToSave = records.map(rec => ({ entity: entityName, ...this.preprocessRecord(rec) }));
 
     // ElectroDB has batch limits of 25 items, so we need to chunk
     const batchSize = 25;
@@ -532,10 +555,10 @@ export class DynamoDBStore extends MastraStorage {
 
       // Apply the 'last' limit if provided
       if (selectBy?.last && typeof selectBy.last === 'number') {
-        // Use ElectroDB's limit parameter (descending sort assumed on GSI SK)
-        // Ensure GSI sk (createdAt) is sorted descending for 'last' to work correctly
-        // Assuming default sort is ascending on SK, use reverse: true for descending
-        const results = await query.go({ limit: selectBy.last, reverse: true });
+        // Use ElectroDB's limit parameter
+        // DDB GSIs are sorted in ascending order
+        // Use ElectroDB's order parameter to sort in descending order to retrieve 'latest' messages
+        const results = await query.go({ limit: selectBy.last, order: 'desc' });
         // Use arrow function in map to preserve 'this' context for parseMessageData
         const list = new MessageList({ threadId, resourceId }).add(
           results.data.map((data: any) => this.parseMessageData(data)),