@medusajs/medusa 1.3.7 → 1.3.8

package/dist/services/swap.js

@@ -108,79 +108,51 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 var medusa_core_utils_1 = require("medusa-core-utils");
-var medusa_interfaces_1 = require("medusa-interfaces");
 var utils_1 = require("../utils");
+var interfaces_1 = require("../interfaces");
+var cart_1 = __importDefault(require("./cart"));
+var models_1 = require("../models");
 /**
  * Handles swaps
- * @extends BaseService
  */
 var SwapService = /** @class */ (function (_super) {
     __extends(SwapService, _super);
     function SwapService(_a) {
-        var manager = _a.manager, swapRepository = _a.swapRepository, eventBusService = _a.eventBusService, cartService = _a.cartService, totalsService = _a.totalsService, returnService = _a.returnService, lineItemService = _a.lineItemService, paymentProviderService = _a.paymentProviderService, shippingMethodTaxLineRepository = _a.shippingMethodTaxLineRepository, shippingOptionService = _a.shippingOptionService, fulfillmentService = _a.fulfillmentService, orderService = _a.orderService, inventoryService = _a.inventoryService, customShippingOptionService = _a.customShippingOptionService, lineItemAdjustmentService = _a.lineItemAdjustmentService;
-        var _this = _super.call(this) || this;
-        /** @private @const {EntityManager} */
+        var manager = _a.manager, swapRepository = _a.swapRepository, eventBusService = _a.eventBusService, cartService = _a.cartService, totalsService = _a.totalsService, returnService = _a.returnService, lineItemService = _a.lineItemService, paymentProviderService = _a.paymentProviderService, shippingOptionService = _a.shippingOptionService, fulfillmentService = _a.fulfillmentService, orderService = _a.orderService, inventoryService = _a.inventoryService, customShippingOptionService = _a.customShippingOptionService, lineItemAdjustmentService = _a.lineItemAdjustmentService;
+        var _this = 
+        // eslint-disable-next-line prefer-rest-params
+        _super.call(this, arguments[0]) || this;
         _this.manager_ = manager;
-        /** @private @const {SwapModel} */
         _this.swapRepository_ = swapRepository;
-        /** @private @const {TotalsService} */
         _this.totalsService_ = totalsService;
-        /** @private @const {LineItemService} */
         _this.lineItemService_ = lineItemService;
-        /** @private @const {ReturnService} */
         _this.returnService_ = returnService;
-        /** @private @const {PaymentProviderService} */
         _this.paymentProviderService_ = paymentProviderService;
-        /** @private @const {CartService} */
         _this.cartService_ = cartService;
-        /** @private @const {FulfillmentService} */
         _this.fulfillmentService_ = fulfillmentService;
-        /** @private @const {OrderService} */
         _this.orderService_ = orderService;
-        /** @private @const {ShippingOptionService} */
         _this.shippingOptionService_ = shippingOptionService;
-        /** @private @const {InventoryService} */
         _this.inventoryService_ = inventoryService;
-        /** @private @const {EventBusService} */
         _this.eventBus_ = eventBusService;
-        /** @private @const {typeof ShippingMethodTaxLineRepository} */
-        _this.shippingTaxLineRepo_ = shippingMethodTaxLineRepository;
-        /** @private @const {CustomShippingOptionService} */
         _this.customShippingOptionService_ = customShippingOptionService;
-        /** @private @const {LineItemAdjustmentService} */
         _this.lineItemAdjustmentService_ = lineItemAdjustmentService;
         return _this;
     }
-    SwapService.prototype.withTransaction = function (transactionManager) {
-        if (!transactionManager) {
-            return this;
-        }
-        var cloned = new SwapService({
-            manager: transactionManager,
-            swapRepository: this.swapRepository_,
-            eventBusService: this.eventBus_,
-            cartService: this.cartService_,
-            totalsService: this.totalsService_,
-            returnService: this.returnService_,
-            lineItemService: this.lineItemService_,
-            shippingMethodTaxLineRepository: this.shippingTaxLineRepo_,
-            paymentProviderService: this.paymentProviderService_,
-            shippingOptionService: this.shippingOptionService_,
-            orderService: this.orderService_,
-            inventoryService: this.inventoryService_,
-            fulfillmentService: this.fulfillmentService_,
-            customShippingOptionService: this.customShippingOptionService_,
-            lineItemAdjustmentService: this.lineItemAdjustmentService_,
-        });
-        cloned.transactionManager_ = transactionManager;
-        return cloned;
-    };
-    SwapService.prototype.transformQueryForCart_ = function (config) {
+    /**
+     * Transform find config object for retrieval.
+     *
+     * @param config parsed swap find config
+     * @return transformed find swap config
+     */
+    SwapService.prototype.transformQueryForCart = function (config) {
         var select = config.select, relations = config.relations;
-        var cartSelects = null;
-        var cartRelations = null;
+        var cartSelects;
+        var cartRelations;
         if ((0, utils_1.isDefined)(relations) && relations.includes("cart")) {
             var _a = __read(relations.reduce(function (acc, next) {
                 if (next === "cart") {
@@ -220,30 +192,31 @@ var SwapService = /** @class */ (function (_super) {
     };
     /**
      * Retrieves a swap with the given id.
-     * @param {string} id - the id of the swap to retrieve
-     * @param {Object} config - the configuration to retrieve the swap
-     * @return {Promise<Swap>} the swap
+     *
+     * @param id - the id of the swap to retrieve
+     * @param config - the configuration to retrieve the swap
+     * @return the swap
      */
     SwapService.prototype.retrieve = function (id, config) {
         if (config === void 0) { config = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var swapRepo, validatedId, _a, cartSelects, cartRelations, newConfig, query, rels, swap, cart;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var swapRepo, _a, cartSelects, cartRelations, newConfig, query, relations, swap, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         swapRepo = this.manager_.getCustomRepository(this.swapRepository_);
-                        validatedId = this.validateId_(id);
-                        _a = this.transformQueryForCart_(config), cartSelects = _a.cartSelects, cartRelations = _a.cartRelations, newConfig = __rest(_a, ["cartSelects", "cartRelations"]);
-                        query = this.buildQuery_({ id: validatedId }, newConfig);
-                        rels = query.relations;
+                        _a = this.transformQueryForCart(config), cartSelects = _a.cartSelects, cartRelations = _a.cartRelations, newConfig = __rest(_a, ["cartSelects", "cartRelations"]);
+                        query = (0, utils_1.buildQuery)({ id: id }, newConfig);
+                        relations = query.relations;
                         delete query.relations;
-                        return [4 /*yield*/, swapRepo.findOneWithRelations(rels, query)];
+                        return [4 /*yield*/, swapRepo.findOneWithRelations(relations, query)];
                     case 1:
-                        swap = _b.sent();
+                        swap = _c.sent();
                         if (!swap) {
                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Swap was not found");
                         }
                         if (!(cartRelations || cartSelects)) return [3 /*break*/, 3];
+                        _b = swap;
                         return [4 /*yield*/, this.cartService_
                                 .withTransaction(this.manager_)
                                 .retrieve(swap.cart_id, {
@@ -251,9 +224,8 @@ var SwapService = /** @class */ (function (_super) {
                                 relations: cartRelations,
                             })];
                     case 2:
-                        cart = _b.sent();
-                        swap.cart = cart;
-                        _b.label = 3;
+                        _b.cart = _c.sent();
+                        _c.label = 3;
                     case 3: return [2 /*return*/, swap];
                 }
             });
@@ -261,9 +233,10 @@ var SwapService = /** @class */ (function (_super) {
     };
     /**
      * Retrieves a swap based on its associated cart id
-     * @param {string} cartId - the cart id that the swap's cart has
-     * @param {string[]} relations - the relations to retrieve swap
-     * @return {Promise<Swap>} the swap
+     *
+     * @param cartId - the cart id that the swap's cart has
+     * @param relations - the relations to retrieve swap
+     * @return the swap
      */
     SwapService.prototype.retrieveByCartId = function (cartId, relations) {
         if (relations === void 0) { relations = []; }
@@ -290,497 +263,505 @@ var SwapService = /** @class */ (function (_super) {
         });
     };
     /**
-     * @param {Object} selector - the query object for find
-     * @param {Object} config - the configuration used to find the objects. contains relations, skip, and take.
-     * @return {Promise} the result of the find operation
+     * List swaps.
+     *
+     * @param selector - the query object for find
+     * @param config - the configuration used to find the objects. contains relations, skip, and take.
+     * @return the result of the find operation
      */
     SwapService.prototype.list = function (selector, config) {
-        if (config === void 0) { config = { skip: 0, take: 50, order: { created_at: "DESC" } }; }
-        var swapRepo = this.manager_.getCustomRepository(this.swapRepository_);
-        var query = this.buildQuery_(selector, config);
-        var rels = query.relations;
-        delete query.relations;
-        return swapRepo.findWithRelations(rels, query);
-    };
-    /**
-     * @typedef OrderLike
-     * @property {Array<LineItem>} items - the items on the order
-     */
-    /**
-     * @typedef ReturnItem
-     * @property {string} item_id - the id of the item in the order to return from.
-     * @property {number} quantity - the amount of the item to return.
-     */
-    /**
-     * Goes through a list of return items to ensure that they exist on the
-     * original order. If the item exists it is verified that the quantity to
-     * return is not higher than the original quantity ordered.
-     * @param {OrderLike} order - the order to return from
-     * @param {Array<ReturnItem>} returnItems - the items to return
-     * @return {Array<ReturnItems>} the validated returnItems
-     */
-    SwapService.prototype.validateReturnItems_ = function (order, returnItems) {
-        return returnItems.map(function (_a) {
-            var item_id = _a.item_id, quantity = _a.quantity;
-            var item = order.items.find(function (i) { return i.id === item_id; });
-            // The item must exist in the order
-            if (!item) {
-                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Item does not exist on order");
-            }
-            // Item's cannot be returned multiple times
-            if (item.quantity < item.returned_quantity + quantity) {
-                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Cannot return more items than have been ordered");
-            }
-            return { item_id: item_id, quantity: quantity };
+        if (config === void 0) { config = {
+            skip: 0,
+            take: 50,
+            order: { created_at: "DESC" },
+        }; }
+        return __awaiter(this, void 0, void 0, function () {
+            var swapRepo, query, relations;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        swapRepo = this.manager_.getCustomRepository(this.swapRepository_);
+                        query = (0, utils_1.buildQuery)(selector, config);
+                        relations = query.relations;
+                        delete query.relations;
+                        return [4 /*yield*/, swapRepo.findWithRelations(relations, query)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
         });
     };
-    /**
-     * @typedef PreliminaryLineItem
-     * @property {string} variant_id - the id of the variant to create an item from
-     * @property {number} quantity - the amount of the variant to add to the line item
-     */
     /**
      * Creates a swap from an order, with given return items, additional items
      * and an optional return shipping method.
-     * @param {Order} order - the order to base the swap off.
-     * @param {Array<ReturnItem>} returnItems - the items to return in the swap.
-     * @param {Array<PreliminaryLineItem> | undefined} additionalItems - the items to send to
-     *  the customer.
-     * @param {ReturnShipping?} returnShipping - an optional shipping method for
-     *  returning the returnItems.
-     * @param {Object} custom - contains relevant custom information. This object may
+     *
+     * @param order - the order to base the swap off
+     * @param returnItems - the items to return in the swap
+     * @param additionalItems - the items to send to the customer
+     * @param returnShipping - an optional shipping method for returning the returnItems
+     * @param custom - contains relevant custom information. This object may
      *  include no_notification which will disable sending notification when creating
-     *  swap. If set, it overrules the attribute inherited from the order.
-     * @return {Promise<Swap>} the newly created swap.
+     *  swap. If set, it overrules the attribute inherited from the order
+     * @return the newly created swap
      */
     SwapService.prototype.create = function (order, returnItems, additionalItems, returnShipping, custom) {
-        if (custom === void 0) { custom = {
-            no_notification: undefined,
-        }; }
+        if (custom === void 0) { custom = { no_notification: undefined }; }
         return __awaiter(this, void 0, void 0, function () {
             var no_notification, rest;
             var _this = this;
             return __generator(this, function (_a) {
-                no_notification = custom.no_notification, rest = __rest(custom, ["no_notification"]);
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var returnItems_1, returnItems_1_1, item, line, e_1_1, newItems, evaluatedNoNotification, swapRepo, created, result;
-                        var e_1, _a;
-                        var _this = this;
-                        var _b, _c, _d;
-                        return __generator(this, function (_e) {
-                            switch (_e.label) {
-                                case 0:
-                                    if (order.fulfillment_status === "not_fulfilled" ||
-                                        order.payment_status !== "captured") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Order cannot be swapped");
-                                    }
-                                    _e.label = 1;
-                                case 1:
-                                    _e.trys.push([1, 6, 7, 8]);
-                                    returnItems_1 = __values(returnItems), returnItems_1_1 = returnItems_1.next();
-                                    _e.label = 2;
-                                case 2:
-                                    if (!!returnItems_1_1.done) return [3 /*break*/, 5];
-                                    item = returnItems_1_1.value;
-                                    return [4 /*yield*/, this.lineItemService_.retrieve(item.item_id, {
-                                            relations: ["order", "swap", "claim_order"],
-                                        })];
-                                case 3:
-                                    line = _e.sent();
-                                    if (((_b = line.order) === null || _b === void 0 ? void 0 : _b.canceled_at) ||
-                                        ((_c = line.swap) === null || _c === void 0 ? void 0 : _c.canceled_at) ||
-                                        ((_d = line.claim_order) === null || _d === void 0 ? void 0 : _d.canceled_at)) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Cannot create a swap on a canceled item.");
-                                    }
-                                    _e.label = 4;
-                                case 4:
-                                    returnItems_1_1 = returnItems_1.next();
-                                    return [3 /*break*/, 2];
-                                case 5: return [3 /*break*/, 8];
-                                case 6:
-                                    e_1_1 = _e.sent();
-                                    e_1 = { error: e_1_1 };
-                                    return [3 /*break*/, 8];
-                                case 7:
-                                    try {
-                                        if (returnItems_1_1 && !returnItems_1_1.done && (_a = returnItems_1.return)) _a.call(returnItems_1);
+                switch (_a.label) {
+                    case 0:
+                        no_notification = custom.no_notification, rest = __rest(custom, ["no_notification"]);
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var lineItemServiceTx, returnItems_1, returnItems_1_1, item, line, e_1_1, newItems, evaluatedNoNotification, swapRepo, created, result;
+                                var e_1, _a;
+                                var _this = this;
+                                var _b, _c, _d;
+                                return __generator(this, function (_e) {
+                                    switch (_e.label) {
+                                        case 0:
+                                            if (order.fulfillment_status === "not_fulfilled" ||
+                                                order.payment_status !== "captured") {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Order cannot be swapped");
+                                            }
+                                            lineItemServiceTx = this.lineItemService_.withTransaction(manager);
+                                            _e.label = 1;
+                                        case 1:
+                                            _e.trys.push([1, 6, 7, 8]);
+                                            returnItems_1 = __values(returnItems), returnItems_1_1 = returnItems_1.next();
+                                            _e.label = 2;
+                                        case 2:
+                                            if (!!returnItems_1_1.done) return [3 /*break*/, 5];
+                                            item = returnItems_1_1.value;
+                                            return [4 /*yield*/, lineItemServiceTx.retrieve(item.item_id, {
+                                                    relations: ["order", "swap", "claim_order"],
+                                                })];
+                                        case 3:
+                                            line = _e.sent();
+                                            if (((_b = line.order) === null || _b === void 0 ? void 0 : _b.canceled_at) ||
+                                                ((_c = line.swap) === null || _c === void 0 ? void 0 : _c.canceled_at) ||
+                                                ((_d = line.claim_order) === null || _d === void 0 ? void 0 : _d.canceled_at)) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Cannot create a swap on a canceled item.");
+                                            }
+                                            _e.label = 4;
+                                        case 4:
+                                            returnItems_1_1 = returnItems_1.next();
+                                            return [3 /*break*/, 2];
+                                        case 5: return [3 /*break*/, 8];
+                                        case 6:
+                                            e_1_1 = _e.sent();
+                                            e_1 = { error: e_1_1 };
+                                            return [3 /*break*/, 8];
+                                        case 7:
+                                            try {
+                                                if (returnItems_1_1 && !returnItems_1_1.done && (_a = returnItems_1.return)) _a.call(returnItems_1);
+                                            }
+                                            finally { if (e_1) throw e_1.error; }
+                                            return [7 /*endfinally*/];
+                                        case 8:
+                                            newItems = [];
+                                            if (!additionalItems) return [3 /*break*/, 10];
+                                            return [4 /*yield*/, Promise.all(additionalItems.map(function (_a) {
+                                                    var variant_id = _a.variant_id, quantity = _a.quantity;
+                                                    return _this.lineItemService_
+                                                        .withTransaction(manager)
+                                                        .generate(variant_id, order.region_id, quantity);
+                                                }))];
+                                        case 9:
+                                            newItems = _e.sent();
+                                            _e.label = 10;
+                                        case 10:
+                                            evaluatedNoNotification = no_notification !== undefined ? no_notification : order.no_notification;
+                                            swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                            created = swapRepo.create(__assign(__assign({}, rest), { fulfillment_status: models_1.SwapFulfillmentStatus.NOT_FULFILLED, payment_status: models_1.SwapPaymentStatus.NOT_PAID, order_id: order.id, additional_items: newItems, no_notification: evaluatedNoNotification }));
+                                            return [4 /*yield*/, swapRepo.save(created)];
+                                        case 11:
+                                            result = _e.sent();
+                                            return [4 /*yield*/, this.returnService_.withTransaction(manager).create({
+                                                    swap_id: result.id,
+                                                    order_id: order.id,
+                                                    items: returnItems,
+                                                    shipping_method: returnShipping,
+                                                    no_notification: evaluatedNoNotification,
+                                                })];
+                                        case 12:
+                                            _e.sent();
+                                            return [4 /*yield*/, this.eventBus_
+                                                    .withTransaction(manager)
+                                                    .emit(SwapService.Events.CREATED, {
+                                                    id: result.id,
+                                                    no_notification: evaluatedNoNotification,
+                                                })];
+                                        case 13:
+                                            _e.sent();
+                                            return [2 /*return*/, result];
                                     }
-                                    finally { if (e_1) throw e_1.error; }
-                                    return [7 /*endfinally*/];
-                                case 8: return [4 /*yield*/, Promise.all(additionalItems.map(function (_a) {
-                                        var variant_id = _a.variant_id, quantity = _a.quantity;
-                                        return _this.lineItemService_.generate(variant_id, order.region_id, quantity);
-                                    }))];
-                                case 9:
-                                    newItems = _e.sent();
-                                    evaluatedNoNotification = no_notification !== undefined ? no_notification : order.no_notification;
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    created = swapRepo.create(__assign(__assign({}, rest), { fulfillment_status: "not_fulfilled", payment_status: "not_paid", order_id: order.id, additional_items: newItems, no_notification: evaluatedNoNotification }));
-                                    return [4 /*yield*/, swapRepo.save(created)];
-                                case 10:
-                                    result = _e.sent();
-                                    return [4 /*yield*/, this.returnService_.withTransaction(manager).create({
-                                            swap_id: result.id,
-                                            order_id: order.id,
-                                            items: returnItems,
-                                            shipping_method: returnShipping,
-                                            no_notification: evaluatedNoNotification,
-                                        })];
-                                case 11:
-                                    _e.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.CREATED, {
-                                            id: result.id,
-                                            no_notification: evaluatedNoNotification,
-                                        })];
-                                case 12:
-                                    _e.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
+    /**
+     * Process difference for the requested swap.
+     *
+     * @param swapId id of a swap being processed
+     * @return processed swap
+     */
     SwapService.prototype.processDifference = function (swapId) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var swap, swapRepo, err_1, result_1, result_2, result_3, err_2, result_4, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(swapId, {
-                                        relations: ["payment", "order", "order.payments"],
-                                    })];
-                                case 1:
-                                    swap = _a.sent();
-                                    if (swap.canceled_at) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be processed");
-                                    }
-                                    if (!swap.confirmed_at) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot process a swap that hasn't been confirmed by the customer");
-                                    }
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    if (!(swap.difference_due < 0)) return [3 /*break*/, 10];
-                                    if (swap.payment_status === "difference_refunded") {
-                                        return [2 /*return*/, swap];
-                                    }
-                                    _a.label = 2;
-                                case 2:
-                                    _a.trys.push([2, 4, , 7]);
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .refundPayment(swap.order.payments, -1 * swap.difference_due, "swap")];
-                                case 3:
-                                    _a.sent();
-                                    return [3 /*break*/, 7];
-                                case 4:
-                                    err_1 = _a.sent();
-                                    swap.payment_status = "requires_action";
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 5:
-                                    result_1 = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.PROCESS_REFUND_FAILED, {
-                                            id: result_1.id,
-                                            no_notification: swap.no_notification,
-                                        })];
-                                case 6:
-                                    _a.sent();
-                                    return [2 /*return*/, result_1];
-                                case 7:
-                                    swap.payment_status = "difference_refunded";
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 8:
-                                    result_2 = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.REFUND_PROCESSED, {
-                                            id: result_2.id,
-                                            no_notification: swap.no_notification,
-                                        })];
-                                case 9:
-                                    _a.sent();
-                                    return [2 /*return*/, result_2];
-                                case 10:
-                                    if (!(swap.difference_due === 0)) return [3 /*break*/, 13];
-                                    if (swap.payment_status === "difference_refunded") {
-                                        return [2 /*return*/, swap];
-                                    }
-                                    swap.payment_status = "difference_refunded";
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 11:
-                                    result_3 = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.REFUND_PROCESSED, {
-                                            id: result_3.id,
-                                            no_notification: swap.no_notification,
-                                        })];
-                                case 12:
-                                    _a.sent();
-                                    return [2 /*return*/, result_3];
-                                case 13:
-                                    _a.trys.push([13, 15, , 18]);
-                                    if (swap.payment_status === "captured") {
-                                        return [2 /*return*/, swap];
-                                    }
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .capturePayment(swap.payment)];
-                                case 14:
-                                    _a.sent();
-                                    return [3 /*break*/, 18];
-                                case 15:
-                                    err_2 = _a.sent();
-                                    swap.payment_status = "requires_action";
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 16:
-                                    result_4 = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.PAYMENT_CAPTURE_FAILED, {
-                                            id: swap.id,
-                                            no_notification: swap.no_notification,
-                                        })];
-                                case 17:
-                                    _a.sent();
-                                    return [2 /*return*/, result_4];
-                                case 18:
-                                    swap.payment_status = "captured";
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 19:
-                                    result = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.PAYMENT_CAPTURED, {
-                                            id: result.id,
-                                            no_notification: swap.no_notification,
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var swap, swapRepo, err_1, result_1, result_2, result_3, err_2, result_4, result;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(swapId, {
+                                            relations: ["payment", "order", "order.payments"],
                                         })];
-                                case 20:
-                                    _a.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                    case 1:
+                                        swap = _a.sent();
+                                        if (swap.canceled_at) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be processed");
+                                        }
+                                        if (!swap.confirmed_at) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot process a swap that hasn't been confirmed by the customer");
+                                        }
+                                        swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                        if (!(swap.difference_due < 0)) return [3 /*break*/, 10];
+                                        if (swap.payment_status === "difference_refunded") {
+                                            return [2 /*return*/, swap];
+                                        }
+                                        _a.label = 2;
+                                    case 2:
+                                        _a.trys.push([2, 4, , 7]);
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .refundPayment(swap.order.payments, -1 * swap.difference_due, "swap")];
+                                    case 3:
+                                        _a.sent();
+                                        return [3 /*break*/, 7];
+                                    case 4:
+                                        err_1 = _a.sent();
+                                        swap.payment_status = models_1.SwapPaymentStatus.REQUIRES_ACTION;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 5:
+                                        result_1 = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(SwapService.Events.PROCESS_REFUND_FAILED, {
+                                                id: result_1.id,
+                                                no_notification: swap.no_notification,
+                                            })];
+                                    case 6:
+                                        _a.sent();
+                                        return [2 /*return*/, result_1];
+                                    case 7:
+                                        swap.payment_status = models_1.SwapPaymentStatus.DIFFERENCE_REFUNDED;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 8:
+                                        result_2 = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(SwapService.Events.REFUND_PROCESSED, {
+                                                id: result_2.id,
+                                                no_notification: swap.no_notification,
+                                            })];
+                                    case 9:
+                                        _a.sent();
+                                        return [2 /*return*/, result_2];
+                                    case 10:
+                                        if (!(swap.difference_due === 0)) return [3 /*break*/, 13];
+                                        if (swap.payment_status === models_1.SwapPaymentStatus.DIFFERENCE_REFUNDED) {
+                                            return [2 /*return*/, swap];
+                                        }
+                                        swap.payment_status = models_1.SwapPaymentStatus.DIFFERENCE_REFUNDED;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 11:
+                                        result_3 = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(SwapService.Events.REFUND_PROCESSED, {
+                                                id: result_3.id,
+                                                no_notification: swap.no_notification,
+                                            })];
+                                    case 12:
+                                        _a.sent();
+                                        return [2 /*return*/, result_3];
+                                    case 13:
+                                        _a.trys.push([13, 15, , 18]);
+                                        if (swap.payment_status === models_1.SwapPaymentStatus.CAPTURED) {
+                                            return [2 /*return*/, swap];
+                                        }
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .capturePayment(swap.payment)];
+                                    case 14:
+                                        _a.sent();
+                                        return [3 /*break*/, 18];
+                                    case 15:
+                                        err_2 = _a.sent();
+                                        swap.payment_status = models_1.SwapPaymentStatus.REQUIRES_ACTION;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 16:
+                                        result_4 = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(SwapService.Events.PAYMENT_CAPTURE_FAILED, {
+                                                id: swap.id,
+                                                no_notification: swap.no_notification,
+                                            })];
+                                    case 17:
+                                        _a.sent();
+                                        return [2 /*return*/, result_4];
+                                    case 18:
+                                        swap.payment_status = models_1.SwapPaymentStatus.CAPTURED;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 19:
+                                        result = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(SwapService.Events.PAYMENT_CAPTURED, {
+                                                id: result.id,
+                                                no_notification: swap.no_notification,
+                                            })];
+                                    case 20:
+                                        _a.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
+    /**
+     * Update the swap record.
+     *
+     * @param swapId id of a swap to update
+     * @param update new data
+     * @return updated swap record
+     */
     SwapService.prototype.update = function (swapId, update) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var swap, swapRepo, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(swapId)];
