@mastra/dynamodb 1.0.1 → 1.0.2

package/dist/index.js

@@ -2142,6 +2142,8 @@ function formatWorkflowRun(snapshotData) {
     resourceId: snapshotData.resourceId
   };
 }
+var MAX_RETRIES = 5;
+var BASE_DELAY_MS = 50;
 var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
   service;
   ttlConfig;
@@ -2151,9 +2153,41 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
     this.service = resolved.service;
     this.ttlConfig = resolved.ttl;
   }
+  supportsConcurrentUpdates() {
+    return true;
+  }
   async dangerouslyClearAll() {
     await deleteTableData(this.service, TABLE_WORKFLOW_SNAPSHOT);
   }
+  /**
+   * Helper to check if an error is a DynamoDB conditional check failure
+   */
+  isConditionalCheckFailed(error) {
+    if (error && typeof error === "object") {
+      const err = error;
+      if (err.name === "ConditionalCheckFailedException" || err.code === "ConditionalCheckFailedException" || (err.__type?.includes("ConditionalCheckFailedException") ?? false)) {
+        return true;
+      }
+      if (err.message?.includes("conditional request failed")) {
+        return true;
+      }
+      if (err.cause && typeof err.cause === "object") {
+        const cause = err.cause;
+        if (cause.name === "ConditionalCheckFailedException" || cause.code === "ConditionalCheckFailedException") {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Helper to delay with exponential backoff and jitter
+   */
+  async delay(attempt) {
+    const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+    const jitter = Math.random() * backoff * 0.5;
+    await new Promise((resolve) => setTimeout(resolve, backoff + jitter));
+  }
   async updateWorkflowResults({
     workflowName,
     runId,
@@ -2161,69 +2195,147 @@ var WorkflowStorageDynamoDB = class extends WorkflowsStorage {
     result,
     requestContext
   }) {
-    try {
-      const existingSnapshot = await this.loadWorkflowSnapshot({ workflowName, runId });
-      let snapshot;
-      if (!existingSnapshot) {
-        snapshot = {
-          context: {},
-          activePaths: [],
-          timestamp: Date.now(),
-          suspendedPaths: {},
-          activeStepsPath: {},
-          resumeLabels: {},
-          serializedStepGraph: [],
-          status: "pending",
-          value: {},
-          waitingPaths: {},
-          runId,
-          requestContext: {}
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const existingRecord = await this.service.entities.workflow_snapshot.get({
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId
+        }).go();
+        const now = /* @__PURE__ */ new Date();
+        let snapshot;
+        let previousUpdatedAt;
+        if (!existingRecord.data) {
+          snapshot = {
+            context: {},
+            activePaths: [],
+            timestamp: Date.now(),
+            suspendedPaths: {},
+            activeStepsPath: {},
+            resumeLabels: {},
+            serializedStepGraph: [],
+            status: "pending",
+            value: {},
+            waitingPaths: {},
+            runId,
+            requestContext: {}
+          };
+        } else {
+          snapshot = existingRecord.data.snapshot;
+          previousUpdatedAt = existingRecord.data.updatedAt;
+        }
+        snapshot.context[stepId] = result;
+        snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+        const data = {
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot: JSON.stringify(snapshot),
+          createdAt: existingRecord.data?.createdAt ?? now.toISOString(),
+          updatedAt: now.toISOString(),
+          ...getTtlProps("workflow_snapshot", this.ttlConfig)
         };
-      } else {
-        snapshot = existingSnapshot;
+        if (previousUpdatedAt) {
+          await this.service.entities.workflow_snapshot.upsert(data).where((attr, op) => op.eq(attr.updatedAt, previousUpdatedAt)).go();
+        } else {
+          await this.service.entities.workflow_snapshot.create(data).where((attr, op) => op.notExists(attr.run_id)).go();
+        }
+        return snapshot.context;
+      } catch (error) {
+        if (this.isConditionalCheckFailed(error)) {
+          if (attempt < MAX_RETRIES - 1) {
+            this.logger.debug(
+              `Optimistic locking conflict in updateWorkflowResults, retrying (attempt ${attempt + 1})`
+            );
+            await this.delay(attempt);
+            continue;
+          }
+        }
+        if (error instanceof MastraError) throw error;
+        throw new MastraError(
+          {
+            id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { workflowName, runId, stepId }
+          },
+          error
+        );
       }
-      snapshot.context[stepId] = result;
-      snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
-      await this.persistWorkflowSnapshot({ workflowName, runId, snapshot });
-      return snapshot.context;
-    } catch (error) {
-      if (error instanceof MastraError) throw error;
-      throw new MastraError(
-        {
-          id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { workflowName, runId, stepId }
-        },
-        error
-      );
     }
+    throw new MastraError(
+      {
+        id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_RESULTS", "MAX_RETRIES_EXCEEDED"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { workflowName, runId, stepId }
+      },
+      new Error("Max retries exceeded for optimistic locking")
+    );
   }
   async updateWorkflowState({
     workflowName,
     runId,
     opts
   }) {
-    try {
-      const existingSnapshot = await this.loadWorkflowSnapshot({ workflowName, runId });
-      if (!existingSnapshot || !existingSnapshot.context) {
-        return void 0;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const existingRecord = await this.service.entities.workflow_snapshot.get({
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId
+        }).go();
+        if (!existingRecord.data) {
+          return void 0;
+        }
+        const existingSnapshot = existingRecord.data.snapshot;
+        if (!existingSnapshot || !existingSnapshot.context) {
+          return void 0;
+        }
+        const previousUpdatedAt = existingRecord.data.updatedAt;
+        const updatedSnapshot = { ...existingSnapshot, ...opts };
+        const now = /* @__PURE__ */ new Date();
+        const data = {
+          entity: "workflow_snapshot",
+          workflow_name: workflowName,
+          run_id: runId,
+          snapshot: JSON.stringify(updatedSnapshot),
+          createdAt: existingRecord.data.createdAt,
+          updatedAt: now.toISOString(),
+          resourceId: existingRecord.data.resourceId,
+          ...getTtlProps("workflow_snapshot", this.ttlConfig)
+        };
+        await this.service.entities.workflow_snapshot.upsert(data).where((attr, op) => op.eq(attr.updatedAt, previousUpdatedAt)).go();
+        return updatedSnapshot;
+      } catch (error) {
+        if (this.isConditionalCheckFailed(error)) {
+          if (attempt < MAX_RETRIES - 1) {
+            this.logger.debug(`Optimistic locking conflict in updateWorkflowState, retrying (attempt ${attempt + 1})`);
+            await this.delay(attempt);
+            continue;
+          }
+        }
+        if (error instanceof MastraError) throw error;
+        throw new MastraError(
+          {
+            id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { workflowName, runId }
+          },
+          error
+        );
       }
-      const updatedSnapshot = { ...existingSnapshot, ...opts };
-      await this.persistWorkflowSnapshot({ workflowName, runId, snapshot: updatedSnapshot });
-      return updatedSnapshot;
-    } catch (error) {
-      if (error instanceof MastraError) throw error;
-      throw new MastraError(
-        {
-          id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_STATE", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { workflowName, runId }
-        },
-        error
-      );
     }
+    throw new MastraError(
+      {
+        id: createStorageErrorId("DYNAMODB", "UPDATE_WORKFLOW_STATE", "MAX_RETRIES_EXCEEDED"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY,
+        details: { workflowName, runId }
+      },
+      new Error("Max retries exceeded for optimistic locking")
+    );
   }
   // Workflow operations
   async persistWorkflowSnapshot({