@medusajs/orchestration 3.0.0-snapshot-20250410105645 → 3.0.0-snapshot-20251104004624

package/dist/transaction/transaction-orchestrator.js

@@ -1,12 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionOrchestrator = void 0;
+const ulid_1 = require("ulid");
 const distributed_transaction_1 = require("./distributed-transaction");
 const transaction_step_1 = require("./transaction-step");
 const types_1 = require("./types");
 const utils_1 = require("@medusajs/utils");
 const events_1 = require("events");
 const errors_1 = require("./errors");
+const canMoveForwardStates = new Set([
+    utils_1.TransactionStepState.DONE,
+    utils_1.TransactionStepState.FAILED,
+    utils_1.TransactionStepState.TIMEOUT,
+    utils_1.TransactionStepState.SKIPPED,
+    utils_1.TransactionStepState.SKIPPED_FAILURE,
+]);
+const canMoveBackwardStates = new Set([
+    utils_1.TransactionStepState.DONE,
+    utils_1.TransactionStepState.REVERTED,
+    utils_1.TransactionStepState.FAILED,
+    utils_1.TransactionStepState.DORMANT,
+    utils_1.TransactionStepState.SKIPPED,
+]);
+const flagStepsToRevertStates = new Set([
+    utils_1.TransactionStepState.DONE,
+    utils_1.TransactionStepState.TIMEOUT,
+]);
+const setStepTimeoutSkipStates = new Set([
+    utils_1.TransactionStepState.TIMEOUT,
+    utils_1.TransactionStepState.DONE,
+    utils_1.TransactionStepState.REVERTED,
+]);
 /**
  * @class TransactionOrchestrator is responsible for managing and executing distributed transactions.
  * It is based on a single transaction definition, which is used to execute all the transaction steps
@@ -26,6 +50,11 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             this.parseFlowOptions();
         }
     }
+    static isExpectedError(error) {
+        return (errors_1.SkipCancelledExecutionError.isSkipCancelledExecutionError(error) ||
+            errors_1.SkipExecutionError.isSkipExecutionError(error) ||
+            errors_1.SkipStepAlreadyFinishedError.isSkipStepAlreadyFinishedError(error));
+    }
     static clone(orchestrator) {
         return new TransactionOrchestrator({
             id: orchestrator.id,
@@ -37,7 +66,7 @@ class TransactionOrchestrator extends events_1.EventEmitter {
     static getKeyName(...params) {
         return params.join(this.SEPARATOR);
     }
-    getPreviousStep(flow, step) {
+    static getPreviousStep(flow, step) {
         const id = step.id.split(".");
         id.pop();
         const parentId = id.join(".");
@@ -64,36 +93,26 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         this.compensateSteps = steps;
         return steps;
     }
+    static countSiblings(flow, step) {
+        const previous = TransactionOrchestrator.getPreviousStep(flow, step);
+        return previous.next.length;
+    }
     canMoveForward(flow, previousStep) {
-        const states = [
-            utils_1.TransactionStepState.DONE,
-            utils_1.TransactionStepState.FAILED,
-            utils_1.TransactionStepState.TIMEOUT,
-            utils_1.TransactionStepState.SKIPPED,
-            utils_1.TransactionStepState.SKIPPED_FAILURE,
-        ];
-        const siblings = this.getPreviousStep(flow, previousStep).next.map((sib) => flow.steps[sib]);
+        const siblings = TransactionOrchestrator.getPreviousStep(flow, previousStep).next.map((sib) => flow.steps[sib]);
         return (!!previousStep.definition.noWait ||
-            siblings.every((sib) => states.includes(sib.invoke.state)));
+            siblings.every((sib) => canMoveForwardStates.has(sib.invoke.state)));
     }
     canMoveBackward(flow, step) {
-        const states = [
-            utils_1.TransactionStepState.DONE,
-            utils_1.TransactionStepState.REVERTED,
-            utils_1.TransactionStepState.FAILED,
-            utils_1.TransactionStepState.DORMANT,
-            utils_1.TransactionStepState.SKIPPED,
-        ];
         const siblings = step.next.map((sib) => flow.steps[sib]);
         return (siblings.length === 0 ||
-            siblings.every((sib) => states.includes(sib.compensate.state)));
+            siblings.every((sib) => canMoveBackwardStates.has(sib.compensate.state)));
     }
     canContinue(flow, step) {
         if (flow.state == types_1.TransactionState.COMPENSATING) {
             return this.canMoveBackward(flow, step);
         }
         else {
-            const previous = this.getPreviousStep(flow, step);
+            const previous = TransactionOrchestrator.getPreviousStep(flow, step);
             if (previous.id === TransactionOrchestrator.ROOT_STEP) {
                 return true;
             }
@@ -139,6 +158,46 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         return hasTimedOut;
     }
     async checkAllSteps(transaction) {
+        const flow = transaction.getFlow();
+        const result = await this.computeCurrentTransactionState(transaction);
+        // Handle state transitions and emit events
+        if (flow.state === types_1.TransactionState.WAITING_TO_COMPENSATE &&
+            result.next.length === 0 &&
+            !flow.hasWaitingSteps) {
+            flow.state = types_1.TransactionState.COMPENSATING;
+            this.flagStepsToRevert(flow);
+            this.emit(types_1.DistributedTransactionEvent.COMPENSATE_BEGIN, { transaction });
+            const result = await this.checkAllSteps(transaction);
+            return result;
+        }
+        else if (result.completed === result.total) {
+            if (result.hasSkippedOnFailure) {
+                flow.hasSkippedOnFailureSteps = true;
+            }
+            if (result.hasSkipped) {
+                flow.hasSkippedSteps = true;
+            }
+            if (result.hasIgnoredFailure) {
+                flow.hasFailedSteps = true;
+            }
+            if (result.hasFailed) {
+                flow.state = types_1.TransactionState.FAILED;
+            }
+            else {
+                flow.state = result.hasReverted
+                    ? types_1.TransactionState.REVERTED
+                    : types_1.TransactionState.DONE;
+            }
+        }
+        return {
+            current: result.current,
+            next: result.next,
+            total: result.total,
+            remaining: result.total - result.completed,
+            completed: result.completed,
+        };
+    }
+    async computeCurrentTransactionState(transaction) {
         let hasSkipped = false;
         let hasSkippedOnFailure = false;
         let hasIgnoredFailure = false;
@@ -177,9 +236,20 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                         await transaction.scheduleRetry(stepDef, stepDef.definition.retryIntervalAwaiting);
                     }
                 }
+                else if (stepDef.retryRescheduledAt) {
+                    // The step is not configured for awaiting retry but is manually force to retry
+                    stepDef.retryRescheduledAt = null;
+                    nextSteps.push(stepDef);
+                }
                 continue;
             }
             else if (curState.status === types_1.TransactionStepStatus.TEMPORARY_FAILURE) {
+                if (!stepDef.temporaryFailedAt &&
+                    stepDef.definition.autoRetry === false) {
+                    stepDef.temporaryFailedAt = Date.now();
+                    continue;
+                }
+                stepDef.temporaryFailedAt = null;
                 currentSteps.push(stepDef);
                 if (!stepDef.canRetry()) {
                     if (stepDef.hasRetryInterval() && !stepDef.retryRescheduledAt) {
@@ -206,7 +276,8 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                     hasReverted = true;
                 }
                 else if (curState.state === utils_1.TransactionStepState.FAILED) {
-                    if (stepDef.definition.continueOnPermanentFailure) {
+                    if (stepDef.definition.continueOnPermanentFailure ||
+                        stepDef.definition.skipOnPermanentFailure) {
                         hasIgnoredFailure = true;
                     }
                     else {
@@ -217,40 +288,17 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         }
         flow.hasWaitingSteps = hasWaiting;
         flow.hasRevertedSteps = hasReverted;
-        const totalSteps = allSteps.length - 1;
-        if (flow.state === types_1.TransactionState.WAITING_TO_COMPENSATE &&
-            nextSteps.length === 0 &&
-            !hasWaiting) {
-            flow.state = types_1.TransactionState.COMPENSATING;
-            this.flagStepsToRevert(flow);
-            this.emit(types_1.DistributedTransactionEvent.COMPENSATE_BEGIN, { transaction });
-            return await this.checkAllSteps(transaction);
-        }
-        else if (completedSteps === totalSteps) {
-            if (hasSkippedOnFailure) {
-                flow.hasSkippedOnFailureSteps = true;
-            }
-            if (hasSkipped) {
-                flow.hasSkippedSteps = true;
-            }
-            if (hasIgnoredFailure) {
-                flow.hasFailedSteps = true;
-            }
-            if (hasFailed) {
-                flow.state = types_1.TransactionState.FAILED;
-            }
-            else {
-                flow.state = hasReverted
-                    ? types_1.TransactionState.REVERTED
-                    : types_1.TransactionState.DONE;
-            }
-        }
         return {
             current: currentSteps,
             next: nextSteps,
-            total: totalSteps,
-            remaining: totalSteps - completedSteps,
+            total: allSteps.length - 1,
             completed: completedSteps,
+            hasSkipped,
+            hasSkippedOnFailure,
+            hasIgnoredFailure,
+            hasFailed,
+            hasWaiting,
+            hasReverted,
         };
     }
     flagStepsToRevert(flow) {
@@ -260,7 +308,11 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             }
             const stepDef = flow.steps[step];
             const curState = stepDef.getStates();
-            if ([utils_1.TransactionStepState.DONE, utils_1.TransactionStepState.TIMEOUT].includes(curState.state) ||
+            if (stepDef._v) {
+                flow._v = 0;
+                stepDef._v = 0;
+            }
+            if (flagStepsToRevertStates.has(curState.state) ||
                 curState.status === types_1.TransactionStepStatus.PERMANENT_FAILURE) {
                 stepDef.beginCompensation();
                 stepDef.changeState(utils_1.TransactionStepState.NOT_STARTED);
@@ -284,11 +336,21 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             step.changeState(utils_1.TransactionStepState.DONE);
         }
         let shouldEmit = true;
+        let transactionIsCancelling = false;
         try {
-            await transaction.saveCheckpoint();
+            await transaction.saveCheckpoint({
+                _v: step._v,
+                parallelSteps: TransactionOrchestrator.countSiblings(transaction.getFlow(), step),
+                stepId: step.id,
+            });
         }
         catch (error) {
-            shouldEmit = false;
+            if (!TransactionOrchestrator.isExpectedError(error)) {
+                throw error;
+            }
+            transactionIsCancelling =
+                errors_1.SkipCancelledExecutionError.isSkipCancelledExecutionError(error);
+            shouldEmit = !errors_1.SkipExecutionError.isSkipExecutionError(error);
         }
         const cleaningUp = [];
         if (step.hasRetryScheduled()) {
@@ -297,7 +359,9 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         if (step.hasTimeout()) {
             cleaningUp.push(transaction.clearStepTimeout(step));
         }
-        await (0, utils_1.promiseAll)(cleaningUp);
+        if (cleaningUp.length) {
+            await (0, utils_1.promiseAll)(cleaningUp);
+        }
         if (shouldEmit) {
             const eventName = step.isCompensating()
                 ? types_1.DistributedTransactionEvent.COMPENSATE_STEP_SUCCESS
@@ -306,25 +370,53 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         }
         return {
             stopExecution: !shouldEmit,
+            transactionIsCancelling,
         };
     }
-    static async skipStep(transaction, step) {
+    static async retryStep(transaction, step) {
+        if (!step.retryRescheduledAt) {
+            step.hasScheduledRetry = true;
+            step.retryRescheduledAt = Date.now();
+        }
+        transaction.getFlow().hasWaitingSteps = true;
+        try {
+            await transaction.saveCheckpoint({
+                _v: step._v,
+                parallelSteps: TransactionOrchestrator.countSiblings(transaction.getFlow(), step),
+                stepId: step.id,
+            });
+            await transaction.scheduleRetry(step, 0);
+        }
+        catch (error) {
+            if (!TransactionOrchestrator.isExpectedError(error)) {
+                throw error;
+            }
+        }
+    }
+    static async skipStep({ transaction, step, }) {
         const hasStepTimedOut = step.getStates().state === utils_1.TransactionStepState.TIMEOUT;
         if (!hasStepTimedOut) {
             step.changeStatus(types_1.TransactionStepStatus.OK);
             step.changeState(utils_1.TransactionStepState.SKIPPED);
         }
         let shouldEmit = true;
+        let transactionIsCancelling = false;
         try {
-            await transaction.saveCheckpoint();
+            await transaction.saveCheckpoint({
+                _v: step._v,
+                parallelSteps: TransactionOrchestrator.countSiblings(transaction.getFlow(), step),
+                stepId: step.id,
+            });
         }
         catch (error) {
+            if (!TransactionOrchestrator.isExpectedError(error)) {
+                throw error;
+            }
+            transactionIsCancelling =
+                errors_1.SkipCancelledExecutionError.isSkipCancelledExecutionError(error);
             if (errors_1.SkipExecutionError.isSkipExecutionError(error)) {
                 shouldEmit = false;
             }
-            else {
-                throw error;
-            }
         }
         const cleaningUp = [];
         if (step.hasRetryScheduled()) {
@@ -333,21 +425,20 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         if (step.hasTimeout()) {
             cleaningUp.push(transaction.clearStepTimeout(step));
         }
-        await (0, utils_1.promiseAll)(cleaningUp);
+        if (cleaningUp.length) {
+            await (0, utils_1.promiseAll)(cleaningUp);
+        }
         if (shouldEmit) {
             const eventName = types_1.DistributedTransactionEvent.STEP_SKIPPED;
             transaction.emit(eventName, { step, transaction });
         }
         return {
             stopExecution: !shouldEmit,
+            transactionIsCancelling,
         };
     }
     static async setStepTimeout(transaction, step, error) {
-        if ([
-            utils_1.TransactionStepState.TIMEOUT,
-            utils_1.TransactionStepState.DONE,
-            utils_1.TransactionStepState.REVERTED,
-        ].includes(step.getStates().state)) {
+        if (setStepTimeoutSkipStates.has(step.getStates().state)) {
             return;
         }
         step.changeState(utils_1.TransactionStepState.TIMEOUT);
@@ -365,15 +456,30 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         await transaction.clearStepTimeout(step);
     }
     static async setStepFailure(transaction, step, error, maxRetries = TransactionOrchestrator.DEFAULT_RETRIES, isTimeout = false, timeoutError) {
+        const result = {
+            stopExecution: false,
+            transactionIsCancelling: false,
+        };
         if (errors_1.SkipExecutionError.isSkipExecutionError(error)) {
-            return {
-                stopExecution: false,
-            };
+            return result;
         }
         step.failures++;
         if ((0, utils_1.isErrorLike)(error)) {
             error = (0, utils_1.serializeError)(error);
         }
+        else {
+            try {
+                const serialized = JSON.stringify(error);
+                error = error?.message
+                    ? JSON.parse(serialized)
+                    : { message: serialized };
+            }
+            catch (e) {
+                error = {
+                    message: "Unknown non-serializable error",
+                };
+            }
+        }
         if (!isTimeout &&
             step.getStates().status !== types_1.TransactionStepStatus.PERMANENT_FAILURE) {
             step.changeStatus(types_1.TransactionStepStatus.TEMPORARY_FAILURE);
@@ -390,23 +496,35 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 const handlerType = step.isCompensating()
                     ? types_1.TransactionHandlerType.COMPENSATE
                     : types_1.TransactionHandlerType.INVOKE;
-                if (error?.stack) {
-                    const workflowId = transaction.modelId;
-                    const stepAction = step.definition.action;
-                    const sourcePath = transaction.getFlow().metadata?.sourcePath;
-                    const sourceStack = sourcePath
-                        ? `\n⮑ \sat ${sourcePath}: [${workflowId} -> ${stepAction} (${types_1.TransactionHandlerType.INVOKE})]`
-                        : `\n⮑ \sat [${workflowId} -> ${stepAction} (${types_1.TransactionHandlerType.INVOKE})]`;
-                    error.stack += sourceStack;
-                }
+                error.stack ??= "";
+                const workflowId = transaction.modelId;
+                const stepAction = step.definition.action;
+                const sourcePath = transaction.getFlow().metadata?.sourcePath;
+                const sourceStack = sourcePath
+                    ? `\n⮑ \sat ${sourcePath}: [${workflowId} -> ${stepAction} (${types_1.TransactionHandlerType.INVOKE})]`
+                    : `\n⮑ \sat [${workflowId} -> ${stepAction} (${types_1.TransactionHandlerType.INVOKE})]`;
+                error.stack += sourceStack;
                 transaction.addError(step.definition.action, handlerType, error);
             }
             if (!step.isCompensating()) {
-                if (step.definition.continueOnPermanentFailure &&
+                if ((step.definition.continueOnPermanentFailure ||
+                    step.definition.skipOnPermanentFailure) &&
                     !errors_1.TransactionTimeoutError.isTransactionTimeoutError(timeoutError)) {
-                    for (const childStep of step.next) {
-                        const child = flow.steps[childStep];
-                        child.changeState(utils_1.TransactionStepState.SKIPPED_FAILURE);
+                    if (step.definition.skipOnPermanentFailure) {
+                        const until = (0, utils_1.isString)(step.definition.skipOnPermanentFailure)
+                            ? step.definition.skipOnPermanentFailure
+                            : undefined;
+                        let stepsToSkip = [...step.next];
+                        while (stepsToSkip.length > 0) {
+                            const currentStep = flow.steps[stepsToSkip.shift()];
+                            if (until && currentStep.definition.action === until) {
+                                break;
+                            }
+                            currentStep.changeState(utils_1.TransactionStepState.SKIPPED_FAILURE);
+                            if (currentStep.next?.length > 0) {
+                                stepsToSkip = stepsToSkip.concat(currentStep.next);
+                            }
+                        }
                     }
                 }
                 else {
@@ -417,30 +535,49 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 cleaningUp.push(transaction.clearStepTimeout(step));
             }
         }
-        let shouldEmit = true;
+        else {
+            const isAsync = step.isCompensating()
+                ? step.definition.compensateAsync
+                : step.definition.async;
+            if (step.getStates().status === types_1.TransactionStepStatus.TEMPORARY_FAILURE &&
+                step.definition.autoRetry === false &&
+                isAsync) {
+                step.temporaryFailedAt = Date.now();
+                result.stopExecution = true;
+            }
+        }
         try {
-            await transaction.saveCheckpoint();
+            await transaction.saveCheckpoint({
+                _v: step._v,
+                parallelSteps: TransactionOrchestrator.countSiblings(transaction.getFlow(), step),
+                stepId: step.id,
+            });
         }
         catch (error) {
-            if (errors_1.SkipExecutionError.isSkipExecutionError(error)) {
-                shouldEmit = false;
-            }
-            else {
+            if (!TransactionOrchestrator.isExpectedError(error)) {
                 throw error;
             }
+            result.transactionIsCancelling =
+                errors_1.SkipCancelledExecutionError.isSkipCancelledExecutionError(error);
+            if (errors_1.SkipExecutionError.isSkipExecutionError(error)) {
+                result.stopExecution = true;
+            }
         }
         if (step.hasRetryScheduled()) {
             cleaningUp.push(transaction.clearRetry(step));
         }
-        await (0, utils_1.promiseAll)(cleaningUp);
-        if (shouldEmit) {
+        if (cleaningUp.length) {
+            await (0, utils_1.promiseAll)(cleaningUp);
+        }
+        if (!result.stopExecution) {
             const eventName = step.isCompensating()
                 ? types_1.DistributedTransactionEvent.COMPENSATE_STEP_FAILURE
                 : types_1.DistributedTransactionEvent.STEP_FAILURE;
             transaction.emit(eventName, { step, transaction });
         }
         return {
-            stopExecution: !shouldEmit,
+            stopExecution: result.stopExecution,
+            transactionIsCancelling: result.transactionIsCancelling,
         };
     }
     async executeNext(transaction) {
@@ -450,51 +587,49 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 return;
             }
             const flow = transaction.getFlow();
-            const nextSteps = await this.checkAllSteps(transaction);
-            const execution = [];
+            let nextSteps = await this.checkAllSteps(transaction);
             const hasTimedOut = await this.checkTransactionTimeout(transaction, nextSteps.current);
             if (hasTimedOut) {
                 continue;
             }
             if (nextSteps.remaining === 0) {
-                if (transaction.hasTimeout()) {
-                    void transaction.clearTransactionTimeout();
+                await this.finalizeTransaction(transaction);
+                return;
+            }
+            const stepsShouldContinueExecution = nextSteps.next.map((step) => {
+                const { shouldContinueExecution } = this.prepareStepForExecution(step, flow);
+                return shouldContinueExecution;
+            });
+            let asyncStepCount = 0;
+            for (const s of nextSteps.next) {
+                const stepIsAsync = s.isCompensating()
+                    ? s.definition.compensateAsync
+                    : s.definition.async;
+                if (stepIsAsync)
+                    asyncStepCount++;
+            }
+            const hasMultipleAsyncSteps = asyncStepCount > 1;
+            const hasAsyncSteps = !!asyncStepCount;
+            // If there is any async step, we don't need to save the checkpoint here as it will be saved
+            // later down there
+            await transaction.saveCheckpoint().catch((error) => {
+                if (TransactionOrchestrator.isExpectedError(error)) {
+                    continueExecution = false;
+                    return;
                 }
-                await transaction.saveCheckpoint();
-                this.emit(types_1.DistributedTransactionEvent.FINISH, { transaction });
+                throw error;
+            });
+            if (!continueExecution) {
+                break;
             }
-            let hasExecutedSyncSteps = false;
+            const execution = [];
+            const executionAsync = [];
+            let i = 0;
             for (const step of nextSteps.next) {
-                const curState = step.getStates();
-                const type = step.isCompensating()
-                    ? types_1.TransactionHandlerType.COMPENSATE
-                    : types_1.TransactionHandlerType.INVOKE;
-                step.lastAttempt = Date.now();
-                step.attempts++;
-                if (curState.state === utils_1.TransactionStepState.NOT_STARTED) {
-                    if (!step.startedAt) {
-                        step.startedAt = Date.now();
-                    }
-                    if (step.isCompensating()) {
-                        step.changeState(utils_1.TransactionStepState.COMPENSATING);
-                        if (step.definition.noCompensation) {
-                            step.changeState(utils_1.TransactionStepState.REVERTED);
-                            continue;
-                        }
-                    }
-                    else if (flow.state === types_1.TransactionState.INVOKING) {
-                        step.changeState(utils_1.TransactionStepState.INVOKING);
-                    }
+                const stepIndex = i++;
+                if (!stepsShouldContinueExecution[stepIndex]) {
+                    continue;
                 }
-                step.changeStatus(types_1.TransactionStepStatus.WAITING);
-                const payload = new distributed_transaction_1.TransactionPayload({
-                    model_id: flow.modelId,
-                    idempotency_key: TransactionOrchestrator.getKeyName(flow.modelId, flow.transactionId, step.definition.action, type),
-                    action: step.definition.action + "",
-                    action_type: type,
-                    attempt: step.attempts,
-                    timestamp: Date.now(),
-                }, transaction.payload, transaction.getContext());
                 if (step.hasTimeout() && !step.timedOutAt && step.attempts === 1) {
                     await transaction.scheduleStepTimeout(step, step.definition.timeout);
                 }
@@ -505,148 +640,262 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                 const isAsync = step.isCompensating()
                     ? step.definition.compensateAsync
                     : step.definition.async;
-                const setStepFailure = async (error, { endRetry, response, } = {}) => {
-                    if ((0, utils_1.isDefined)(response) && step.saveResponse) {
-                        transaction.addResponse(step.definition.action, step.isCompensating()
-                            ? types_1.TransactionHandlerType.COMPENSATE
-                            : types_1.TransactionHandlerType.INVOKE, response);
-                    }
-                    const ret = await TransactionOrchestrator.setStepFailure(transaction, step, error, endRetry ? 0 : step.definition.maxRetries);
-                    if (isAsync && !ret.stopExecution) {
-                        await transaction.scheduleRetry(step, 0);
-                    }
-                    return ret;
-                };
-                const traceData = {
-                    action: step.definition.action + "",
-                    type,
-                    step_id: step.id,
-                    step_uuid: step.uuid + "",
-                    attempts: step.attempts,
-                    failures: step.failures,
-                    async: !!(type === "invoke"
-                        ? step.definition.async
-                        : step.definition.compensateAsync),
-                    idempotency_key: payload.metadata.idempotency_key,
-                };
-                const handlerArgs = [
-                    step.definition.action + "",
-                    type,
-                    payload,
-                    transaction,
-                    step,
-                    this,
-                ];
+                // Compute current transaction state
+                await this.computeCurrentTransactionState(transaction);
+                const promise = this.createStepExecutionPromise(transaction, step);
+                const hasVersionControl = hasMultipleAsyncSteps || step.hasAwaitingRetry();
+                if (hasVersionControl && !step._v) {
+                    transaction.getFlow()._v += 1;
+                    step._v = transaction.getFlow()._v;
+                }
                 if (!isAsync) {
-                    hasExecutedSyncSteps = true;
-                    const stepHandler = async () => {
-                        return await transaction.handler(...handlerArgs);
-                    };
-                    let promise;
-                    if (TransactionOrchestrator.traceStep) {
-                        promise = TransactionOrchestrator.traceStep(stepHandler, traceData);
-                    }
-                    else {
-                        promise = stepHandler();
-                    }
-                    execution.push(promise
-                        .then(async (response) => {
-                        if (this.hasExpired({ transaction, step }, Date.now())) {
-                            await this.checkStepTimeout(transaction, step);
-                            await this.checkTransactionTimeout(transaction, nextSteps.next.includes(step) ? nextSteps.next : [step]);
-                        }
-                        const output = response?.__type ? response.output : response;
-                        if (errors_1.SkipStepResponse.isSkipStepResponse(output)) {
-                            await TransactionOrchestrator.skipStep(transaction, step);
-                            return;
-                        }
-                        await TransactionOrchestrator.setStepSuccess(transaction, step, response);
-                    })
-                        .catch(async (error) => {
-                        const response = error?.getStepResponse?.();
-                        if (this.hasExpired({ transaction, step }, Date.now())) {
-                            await this.checkStepTimeout(transaction, step);
-                            await this.checkTransactionTimeout(transaction, nextSteps.next.includes(step) ? nextSteps.next : [step]);
-                        }
-                        if (errors_1.PermanentStepFailureError.isPermanentStepFailureError(error)) {
-                            await setStepFailure(error, {
-                                endRetry: true,
-                                response,
-                            });
-                            return;
-                        }
-                        await setStepFailure(error, {
-                            response,
-                        });
-                    }));
+                    execution.push(this.executeSyncStep(promise, transaction, step, nextSteps));
                 }
                 else {
-                    const stepHandler = async () => {
-                        return await transaction.handler(...handlerArgs);
-                    };
-                    execution.push(transaction.saveCheckpoint().then(() => {
-                        let promise;
-                        if (TransactionOrchestrator.traceStep) {
-                            promise = TransactionOrchestrator.traceStep(stepHandler, traceData);
-                        }
-                        else {
-                            promise = stepHandler();
-                        }
-                        promise
-                            .then(async (response) => {
-                            const output = response?.__type ? response.output : response;
-                            if (errors_1.SkipStepResponse.isSkipStepResponse(output)) {
-                                await TransactionOrchestrator.skipStep(transaction, step);
-                            }
-                            else {
-                                if (!step.definition.backgroundExecution ||
-                                    step.definition.nested) {
-                                    const eventName = types_1.DistributedTransactionEvent.STEP_AWAITING;
-                                    transaction.emit(eventName, { step, transaction });
-                                    return;
-                                }
-                                if (this.hasExpired({ transaction, step }, Date.now())) {
-                                    await this.checkStepTimeout(transaction, step);
-                                    await this.checkTransactionTimeout(transaction, nextSteps.next.includes(step) ? nextSteps.next : [step]);
-                                }
-                                await TransactionOrchestrator.setStepSuccess(transaction, step, response);
-                            }
-                            // check nested flow
-                            await transaction.scheduleRetry(step, 0);
-                        })
-                            .catch(async (error) => {
-                            const response = error?.getStepResponse?.();
-                            if (errors_1.PermanentStepFailureError.isPermanentStepFailureError(error)) {
-                                await setStepFailure(error, {
-                                    endRetry: true,
-                                    response,
-                                });
-                                return;
-                            }
-                            await setStepFailure(error, {
-                                response,
-                            });
-                        });
-                    }));
+                    // Execute async step in background as part of the next event loop cycle and continue the execution of the transaction
+                    executionAsync.push(() => this.executeAsyncStep(promise, transaction, step, nextSteps));
                 }
             }
-            try {
-                if (hasExecutedSyncSteps) {
-                    await transaction.saveCheckpoint();
+            await (0, utils_1.promiseAll)(execution);
+            if (!nextSteps.next.length || (hasAsyncSteps && !execution.length)) {
+                continueExecution = false;
+            }
+            if (hasAsyncSteps) {
+                await transaction.saveCheckpoint().catch((error) => {
+                    if (TransactionOrchestrator.isExpectedError(error)) {
+                        continueExecution = false;
+                    }
+                    throw error;
+                });
+                for (const exec of executionAsync) {
+                    void exec();
                 }
             }
-            catch (error) {
-                if (errors_1.SkipExecutionError.isSkipExecutionError(error)) {
-                    break;
+        }
+    }
+    /**
+     * Finalize the transaction when all steps are complete
+     */
+    async finalizeTransaction(transaction) {
+        if (transaction.hasTimeout()) {
+            void transaction.clearTransactionTimeout();
+        }
+        await transaction.saveCheckpoint().catch((error) => {
+            if (!TransactionOrchestrator.isExpectedError(error)) {
+                throw error;
+            }
+        });
+        this.emit(types_1.DistributedTransactionEvent.FINISH, { transaction });
+    }
+    /**
+     * Prepare a step for execution by setting state and incrementing attempts
+     */
+    prepareStepForExecution(step, flow) {
+        const curState = step.getStates();
+        step.lastAttempt = Date.now();
+        step.attempts++;
+        if (curState.state === utils_1.TransactionStepState.NOT_STARTED) {
+            if (!step.startedAt) {
+                step.startedAt = Date.now();
+            }
+            if (step.isCompensating()) {
+                step.changeState(utils_1.TransactionStepState.COMPENSATING);
+                if (step.definition.noCompensation) {
+                    step.changeState(utils_1.TransactionStepState.REVERTED);
+                    return { shouldContinueExecution: false };
                 }
-                else {
-                    throw error;
+            }
+            else if (flow.state === types_1.TransactionState.INVOKING) {
+                step.changeState(utils_1.TransactionStepState.INVOKING);
+            }
+        }
+        step.changeStatus(types_1.TransactionStepStatus.WAITING);
+        return { shouldContinueExecution: true };
+    }
+    /**
+     * Create the payload for a step execution
+     */
+    createStepPayload(transaction, step, flow, type) {
+        return new distributed_transaction_1.TransactionPayload({
+            model_id: flow.modelId,
+            idempotency_key: TransactionOrchestrator.getKeyName(flow.modelId, flow.transactionId, step.definition.action, type),
+            action: step.definition.action + "",
+            action_type: type,
+            attempt: step.attempts,
+            timestamp: Date.now(),
+        }, transaction.payload, transaction.getContext());
+    }
+    /**
+     * Prepare handler arguments for step execution
+     */
+    prepareHandlerArgs(transaction, step, payload, type) {
+        return [
+            step.definition.action + "",
+            type,
+            payload,
+            transaction,
+            step,
+            this,
+        ];
+    }
+    /**
+     * Create the step execution promise with optional tracing
+     */
+    createStepExecutionPromise(transaction, step) {
+        const type = step.isCompensating()
+            ? types_1.TransactionHandlerType.COMPENSATE
+            : types_1.TransactionHandlerType.INVOKE;
+        const flow = transaction.getFlow();
+        const payload = this.createStepPayload(transaction, step, flow, type);
+        const handlerArgs = this.prepareHandlerArgs(transaction, step, payload, type);
+        const traceData = {
+            action: step.definition.action + "",
+            type,
+            step_id: step.id,
+            step_uuid: step.uuid + "",
+            attempts: step.attempts,
+            failures: step.failures,
+            async: !!(type === "invoke"
+                ? step.definition.async
+                : step.definition.compensateAsync),
+            idempotency_key: handlerArgs[2].metadata.idempotency_key,
+        };
+        const stepHandler = async () => {
+            return await transaction.handler(...handlerArgs);
+        };
+        // Return the appropriate promise based on tracing configuration
+        if (TransactionOrchestrator.traceStep) {
+            return () => TransactionOrchestrator.traceStep(stepHandler, traceData);
+        }
+        else {
+            return stepHandler;
+        }
+    }
+    /**
+     * Execute a synchronous step and handle its result
+     */
+    executeSyncStep(promiseFn, transaction, step, nextSteps) {
+        return promiseFn()
+            .then(async (response) => {
+            await this.handleStepExpiration(transaction, step, nextSteps);
+            const output = response?.__type || response?.output?.__type
+                ? response.output
+                : response;
+            if (errors_1.SkipStepResponse.isSkipStepResponse(output)) {
+                await TransactionOrchestrator.skipStep({
+                    transaction,
+                    step,
+                });
+                return;
+            }
+            await this.handleStepSuccess(transaction, step, response);
+        })
+            .catch(async (error) => {
+            if (TransactionOrchestrator.isExpectedError(error)) {
+                return;
+            }
+            const response = error?.getStepResponse?.();
+            await this.handleStepExpiration(transaction, step, nextSteps);
+            if (errors_1.PermanentStepFailureError.isPermanentStepFailureError(error)) {
+                await this.handleStepFailure(transaction, step, error, true, response);
+                return;
+            }
+            await this.handleStepFailure(transaction, step, error, false, response);
+        });
+    }
+    /**
+     * Execute an asynchronous step and handle its result
+     */
+    executeAsyncStep(promiseFn, transaction, step, nextSteps) {
+        return promiseFn()
+            .then(async (response) => {
+            const output = response?.__type || response?.output?.__type
+                ? response.output
+                : response;
+            if (errors_1.SkipStepResponse.isSkipStepResponse(output)) {
+                await TransactionOrchestrator.skipStep({
+                    transaction,
+                    step,
+                });
+                // Schedule to continue the execution of async steps because they are not awaited on purpose and can be handled by another machine
+                await transaction.scheduleRetry(step, 0);
+                return;
+            }
+            else {
+                if (!step.definition.backgroundExecution || step.definition.nested) {
+                    const eventName = types_1.DistributedTransactionEvent.STEP_AWAITING;
+                    transaction.emit(eventName, { step, transaction });
+                    return;
                 }
+                await this.handleStepExpiration(transaction, step, nextSteps);
+                await this.handleStepSuccess(transaction, step, response);
             }
-            await (0, utils_1.promiseAll)(execution);
-            if (nextSteps.next.length === 0) {
-                continueExecution = false;
+        })
+            .catch(async (error) => {
+            if (TransactionOrchestrator.isExpectedError(error)) {
+                return;
+            }
+            const response = error?.getStepResponse?.();
+            if (errors_1.PermanentStepFailureError.isPermanentStepFailureError(error)) {
+                await this.handleStepFailure(transaction, step, error, true, response);
+                return;
             }
+            await this.handleStepFailure(transaction, step, error, false, response);
+        });
+    }
+    /**
+     * Check if step or transaction has expired and handle timeouts
+     */
+    async handleStepExpiration(transaction, step, nextSteps) {
+        if (this.hasExpired({ transaction, step }, Date.now())) {
+            await this.checkStepTimeout(transaction, step);
+            await this.checkTransactionTimeout(transaction, nextSteps.next.includes(step) ? nextSteps.next : [step]);
+        }
+    }
+    /**
+     * Handle successful step completion
+     */
+    async handleStepSuccess(transaction, step, response) {
+        const isAsync = step.isCompensating()
+            ? step.definition.compensateAsync
+            : step.definition.async;
+        if ((0, utils_1.isDefined)(response) && step.saveResponse && !isAsync) {
+            transaction.addResponse(step.definition.action, step.isCompensating()
+                ? types_1.TransactionHandlerType.COMPENSATE
+                : types_1.TransactionHandlerType.INVOKE, response);
+        }
+        const ret = await TransactionOrchestrator.setStepSuccess(transaction, step, response);
+        if (ret.transactionIsCancelling) {
+            await this.cancelTransaction(transaction, {
+                preventExecuteNext: true,
+            });
+        }
+        if (isAsync && !ret.stopExecution) {
+            // Schedule to continue the execution of async steps because they are not awaited on purpose and can be handled by another machine
+            await transaction.scheduleRetry(step, 0);
+        }
+    }
+    /**
+     * Handle step failure
+     */
+    async handleStepFailure(transaction, step, error, isPermanent, response) {
+        const isAsync = step.isCompensating()
+            ? step.definition.compensateAsync
+            : step.definition.async;
+        if ((0, utils_1.isDefined)(response) && step.saveResponse) {
+            transaction.addResponse(step.definition.action, step.isCompensating()
+                ? types_1.TransactionHandlerType.COMPENSATE
+                : types_1.TransactionHandlerType.INVOKE, response);
+        }
+        const ret = await TransactionOrchestrator.setStepFailure(transaction, step, error, isPermanent ? 0 : step.definition.maxRetries);
+        if (ret.transactionIsCancelling) {
+            await this.cancelTransaction(transaction, {
+                preventExecuteNext: true,
+            });
+        }
+        if (isAsync && !ret.stopExecution) {
+            // Schedule to continue the execution of async steps because they are not awaited on purpose and can be handled by another machine
+            await transaction.scheduleRetry(step, 0);
         }
     }
     /**
@@ -665,7 +914,9 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             if (flow.state === types_1.TransactionState.NOT_STARTED) {
                 flow.state = types_1.TransactionState.INVOKING;
                 flow.startedAt = Date.now();
-                await transaction.saveCheckpoint(flow.hasAsyncSteps ? 0 : TransactionOrchestrator.DEFAULT_TTL);
+                await transaction.saveCheckpoint({
+                    ttl: flow.hasAsyncSteps ? 0 : TransactionOrchestrator.DEFAULT_TTL,
+                });
                 if (transaction.hasTimeout()) {
                     await transaction.scheduleTransactionTimeout(transaction.getTimeout());
                 }
@@ -691,7 +942,7 @@ class TransactionOrchestrator extends events_1.EventEmitter {
      * Cancel and revert a transaction compensating all its executed steps. It can be an ongoing transaction or a completed one
      * @param transaction - The transaction to be reverted
      */
-    async cancelTransaction(transaction) {
+    async cancelTransaction(transaction, options) {
         if (transaction.modelId !== this.id) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `TransactionModel "${transaction.modelId}" cannot be orchestrated by "${this.id}" model.`);
         }
@@ -699,7 +950,16 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         if (flow.state === types_1.TransactionState.FAILED) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot revert a permanent failed transaction.`);
         }
+        if (flow.state === types_1.TransactionState.COMPENSATING ||
+            flow.state === types_1.TransactionState.WAITING_TO_COMPENSATE) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot revert a transaction that is already compensating.`);
+        }
         flow.state = types_1.TransactionState.WAITING_TO_COMPENSATE;