-                                case 1:
-                                    swap = _a.sent();
-                                    if ("metadata" in update) {
-                                        swap.metadata = this.setMetadata_(swap, update.metadata);
-                                    }
-                                    if ("no_notification" in update) {
-                                        swap.no_notification = update.no_notification;
-                                    }
-                                    if (!("shipping_address" in update)) return [3 /*break*/, 3];
-                                    return [4 /*yield*/, this.updateShippingAddress_(swap, update.shipping_address)];
-                                case 2:
-                                    _a.sent();
-                                    _a.label = 3;
-                                case 3:
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 4:
-                                    result = _a.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var swap, swapRepo;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(swapId)];
+                                    case 1:
+                                        swap = _a.sent();
+                                        if ("metadata" in update) {
+                                            swap.metadata = (0, utils_1.setMetadata)(swap, update.metadata);
+                                        }
+                                        if ("no_notification" in update) {
+                                            swap.no_notification = update.no_notification;
+                                        }
+                                        if ("shipping_address" in update) {
+                                            // TODO: Check this - calling method that doesn't exist
+                                            // also it seems that update swap isn't call anywhere
+                                            // await this.updateShippingAddress_(swap, update.shipping_address)
+                                        }
+                                        swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 2: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
-     * Creates a cart from the given swap and order. The cart can be used to pay
+     * Creates a cart from the given swap. The cart can be used to pay
      * for differences associated with the swap. The swap represented by the
      * swapId must belong to the order. Fails if there is already a cart on the
      * swap.
