@mastra/dynamodb 0.14.5 → 0.14.6-alpha.0

package/src/entities/thread.ts

@@ -1,66 +0,0 @@
-import { Entity } from 'electrodb';
-import { baseAttributes } from './utils';
-
-export const threadEntity = new Entity({
-  model: {
-    entity: 'thread',
-    version: '1',
-    service: 'mastra',
-  },
-  attributes: {
-    entity: {
-      type: 'string',
-      required: true,
-    },
-    ...baseAttributes,
-    id: {
-      type: 'string',
-      required: true,
-    },
-    resourceId: {
-      type: 'string',
-      required: true,
-    },
-    title: {
-      type: 'string',
-      required: true,
-    },
-    metadata: {
-      type: 'string',
-      required: false,
-      // Stringify metadata object on set if it's not already a string
-      set: (value?: Record<string, unknown> | string) => {
-        if (value && typeof value !== 'string') {
-          return JSON.stringify(value);
-        }
-        return value;
-      },
-      // Parse JSON string to object on get
-      get: (value?: string) => {
-        if (value && typeof value === 'string') {
-          try {
-            // Attempt to parse only if it might be JSON (e.g., starts with { or [)
-            if (value.startsWith('{') || value.startsWith('[')) {
-              return JSON.parse(value);
-            }
-          } catch {
-            // Ignore parse error, return original string
-            return value;
-          }
-        }
-        return value;
-      },
-    },
-  },
-  indexes: {
-    primary: {
-      pk: { field: 'pk', composite: ['entity', 'id'] },
-      sk: { field: 'sk', composite: ['id'] },
-    },
-    byResource: {
-      index: 'gsi1',
-      pk: { field: 'gsi1pk', composite: ['entity', 'resourceId'] },
-      sk: { field: 'gsi1sk', composite: ['createdAt'] },
-    },
-  },
-});

package/src/entities/trace.ts

@@ -1,129 +0,0 @@
-import { Entity } from 'electrodb';
-import { baseAttributes } from './utils';
-
-export const traceEntity = new Entity({
-  model: {
-    entity: 'trace',
-    version: '1',
-    service: 'mastra',
-  },
-  attributes: {
-    entity: {
-      type: 'string',
-      required: true,
-    },
-    ...baseAttributes,
-    id: {
-      type: 'string',
-      required: true,
-    },
-    parentSpanId: {
-      type: 'string',
-      required: false,
-    },
-    name: {
-      type: 'string',
-      required: true,
-    },
-    traceId: {
-      type: 'string',
-      required: true,
-    },
-    scope: {
-      type: 'string',
-      required: true,
-    },
-    kind: {
-      type: 'number',
-      required: true,
-    },
-    attributes: {
-      type: 'string', // JSON stringified
-      required: false,
-      // Stringify object on set
-      set: (value?: any) => {
-        if (value && typeof value !== 'string') {
-          return JSON.stringify(value);
-        }
-        return value;
-      },
-      // Parse JSON string to object on get
-      get: (value?: string) => {
-        return value ? JSON.parse(value) : value;
-      },
-    },
-    status: {
-      type: 'string', // JSON stringified
-      required: false,
-      // Stringify object on set
-      set: (value?: any) => {
-        if (value && typeof value !== 'string') {
-          return JSON.stringify(value);
-        }
-        return value;
-      },
-      // Parse JSON string to object on get
-      get: (value?: string) => {
-        return value;
-      },
-    },
-    events: {
-      type: 'string', // JSON stringified
-      required: false,
-      // Stringify object on set
-      set: (value?: any) => {
-        if (value && typeof value !== 'string') {
-          return JSON.stringify(value);
-        }
-        return value;
-      },
-      // Parse JSON string to object on get
-      get: (value?: string) => {
-        return value;
-      },
-    },
-    links: {
-      type: 'string', // JSON stringified
-      required: false,
-      // Stringify object on set
-      set: (value?: any) => {
-        if (value && typeof value !== 'string') {
-          return JSON.stringify(value);
-        }
-        return value;
-      },
-      // Parse JSON string to object on get
-      get: (value?: string) => {
-        return value;
-      },
-    },
-    other: {
-      type: 'string',
-      required: false,
-    },
-    startTime: {
-      type: 'number',
-      required: true,
-    },
-    endTime: {
-      type: 'number',
-      required: true,
-    },
-  },
-  indexes: {
-    primary: {
-      pk: { field: 'pk', composite: ['entity', 'id'] },
-      sk: { field: 'sk', composite: [] },
-    },
-    byName: {
-      index: 'gsi1',
-      pk: { field: 'gsi1pk', composite: ['entity', 'name'] },
-      sk: { field: 'gsi1sk', composite: ['startTime'] },
-    },
-    byScope: {
-      index: 'gsi2',
-      pk: { field: 'gsi2pk', composite: ['entity', 'scope'] },
-      sk: { field: 'gsi2sk', composite: ['startTime'] },
-    },
-  },
-});