+        flow.cancelledAt = Date.now();
+        await transaction.saveCheckpoint();
+        if (options?.preventExecuteNext) {
+            return;
+        }
         await this.executeNext(transaction);
     }
     parseFlowOptions() {
@@ -716,7 +976,8 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         if (hasStepTimeouts ||
             hasRetriesTimeout ||
             hasTransactionTimeout ||
-            isIdempotent) {
+            isIdempotent ||
+            this.options.retentionTime) {
             this.options.store = true;
         }
         const parsedOptions = {
@@ -728,12 +989,13 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         TransactionOrchestrator.workflowOptions[this.id] = parsedOptions;
         return [steps, features];
     }
-    createTransactionFlow(transactionId, flowMetadata) {
+    createTransactionFlow(transactionId, flowMetadata, context) {
         const [steps, features] = TransactionOrchestrator.buildSteps(this.definition);
         const flow = {
             modelId: this.id,
             options: this.options,
             transactionId: transactionId,
+            runId: context?.runId ?? (0, ulid_1.ulid)(),
             metadata: flowMetadata,
             hasAsyncSteps: features.hasAsyncSteps,
             hasFailedSteps: false,
@@ -745,11 +1007,12 @@ class TransactionOrchestrator extends events_1.EventEmitter {
             state: types_1.TransactionState.NOT_STARTED,
             definition: this.definition,
             steps,
+            _v: 0, // Initialize version to 0
         };
         return flow;
     }
-    static async loadTransactionById(modelId, transactionId) {
-        const transaction = await distributed_transaction_1.DistributedTransaction.loadTransaction(modelId, transactionId);
+    static async loadTransactionById(modelId, transactionId, options) {
+        const transaction = await distributed_transaction_1.DistributedTransaction.loadTransaction(modelId, transactionId, options);
         if (transaction !== null) {
             const flow = transaction.flow;
             const [steps] = TransactionOrchestrator.buildSteps(flow.definition, flow.steps);
@@ -821,6 +1084,7 @@ class TransactionOrchestrator extends events_1.EventEmitter {
                     failures: 0,
                     lastAttempt: null,
                     next: [],
+                    _v: 0, // Initialize step version to 0
                 });
             }
             if (Array.isArray(obj.next)) {
@@ -840,12 +1104,12 @@ class TransactionOrchestrator extends events_1.EventEmitter {
      * @param payload - payload to be passed to all the transaction steps
      * @param flowMetadata - flow metadata which can include event group id for example
      */
-    async beginTransaction(transactionId, handler, payload, flowMetadata) {
+    async beginTransaction({ transactionId, handler, payload, flowMetadata, context, onLoad, }) {
         const existingTransaction = await TransactionOrchestrator.loadTransactionById(this.id, transactionId);
         let newTransaction = false;
         let modelFlow;
         if (!existingTransaction) {
-            modelFlow = this.createTransactionFlow(transactionId, flowMetadata);
+            modelFlow = this.createTransactionFlow(transactionId, flowMetadata, context);
             newTransaction = true;
         }
         else {
@@ -853,7 +1117,12 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         }
         const transaction = new distributed_transaction_1.DistributedTransaction(modelFlow, handler, payload, existingTransaction?.errors, existingTransaction?.context);
         if (newTransaction && this.getOptions().store) {
-            await transaction.saveCheckpoint(modelFlow.hasAsyncSteps ? 0 : TransactionOrchestrator.DEFAULT_TTL);
+            await transaction.saveCheckpoint({
+                ttl: modelFlow.hasAsyncSteps ? 0 : TransactionOrchestrator.DEFAULT_TTL,
+            });
+        }
+        if (onLoad) {
+            await onLoad(transaction);
         }
         return transaction;
     }
@@ -861,8 +1130,8 @@ class TransactionOrchestrator extends events_1.EventEmitter {
      * @param transactionId - unique identifier of the transaction
      * @param handler - function to handle action of the transaction
      */
-    async retrieveExistingTransaction(transactionId, handler) {
-        const existingTransaction = await TransactionOrchestrator.loadTransactionById(this.id, transactionId);
+    async retrieveExistingTransaction(transactionId, handler, options) {
+        const existingTransaction = await TransactionOrchestrator.loadTransactionById(this.id, transactionId, { isCancelling: options?.isCancelling });
         if (!existingTransaction) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Transaction ${transactionId} could not be found.`);
         }
@@ -905,13 +1174,16 @@ class TransactionOrchestrator extends events_1.EventEmitter {
      * @param handler - The handler function to execute the step
      * @param transaction - The current transaction. If not provided it will be loaded based on the responseIdempotencyKey
      */
-    async skipStep(responseIdempotencyKey, handler, transaction) {
+    async skipStep({ responseIdempotencyKey, handler, transaction, }) {
         const [curTransaction, step] = await TransactionOrchestrator.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction);
         if (step.getStates().status === types_1.TransactionStepStatus.WAITING) {
             this.emit(types_1.DistributedTransactionEvent.RESUME, {
                 transaction: curTransaction,
             });
-            await TransactionOrchestrator.skipStep(curTransaction, step);
+            await TransactionOrchestrator.skipStep({
+                transaction: curTransaction,
+                step,
+            });
             await this.executeNext(curTransaction);
         }
         else {
@@ -919,19 +1191,48 @@ class TransactionOrchestrator extends events_1.EventEmitter {
         }
         return curTransaction;
     }
+    /**
+     * Manually force a step to retry even if it is still in awaiting status
+     * @param responseIdempotencyKey - The idempotency key for the step
+     * @param handler - The handler function to execute the step
+     * @param transaction - The current transaction. If not provided it will be loaded based on the responseIdempotencyKey
+     */
+    async retryStep({ responseIdempotencyKey, handler, transaction, onLoad, }) {
+        const [curTransaction, step] = await TransactionOrchestrator.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction);
+        if (onLoad) {
+            await onLoad(curTransaction);
+        }
+        if (step.getStates().status === types_1.TransactionStepStatus.WAITING) {
+            this.emit(types_1.DistributedTransactionEvent.RESUME, {
+                transaction: curTransaction,
+            });
+            await TransactionOrchestrator.retryStep(curTransaction, step);
+        }
+        else {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot retry step when status is ${step.getStates().status}`);
+        }
+        return curTransaction;
+    }
     /** Register a step success for a specific transaction and step
      * @param responseIdempotencyKey - The idempotency key for the step
      * @param handler - The handler function to execute the step
      * @param transaction - The current transaction. If not provided it will be loaded based on the responseIdempotencyKey
      * @param response - The response of the step
      */
-    async registerStepSuccess(responseIdempotencyKey, handler, transaction, response) {
+    async registerStepSuccess({ responseIdempotencyKey, handler, transaction, response, onLoad, }) {
         const [curTransaction, step] = await TransactionOrchestrator.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction);
+        if (onLoad) {
+            await onLoad(curTransaction);
+        }
         if (step.getStates().status === types_1.TransactionStepStatus.WAITING) {
             this.emit(types_1.DistributedTransactionEvent.RESUME, {
                 transaction: curTransaction,
             });
-            await TransactionOrchestrator.setStepSuccess(curTransaction, step, response);
+            const ret = await TransactionOrchestrator.setStepSuccess(curTransaction, step, response);
+            if (ret.transactionIsCancelling) {
+                await this.cancelTransaction(curTransaction);
+                return curTransaction;
+            }
             await this.executeNext(curTransaction);
         }
         else {
@@ -947,13 +1248,22 @@ class TransactionOrchestrator extends events_1.EventEmitter {
      * @param transaction - The current transaction
      * @param response - The response of the step
      */
-    async registerStepFailure(responseIdempotencyKey, error, handler, transaction) {
+    async registerStepFailure({ responseIdempotencyKey, error, handler, transaction, onLoad, forcePermanentFailure, }) {
         const [curTransaction, step] = await TransactionOrchestrator.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction);
+        if (onLoad) {
+            await onLoad(curTransaction);
+        }
         if (step.getStates().status === types_1.TransactionStepStatus.WAITING) {
             this.emit(types_1.DistributedTransactionEvent.RESUME, {
                 transaction: curTransaction,
             });
-            await TransactionOrchestrator.setStepFailure(curTransaction, step, error, 0);
+            const ret = await TransactionOrchestrator.setStepFailure(curTransaction, step, error, 
+            // On permanent failure, the step should not consider any retries
+            forcePermanentFailure ? 0 : step.definition.maxRetries);
+            if (ret.transactionIsCancelling) {
+                await this.cancelTransaction(curTransaction);
+                return curTransaction;
+            }
             await this.executeNext(curTransaction);
         }
         else {