@mastra/dynamodb 0.10.2 → 0.10.4-alpha.0

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

@@ -5,6 +5,7 @@ import type { MastraMessageV1 } from '@mastra/core';
 import type { MastraMessageV2 } from '@mastra/core';
 import { MastraStorage } from '@mastra/core/storage';
 import { Service } from 'electrodb';
+import type { StorageColumn } from '@mastra/core';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core';
 import type { TABLE_NAMES } from '@mastra/core/storage';
@@ -70,6 +71,16 @@ 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;
+    alterTable(_args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     /**
      * Clear all items from a logical "table" (entity type)
      */

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

@@ -5,6 +5,7 @@ import type { MastraMessageV1 } from '@mastra/core';
 import type { MastraMessageV2 } from '@mastra/core';
 import { MastraStorage } from '@mastra/core/storage';
 import { Service } from 'electrodb';
+import type { StorageColumn } from '@mastra/core';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core';
 import type { TABLE_NAMES } from '@mastra/core/storage';
@@ -70,6 +71,16 @@ 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;
+    alterTable(_args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     /**
      * Clear all items from a logical "table" (entity type)
      */

package/dist/index.cjs

@@ -659,6 +659,25 @@ 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;
+  }
+  async alterTable(_args) {
+  }
   /**
    * Clear all items from a logical "table" (entity type)
    */
@@ -728,7 +747,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 +763,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) {

package/dist/index.js

@@ -657,6 +657,25 @@ 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;
+  }
+  async alterTable(_args) {
+  }
   /**
    * Clear all items from a logical "table" (entity type)
    */
@@ -726,7 +745,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 +761,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/dynamodb",
-  "version": "0.10.2",
+  "version": "0.10.4-alpha.0",
   "description": "DynamoDB storage adapter for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -23,25 +23,26 @@
     "src"
   ],
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.0.0",
-    "@aws-sdk/lib-dynamodb": "^3.0.0",
+    "@aws-sdk/client-dynamodb": "^3.823.0",
+    "@aws-sdk/lib-dynamodb": "^3.823.0",
     "electrodb": "^3.4.1"
   },
   "peerDependencies": {
     "@mastra/core": "^0.10.2-alpha.0"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.52.1",
-    "@types/node": "^20.17.27",
-    "@vitest/coverage-v8": "3.0.9",
-    "@vitest/ui": "3.0.9",
-    "axios": "^1.8.4",
-    "eslint": "^9.23.0",
-    "tsup": "^8.4.0",
+    "@microsoft/api-extractor": "^7.52.8",
+    "@types/node": "^20.17.57",
+    "@vitest/coverage-v8": "3.2.2",
+    "@vitest/ui": "3.2.2",
+    "axios": "^1.9.0",
+    "eslint": "^9.28.0",
+    "tsup": "^8.5.0",
     "typescript": "^5.8.2",
-    "vitest": "^3.0.9",
-    "@internal/lint": "0.0.9",
-    "@mastra/core": "0.10.2"
+    "vitest": "^3.2.2",
+    "@internal/lint": "0.0.10",
+    "@internal/storage-test-utils": "0.0.6",
+    "@mastra/core": "0.10.4-alpha.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.test.ts

@@ -644,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);
@@ -725,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';
@@ -1067,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

@@ -1,6 +1,12 @@
 import { DynamoDBClient, DescribeTableCommand } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-import type { StorageThreadType, WorkflowRunState, MastraMessageV1, MastraMessageV2 } from '@mastra/core';
+import type {
+  StorageThreadType,
+  WorkflowRunState,
+  MastraMessageV1,
+  MastraMessageV2,
+  StorageColumn,
+} from '@mastra/core';
 import { MessageList } from '@mastra/core/agent';
 import {
   MastraStorage,
@@ -180,6 +186,37 @@ 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;
+  }
+
+  async alterTable(_args: {
+    tableName: TABLE_NAMES;
+    schema: Record<string, StorageColumn>;
+    ifNotExists: string[];
+  }): Promise<void> {
+    // Nothing to do here, DynamoDB has a flexible schema and handles new attributes automatically upon insertion/update.
+  }
+
   /**
    * Clear all items from a logical "table" (entity type)
    */
@@ -275,8 +312,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 +332,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;