fix(): Identify step that should require a save on checkpoint (#14037)

* fix(): Identify step that force save checkpoint

* Create sour-peas-provide.md

Author: adrien2p

.changeset/sour-peas-provide.md

@@ -0,0 +1,7 @@
+---
+"@medusajs/workflow-engine-inmemory": patch
+"@medusajs/workflow-engine-redis": patch
+"@medusajs/orchestration": patch
+---
+
+fix(): Identify step that force save checkpoint

packages/core/orchestration/src/transaction/transaction-orchestrator.ts

@@ -1504,16 +1504,13 @@ export class TransactionOrchestrator extends EventEmitter {
     const hasTransactionTimeout = !!this.options.timeout
     const isIdempotent = !!this.options.idempotent
 
-    if (hasAsyncSteps) {
-      this.options.store = true
-    }
-
     if (
       hasStepTimeouts ||
       hasRetriesTimeout ||
       hasTransactionTimeout ||
       isIdempotent ||
-      this.options.retentionTime
+      this.options.retentionTime ||
+      hasAsyncSteps
     ) {
       this.options.store = true
     }
@@ -1628,6 +1625,12 @@ export class TransactionOrchestrator extends EventEmitter {
         const definitionCopy = { ...obj } as TransactionStepsDefinition
         delete definitionCopy.next
 
+        const isAsync = !!definitionCopy.async
+        const hasRetryInterval = !!(
+          definitionCopy.retryInterval || definitionCopy.retryIntervalAwaiting
+        )
+        const hasTimeout = !!definitionCopy.timeout
+
         if (definitionCopy.async) {
           features.hasAsyncSteps = true
         }
@@ -1647,6 +1650,20 @@ export class TransactionOrchestrator extends EventEmitter {
           features.hasNestedTransactions = true
         }
 
+        /**
+         * Force the checkpoint to save even for sync step when they have specific configurations.
+         */
+        definitionCopy.store = !!(
+          definitionCopy.store ||
+          isAsync ||
+          hasRetryInterval ||
+          hasTimeout
+        )
+
+        if (existingSteps?.[id]) {
+          existingSteps[id].definition.store = definitionCopy.store
+        }
+
         states[id] = Object.assign(
           new TransactionStep(),
           existingSteps?.[id] || {

packages/core/orchestration/src/transaction/types.ts

@@ -115,6 +115,12 @@ export type TransactionStepsDefinition = {
    */
   next?: TransactionStepsDefinition | TransactionStepsDefinition[]
 
+  /**
+   * @private
+   * Whether we need to store checkpoint at this step.
+   */
+  store?: boolean
+
   // TODO: add metadata field for customizations
 }
 

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/workflow_retry_interval.ts

@@ -0,0 +1,74 @@
+/**
+ * Test fixture for workflow with retry interval
+ * Tests that steps with retry intervals properly retry after failures
+ */
+
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk"
+
+// Mock counters to track execution attempts
+export const retryIntervalStep1InvokeMock = jest.fn()
+export const retryIntervalStep2InvokeMock = jest.fn()
+
+// Step 1: Fails first 2 times, succeeds on 3rd attempt
+const step_1_retry_interval = createStep(
+  {
+    name: "step_1_retry_interval",
+    async: true,
+    retryInterval: 1, // 1 second retry interval
+    maxRetries: 3,
+  },
+  async (input: { attemptToSucceedOn: number }) => {
+    const attemptCount = retryIntervalStep1InvokeMock.mock.calls.length + 1
+    retryIntervalStep1InvokeMock(input)
+
+    // Fail until we reach the target attempt
+    if (attemptCount < input.attemptToSucceedOn) {
+      throw new Error(`Step 1 failed on attempt ${attemptCount}, will retry`)
+    }
+
+    return new StepResponse({
+      success: true,
+      attempts: attemptCount,
+      step: "step_1",
+    })
+  }
+)
+
+// Step 2: Always succeeds (to verify workflow continues after retry)
+const step_2_after_retry = createStep(
+  {
+    name: "step_2_after_retry",
+    async: true,
+  },
+  async (input: any) => {
+    retryIntervalStep2InvokeMock(input)
+
+    return new StepResponse({
+      success: true,
+      step: "step_2",
+    })
+  }
+)
+
+export const workflowRetryIntervalId = "workflow_retry_interval_test"
+
+createWorkflow(
+  {
+    name: workflowRetryIntervalId,
+    retentionTime: 600, // Keep for 10 minutes for debugging
+  },
+  function (input: { attemptToSucceedOn: number }) {
+    const step1Result = step_1_retry_interval(input)
+    const step2Result = step_2_after_retry({ step1Result })
+
+    return new WorkflowResponse({
+      step1: step1Result,
+      step2: step2Result,
+    })
+  }
+)

packages/modules/workflow-engine-inmemory/integration-tests/__fixtures__/workflow_sync_retry_interval.ts

@@ -0,0 +1,84 @@
+/**
+ * Test fixture for workflow with retry interval
+ * Tests that steps with retry intervals properly retry after failures
+ */
+
+import {
+  createStep,
+  createWorkflow,
+  StepResponse,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk"
+
+// Mock counters to track execution attempts
+export const retryIntervalStep1InvokeMock = jest.fn()
+export const retryIntervalStep2InvokeMock = jest.fn()
+export const retryIntervalStep0InvokeMock = jest.fn()
+
+const step_0_retry_interval = createStep(
+  {
+    name: "step_0_sync_retry_interval",
+  },
+  async (input: any) => {
+    retryIntervalStep0InvokeMock(input)
+    return new StepResponse(input)
+  }
+)
+
+// Step 1: Fails first 2 times, succeeds on 3rd attempt
+const step_1_retry_interval = createStep(
+  {
+    name: "step_1_sync_retry_interval",
+    retryInterval: 1, // 1 second retry interval
+    maxRetries: 3,
+  },
+  async (input: { attemptToSucceedOn: number }) => {
+    const attemptCount = retryIntervalStep1InvokeMock.mock.calls.length + 1
+    retryIntervalStep1InvokeMock(input)
+
+    // Fail until we reach the target attempt
+    if (attemptCount < input.attemptToSucceedOn) {
+      throw new Error(`Step 1 failed on attempt ${attemptCount}, will retry`)
+    }
+
+    return new StepResponse({
+      success: true,
+      attempts: attemptCount,
+      step: "step_1",
+    })
+  }
+)
+
+// Step 2: Always succeeds (to verify workflow continues after retry)
+const step_2_after_retry = createStep(
+  {
+    name: "step_2_sync_after_retry",
+  },
+  async (input: any) => {
+    retryIntervalStep2InvokeMock(input)
+
+    return new StepResponse({
+      success: true,
+      step: "step_2",
+    })
+  }
+)
+
+export const workflowRetryIntervalId = "workflow_sync_retry_interval_test"
+
+createWorkflow(
+  {
+    name: workflowRetryIntervalId,
+    retentionTime: 600, // Keep for 10 minutes for debugging
+  },
+  function (input: { attemptToSucceedOn: number }) {
+    const step0Result = step_0_retry_interval(input)
+    const step1Result = step_1_retry_interval(step0Result)
+    const step2Result = step_2_after_retry({ step1Result })
+
+    return new WorkflowResponse({
+      step1: step1Result,
+      step2: step2Result,
+    })
+  }
+)