package/src/entities/utils.ts

@@ -1,51 +0,0 @@
-export const baseAttributes = {
-  createdAt: {
-    type: 'string',
-    required: true,
-    readOnly: true,
-    // Convert Date to ISO string on set
-    set: (value?: Date | string) => {
-      if (value instanceof Date) {
-        return value.toISOString();
-      }
-      return value || new Date().toISOString();
-    },
-    // Initialize with current timestamp if not provided
-    default: () => new Date().toISOString(),
-  },
-  updatedAt: {
-    type: 'string',
-    required: true,
-    // Convert Date to ISO string on set
-    set: (value?: Date | string) => {
-      if (value instanceof Date) {
-        return value.toISOString();
-      }
-      return value || new Date().toISOString();
-    },
-    // Always use current timestamp when creating/updating
-    default: () => new Date().toISOString(),
-  },
-  metadata: {
-    type: 'string', // JSON stringified
-    // Stringify objects on set
-    set: (value?: Record<string, unknown> | string) => {
-      if (value && typeof value !== 'string') {
-        return JSON.stringify(value);
-      }
-      return value;
-    },
-    // Parse JSON string to object on get
-    get: (value?: string) => {
-      if (value) {
-        try {
-          return JSON.parse(value);
-        } catch {
-          // If parsing fails, return the original string
-          return value;
-        }
-      }
-      return value;
-    },
-  },
-} as const;

package/src/entities/workflow-snapshot.ts

@@ -1,56 +0,0 @@
-import { Entity } from 'electrodb';
-import { baseAttributes } from './utils';
-
-export const workflowSnapshotEntity = new Entity({
-  model: {
-    entity: 'workflow_snapshot',
-    version: '1',
-    service: 'mastra',
-  },
-  attributes: {
-    entity: {
-      type: 'string',
-      required: true,
-    },
-    ...baseAttributes,
-    workflow_name: {
-      type: 'string',
-      required: true,
-    },
-    run_id: {
-      type: 'string',
-      required: true,
-    },
-    snapshot: {
-      type: 'string', // JSON stringified
-      required: true,
-      // Stringify snapshot object on set
-      set: (value?: any) => {
-        if (value && typeof value !== 'string') {
-          return JSON.stringify(value);
-        }
-        return value;
-      },
-      // Parse JSON string to object on get
-      get: (value?: string) => {
-        return value ? JSON.parse(value) : value;
-      },
-    },
-    resourceId: {
-      type: 'string',
-      required: false,
-    },
-  },
-  indexes: {
-    primary: {
-      pk: { field: 'pk', composite: ['entity', 'workflow_name'] },
-      sk: { field: 'sk', composite: ['run_id'] },
-    },
-    // GSI to allow querying by run_id efficiently without knowing the workflow_name
-    gsi2: {
-      index: 'gsi2',
-      pk: { field: 'gsi2pk', composite: ['entity', 'run_id'] },
-      sk: { field: 'gsi2sk', composite: ['workflow_name'] },
-    },
-  },
-});

package/src/index.ts

@@ -1 +0,0 @@
-export * from './storage';

package/src/storage/docker-compose.yml