-     * @param {string} swapId - the id of the swap to create the cart from
-     * @param {object[]} customShippingOptions - the shipping options
-     * @param {Order} order - the order to create the cart from
-     * @return {Promise<Swap>} the swap with its cart_id prop set to the id of
-     *   the new cart.
+     *
+     * @param swapId - the id of the swap to create the cart from
+     * @param customShippingOptions - the shipping options
+     * @return the swap with its cart_id prop set to the id of the new cart.
      */
     SwapService.prototype.createCart = function (swapId, customShippingOptions) {
         if (customShippingOptions === void 0) { customShippingOptions = []; }
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var swap, order, discounts, cart, customShippingOptionServiceTx, customShippingOptions_1, customShippingOptions_1_1, customShippingOption, e_2_1, lineItemServiceTx, lineItemAdjustmentServiceTx, _a, _b, item, e_3_1, shippingTaxLineRepo_1, swapRepo;
-                        var e_2, _c, e_3, _d;
-                        var _e;
-                        return __generator(this, function (_f) {
-                            switch (_f.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(swapId, {
-                                        relations: [
-                                            "order",
-                                            "order.items",
-                                            "order.swaps",
-                                            "order.swaps.additional_items",
-                                            "order.discounts",
-                                            "order.discounts.rule",
-                                            "order.claims",
-                                            "order.claims.additional_items",
-                                            "additional_items",
-                                            "additional_items.variant",
-                                            "return_order",
-                                            "return_order.items",
-                                            "return_order.shipping_method",
-                                            "return_order.shipping_method.tax_lines",
-                                        ],
-                                    })];
-                                case 1:
-                                    swap = _f.sent();
-                                    if (swap.canceled_at) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be used to create a cart");
-                                    }
-                                    if (swap.cart_id) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DUPLICATE_ERROR, "A cart has already been created for the swap");
-                                    }
-                                    order = swap.order;
-                                    discounts = ((_e = order === null || order === void 0 ? void 0 : order.discounts) === null || _e === void 0 ? void 0 : _e.filter(function (_a) {
-                                        var rule = _a.rule;
-                                        return rule.type !== "free_shipping";
-                                    })) ||
-                                        undefined;
-                                    return [4 /*yield*/, this.cartService_.withTransaction(manager).create({
-                                            discounts: discounts,
-                                            email: order.email,
-                                            billing_address_id: order.billing_address_id,
-                                            shipping_address_id: order.shipping_address_id,
-                                            region_id: order.region_id,
-                                            customer_id: order.customer_id,
-                                            type: "swap",
-                                            metadata: {
-                                                swap_id: swap.id,
-                                                parent_order_id: order.id,
-                                            },
-                                        })];
-                                case 2:
-                                    cart = _f.sent();
-                                    customShippingOptionServiceTx = this.customShippingOptionService_.withTransaction(manager);
-                                    _f.label = 3;
-                                case 3:
-                                    _f.trys.push([3, 8, 9, 10]);
-                                    customShippingOptions_1 = __values(customShippingOptions), customShippingOptions_1_1 = customShippingOptions_1.next();
-                                    _f.label = 4;
-                                case 4:
-                                    if (!!customShippingOptions_1_1.done) return [3 /*break*/, 7];
-                                    customShippingOption = customShippingOptions_1_1.value;
-                                    return [4 /*yield*/, customShippingOptionServiceTx.create({
-                                            cart_id: cart.id,
-                                            shipping_option_id: customShippingOption.option_id,
-                                            price: customShippingOption.price,
-                                        })];
-                                case 5:
-                                    _f.sent();
-                                    _f.label = 6;
-                                case 6:
-                                    customShippingOptions_1_1 = customShippingOptions_1.next();
-                                    return [3 /*break*/, 4];
-                                case 7: return [3 /*break*/, 10];
-                                case 8:
-                                    e_2_1 = _f.sent();
-                                    e_2 = { error: e_2_1 };
-                                    return [3 /*break*/, 10];
-                                case 9:
-                                    try {
-                                        if (customShippingOptions_1_1 && !customShippingOptions_1_1.done && (_c = customShippingOptions_1.return)) _c.call(customShippingOptions_1);
-                                    }
-                                    finally { if (e_2) throw e_2.error; }
-                                    return [7 /*endfinally*/];
-                                case 10:
-                                    lineItemServiceTx = this.lineItemService_.withTransaction(manager);
-                                    lineItemAdjustmentServiceTx = this.lineItemAdjustmentService_.withTransaction(manager);
-                                    _f.label = 11;
-                                case 11:
-                                    _f.trys.push([11, 17, 18, 19]);
-                                    _a = __values(swap.additional_items), _b = _a.next();
-                                    _f.label = 12;
-                                case 12:
-                                    if (!!_b.done) return [3 /*break*/, 16];
-                                    item = _b.value;
-                                    return [4 /*yield*/, lineItemServiceTx.update(item.id, {
-                                            cart_id: cart.id,
-                                        })
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var swapRepo, swap, order, discounts, cart, customShippingOptionServiceTx, customShippingOptions_1, customShippingOptions_1_1, customShippingOption, e_2_1, lineItemServiceTx, lineItemAdjustmentServiceTx, _a, _b, item, e_3_1;
+                            var e_2, _c, e_3, _d;
+                            var _e;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                        return [4 /*yield*/, this.retrieve(swapId, {
+                                                relations: [
+                                                    "order",
+                                                    "order.items",
+                                                    "order.swaps",
+                                                    "order.swaps.additional_items",
+                                                    "order.discounts",
+                                                    "order.discounts.rule",
+                                                    "order.claims",
+                                                    "order.claims.additional_items",
+                                                    "additional_items",
+                                                    "additional_items.variant",
+                                                    "return_order",
+                                                    "return_order.items",
+                                                    "return_order.shipping_method",
+                                                    "return_order.shipping_method.tax_lines",
+                                                ],
+                                            })];
+                                    case 1:
+                                        swap = _f.sent();
+                                        if (swap.canceled_at) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be used to create a cart");
+                                        }
+                                        if (swap.cart_id) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DUPLICATE_ERROR, "A cart has already been created for the swap");
+                                        }
+                                        order = swap.order;
+                                        discounts = ((_e = order === null || order === void 0 ? void 0 : order.discounts) === null || _e === void 0 ? void 0 : _e.filter(function (_a) {
+                                            var rule = _a.rule;
+                                            return rule.type !== "free_shipping";
+                                        })) ||
+                                            undefined;
+                                        return [4 /*yield*/, this.cartService_.withTransaction(manager).create({
+                                                discounts: discounts,
+                                                email: order.email,
+                                                billing_address_id: order.billing_address_id,
+                                                shipping_address_id: order.shipping_address_id,
+                                                region_id: order.region_id,
+                                                customer_id: order.customer_id,
+                                                type: models_1.CartType.SWAP,
+                                                metadata: {
+                                                    swap_id: swap.id,
+                                                    parent_order_id: order.id,
+                                                },
+                                            })];
+                                    case 2:
+                                        cart = _f.sent();
+                                        customShippingOptionServiceTx = this.customShippingOptionService_.withTransaction(manager);
+                                        _f.label = 3;
+                                    case 3:
+                                        _f.trys.push([3, 8, 9, 10]);
+                                        customShippingOptions_1 = __values(customShippingOptions), customShippingOptions_1_1 = customShippingOptions_1.next();
+                                        _f.label = 4;
+                                    case 4:
+                                        if (!!customShippingOptions_1_1.done) return [3 /*break*/, 7];
+                                        customShippingOption = customShippingOptions_1_1.value;
+                                        return [4 /*yield*/, customShippingOptionServiceTx.create({
+                                                cart_id: cart.id,
+                                                shipping_option_id: customShippingOption.option_id,
+                                                price: customShippingOption.price,
+                                            })];
+                                    case 5:
+                                        _f.sent();
+                                        _f.label = 6;
+                                    case 6:
+                                        customShippingOptions_1_1 = customShippingOptions_1.next();
+                                        return [3 /*break*/, 4];
+                                    case 7: return [3 /*break*/, 10];
+                                    case 8:
+                                        e_2_1 = _f.sent();
+                                        e_2 = { error: e_2_1 };
+                                        return [3 /*break*/, 10];
+                                    case 9:
+                                        try {
+                                            if (customShippingOptions_1_1 && !customShippingOptions_1_1.done && (_c = customShippingOptions_1.return)) _c.call(customShippingOptions_1);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                        return [7 /*endfinally*/];
+                                    case 10:
+                                        lineItemServiceTx = this.lineItemService_.withTransaction(manager);
+                                        lineItemAdjustmentServiceTx = this.lineItemAdjustmentService_.withTransaction(manager);
+                                        _f.label = 11;
+                                    case 11:
+                                        _f.trys.push([11, 17, 18, 19]);
+                                        _a = __values(swap.additional_items), _b = _a.next();
+                                        _f.label = 12;
+                                    case 12:
+                                        if (!!_b.done) return [3 /*break*/, 16];
+                                        item = _b.value;
+                                        return [4 /*yield*/, lineItemServiceTx.update(item.id, {
+                                                cart_id: cart.id,
+                                            })
+                                            // we generate adjustments in case the cart has any discounts that should be applied to the additional items
+                                        ];
+                                    case 13:
+                                        _f.sent();
                                         // we generate adjustments in case the cart has any discounts that should be applied to the additional items
-                                    ];
-                                case 13:
-                                    _f.sent();
-                                    // we generate adjustments in case the cart has any discounts that should be applied to the additional items
-                                    return [4 /*yield*/, lineItemAdjustmentServiceTx.createAdjustmentForLineItem(cart, item)];
-                                case 14:
-                                    // we generate adjustments in case the cart has any discounts that should be applied to the additional items
-                                    _f.sent();
-                                    _f.label = 15;
-                                case 15:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 12];
-                                case 16: return [3 /*break*/, 19];
-                                case 17:
-                                    e_3_1 = _f.sent();
-                                    e_3 = { error: e_3_1 };
-                                    return [3 /*break*/, 19];
-                                case 18:
-                                    try {
-                                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                                    }
-                                    finally { if (e_3) throw e_3.error; }
-                                    return [7 /*endfinally*/];
-                                case 19:
-                                    if (!(swap.return_order && swap.return_order.shipping_method)) return [3 /*break*/, 21];
-                                    shippingTaxLineRepo_1 = this.manager_.getCustomRepository(this.shippingTaxLineRepo_);
-                                    return [4 /*yield*/, this.lineItemService_.withTransaction(manager).create({
-                                            cart_id: cart.id,
-                                            title: "Return shipping",
-                                            quantity: 1,
-                                            has_shipping: true,
-                                            allow_discounts: false,
-                                            unit_price: swap.return_order.shipping_method.price,
-                                            is_return: true,
-                                            tax_lines: swap.return_order.shipping_method.tax_lines.map(function (tl) {
-                                                return shippingTaxLineRepo_1.create({
-                                                    name: tl.name,
-                                                    code: tl.code,
-                                                    rate: tl.rate,
-                                                    metadata: tl.metadata,
-                                                });
-                                            }),
-                                        })];
-                                case 20:
-                                    _f.sent();
-                                    _f.label = 21;
-                                case 21: return [4 /*yield*/, this.lineItemService_
-                                        .withTransaction(manager)
-                                        .createReturnLines(swap.return_order.id, cart.id)];
-                                case 22:
-                                    _f.sent();
-                                    swap.cart_id = cart.id;
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 23: return [2 /*return*/, _f.sent()];
-                            }
-                        });
-                    }); })];
+                                        return [4 /*yield*/, lineItemAdjustmentServiceTx.createAdjustmentForLineItem(cart, item)];
+                                    case 14:
+                                        // we generate adjustments in case the cart has any discounts that should be applied to the additional items
+                                        _f.sent();
+                                        _f.label = 15;
+                                    case 15:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 12];
+                                    case 16: return [3 /*break*/, 19];
+                                    case 17:
+                                        e_3_1 = _f.sent();
+                                        e_3 = { error: e_3_1 };
+                                        return [3 /*break*/, 19];
+                                    case 18:
+                                        try {
+                                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                        return [7 /*endfinally*/];
+                                    case 19:
+                                        if (!(swap.return_order && swap.return_order.shipping_method)) return [3 /*break*/, 21];
+                                        return [4 /*yield*/, this.lineItemService_.withTransaction(manager).create({
+                                                cart_id: cart.id,
+                                                title: "Return shipping",
+                                                quantity: 1,
+                                                has_shipping: true,
+                                                allow_discounts: false,
+                                                unit_price: swap.return_order.shipping_method.price,
+                                                is_return: true,
+                                                tax_lines: swap.return_order.shipping_method.tax_lines.map(function (tl) {
+                                                    return lineItemServiceTx.createTaxLine({
+                                                        name: tl.name,
+                                                        code: tl.code,
+                                                        rate: tl.rate,
+                                                        metadata: tl.metadata,
+                                                    });
+                                                }),
+                                            })];
+                                    case 20:
+                                        _f.sent();
+                                        _f.label = 21;
+                                    case 21: return [4 /*yield*/, this.lineItemService_
+                                            .withTransaction(manager)
+                                            .createReturnLines(swap.return_order.id, cart.id)];
+                                    case 22:
+                                        _f.sent();
+                                        swap.cart_id = cart.id;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 23: return [2 /*return*/, _f.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
-     *@param {string} swapId - The id of the swap
+     * Register a cart completion
+     *
+     * @param swapId - The id of the swap
+     * @return swap related to the cart
      */
     SwapService.prototype.registerCartCompletion = function (swapId) {
         return __awaiter(this, void 0, void 0, function () {
@@ -788,7 +769,7 @@ var SwapService = /** @class */ (function (_super) {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                            var swap, cart, payment, items, inventoryServiceTx, paymentProviderServiceTx, cartServiceTx, items_1, items_1_1, item, err_3, e_4_1, total, paymentStatus, inventoryServiceTx, items_2, items_2_1, item, e_5_1, now, swapRepo, result, shippingOptionServiceTx, _a, _b, method, e_6_1;
+                            var swap, cart, payment, items, inventoryServiceTx, paymentProviderServiceTx, cartServiceTx, items_1, items_1_1, item, err_3, e_4_1, total, paymentStatus, inventoryServiceTx, items_2, items_2_1, item, e_5_1, swapRepo, result, shippingOptionServiceTx, _a, _b, method, e_6_1;
                             var e_4, _c, e_5, _d, e_6, _e;
                             return __generator(this, function (_f) {
                                 switch (_f.label) {
@@ -814,7 +795,9 @@ var SwapService = /** @class */ (function (_super) {
                                         if (swap.canceled_at) {
                                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cart related to canceled swap cannot be completed");
                                         }
-                                        return [4 /*yield*/, this.cartService_.retrieve(swap.cart_id, {
+                                        return [4 /*yield*/, this.cartService_
+                                                .withTransaction(manager)
+                                                .retrieve(swap.cart_id, {
                                                 select: ["total"],
                                                 relations: [
                                                     "payment",
@@ -885,7 +868,9 @@ var SwapService = /** @class */ (function (_super) {
                                     case 16:
                                         paymentStatus = _f.sent();
                                         // If payment status is not authorized, we throw
-                                        if (paymentStatus !== "authorized" && paymentStatus !== "succeeded") {
+                                        if (paymentStatus !== models_1.PaymentSessionStatus.AUTHORIZED &&
+                                            // @ts-ignore TODO: check why this is not in the enum
+                                            paymentStatus !== "succeeded") {
                                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_ARGUMENT, "Payment method is not authorized");
                                         }
                                         return [4 /*yield*/, this.paymentProviderService_
@@ -924,12 +909,12 @@ var SwapService = /** @class */ (function (_super) {
                                         finally { if (e_5) throw e_5.error; }
                                         return [7 /*endfinally*/];
                                     case 25:
-                                        now = new Date();
                                         swap.difference_due = total;
                                         swap.shipping_address_id = cart.shipping_address_id;
                                         swap.shipping_methods = cart.shipping_methods;
-                                        swap.confirmed_at = now.toISOString();
-                                        swap.payment_status = total === 0 ? "confirmed" : "awaiting";
+                                        swap.confirmed_at = new Date();
+                                        swap.payment_status =
+                                            total === 0 ? models_1.SwapPaymentStatus.CONFIRMED : models_1.SwapPaymentStatus.AWAITING;
                                         swapRepo = manager.getCustomRepository(this.swapRepository_);
                                         return [4 /*yield*/, swapRepo.save(swap)];
                                     case 26:
@@ -963,17 +948,18 @@ var SwapService = /** @class */ (function (_super) {
                                         }
                                         finally { if (e_6) throw e_6.error; }
                                         return [7 /*endfinally*/];
-                                    case 34:
-                                        this.eventBus_
+                                    case 34: return [4 /*yield*/, this.eventBus_
                                             .withTransaction(manager)
                                             .emit(SwapService.Events.PAYMENT_COMPLETED, {
                                             id: swap.id,
                                             no_notification: swap.no_notification,
-                                        });
+                                        })];
+                                    case 35:
+                                        _f.sent();
                                         return [4 /*yield*/, this.cartService_
                                                 .withTransaction(manager)
                                                 .update(cart.id, { completed_at: new Date() })];
-                                    case 35:
+                                    case 36:
                                         _f.sent();
                                         return [2 /*return*/, result];
                                 }
@@ -988,73 +974,77 @@ var SwapService = /** @class */ (function (_super) {
      * Cancels a given swap if possible. A swap can only be canceled if all
      * related returns, fulfillments, and payments have been canceled. If a swap
      * is associated with a refund, it cannot be canceled.
-     * @param {string} swapId - the id of the swap to cancel.
-     * @return {Promise<Swap>} the canceled swap.
+     *
+     * @param swapId - the id of the swap to cancel.
+     * @return the canceled swap.
      */
     SwapService.prototype.cancel = function (swapId) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var swap, _a, _b, f, swapRepo, result;
-                        var e_7, _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(swapId, {
-                                        relations: ["payment", "fulfillments", "return_order"],
-                                    })];
-                                case 1:
-                                    swap = _d.sent();
-                                    if (swap.payment_status === "difference_refunded" ||
-                                        swap.payment_status === "partially_refunded" ||
-                                        swap.payment_status === "refunded") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Swap with a refund cannot be canceled");
-                                    }
-                                    if (swap.fulfillments) {
-                                        try {
-                                            for (_a = __values(swap.fulfillments), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                                f = _b.value;
-                                                if (!f.canceled_at) {
-                                                    throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "All fulfillments must be canceled before the swap can be canceled");
-                                                }
-                                            }
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var swapRepo, swap, _a, _b, f;
+                            var e_7, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                        return [4 /*yield*/, this.retrieve(swapId, {
+                                                relations: ["payment", "fulfillments", "return_order"],
+                                            })];
+                                    case 1:
+                                        swap = _d.sent();
+                                        if (swap.payment_status === models_1.SwapPaymentStatus.DIFFERENCE_REFUNDED ||
+                                            swap.payment_status === models_1.SwapPaymentStatus.PARTIALLY_REFUNDED ||
+                                            swap.payment_status === models_1.SwapPaymentStatus.REFUNDED) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Swap with a refund cannot be canceled");
                                         }
-                                        catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                                        finally {
+                                        if (swap.fulfillments) {
                                             try {
-                                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                                for (_a = __values(swap.fulfillments), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                    f = _b.value;
+                                                    if (!f.canceled_at) {
+                                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "All fulfillments must be canceled before the swap can be canceled");
+                                                    }
+                                                }
+                                            }
+                                            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                                }
+                                                finally { if (e_7) throw e_7.error; }
                                             }
-                                            finally { if (e_7) throw e_7.error; }
                                         }
-                                    }
-                                    if (swap.return_order && swap.return_order.status !== "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Return must be canceled before the swap can be canceled");
-                                    }
-                                    swap.payment_status = "canceled";
-                                    swap.fulfillment_status = "canceled";
-                                    swap.canceled_at = new Date();
-                                    if (!swap.payment) return [3 /*break*/, 3];
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .cancelPayment(swap.payment)];
-                                case 2:
-                                    _d.sent();
-                                    _d.label = 3;
-                                case 3:
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 4:
-                                    result = _d.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                        if (swap.return_order &&
+                                            swap.return_order.status !== models_1.ReturnStatus.CANCELED) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Return must be canceled before the swap can be canceled");
+                                        }
+                                        swap.payment_status = models_1.SwapPaymentStatus.CANCELED;
+                                        swap.fulfillment_status = models_1.SwapFulfillmentStatus.CANCELED;
+                                        swap.canceled_at = new Date();
+                                        if (!swap.payment) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .cancelPayment(swap.payment)];
+                                    case 2:
+                                        _d.sent();
+                                        _d.label = 3;
+                                    case 3: return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 4: return [2 /*return*/, _d.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
-     * Fulfills the addtional items associated with the swap. Will call the
+     * Fulfills the additional items associated with the swap. Will call the
      * fulfillment providers associated with the shipping methods.
+     *
      * @param {string} swapId - the id of the swap to fulfill,
      * @param {object} config - optional configurations, includes optional metadata to attach to the shipment, and a no_notification flag.
      * @return {Promise<Swap>} the updated swap with new status and fulfillments.
@@ -1065,189 +1055,193 @@ var SwapService = /** @class */ (function (_super) {
             no_notification: undefined,
         }; }
         return __awaiter(this, void 0, void 0, function () {
-            var metadata, no_notification;
             var _this = this;
             return __generator(this, function (_a) {
-                metadata = config.metadata, no_notification = config.no_notification;
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var swap, order, evaluatedNoNotification, _a, successfullyFulfilled, _b, _c, f, lineItemServiceTx, _loop_1, _d, _e, item, e_8_1, swapRepo, result;
-                        var e_9, _f, e_8, _g;
-                        var _h;
-                        return __generator(this, function (_j) {
-                            switch (_j.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(swapId, {
-                                        relations: [
-                                            "payment",
-                                            "shipping_address",
-                                            "additional_items",
-                                            "additional_items.tax_lines",
-                                            "shipping_methods",
-                                            "shipping_methods.tax_lines",
-                                            "order",
-                                            "order.region",
-                                            "order.billing_address",
-                                            "order.discounts",
-                                            "order.discounts.rule",
-                                            "order.payments",
-                                        ],
-                                    })];
-                                case 1:
-                                    swap = _j.sent();
-                                    order = swap.order;
-                                    if (swap.canceled_at) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be fulfilled");
-                                    }
-                                    if (swap.fulfillment_status !== "not_fulfilled" &&
-                                        swap.fulfillment_status !== "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "The swap was already fulfilled");
-                                    }
-                                    if (!((_h = swap.shipping_methods) === null || _h === void 0 ? void 0 : _h.length)) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot fulfill an swap that doesn't have shipping methods");
-                                    }
-                                    evaluatedNoNotification = no_notification !== undefined ? no_notification : swap.no_notification;
-                                    _a = swap;
-                                    return [4 /*yield*/, this.fulfillmentService_
-                                            .withTransaction(manager)
-                                            .createFulfillment(__assign(__assign({}, swap), { payments: swap.payment ? [swap.payment] : order.payments, email: order.email, discounts: order.discounts, currency_code: order.currency_code, tax_rate: order.tax_rate, region_id: order.region_id, region: order.region, display_id: order.display_id, billing_address: order.billing_address, items: swap.additional_items, shipping_methods: swap.shipping_methods, is_swap: true, no_notification: evaluatedNoNotification }), swap.additional_items.map(function (i) { return ({
-                                            item_id: i.id,
-                                            quantity: i.quantity,
-                                        }); }), { swap_id: swapId, metadata: metadata })];
-                                case 2:
-                                    _a.fulfillments = _j.sent();
-                                    successfullyFulfilled = [];
-                                    try {
-                                        for (_b = __values(swap.fulfillments), _c = _b.next(); !_c.done; _c = _b.next()) {
-                                            f = _c.value;
-                                            successfullyFulfilled = successfullyFulfilled.concat(f.items);
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var metadata, no_notification, swapRepo, swap, order, evaluatedNoNotification, _a, successfullyFulfilled, _b, _c, f, lineItemServiceTx, _loop_1, _d, _e, item, e_8_1, result;
+                            var e_9, _f, e_8, _g;
+                            var _h;
+                            return __generator(this, function (_j) {
+                                switch (_j.label) {
+                                    case 0:
+                                        metadata = config.metadata, no_notification = config.no_notification;
+                                        swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                        return [4 /*yield*/, this.retrieve(swapId, {
+                                                relations: [
+                                                    "payment",
+                                                    "shipping_address",
+                                                    "additional_items",
+                                                    "additional_items.tax_lines",
+                                                    "shipping_methods",
+                                                    "shipping_methods.tax_lines",
+                                                    "order",
+                                                    "order.region",
+                                                    "order.billing_address",
+                                                    "order.discounts",
+                                                    "order.discounts.rule",
+                                                    "order.payments",
+                                                ],
+                                            })];
+                                    case 1:
+                                        swap = _j.sent();
+                                        order = swap.order;
+                                        if (swap.canceled_at) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be fulfilled");
                                         }
-                                    }
-                                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                                    finally {
+                                        if (swap.fulfillment_status !== "not_fulfilled" &&
+                                            swap.fulfillment_status !== "canceled") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "The swap was already fulfilled");
+                                        }
+                                        if (!((_h = swap.shipping_methods) === null || _h === void 0 ? void 0 : _h.length)) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot fulfill an swap that doesn't have shipping methods");
+                                        }
+                                        evaluatedNoNotification = no_notification !== undefined ? no_notification : swap.no_notification;
+                                        _a = swap;
+                                        return [4 /*yield*/, this.fulfillmentService_
+                                                .withTransaction(manager)
+                                                .createFulfillment(__assign(__assign({}, swap), { payments: swap.payment ? [swap.payment] : order.payments, email: order.email, discounts: order.discounts, currency_code: order.currency_code, tax_rate: order.tax_rate, region_id: order.region_id, region: order.region, display_id: order.display_id, billing_address: order.billing_address, items: swap.additional_items, shipping_methods: swap.shipping_methods, is_swap: true, no_notification: evaluatedNoNotification }), swap.additional_items.map(function (i) { return ({
+                                                item_id: i.id,
+                                                quantity: i.quantity,
+                                            }); }), { swap_id: swapId, metadata: metadata })];
+                                    case 2:
+                                        _a.fulfillments = _j.sent();
+                                        successfullyFulfilled = [];
                                         try {
-                                            if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
+                                            for (_b = __values(swap.fulfillments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                                f = _c.value;
+                                                successfullyFulfilled = successfullyFulfilled.concat(f.items);
+                                            }
                                         }
-                                        finally { if (e_9) throw e_9.error; }
-                                    }
-                                    swap.fulfillment_status = "fulfilled";
-                                    lineItemServiceTx = this.lineItemService_.withTransaction(manager);
-                                    _loop_1 = function (item) {
-                                        var fulfillmentItem, fulfilledQuantity;
-                                        return __generator(this, function (_k) {
-                                            switch (_k.label) {
-                                                case 0:
-                                                    fulfillmentItem = successfullyFulfilled.find(function (f) { return item.id === f.item_id; });
-                                                    if (!fulfillmentItem) return [3 /*break*/, 2];
-                                                    fulfilledQuantity = (item.fulfilled_quantity || 0) + fulfillmentItem.quantity;
-                                                    // Update the fulfilled quantity
-                                                    return [4 /*yield*/, lineItemServiceTx.update(item.id, {
-                                                            fulfilled_quantity: fulfilledQuantity,
-                                                        })];
-                                                case 1:
-                                                    // Update the fulfilled quantity
-                                                    _k.sent();
-                                                    if (item.quantity !== fulfilledQuantity) {
-                                                        swap.fulfillment_status = "requires_action";
-                                                    }
-                                                    return [3 /*break*/, 3];
-                                                case 2:
-                                                    if (item.quantity !== item.fulfilled_quantity) {
-                                                        swap.fulfillment_status = "requires_action";
-                                                    }
-                                                    _k.label = 3;
-                                                case 3: return [2 /*return*/];
+                                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                                        finally {
+                                            try {
+                                                if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
                                             }
-                                        });
-                                    };
-                                    _j.label = 3;
-                                case 3:
-                                    _j.trys.push([3, 8, 9, 10]);
-                                    _d = __values(swap.additional_items), _e = _d.next();
-                                    _j.label = 4;
-                                case 4:
-                                    if (!!_e.done) return [3 /*break*/, 7];
-                                    item = _e.value;
-                                    return [5 /*yield**/, _loop_1(item)];
-                                case 5:
-                                    _j.sent();
-                                    _j.label = 6;
-                                case 6:
-                                    _e = _d.next();
-                                    return [3 /*break*/, 4];
-                                case 7: return [3 /*break*/, 10];
-                                case 8:
-                                    e_8_1 = _j.sent();
-                                    e_8 = { error: e_8_1 };
-                                    return [3 /*break*/, 10];
-                                case 9:
-                                    try {
-                                        if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
-                                    }
-                                    finally { if (e_8) throw e_8.error; }
-                                    return [7 /*endfinally*/];
-                                case 10:
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 11:
-                                    result = _j.sent();
-                                    return [4 /*yield*/, this.eventBus_.withTransaction(manager).emit(SwapService.Events.FULFILLMENT_CREATED, {
-                                            id: swapId,
-                                            fulfillment_id: result.id,
-                                            no_notification: evaluatedNoNotification,
-                                        })];
-                                case 12:
-                                    _j.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                            finally { if (e_9) throw e_9.error; }
+                                        }
+                                        swap.fulfillment_status = models_1.SwapFulfillmentStatus.FULFILLED;
+                                        lineItemServiceTx = this.lineItemService_.withTransaction(manager);
+                                        _loop_1 = function (item) {
+                                            var fulfillmentItem, fulfilledQuantity;
+                                            return __generator(this, function (_k) {
+                                                switch (_k.label) {
+                                                    case 0:
+                                                        fulfillmentItem = successfullyFulfilled.find(function (f) { return item.id === f.item_id; });
+                                                        if (!fulfillmentItem) return [3 /*break*/, 2];
+                                                        fulfilledQuantity = (item.fulfilled_quantity || 0) + fulfillmentItem.quantity;
+                                                        // Update the fulfilled quantity
+                                                        return [4 /*yield*/, lineItemServiceTx.update(item.id, {
+                                                                fulfilled_quantity: fulfilledQuantity,
+                                                            })];
+                                                    case 1:
+                                                        // Update the fulfilled quantity
+                                                        _k.sent();
+                                                        if (item.quantity !== fulfilledQuantity) {
+                                                            swap.fulfillment_status = models_1.SwapFulfillmentStatus.REQUIRES_ACTION;
+                                                        }
+                                                        return [3 /*break*/, 3];
+                                                    case 2:
+                                                        if (item.quantity !== item.fulfilled_quantity) {
+                                                            swap.fulfillment_status = models_1.SwapFulfillmentStatus.REQUIRES_ACTION;
+                                                        }
+                                                        _k.label = 3;
+                                                    case 3: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        _j.label = 3;
+                                    case 3:
+                                        _j.trys.push([3, 8, 9, 10]);
+                                        _d = __values(swap.additional_items), _e = _d.next();
+                                        _j.label = 4;
+                                    case 4:
+                                        if (!!_e.done) return [3 /*break*/, 7];
+                                        item = _e.value;
+                                        return [5 /*yield**/, _loop_1(item)];
+                                    case 5:
+                                        _j.sent();
+                                        _j.label = 6;
+                                    case 6:
+                                        _e = _d.next();
+                                        return [3 /*break*/, 4];
+                                    case 7: return [3 /*break*/, 10];
+                                    case 8:
+                                        e_8_1 = _j.sent();
+                                        e_8 = { error: e_8_1 };
+                                        return [3 /*break*/, 10];
+                                    case 9:
+                                        try {
+                                            if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
+                                        }
+                                        finally { if (e_8) throw e_8.error; }
+                                        return [7 /*endfinally*/];
+                                    case 10: return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 11:
+                                        result = _j.sent();
+                                        return [4 /*yield*/, this.eventBus_.withTransaction(manager).emit(SwapService.Events.FULFILLMENT_CREATED, {
+                                                id: swapId,
+                                                fulfillment_id: result.id,
+                                                no_notification: evaluatedNoNotification,
+                                            })];
+                                    case 12:
+                                        _j.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Cancels a fulfillment (if related to a swap)
-     * @param {string} fulfillmentId - the ID of the fulfillment to cancel
-     * @return {Swap} updated swap
+     *
+     * @param fulfillmentId - the ID of the fulfillment to cancel
+     * @return updated swap
      */
     SwapService.prototype.cancelFulfillment = function (fulfillmentId) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var canceled, swap, swapRepo, updated;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.fulfillmentService_
-                                        .withTransaction(manager)
-                                        .cancelFulfillment(fulfillmentId)];
-                                case 1:
-                                    canceled = _a.sent();
-                                    if (!canceled.swap_id) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Fufillment not related to a swap");
-                                    }
-                                    return [4 /*yield*/, this.retrieve(canceled.swap_id)];
-                                case 2:
-                                    swap = _a.sent();
-                                    swap.fulfillment_status = "canceled";
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 3:
-                                    updated = _a.sent();
-                                    return [2 /*return*/, updated];
-                            }
-                        });
-                    }); })];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var swapRepo, canceled, swap;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                        return [4 /*yield*/, this.fulfillmentService_
+                                                .withTransaction(manager)
+                                                .cancelFulfillment(fulfillmentId)];
+                                    case 1:
+                                        canceled = _a.sent();
+                                        if (!canceled.swap_id) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Fufillment not related to a swap");
+                                        }
+                                        return [4 /*yield*/, this.retrieve(canceled.swap_id)];
+                                    case 2:
+                                        swap = _a.sent();
+                                        swap.fulfillment_status = models_1.SwapFulfillmentStatus.CANCELED;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 3: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Marks a fulfillment as shipped and attaches tracking numbers.
-     * @param {string} swapId - the id of the swap that has been shipped.
-     * @param {string} fulfillmentId - the id of the specific fulfillment that
-     *   has been shipped
-     * @param {TrackingLink[] | undefined} trackingLinks - the tracking numbers associated
-     *   with the shipment
-     * @param {object} config - optional configurations, includes optional metadata to attach to the shipment, and a noNotification flag.
-     * @return {Promise<Swap>} the updated swap with new fulfillments and status.
+     *
+     * @param swapId - the id of the swap that has been shipped.
+     * @param fulfillmentId - the id of the specific fulfillment that has been shipped
+     * @param trackingLinks - the tracking numbers associated with the shipment
+     * @param config - optional configurations, includes optional metadata to attach to the shipment, and a noNotification flag.
+     * @return the updated swap with new fulfillments and status.
      */
     SwapService.prototype.createShipment = function (swapId, fulfillmentId, trackingLinks, config) {
         if (config === void 0) { config = {
@@ -1255,173 +1249,199 @@ var SwapService = /** @class */ (function (_super) {
             no_notification: undefined,
         }; }
         return __awaiter(this, void 0, void 0, function () {
-            var metadata, no_notification;
             var _this = this;
             return __generator(this, function (_a) {
-                metadata = config.metadata, no_notification = config.no_notification;
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var swap, evaluatedNoNotification, shipment, lineItemServiceTx, _loop_2, _a, _b, i, e_10_1, swapRepo, result;
-                        var e_10, _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(swapId, {
-                                        relations: ["additional_items"],
-                                    })];
-                                case 1:
-                                    swap = _d.sent();
-                                    if (swap.canceled_at) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be fulfilled as shipped");
-                                    }
-                                    evaluatedNoNotification = no_notification !== undefined ? no_notification : swap.no_notification;
-                                    return [4 /*yield*/, this.fulfillmentService_
-                                            .withTransaction(manager)
-                                            .createShipment(fulfillmentId, trackingLinks, {
-                                            metadata: metadata,
-                                            no_notification: evaluatedNoNotification,
-                                        })];
-                                case 2:
-                                    shipment = _d.sent();
-                                    swap.fulfillment_status = "shipped";
-                                    lineItemServiceTx = this.lineItemService_.withTransaction(manager);
-                                    _loop_2 = function (i) {
-                                        var shipped, shippedQty;
-                                        return __generator(this, function (_e) {
-                                            switch (_e.label) {
-                                                case 0:
-                                                    shipped = shipment.items.find(function (si) { return si.item_id === i.id; });
-                                                    if (!shipped) return [3 /*break*/, 2];
-                                                    shippedQty = (i.shipped_quantity || 0) + shipped.quantity;
-                                                    return [4 /*yield*/, lineItemServiceTx.update(i.id, {
-                                                            shipped_quantity: shippedQty,
-                                                        })];
-                                                case 1:
-                                                    _e.sent();
-                                                    if (shippedQty !== i.quantity) {
-                                                        swap.fulfillment_status = "partially_shipped";
-                                                    }
-                                                    return [3 /*break*/, 3];
-                                                case 2:
-                                                    if (i.shipped_quantity !== i.quantity) {
-                                                        swap.fulfillment_status = "partially_shipped";
-                                                    }
-                                                    _e.label = 3;
-                                                case 3: return [2 /*return*/];
-                                            }
-                                        });
-                                    };
-                                    _d.label = 3;
-                                case 3:
-                                    _d.trys.push([3, 8, 9, 10]);
-                                    _a = __values(swap.additional_items), _b = _a.next();
-                                    _d.label = 4;
-                                case 4:
-                                    if (!!_b.done) return [3 /*break*/, 7];
-                                    i = _b.value;
-                                    return [5 /*yield**/, _loop_2(i)];
-                                case 5:
-                                    _d.sent();
-                                    _d.label = 6;
-                                case 6:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 4];
-                                case 7: return [3 /*break*/, 10];
-                                case 8:
-                                    e_10_1 = _d.sent();
-                                    e_10 = { error: e_10_1 };
-                                    return [3 /*break*/, 10];
-                                case 9:
-                                    try {
-                                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                                    }
-                                    finally { if (e_10) throw e_10.error; }
-                                    return [7 /*endfinally*/];
-                                case 10:
-                                    swapRepo = manager.getCustomRepository(this.swapRepository_);
-                                    return [4 /*yield*/, swapRepo.save(swap)];
-                                case 11:
-                                    result = _d.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.SHIPMENT_CREATED, {
-                                            id: swapId,
-                                            fulfillment_id: shipment.id,
-                                            no_notification: swap.no_notification,
-                                        })];
-                                case 12:
-                                    _d.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var metadata, no_notification, swapRepo, swap, evaluatedNoNotification, shipment, lineItemServiceTx, _loop_2, _a, _b, i, e_10_1, result;
+                            var e_10, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        metadata = config.metadata, no_notification = config.no_notification;
+                                        swapRepo = manager.getCustomRepository(this.swapRepository_);
+                                        return [4 /*yield*/, this.retrieve(swapId, {
+                                                relations: ["additional_items"],
+                                            })];
+                                    case 1:
+                                        swap = _d.sent();
+                                        if (swap.canceled_at) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be fulfilled as shipped");
+                                        }
+                                        evaluatedNoNotification = no_notification !== undefined ? no_notification : swap.no_notification;
+                                        return [4 /*yield*/, this.fulfillmentService_
+                                                .withTransaction(manager)
+                                                .createShipment(fulfillmentId, trackingLinks, {
+                                                metadata: metadata,
+                                                no_notification: evaluatedNoNotification,
+                                            })];
+                                    case 2:
+                                        shipment = _d.sent();
+                                        swap.fulfillment_status = models_1.SwapFulfillmentStatus.SHIPPED;
+                                        lineItemServiceTx = this.lineItemService_.withTransaction(manager);
+                                        _loop_2 = function (i) {
+                                            var shipped, shippedQty;
+                                            return __generator(this, function (_e) {
+                                                switch (_e.label) {
+                                                    case 0:
+                                                        shipped = shipment.items.find(function (si) { return si.item_id === i.id; });
+                                                        if (!shipped) return [3 /*break*/, 2];
+                                                        shippedQty = (i.shipped_quantity || 0) + shipped.quantity;
+                                                        return [4 /*yield*/, lineItemServiceTx.update(i.id, {
+                                                                shipped_quantity: shippedQty,
+                                                            })];
+                                                    case 1:
+                                                        _e.sent();
+                                                        if (shippedQty !== i.quantity) {
+                                                            swap.fulfillment_status = models_1.SwapFulfillmentStatus.PARTIALLY_SHIPPED;
+                                                        }
+                                                        return [3 /*break*/, 3];
+                                                    case 2:
+                                                        if (i.shipped_quantity !== i.quantity) {
+                                                            swap.fulfillment_status = models_1.SwapFulfillmentStatus.PARTIALLY_SHIPPED;
+                                                        }
+                                                        _e.label = 3;
+                                                    case 3: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        _d.label = 3;
+                                    case 3:
+                                        _d.trys.push([3, 8, 9, 10]);
+                                        _a = __values(swap.additional_items), _b = _a.next();
+                                        _d.label = 4;
+                                    case 4:
+                                        if (!!_b.done) return [3 /*break*/, 7];
+                                        i = _b.value;
+                                        return [5 /*yield**/, _loop_2(i)];
+                                    case 5:
+                                        _d.sent();
+                                        _d.label = 6;
+                                    case 6:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 4];
+                                    case 7: return [3 /*break*/, 10];
+                                    case 8:
+                                        e_10_1 = _d.sent();
+                                        e_10 = { error: e_10_1 };
+                                        return [3 /*break*/, 10];
+                                    case 9:
+                                        try {
+                                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                        }
+                                        finally { if (e_10) throw e_10.error; }
+                                        return [7 /*endfinally*/];
+                                    case 10: return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 11:
+                                        result = _d.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(SwapService.Events.SHIPMENT_CREATED, {
+                                                id: swapId,
+                                                fulfillment_id: shipment.id,
+                                                no_notification: swap.no_notification,
+                                            })];
+                                    case 12:
+                                        _d.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Dedicated method to delete metadata for a swap.
-     * @param {string} swapId - the order to delete metadata from.
-     * @param {string} key - key for metadata field
-     * @return {Promise} resolves to the updated result.
+     *
+     * @param swapId - the order to delete metadata from.
+     * @param key - key for metadata field
+     * @return resolves to the updated result.
      */
     SwapService.prototype.deleteMetadata = function (swapId, key) {
         return __awaiter(this, void 0, void 0, function () {
-            var validatedId, keyPath;
-            var _a;
-            return __generator(this, function (_b) {
-                validatedId = this.validateId_(swapId);
-                if (typeof key !== "string") {
-                    throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_ARGUMENT, "Key type is invalid. Metadata keys must be strings");
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (transactionManager) { return __awaiter(_this, void 0, void 0, function () {
+                            var validatedId, swapRepo, swap, updated, updatedSwap;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        validatedId = (0, utils_1.validateId)(swapId);
+                                        swapRepo = transactionManager.getCustomRepository(this.swapRepository_);
+                                        return [4 /*yield*/, swapRepo.findOne(validatedId)];
+                                    case 1:
+                                        swap = _a.sent();
+                                        if (!swap) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Swap with id: ".concat(validatedId, " was not found"));
+                                        }
+                                        updated = swap.metadata || {};
+                                        delete updated[key];
+                                        swap.metadata = updated;
+                                        return [4 /*yield*/, swapRepo.save(swap)];
+                                    case 2:
+                                        updatedSwap = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(transactionManager)
+                                                .emit(cart_1.default.Events.UPDATED, updatedSwap)];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/, updatedSwap];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
-                keyPath = "metadata.".concat(key);
-                return [2 /*return*/, this.swapModel_
-                        .updateOne({ _id: validatedId }, { $unset: (_a = {}, _a[keyPath] = "", _a) })
-                        .catch(function (err) {
-                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DB_ERROR, err.message);
-                    })];
             });
         });
     };
     /**
      * Registers the swap return items as received so that they cannot be used
      * as a part of other swaps/returns.
-     * @param {string} id - the id of the order with the swap.
-     * @param {string} swapId - the id of the swap that has been received.
-     * @return {Promise<Order>} the resulting order
+     *
+     * @param id - the id of the order with the swap.
+     * @return the resulting order
      */
     SwapService.prototype.registerReceived = function (id) {
         return __awaiter(this, void 0, void 0, function () {
             var _this = this;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var swap, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(id, {
-                                        relations: ["return_order", "return_order.items"],
-                                    })];
-                                case 1:
-                                    swap = _a.sent();
-                                    if (swap.canceled_at) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be registered as received");
-                                    }
-                                    if (swap.return_order.status !== "received") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Swap is not received");
-                                    }
-                                    return [4 /*yield*/, this.retrieve(id)];
-                                case 2:
-                                    result = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(SwapService.Events.RECEIVED, {
-                                            id: id,
-                                            order_id: result.order_id,
-                                            no_notification: swap.no_notification,
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var swap, result;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(id, {
+                                            relations: ["return_order", "return_order.items"],
                                         })];
-                                case 3:
-                                    _a.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                    case 1:
+                                        swap = _a.sent();
+                                        if (swap.canceled_at) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Canceled swap cannot be registered as received");
+                                        }
+                                        if (swap.return_order.status !== "received") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Swap is not received");
+                                        }
+                                        return [4 /*yield*/, this.retrieve(id)];
+                                    case 2:
+                                        result = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(SwapService.Events.RECEIVED, {
+                                                id: id,
+                                                order_id: result.order_id,
+                                                no_notification: swap.no_notification,
+                                            })];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
@@ -1437,6 +1457,6 @@ var SwapService = /** @class */ (function (_super) {
         FULFILLMENT_CREATED: "swap.fulfillment_created",
     };
     return SwapService;
-}(medusa_interfaces_1.BaseService));
+}(interfaces_1.TransactionBaseService));
 exports.default = SwapService;
 //# sourceMappingURL=swap.js.map