@medusajs/medusa 1.7.5 → 1.7.6

package/dist/utils/transaction/distributed-transaction.d.ts

@@ -1,13 +1,13 @@
 import { TransactionFlow, TransactionHandlerType, TransactionState } from ".";
 /**
- * @typedef {Object} TransactionMetadata
- * @property {string} producer - The id of the producer that created the transaction (transactionModelId).
- * @property {string} reply_to_topic - The topic to reply to for the transaction.
- * @property {string} idempotency_key - The idempotency key of the transaction.
- * @property {string} action - The action of the transaction.
- * @property {TransactionHandlerType} action_type - The type of the transaction.
- * @property {number} attempt - The number of attempts for the transaction.
- * @property {number} timestamp - The timestamp of the transaction.
+ * @typedef TransactionMetadata
+ * @property producer - The id of the producer that created the transaction (transactionModelId).
+ * @property reply_to_topic - The topic to reply to for the transaction.
+ * @property idempotency_key - The idempotency key of the transaction.
+ * @property action - The action of the transaction.
+ * @property action_type - The type of the transaction.
+ * @property attempt - The number of attempts for the transaction.
+ * @property timestamp - The timestamp of the transaction.
  */
 export declare type TransactionMetadata = {
     producer: string;
@@ -18,18 +18,38 @@ export declare type TransactionMetadata = {
     attempt: number;
     timestamp: number;
 };
+/**
+ * @typedef TransactionContext
+ * @property invoke - Object containing responses of Invoke handlers on steps flagged with saveResponse.
+ * @property compensate - Object containing responses of Compensate handlers on steps flagged with saveResponse.
+ */
+export declare class TransactionContext {
+    invoke: Record<string, unknown>;
+    compensate: Record<string, unknown>;
+    constructor(invoke?: Record<string, unknown>, compensate?: Record<string, unknown>);
+}
+export declare class TransactionStepError {
+    action: string;
+    handlerType: TransactionHandlerType;
+    error: Error | null;
+    constructor(action: string, handlerType: TransactionHandlerType, error: Error | null);
+}
+export declare class TransactionCheckpoint {
+    flow: TransactionFlow;
+    context: TransactionContext;
+    errors: TransactionStepError[];
+    constructor(flow: TransactionFlow, context: TransactionContext, errors?: TransactionStepError[]);
+}
 export declare class TransactionPayload {
     metadata: TransactionMetadata;
-    data: Record<string, unknown> & {
-        _response: Record<string, unknown>;
-    };
+    data: Record<string, unknown>;
+    context: TransactionContext;
     /**
      * @param metadata - The metadata of the transaction.
-     * @param data - The payload data of the transaction and the response of the previous step if forwardResponse is true.
+     * @param data - The initial payload data to begin a transation.
+     * @param context - Object gathering responses of all steps flagged with saveResponse.
      */
-    constructor(metadata: TransactionMetadata, data: Record<string, unknown> & {
-        _response: Record<string, unknown>;
-    });
+    constructor(metadata: TransactionMetadata, data: Record<string, unknown>, context: TransactionContext);
 }
 /**
  * DistributedTransaction represents a distributed transaction, which is a transaction that is composed of multiple steps that are executed in a specific order.
@@ -40,14 +60,14 @@ export declare class DistributedTransaction {
     payload?: any;
     modelId: string;
     transactionId: string;
-    errors: {
-        action: string;
-        handlerType: TransactionHandlerType;
-        error: Error | null;
-    }[];
-    constructor(flow: TransactionFlow, handler: (actionId: string, handlerType: TransactionHandlerType, payload: TransactionPayload) => Promise<unknown>, payload?: any);
+    private errors;
+    private context;
+    constructor(flow: TransactionFlow, handler: (actionId: string, handlerType: TransactionHandlerType, payload: TransactionPayload) => Promise<unknown>, payload?: any, errors?: TransactionStepError[], context?: TransactionContext);
     getFlow(): TransactionFlow;
+    getContext(): TransactionContext;
+    getErrors(): TransactionStepError[];
     addError(action: string, handlerType: TransactionHandlerType, error: Error | null): void;
+    addResponse(action: string, handlerType: TransactionHandlerType, response: unknown): void;
     hasFinished(): boolean;
     getState(): TransactionState;
     get isPartiallyCompleted(): boolean;
@@ -55,7 +75,7 @@ export declare class DistributedTransaction {
     canRevert(): boolean;
     static keyValueStore: any;
     private static keyPrefix;
-    saveCheckpoint(): Promise<void>;
-    static loadTransactionFlow(transactionId: string): Promise<TransactionFlow | null>;
+    saveCheckpoint(): Promise<TransactionCheckpoint>;
+    static loadTransaction(transactionId: string): Promise<TransactionCheckpoint | null>;
     deleteCheckpoint(): Promise<void>;
 }

package/dist/utils/transaction/distributed-transaction.js

@@ -36,16 +36,52 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DistributedTransaction = exports.TransactionPayload = void 0;
+exports.DistributedTransaction = exports.TransactionPayload = exports.TransactionCheckpoint = exports.TransactionStepError = exports.TransactionContext = void 0;
 var _1 = require(".");
+/**
+ * @typedef TransactionContext
+ * @property invoke - Object containing responses of Invoke handlers on steps flagged with saveResponse.
+ * @property compensate - Object containing responses of Compensate handlers on steps flagged with saveResponse.
+ */
+var TransactionContext = /** @class */ (function () {
+    function TransactionContext(invoke, compensate) {
+        if (invoke === void 0) { invoke = {}; }
+        if (compensate === void 0) { compensate = {}; }
+        this.invoke = invoke;
+        this.compensate = compensate;
+    }
+    return TransactionContext;
+}());
+exports.TransactionContext = TransactionContext;
+var TransactionStepError = /** @class */ (function () {
+    function TransactionStepError(action, handlerType, error) {
+        this.action = action;
+        this.handlerType = handlerType;
+        this.error = error;
+    }
+    return TransactionStepError;
+}());
+exports.TransactionStepError = TransactionStepError;
+var TransactionCheckpoint = /** @class */ (function () {
+    function TransactionCheckpoint(flow, context, errors) {
+        if (errors === void 0) { errors = []; }
+        this.flow = flow;
+        this.context = context;
+        this.errors = errors;
+    }
+    return TransactionCheckpoint;
+}());
+exports.TransactionCheckpoint = TransactionCheckpoint;
 var TransactionPayload = /** @class */ (function () {
     /**
      * @param metadata - The metadata of the transaction.
-     * @param data - The payload data of the transaction and the response of the previous step if forwardResponse is true.
+     * @param data - The initial payload data to begin a transation.
+     * @param context - Object gathering responses of all steps flagged with saveResponse.
      */
-    function TransactionPayload(metadata, data) {
+    function TransactionPayload(metadata, data, context) {
         this.metadata = metadata;
         this.data = data;
+        this.context = context;
     }
     return TransactionPayload;
 }());
@@ -54,17 +90,30 @@ exports.TransactionPayload = TransactionPayload;
  * DistributedTransaction represents a distributed transaction, which is a transaction that is composed of multiple steps that are executed in a specific order.
  */
 var DistributedTransaction = /** @class */ (function () {
-    function DistributedTransaction(flow, handler, payload) {
+    function DistributedTransaction(flow, handler, payload, errors, context) {
         this.flow = flow;
         this.handler = handler;
         this.payload = payload;
         this.errors = [];
+        this.context = new TransactionContext();
         this.transactionId = flow.transactionId;
         this.modelId = flow.transactionModelId;
+        if (errors) {
+            this.errors = errors;
+        }
+        if (context) {
+            this.context = context;
+        }
     }
     DistributedTransaction.prototype.getFlow = function () {
         return this.flow;
     };
+    DistributedTransaction.prototype.getContext = function () {
+        return this.context;
+    };
+    DistributedTransaction.prototype.getErrors = function () {
+        return this.errors;
+    };
     DistributedTransaction.prototype.addError = function (action, handlerType, error) {
         this.errors.push({
             action: action,
@@ -72,6 +121,9 @@ var DistributedTransaction = /** @class */ (function () {
             error: error,
         });
     };
+    DistributedTransaction.prototype.addResponse = function (action, handlerType, response) {
+        this.context[handlerType][action] = response;
+    };
     DistributedTransaction.prototype.hasFinished = function () {
         return [
             _1.TransactionState.DONE,
@@ -99,15 +151,16 @@ var DistributedTransaction = /** @class */ (function () {
     };
     DistributedTransaction.prototype.saveCheckpoint = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var key;
+            var key, data;
             return __generator(this, function (_a) {
                 key = DistributedTransaction.keyPrefix + this.transactionId;
-                DistributedTransaction.keyValueStore[key] = JSON.stringify(this.getFlow());
-                return [2 /*return*/];
+                data = new TransactionCheckpoint(this.getFlow(), this.getContext(), this.getErrors());
+                DistributedTransaction.keyValueStore[key] = JSON.stringify(data);
+                return [2 /*return*/, data];
             });
         });
     };
-    DistributedTransaction.loadTransactionFlow = function (transactionId) {
+    DistributedTransaction.loadTransaction = function (transactionId) {
         return __awaiter(this, void 0, void 0, function () {
             var key;
             return __generator(this, function (_a) {

package/dist/utils/transaction/distributed-transaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"distributed-transaction.js","sourceRoot":"","sources":["../../../src/utils/transaction/distributed-transaction.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"distributed-transaction.js","sourceRoot":"","sources":["../../../src/utils/transaction/distributed-transaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,sBAA6E;AAsB7E;;;;GAIG;AACH;IACE,4BACS,MAAoC,EACpC,UAAwC;QADxC,uBAAA,EAAA,WAAoC;QACpC,2BAAA,EAAA,eAAwC;QADxC,WAAM,GAAN,MAAM,CAA8B;QACpC,eAAU,GAAV,UAAU,CAA8B;IAC9C,CAAC;IACN,yBAAC;AAAD,CAAC,AALD,IAKC;AALY,gDAAkB;AAO/B;IACE,8BACS,MAAc,EACd,WAAmC,EACnC,KAAmB;QAFnB,WAAM,GAAN,MAAM,CAAQ;QACd,gBAAW,GAAX,WAAW,CAAwB;QACnC,UAAK,GAAL,KAAK,CAAc;IACzB,CAAC;IACN,2BAAC;AAAD,CAAC,AAND,IAMC;AANY,oDAAoB;AAQjC;IACE,+BACS,IAAqB,EACrB,OAA2B,EAC3B,MAAmC;QAAnC,uBAAA,EAAA,WAAmC;QAFnC,SAAI,GAAJ,IAAI,CAAiB;QACrB,YAAO,GAAP,OAAO,CAAoB;QAC3B,WAAM,GAAN,MAAM,CAA6B;IACzC,CAAC;IACN,4BAAC;AAAD,CAAC,AAND,IAMC;AANY,sDAAqB;AAQlC;IACE;;;;OAIG;IACH,4BACS,QAA6B,EAC7B,IAA6B,EAC7B,OAA2B;QAF3B,aAAQ,GAAR,QAAQ,CAAqB;QAC7B,SAAI,GAAJ,IAAI,CAAyB;QAC7B,YAAO,GAAP,OAAO,CAAoB;IACjC,CAAC;IACN,yBAAC;AAAD,CAAC,AAXD,IAWC;AAXY,gDAAkB;AAa/B;;GAEG;AAEH;IAQE,gCACU,IAAqB,EACtB,OAIc,EACd,OAAa,EACpB,MAA+B,EAC/B,OAA4B;QARpB,SAAI,GAAJ,IAAI,CAAiB;QACtB,YAAO,GAAP,OAAO,CAIO;QACd,YAAO,GAAP,OAAO,CAAM;QAXd,WAAM,GAA2B,EAAE,CAAA;QAEnC,YAAO,GAAuB,IAAI,kBAAkB,EAAE,CAAA;QAa5D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAA;QACvC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAA;QAEtC,IAAI,MAAM,EAAE;YACV,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;SACrB;QAED,IAAI,OAAO,EAAE;YACX,IAAI,CAAC,OAAO,GAAG,OAAO,CAAA;SACvB;IACH,CAAC;IAEM,wCAAO,GAAd;QACE,OAAO,IAAI,CAAC,IAAI,CAAA;IAClB,CAAC;IAEM,2CAAU,GAAjB;QACE,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;IAEM,0CAAS,GAAhB;QACE,OAAO,IAAI,CAAC,MAAM,CAAA;IACpB,CAAC;IAEM,yCAAQ,GAAf,UACE,MAAc,EACd,WAAmC,EACnC,KAAmB;QAEnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YACf,MAAM,QAAA;YACN,WAAW,aAAA;YACX,KAAK,OAAA;SACN,CAAC,CAAA;IACJ,CAAC;IAEM,4CAAW,GAAlB,UACE,MAAc,EACd,WAAmC,EACnC,QAAiB;QAEjB,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAA;IAC9C,CAAC;IAEM,4CAAW,GAAlB;QACE,OAAO;YACL,mBAAgB,CAAC,IAAI;YACrB,mBAAgB,CAAC,QAAQ;YACzB,mBAAgB,CAAC,MAAM;SACxB,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAA;IAC7B,CAAC;IAEM,yCAAQ,GAAf;QACE,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAA;IAC7B,CAAC;IAED,sBAAW,wDAAoB;aAA/B;YACE,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,cAAc,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,eAAe,CAAA;QAC5E,CAAC;;;OAAA;IAEM,0CAAS,GAAhB;QACE,OAAO,CACL,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,KAAK,mBAAgB,CAAC,WAAW;YACrD,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,KAAK,mBAAgB,CAAC,QAAQ,CACnD,CAAA;IACH,CAAC;IACM,0CAAS,GAAhB;QACE,OAAO,CACL,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,KAAK,mBAAgB,CAAC,IAAI;YAC9C,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,KAAK,mBAAgB,CAAC,YAAY,CACvD,CAAA;IACH,CAAC;IAIY,+CAAc,GAA3B;;;;gBAEQ,GAAG,GAAG,sBAAsB,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAA;gBAC3D,IAAI,GAAG,IAAI,qBAAqB,CACpC,IAAI,CAAC,OAAO,EAAE,EACd,IAAI,CAAC,UAAU,EAAE,EACjB,IAAI,CAAC,SAAS,EAAE,CACjB,CAAA;gBACD,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAA;gBAEhE,sBAAO,IAAI,EAAA;;;KACZ;IAEmB,sCAAe,GAAnC,UACE,aAAqB;;;;gBAGf,GAAG,GAAG,sBAAsB,CAAC,SAAS,GAAG,aAAa,CAAA;gBAC5D,IAAI,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE;oBAC7C,sBAAO,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,EAAA;iBAC7D;gBAED,sBAAO,IAAI,EAAA;;;KACZ;IAEY,iDAAgB,GAA7B;;;;gBAEQ,GAAG,GAAG,sBAAsB,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAA;gBACjE,OAAO,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAA;;;;KACjD;IA/Ba,oCAAa,GAAQ,EAAE,CAAA,CAAC,yBAAyB;IAChD,gCAAS,GAAG,SAAS,CAAA;IA+BtC,6BAAC;CAAA,AA5HD,IA4HC;AA5HY,wDAAsB"}

package/dist/utils/transaction/index.d.ts

@@ -11,7 +11,7 @@ export declare type TransactionStepsDefinition = {
     timeout?: number;
     async?: boolean;
     noWait?: boolean;
-    forwardResponse?: boolean;
+    saveResponse?: boolean;
     next?: TransactionStepsDefinition | TransactionStepsDefinition[];
 };
 export declare enum TransactionStepStatus {

package/dist/utils/transaction/transaction-orchestrator.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import { EventEmitter } from "events";
-import { TransactionHandlerType, TransactionStepsDefinition, TransactionState } from ".";
-import { DistributedTransaction, TransactionPayload } from "./distributed-transaction";
-import { TransactionStep } from "./transaction-step";
+import { TransactionStepsDefinition, TransactionState } from ".";
+import { DistributedTransaction } from "./distributed-transaction";
+import { TransactionStep, TransactionStepHandler } from "./transaction-step";
 export declare type TransactionFlow = {
     transactionModelId: string;
     definition: TransactionStepsDefinition;
@@ -14,7 +14,6 @@ export declare type TransactionFlow = {
         [key: string]: TransactionStep;
     };
 };
-export declare type TransactionStepHandler = (actionId: string, handlerType: TransactionHandlerType, payload: TransactionPayload) => Promise<unknown>;
 /**
  * @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
@@ -45,8 +44,13 @@ export declare class TransactionOrchestrator extends EventEmitter {
      * @param transaction - The transaction to resume
      */
     resume(transaction: DistributedTransaction): Promise<void>;
+    /**
+     * 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
+     */
+    cancelTransaction(transaction: DistributedTransaction): Promise<void>;
     private createTransactionFlow;
-    private getTransactionFlowById;
+    private loadTransactionById;
     private buildSteps;
     /** Create a new transaction
      * @param transactionId - unique identifier of the transaction
@@ -60,17 +64,16 @@ export declare class TransactionOrchestrator extends EventEmitter {
      * @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 payload - The payload of the step
+     * @param response - The response of the step
      */
-    registerStepSuccess(responseIdempotencyKey: string, handler?: TransactionStepHandler, transaction?: DistributedTransaction, payload?: unknown): Promise<DistributedTransaction>;
+    registerStepSuccess(responseIdempotencyKey: string, handler?: TransactionStepHandler, transaction?: DistributedTransaction, response?: unknown): Promise<DistributedTransaction>;
     /**
      * Register a step failure for a specific transaction and step
      * @param responseIdempotencyKey - The idempotency key for the step
      * @param error - The error that caused the failure
      * @param handler - The handler function to execute the step
      * @param transaction - The current transaction
-     * @param payload - The payload of the step
+     * @param response - The response of the step
      */
-    registerStepFailure(responseIdempotencyKey: string, error: Error | null, handler?: TransactionStepHandler, transaction?: DistributedTransaction, payload?: unknown): Promise<DistributedTransaction>;
-    cancelTransaction(transactionId: string): void;
+    registerStepFailure(responseIdempotencyKey: string, error: Error | null, handler?: TransactionStepHandler, transaction?: DistributedTransaction, response?: unknown): Promise<DistributedTransaction>;
 }

package/dist/utils/transaction/transaction-orchestrator.js

@@ -116,7 +116,7 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
         _this.ROOT_STEP = "_root";
         _this.invokeSteps = [];
         _this.compensateSteps = [];
-        _this.DEFAULT_RETRIES = 3;
+        _this.DEFAULT_RETRIES = 0;
         return _this;
     }
     TransactionOrchestrator.getKeyName = function () {
@@ -266,6 +266,7 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
                     : _1.TransactionState.DONE;
             }
             this.emit("finish", transaction);
+            // TODO: check TransactionModel if it should delete the checkpoint when the transaction is done
             void transaction.deleteCheckpoint();
         }
         return {
@@ -295,8 +296,10 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (step.forwardResponse) {
-                            step.saveResponse(response);
+                        if (step.saveResponse) {
+                            transaction.addResponse(step.definition.action, step.isCompensating()
+                                ? _1.TransactionHandlerType.COMPENSATE
+                                : _1.TransactionHandlerType.INVOKE, response);
                         }
                         step.changeStatus(_1.TransactionStepStatus.OK);
                         if (step.isCompensating()) {
@@ -366,7 +369,7 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
     };
     TransactionOrchestrator.prototype.executeNext = function (transaction) {
         return __awaiter(this, void 0, void 0, function () {
-            var flow, nextSteps, execution, _loop_1, this_1, _a, _b, step;
+            var flow, nextSteps, execution, _loop_1, _a, _b, step;
             var e_3, _c;
             var _this = this;
             return __generator(this, function (_d) {
@@ -394,14 +397,6 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
                                 }
                             }
                             step.changeStatus(_1.TransactionStepStatus.WAITING);
-                            var parent = this_1.getPreviousStep(flow, step);
-                            var payloadData = transaction.payload;
-                            if (parent.forwardResponse) {
-                                if (!payloadData) {
-                                    payloadData = {};
-                                }
-                                payloadData._response = parent.getResponse();
-                            }
                             var payload = new distributed_transaction_1.TransactionPayload({
                                 producer: flow.transactionModelId,
                                 reply_to_topic: TransactionOrchestrator.getKeyName("trans", flow.transactionModelId),
@@ -410,7 +405,7 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
                                 action_type: type,
                                 attempt: step.attempts,
                                 timestamp: Date.now(),
-                            }, payloadData);
+                            }, transaction.payload, transaction.getContext());
                             if (!step.definition.async) {
                                 execution.push(transaction
                                     .handler(step.definition.action + "", type, payload)
@@ -447,7 +442,6 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
                                 }); }));
                             }
                         };
-                        this_1 = this;
                         try {
                             for (_a = __values(nextSteps.next), _b = _a.next(); !_b.done; _b = _a.next()) {
                                 step = _b.value;
@@ -506,34 +500,59 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * 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
+     */
+    TransactionOrchestrator.prototype.cancelTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var flow;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (transaction.modelId !== this.id) {
+                            throw new Error("TransactionModel \"".concat(transaction.modelId, "\" cannot be orchestrated by \"").concat(this.id, "\" model."));
+                        }
+                        flow = transaction.getFlow();
+                        if (flow.state === _1.TransactionState.FAILED) {
+                            throw new Error("Cannot revert a perment failed transaction.");
+                        }
+                        flow.state = _1.TransactionState.WAITING_TO_COMPENSATE;
+                        return [4 /*yield*/, this.executeNext(transaction)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     TransactionOrchestrator.prototype.createTransactionFlow = function (transactionId) {
         return __awaiter(this, void 0, void 0, function () {
-            var model;
             return __generator(this, function (_a) {
-                model = {
-                    transactionModelId: this.id,
-                    transactionId: transactionId,
-                    hasFailedSteps: false,
-                    hasSkippedSteps: false,
-                    state: _1.TransactionState.NOT_STARTED,
-                    definition: this.definition,
-                    steps: this.buildSteps(this.definition),
-                };
-                return [2 /*return*/, model];
+                return [2 /*return*/, {
+                        transactionModelId: this.id,
+                        transactionId: transactionId,
+                        hasFailedSteps: false,
+                        hasSkippedSteps: false,
+                        state: _1.TransactionState.NOT_STARTED,
+                        definition: this.definition,
+                        steps: this.buildSteps(this.definition),
+                    }];
             });
         });
     };
-    TransactionOrchestrator.prototype.getTransactionFlowById = function (transactionId) {
+    TransactionOrchestrator.prototype.loadTransactionById = function (transactionId) {
         return __awaiter(this, void 0, void 0, function () {
-            var flow;
+            var transaction, flow;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, distributed_transaction_1.DistributedTransaction.loadTransactionFlow(transactionId)];
+                    case 0: return [4 /*yield*/, distributed_transaction_1.DistributedTransaction.loadTransaction(transactionId)];
                     case 1:
-                        flow = _a.sent();
-                        if (flow !== null) {
-                            flow.steps = this.buildSteps(flow.definition, flow.steps);
-                            return [2 /*return*/, flow];
+                        transaction = _a.sent();
+                        if (transaction !== null) {
+                            flow = transaction.flow;
+                            transaction.flow.steps = this.buildSteps(flow.definition, flow.steps);
+                            return [2 /*return*/, transaction];
                         }
                         return [2 /*return*/, null];
                 }
@@ -568,15 +587,15 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
                     actionNames.add(obj.action);
                     level.push(obj.action);
                     var id = level.join(".");
-                    var parent = level.slice(0, level.length - 1).join(".");
-                    (_b = states[parent].next) === null || _b === void 0 ? void 0 : _b.push(id);
+                    var parent_1 = level.slice(0, level.length - 1).join(".");
+                    (_b = states[parent_1].next) === null || _b === void 0 ? void 0 : _b.push(id);
                     var definitionCopy = __assign({}, obj);
                     delete definitionCopy.next;
                     states[id] = Object.assign(new transaction_step_1.TransactionStep(), (existingSteps === null || existingSteps === void 0 ? void 0 : existingSteps[id]) || {
                         id: id,
                         depth: level.length - 1,
                         definition: definitionCopy,
-                        forwardResponse: definitionCopy.forwardResponse,
+                        saveResponse: definitionCopy.saveResponse,
                         invoke: {
                             state: _1.TransactionState.NOT_STARTED,
                             status: _1.TransactionStepStatus.IDLE,
@@ -602,27 +621,30 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
      */
     TransactionOrchestrator.prototype.beginTransaction = function (transactionId, handler, payload) {
         return __awaiter(this, void 0, void 0, function () {
-            var modelFlow, newTransaction, transaction;
+            var existingTransaction, newTransaction, modelFlow, transaction;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getTransactionFlowById(transactionId)];
+                    case 0: return [4 /*yield*/, this.loadTransactionById(transactionId)];
                     case 1:
-                        modelFlow = _a.sent();
+                        existingTransaction = _a.sent();
                         newTransaction = false;
-                        if (!!modelFlow) return [3 /*break*/, 3];
+                        if (!!existingTransaction) return [3 /*break*/, 3];
                         return [4 /*yield*/, this.createTransactionFlow(transactionId)];
                     case 2:
                         modelFlow = _a.sent();
                         newTransaction = true;
-                        _a.label = 3;
+                        return [3 /*break*/, 4];
                     case 3:
-                        transaction = new distributed_transaction_1.DistributedTransaction(modelFlow, handler, payload);
-                        if (!newTransaction) return [3 /*break*/, 5];
-                        return [4 /*yield*/, transaction.saveCheckpoint()];
+                        modelFlow = existingTransaction.flow;
+                        _a.label = 4;
                     case 4:
+                        transaction = new distributed_transaction_1.DistributedTransaction(modelFlow, handler, payload, existingTransaction === null || existingTransaction === void 0 ? void 0 : existingTransaction.errors, existingTransaction === null || existingTransaction === void 0 ? void 0 : existingTransaction.context);
+                        if (!newTransaction) return [3 /*break*/, 6];
+                        return [4 /*yield*/, transaction.saveCheckpoint()];
+                    case 5:
                         _a.sent();
-                        _a.label = 5;
-                    case 5: return [2 /*return*/, transaction];
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, transaction];
                 }
             });
         });
@@ -647,13 +669,13 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
                             throw new Error("If a transaction is not provided, the handler is required");
                         }
                         if (!!transaction) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.getTransactionFlowById(transactionId)];
+                        return [4 /*yield*/, this.loadTransactionById(transactionId)];
                     case 1:
                         existingTransaction = _b.sent();
                         if (existingTransaction === null) {
-                            throw new Error("Transaction could not be found.");
+                            throw new Error("Transaction ".concat(transactionId, " could not be found."));
                         }
-                        transaction = new distributed_transaction_1.DistributedTransaction(existingTransaction, handler, payload);
+                        transaction = new distributed_transaction_1.DistributedTransaction(existingTransaction.flow, handler, payload, existingTransaction.errors, existingTransaction.context);
                         _b.label = 2;
                     case 2:
                         step = this.getStepByAction(transaction.getFlow(), action);
@@ -674,18 +696,18 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
      * @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 payload - The payload of the step
+     * @param response - The response of the step
      */
-    TransactionOrchestrator.prototype.registerStepSuccess = function (responseIdempotencyKey, handler, transaction, payload) {
+    TransactionOrchestrator.prototype.registerStepSuccess = function (responseIdempotencyKey, handler, transaction, response) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, curTransaction, step;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction, payload)];
+                    case 0: return [4 /*yield*/, this.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction, response)];
                     case 1:
                         _a = __read.apply(void 0, [_b.sent(), 2]), curTransaction = _a[0], step = _a[1];
                         if (!(step.getStates().status === _1.TransactionStepStatus.WAITING)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.setStepSuccess(curTransaction, step, payload)];
+                        return [4 /*yield*/, this.setStepSuccess(curTransaction, step, response)];
                     case 2:
                         _b.sent();
                         this.emit("resume", curTransaction);
@@ -705,14 +727,14 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
      * @param error - The error that caused the failure
      * @param handler - The handler function to execute the step
      * @param transaction - The current transaction
-     * @param payload - The payload of the step
+     * @param response - The response of the step
      */
-    TransactionOrchestrator.prototype.registerStepFailure = function (responseIdempotencyKey, error, handler, transaction, payload) {
+    TransactionOrchestrator.prototype.registerStepFailure = function (responseIdempotencyKey, error, handler, transaction, response) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, curTransaction, step;
             return __generator(this, function (_b) {
                 switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction, payload)];
+                    case 0: return [4 /*yield*/, this.getTransactionAndStepFromIdempotencyKey(responseIdempotencyKey, handler, transaction, response)];
                     case 1:
                         _a = __read.apply(void 0, [_b.sent(), 2]), curTransaction = _a[0], step = _a[1];
                         if (!(step.getStates().status === _1.TransactionStepStatus.WAITING)) return [3 /*break*/, 4];
@@ -730,9 +752,6 @@ var TransactionOrchestrator = /** @class */ (function (_super) {
             });
         });
     };
-    TransactionOrchestrator.prototype.cancelTransaction = function (transactionId) {
-        // TODO: stop a transaction while in progress and compensate all executed steps
-    };
     TransactionOrchestrator.SEPARATOR = ":";
     return TransactionOrchestrator;
 }(events_1.EventEmitter));