@@ -1,16 +0,0 @@
-version: '3.8'
-
-services:
-  dynamodb-local:
-    image: amazon/dynamodb-local:latest
-    # Use host network mode for simpler connection from tests,
-    # or define ports if running in bridge mode.
-    # network_mode: host
-    ports:
-      - '8000:8000' # Map container port 8000 to host port 8000
-    command: ['-jar', 'DynamoDBLocal.jar', '-sharedDb']
-    volumes:
-      - dynamodb_data:/home/dynamodblocal/data
-
-volumes:
-  dynamodb_data: {}

package/src/storage/domains/legacy-evals/index.ts

@@ -1,243 +0,0 @@
-import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import type { EvalRow, PaginationArgs, PaginationInfo } from '@mastra/core/storage';
-import { LegacyEvalsStorage } from '@mastra/core/storage';
-import type { Service } from 'electrodb';
-
-export class LegacyEvalsDynamoDB extends LegacyEvalsStorage {
-  service: Service<Record<string, any>>;
-  tableName: string;
-
-  constructor({ service, tableName }: { service: Service<Record<string, any>>; tableName: string }) {
-    super();
-    this.service = service;
-    this.tableName = tableName;
-  }
-
-  // Eval operations
-  async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
-    this.logger.debug('Getting evals for agent', { agentName, type });
-
-    try {
-      // Query evals by agent name using the GSI
-      // Provide *all* composite key components for the 'byAgent' index ('entity', 'agent_name')
-      const query = this.service.entities.eval.query.byAgent({ entity: 'eval', agent_name: agentName });
-
-      // Fetch potentially all items in descending order, using the correct 'order' option
-      const results = await query.go({ order: 'desc', limit: 100 }); // Use order: 'desc'
-
-      if (!results.data.length) {
-        return [];
-      }
-
-      // Filter by type if specified
-      let filteredData = results.data;
-      if (type) {
-        filteredData = filteredData.filter((evalRecord: Record<string, any>) => {
-          try {
-            // Need to handle potential parse errors for test_info
-            const testInfo =
-              evalRecord.test_info && typeof evalRecord.test_info === 'string'
-                ? JSON.parse(evalRecord.test_info)
-                : undefined;
-
-            if (type === 'test' && !testInfo) {
-              return false;
-            }
-            if (type === 'live' && testInfo) {
-              return false;
-            }
-          } catch (e) {
-            this.logger.warn('Failed to parse test_info during filtering', { record: evalRecord, error: e });
-            // Decide how to handle parse errors - exclude or include? Including for now.
-          }
-          return true;
-        });
-      }
-
-      // Format the results - ElectroDB transforms most attributes, but we need to map/parse
-      return filteredData.map((evalRecord: Record<string, any>) => {
-        try {
-          return {
-            input: evalRecord.input,
-            output: evalRecord.output,
-            // Safely parse result and test_info
-            result:
-              evalRecord.result && typeof evalRecord.result === 'string' ? JSON.parse(evalRecord.result) : undefined,
-            agentName: evalRecord.agent_name,
-            createdAt: evalRecord.created_at, // Keep as string from DDB?
-            metricName: evalRecord.metric_name,
-            instructions: evalRecord.instructions,
-            runId: evalRecord.run_id,
-            globalRunId: evalRecord.global_run_id,
-            testInfo:
-              evalRecord.test_info && typeof evalRecord.test_info === 'string'
-                ? JSON.parse(evalRecord.test_info)
-                : undefined,
-          } as EvalRow;
-        } catch (parseError) {
-          this.logger.error('Failed to parse eval record', { record: evalRecord, error: parseError });
-          // Return a partial record or null/undefined on error?
-          // Returning partial for now, might need adjustment based on requirements.
-          return {
-            agentName: evalRecord.agent_name,
-            createdAt: evalRecord.created_at,
-            runId: evalRecord.run_id,
-            globalRunId: evalRecord.global_run_id,
-          } as Partial<EvalRow> as EvalRow; // Cast needed for return type
-        }
-      });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_DYNAMODB_STORE_GET_EVALS_BY_AGENT_NAME_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { agentName },
-        },
-        error,
-      );
-    }
-  }
-
-  async getEvals(
-    options: {
-      agentName?: string;
-      type?: 'test' | 'live';
-    } & PaginationArgs = {},
-  ): Promise<PaginationInfo & { evals: EvalRow[] }> {
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-
-    this.logger.debug('Getting evals with pagination', { agentName, type, page, perPage, dateRange });
-
-    try {
-      let query;
-
-      if (agentName) {
-        // Query by specific agent name
-        query = this.service.entities.eval.query.byAgent({ entity: 'eval', agent_name: agentName });
-      } else {
-        // Query all evals using the primary index
-        query = this.service.entities.eval.query.byEntity({ entity: 'eval' });
-      }
-
-      // For DynamoDB, we need to fetch all data and apply pagination in memory
-      // since DynamoDB doesn't support traditional offset-based pagination
-      const results = await query.go({
-        order: 'desc',
-        pages: 'all', // Get all pages to apply filtering and pagination
-      });
-
-      if (!results.data.length) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false,
-        };
-      }
-
-      // Filter by type if specified
-      let filteredData = results.data;
-      if (type) {
-        filteredData = filteredData.filter((evalRecord: Record<string, any>) => {
-          try {
-            const testInfo =
-              evalRecord.test_info && typeof evalRecord.test_info === 'string'
-                ? JSON.parse(evalRecord.test_info)
-                : undefined;
-
-            if (type === 'test' && !testInfo) {
-              return false;
-            }
-            if (type === 'live' && testInfo) {
-              return false;
-            }
-          } catch (e) {
-            this.logger.warn('Failed to parse test_info during filtering', { record: evalRecord, error: e });
-          }
-          return true;
-        });
-      }
-
-      // Apply date range filtering if specified
-      if (dateRange) {
-        const fromDate = dateRange.start;
-        const toDate = dateRange.end;
-
-        filteredData = filteredData.filter((evalRecord: Record<string, any>) => {
-          const recordDate = new Date(evalRecord.created_at);
-
-          if (fromDate && recordDate < fromDate) {
-            return false;
-          }
-          if (toDate && recordDate > toDate) {
-            return false;
-          }
-          return true;
-        });
-      }
-
-      // Apply pagination
-      const total = filteredData.length;
-      const start = page * perPage;
-      const end = start + perPage;
-      const paginatedData = filteredData.slice(start, end);
-
-      // Transform to EvalRow format
-      const evals = paginatedData.map((evalRecord: Record<string, any>) => {
-        try {
-          return {
-            input: evalRecord.input,
-            output: evalRecord.output,
-            result:
-              evalRecord.result && typeof evalRecord.result === 'string' ? JSON.parse(evalRecord.result) : undefined,
-            agentName: evalRecord.agent_name,
-            createdAt: evalRecord.created_at,
-            metricName: evalRecord.metric_name,
-            instructions: evalRecord.instructions,
-            runId: evalRecord.run_id,
-            globalRunId: evalRecord.global_run_id,
-            testInfo:
-              evalRecord.test_info && typeof evalRecord.test_info === 'string'
-                ? JSON.parse(evalRecord.test_info)
-                : undefined,
-          } as EvalRow;
-        } catch (parseError) {
-          this.logger.error('Failed to parse eval record', { record: evalRecord, error: parseError });
-          return {
-            agentName: evalRecord.agent_name,
-            createdAt: evalRecord.created_at,
-            runId: evalRecord.run_id,
-            globalRunId: evalRecord.global_run_id,
-          } as Partial<EvalRow> as EvalRow;
-        }
-      });
-
-      const hasMore = end < total;
-
-      return {
-        evals,
-        total,
-        page,
-        perPage,
-        hasMore,
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'STORAGE_DYNAMODB_STORE_GET_EVALS_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            agentName: agentName || 'all',
-            type: type || 'all',
-            page,
-            perPage,
-          },
-        },
-        error,
-      );
-    }
-  }
-}