@medusajs/medusa 1.3.3 → 1.3.6-next.0

package/dist/services/order.js

@@ -110,94 +110,48 @@ var __values = (this && this.__values) || function(o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var medusa_core_utils_1 = require("medusa-core-utils");
-var medusa_interfaces_1 = require("medusa-interfaces");
 var typeorm_1 = require("typeorm");
+var interfaces_1 = require("../interfaces");
+var models_1 = require("../models");
+var utils_1 = require("../utils");
 var OrderService = /** @class */ (function (_super) {
     __extends(OrderService, _super);
     function OrderService(_a) {
         var manager = _a.manager, orderRepository = _a.orderRepository, customerService = _a.customerService, paymentProviderService = _a.paymentProviderService, shippingOptionService = _a.shippingOptionService, shippingProfileService = _a.shippingProfileService, discountService = _a.discountService, fulfillmentProviderService = _a.fulfillmentProviderService, fulfillmentService = _a.fulfillmentService, lineItemService = _a.lineItemService, totalsService = _a.totalsService, regionService = _a.regionService, cartService = _a.cartService, addressRepository = _a.addressRepository, giftCardService = _a.giftCardService, draftOrderService = _a.draftOrderService, inventoryService = _a.inventoryService, eventBusService = _a.eventBusService;
-        var _this = _super.call(this) || this;
-        /** @private @constant {EntityManager} */
+        var _this = 
+        // eslint-disable-next-line prefer-rest-params
+        _super.call(this, arguments[0]) || this;
         _this.manager_ = manager;
-        /** @private @constant {OrderRepository} */
         _this.orderRepository_ = orderRepository;
-        /** @private @constant {CustomerService} */
         _this.customerService_ = customerService;
-        /** @private @constant {PaymentProviderService} */
         _this.paymentProviderService_ = paymentProviderService;
-        /** @private @constant {ShippingProvileService} */
         _this.shippingProfileService_ = shippingProfileService;
-        /** @private @constant {FulfillmentProviderService} */
         _this.fulfillmentProviderService_ = fulfillmentProviderService;
-        /** @private @constant {LineItemService} */
         _this.lineItemService_ = lineItemService;
-        /** @private @constant {TotalsService} */
         _this.totalsService_ = totalsService;
-        /** @private @constant {RegionService} */
         _this.regionService_ = regionService;
-        /** @private @constant {FulfillmentService} */
         _this.fulfillmentService_ = fulfillmentService;
-        /** @private @constant {DiscountService} */
         _this.discountService_ = discountService;
-        /** @private @constant {DiscountService} */
         _this.giftCardService_ = giftCardService;
-        /** @private @constant {EventBus} */
         _this.eventBus_ = eventBusService;
-        /** @private @constant {ShippingOptionService} */
         _this.shippingOptionService_ = shippingOptionService;
-        /** @private @constant {CartService} */
         _this.cartService_ = cartService;
-        /** @private @constant {AddressRepository} */
         _this.addressRepository_ = addressRepository;
-        /** @private @constant {DraftOrderService} */
         _this.draftOrderService_ = draftOrderService;
-        /** @private @constant {InventoryService} */
         _this.inventoryService_ = inventoryService;
         return _this;
     }
-    OrderService.prototype.withTransaction = function (manager) {
-        if (!manager) {
-            return this;
-        }
-        var cloned = new OrderService({
-            manager: manager,
-            orderRepository: this.orderRepository_,
-            eventBusService: this.eventBus_,
-            paymentProviderService: this.paymentProviderService_,
-            regionService: this.regionService_,
-            lineItemService: this.lineItemService_,
-            shippingOptionService: this.shippingOptionService_,
-            shippingProfileService: this.shippingProfileService_,
-            fulfillmentProviderService: this.fulfillmentProviderService_,
-            fulfillmentService: this.fulfillmentService_,
-            customerService: this.customerService_,
-            discountService: this.discountService_,
-            totalsService: this.totalsService_,
-            cartService: this.cartService_,
-            giftCardService: this.giftCardService_,
-            addressRepository: this.addressRepository_,
-            draftOrderService: this.draftOrderService_,
-            inventoryService: this.inventoryService_,
-        });
-        cloned.transactionManager_ = manager;
-        cloned.manager_ = manager;
-        return cloned;
-    };
     /**
-     * Used to validate order ids. Throws an error if the cast fails
-     * @param {string} rawId - the raw order id to validate.
-     * @return {string} the validated id
-     */
-    OrderService.prototype.validateId_ = function (rawId) {
-        return rawId;
-    };
-    /**
-     * @param {Object} selector - the query object for find
-     * @param {Object} config - the config to be used for find
-     * @return {Promise} the result of the find operation
+     * @param selector the query object for find
+     * @param config the config to be used for find
+     * @return the result of the find operation
      */
     OrderService.prototype.list = function (selector, config) {
-        if (config === void 0) { config = { skip: 0, take: 50, order: { created_at: "DESC" } }; }
+        if (config === void 0) { config = {
+            skip: 0,
+            take: 50,
+            order: { created_at: "DESC" },
+        }; }
         return __awaiter(this, void 0, void 0, function () {
             var orderRepo, query, _a, select, relations, totalsToSelect, raw;
             var _this = this;
@@ -205,8 +159,8 @@ var OrderService = /** @class */ (function (_super) {
                 switch (_b.label) {
                     case 0:
                         orderRepo = this.manager_.getCustomRepository(this.orderRepository_);
-                        query = this.buildQuery_(selector, config);
-                        _a = this.transformQueryForTotals_(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
+                        query = (0, utils_1.buildQuery)(selector, config);
+                        _a = this.transformQueryForTotals(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
                         if (select && select.length) {
                             query.select = select;
                         }
@@ -218,7 +172,7 @@ var OrderService = /** @class */ (function (_super) {
                         raw = _b.sent();
                         return [4 /*yield*/, Promise.all(raw.map(function (r) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, this.decorateTotals_(r, totalsToSelect)];
+                                    case 0: return [4 /*yield*/, this.decorateTotals(r, totalsToSelect)];
                                     case 1: return [2 /*return*/, _a.sent()];
                                 }
                             }); }); }))];
@@ -228,7 +182,11 @@ var OrderService = /** @class */ (function (_super) {
         });
     };
     OrderService.prototype.listAndCount = function (selector, config) {
-        if (config === void 0) { config = { skip: 0, take: 50, order: { created_at: "DESC" } }; }
+        if (config === void 0) { config = {
+            skip: 0,
+            take: 50,
+            order: { created_at: "DESC" },
+        }; }
         return __awaiter(this, void 0, void 0, function () {
             var orderRepo, q, query, where_1, _a, select, relations, totalsToSelect, rels, raw, count, orders;
             var _this = this;
@@ -240,7 +198,7 @@ var OrderService = /** @class */ (function (_super) {
                             q = selector.q;
                             delete selector.q;
                         }
-                        query = this.buildQuery_(selector, config);
+                        query = (0, utils_1.buildQuery)(selector, config);
                         if (q) {
                             where_1 = query.where;
                             delete where_1.display_id;
@@ -262,7 +220,7 @@ var OrderService = /** @class */ (function (_super) {
                                 }));
                             };
                         }
-                        _a = this.transformQueryForTotals_(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
+                        _a = this.transformQueryForTotals(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
                         if (select && select.length) {
                             query.select = select;
                         }
@@ -276,7 +234,7 @@ var OrderService = /** @class */ (function (_super) {
                         count = _b.sent();
                         return [4 /*yield*/, Promise.all(raw.map(function (r) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                                 switch (_a.label) {
-                                    case 0: return [4 /*yield*/, this.decorateTotals_(r, totalsToSelect)];
+                                    case 0: return [4 /*yield*/, this.decorateTotals(r, totalsToSelect)];
                                     case 1: return [2 /*return*/, _a.sent()];
                                 }
                             }); }); }))];
@@ -287,7 +245,7 @@ var OrderService = /** @class */ (function (_super) {
             });
         });
     };
-    OrderService.prototype.transformQueryForTotals_ = function (config) {
+    OrderService.prototype.transformQueryForTotals = function (config) {
         var select = config.select, relations = config.relations;
         if (!select) {
             return {
@@ -347,22 +305,21 @@ var OrderService = /** @class */ (function (_super) {
     };
     /**
      * Gets an order by id.
-     * @param {string} orderId - id of order to retrieve
-     * @param {Object} config - config of order to retrieve
-     * @return {Promise<Order>} the order document
+     * @param orderId - id of order to retrieve
+     * @param config - config of order to retrieve
+     * @return the order document
      */
     OrderService.prototype.retrieve = function (orderId, config) {
         if (config === void 0) { config = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var orderRepo, validatedId, _a, select, relations, totalsToSelect, query, rels, raw;
+            var orderRepo, _a, select, relations, totalsToSelect, query, rels, raw;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         orderRepo = this.manager_.getCustomRepository(this.orderRepository_);
-                        validatedId = this.validateId_(orderId);
-                        _a = this.transformQueryForTotals_(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
+                        _a = this.transformQueryForTotals(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
                         query = {
-                            where: { id: validatedId },
+                            where: { id: orderId },
                         };
                         if (relations && relations.length > 0) {
                             query.relations = relations;
@@ -378,7 +335,7 @@ var OrderService = /** @class */ (function (_super) {
                         if (!raw) {
                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Order with ".concat(orderId, " was not found"));
                         }
-                        return [4 /*yield*/, this.decorateTotals_(raw, totalsToSelect)];
+                        return [4 /*yield*/, this.decorateTotals(raw, totalsToSelect)];
                     case 2: return [2 /*return*/, _b.sent()];
                 }
             });
@@ -386,19 +343,19 @@ var OrderService = /** @class */ (function (_super) {
     };
     /**
      * Gets an order by cart id.
-     * @param {string} cartId - cart id to find order
-     * @param {Object} config - the config to be used to find order
-     * @return {Promise<Order>} the order document
+     * @param cartId - cart id to find order
+     * @param config - the config to be used to find order
+     * @return the order document
      */
     OrderService.prototype.retrieveByCartId = function (cartId, config) {
         if (config === void 0) { config = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var orderRepo, _a, select, relations, totalsToSelect, query, raw, order;
+            var orderRepo, _a, select, relations, totalsToSelect, query, raw;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         orderRepo = this.manager_.getCustomRepository(this.orderRepository_);
-                        _a = this.transformQueryForTotals_(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
+                        _a = this.transformQueryForTotals(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
                         query = {
                             where: { cart_id: cartId },
                         };
@@ -414,29 +371,27 @@ var OrderService = /** @class */ (function (_super) {
                         if (!raw) {
                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Order with cart id: ".concat(cartId, " was not found"));
                         }
-                        return [4 /*yield*/, this.decorateTotals_(raw, totalsToSelect)];
-                    case 2:
-                        order = _b.sent();
-                        return [2 /*return*/, order];
+                        return [4 /*yield*/, this.decorateTotals(raw, totalsToSelect)];
+                    case 2: return [2 /*return*/, _b.sent()];
                 }
             });
         });
     };
     /**
      * Gets an order by id.
-     * @param {string} externalId - id of order to retrieve
-     * @param {object} config - query config to get order by
-     * @return {Promise<Order>} the order document
+     * @param externalId - id of order to retrieve
+     * @param config - query config to get order by
+     * @return the order document
      */
     OrderService.prototype.retrieveByExternalId = function (externalId, config) {
         if (config === void 0) { config = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var orderRepo, _a, select, relations, totalsToSelect, query, rels, raw, order;
+            var orderRepo, _a, select, relations, totalsToSelect, query, rels, raw;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         orderRepo = this.manager_.getCustomRepository(this.orderRepository_);
-                        _a = this.transformQueryForTotals_(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
+                        _a = this.transformQueryForTotals(config), select = _a.select, relations = _a.relations, totalsToSelect = _a.totalsToSelect;
                         query = {
                             where: { external_id: externalId },
                         };
@@ -454,355 +409,348 @@ var OrderService = /** @class */ (function (_super) {
                         if (!raw) {
                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Order with external id ".concat(externalId, " was not found"));
                         }
-                        return [4 /*yield*/, this.decorateTotals_(raw, totalsToSelect)];
-                    case 2:
-                        order = _b.sent();
-                        return [2 /*return*/, order];
+                        return [4 /*yield*/, this.decorateTotals(raw, totalsToSelect)];
+                    case 2: return [2 /*return*/, _b.sent()];
                 }
             });
         });
     };
     /**
      * Checks the existence of an order by cart id.
-     * @param {string} cartId - cart id to find order
-     * @return {Promise<Order>} the order document
+     * @param cartId - cart id to find order
+     * @return the order document
      */
     OrderService.prototype.existsByCartId = function (cartId) {
         return __awaiter(this, void 0, void 0, function () {
             var order;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.retrieveByCartId(cartId).catch(function (_) { return undefined; })];
+                    case 0: return [4 /*yield*/, this.retrieveByCartId(cartId).catch(function () { return undefined; })];
                     case 1:
                         order = _a.sent();
-                        if (!order) {
-                            return [2 /*return*/, false];
-                        }
-                        return [2 /*return*/, true];
+                        return [2 /*return*/, !!order];
                 }
             });
         });
     };
     /**
-     * @param {string} orderId - id of the order to complete
-     * @return {Promise} the result of the find operation
+     * @param orderId - id of the order to complete
+     * @return the result of the find operation
      */
     OrderService.prototype.completeOrder = function (orderId) {
         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 order, completeOrderJob, orderRepo;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId)];
-                                case 1:
-                                    order = _a.sent();
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be completed");
-                                    }
-                                    return [4 /*yield*/, this.eventBus_.emit(OrderService.Events.COMPLETED, {
-                                            id: orderId,
-                                            no_notification: order.no_notification,
-                                        })];
-                                case 2:
-                                    completeOrderJob = _a.sent();
-                                    return [4 /*yield*/, completeOrderJob.finished().catch(function (error) {
-                                            throw error;
-                                        })];
-                                case 3:
-                                    _a.sent();
-                                    order.status = "completed";
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    return [2 /*return*/, orderRepo.save(order)];
-                            }
-                        });
-                    }); })];
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var order, orderRepo;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(orderId)];
+                                    case 1:
+                                        order = _a.sent();
+                                        if (order.status === "canceled") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be completed");
+                                        }
+                                        return [4 /*yield*/, this.eventBus_.emit(OrderService.Events.COMPLETED, {
+                                                id: orderId,
+                                                no_notification: order.no_notification,
+                                            })];
+                                    case 2:
+                                        _a.sent();
+                                        order.status = models_1.OrderStatus.COMPLETED;
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        return [2 /*return*/, orderRepo.save(order)];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Creates an order from a cart
-     * @param {string} cartId - id of the cart to create an order from
-     * @return {Promise} resolves to the creation result.
+     * @param cartId - id of the cart to create an order from
+     * @return resolves to the creation result.
      */
     OrderService.prototype.createFromCart = function (cartId) {
         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 cart, payment, region, total, _a, _b, item, err_1, e_1_1, exists, paymentStatus, orderRepo, toCreate, draft, o, result, gcBalance, _c, _d, g, newBalance, usage, e_2_1, _e, _f, method, e_3_1, _g, _h, item, e_4_1, _j, _k, item, e_5_1;
-                        var e_1, _l, e_2, _m, e_3, _o, e_4, _p, e_5, _q;
-                        return __generator(this, function (_r) {
-                            switch (_r.label) {
-                                case 0: return [4 /*yield*/, this.cartService_
-                                        .withTransaction(manager)
-                                        .retrieve(cartId, {
-                                        select: ["subtotal", "total"],
-                                        relations: [
-                                            "region",
-                                            "payment",
-                                            "items",
-                                            "discounts",
-                                            "discounts.rule",
-                                            "gift_cards",
-                                            "shipping_methods",
-                                        ],
-                                    })];
-                                case 1:
-                                    cart = _r.sent();
-                                    if (cart.items.length === 0) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Cannot create order from empty cart");
-                                    }
-                                    payment = cart.payment, region = cart.region, total = cart.total;
-                                    _r.label = 2;
-                                case 2:
-                                    _r.trys.push([2, 12, 13, 14]);
-                                    _a = __values(cart.items), _b = _a.next();
-                                    _r.label = 3;
-                                case 3:
-                                    if (!!_b.done) return [3 /*break*/, 11];
-                                    item = _b.value;
-                                    _r.label = 4;
-                                case 4:
-                                    _r.trys.push([4, 6, , 10]);
-                                    return [4 /*yield*/, this.inventoryService_
-                                            .withTransaction(manager)
-                                            .confirmInventory(item.variant_id, item.quantity)];
-                                case 5:
-                                    _r.sent();
-                                    return [3 /*break*/, 10];
-                                case 6:
-                                    err_1 = _r.sent();
-                                    if (!payment) return [3 /*break*/, 8];
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .cancelPayment(payment)];
-                                case 7:
-                                    _r.sent();
-                                    _r.label = 8;
-                                case 8: return [4 /*yield*/, this.cartService_
-                                        .withTransaction(manager)
-                                        .update(cart.id, { payment_authorized_at: null })];
-                                case 9:
-                                    _r.sent();
-                                    throw err_1;
-                                case 10:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 3];
-                                case 11: return [3 /*break*/, 14];
-                                case 12:
-                                    e_1_1 = _r.sent();
-                                    e_1 = { error: e_1_1 };
-                                    return [3 /*break*/, 14];
-                                case 13:
-                                    try {
-                                        if (_b && !_b.done && (_l = _a.return)) _l.call(_a);
-                                    }
-                                    finally { if (e_1) throw e_1.error; }
-                                    return [7 /*endfinally*/];
-                                case 14: return [4 /*yield*/, this.existsByCartId(cart.id)];
-                                case 15:
-                                    exists = _r.sent();
-                                    if (exists) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DUPLICATE_ERROR, "Order from cart already exists");
-                                    }
-                                    if (!(total !== 0)) return [3 /*break*/, 17];
-                                    // Throw if payment method does not exist
-                                    if (!payment) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_ARGUMENT, "Cart does not contain a payment method");
-                                    }
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .getStatus(payment)
-                                        // If payment status is not authorized, we throw
-                                    ];
-                                case 16:
-                                    paymentStatus = _r.sent();
-                                    // If payment status is not authorized, we throw
-                                    if (paymentStatus !== "authorized" && paymentStatus !== "succeeded") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_ARGUMENT, "Payment method is not authorized");
-                                    }
-                                    _r.label = 17;
-                                case 17:
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    toCreate = {
-                                        payment_status: "awaiting",
-                                        discounts: cart.discounts,
-                                        gift_cards: cart.gift_cards,
-                                        shipping_methods: cart.shipping_methods,
-                                        shipping_address_id: cart.shipping_address_id,
-                                        billing_address_id: cart.billing_address_id,
-                                        region_id: cart.region_id,
-                                        email: cart.email,
-                                        customer_id: cart.customer_id,
-                                        cart_id: cart.id,
-                                        currency_code: region.currency_code,
-                                        metadata: cart.metadata || {},
-                                    };
-                                    if (!(cart.type === "draft_order")) return [3 /*break*/, 19];
-                                    return [4 /*yield*/, this.draftOrderService_
-                                            .withTransaction(manager)
-                                            .retrieveByCartId(cart.id)];
-                                case 18:
-                                    draft = _r.sent();
-                                    toCreate.draft_order_id = draft.id;
-                                    toCreate.no_notification = draft.no_notification_order;
-                                    _r.label = 19;
-                                case 19: return [4 /*yield*/, orderRepo.create(toCreate)];
-                                case 20:
-                                    o = _r.sent();
-                                    return [4 /*yield*/, orderRepo.save(o)];
-                                case 21:
-                                    result = _r.sent();
-                                    if (!(total !== 0)) return [3 /*break*/, 23];
-                                    return [4 /*yield*/, this.paymentProviderService_
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var cartServiceTx, inventoryServiceTx, cart, payment, region, total, _a, _b, item, err_1, e_1_1, exists, paymentStatus, orderRepo, toCreate, draft, o, result, gcBalance, gcService, _c, _d, g, newBalance, usage, e_2_1, _e, _f, method, e_3_1, lineItemServiceTx, _g, _h, item, e_4_1, _j, _k, item, e_5_1;
+                            var e_1, _l, e_2, _m, e_3, _o, e_4, _p, e_5, _q;
+                            return __generator(this, function (_r) {
+                                switch (_r.label) {
+                                    case 0:
+                                        cartServiceTx = this.cartService_.withTransaction(manager);
+                                        inventoryServiceTx = this.inventoryService_.withTransaction(manager);
+                                        return [4 /*yield*/, cartServiceTx.retrieve(cartId, {
+                                                select: ["subtotal", "total"],
+                                                relations: [
+                                                    "region",
+                                                    "payment",
+                                                    "items",
+                                                    "discounts",
+                                                    "discounts.rule",
+                                                    "gift_cards",
+                                                    "shipping_methods",
+                                                    "items",
+                                                    "items.adjustments",
+                                                ],
+                                            })];
+                                    case 1:
+                                        cart = _r.sent();
+                                        if (cart.items.length === 0) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Cannot create order from empty cart");
+                                        }
+                                        payment = cart.payment, region = cart.region, total = cart.total;
+                                        _r.label = 2;
+                                    case 2:
+                                        _r.trys.push([2, 12, 13, 14]);
+                                        _a = __values(cart.items), _b = _a.next();
+                                        _r.label = 3;
+                                    case 3:
+                                        if (!!_b.done) return [3 /*break*/, 11];
+                                        item = _b.value;
+                                        _r.label = 4;
+                                    case 4:
+                                        _r.trys.push([4, 6, , 10]);
+                                        return [4 /*yield*/, inventoryServiceTx.confirmInventory(item.variant_id, item.quantity)];
+                                    case 5:
+                                        _r.sent();
+                                        return [3 /*break*/, 10];
+                                    case 6:
+                                        err_1 = _r.sent();
+                                        if (!payment) return [3 /*break*/, 8];
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .cancelPayment(payment)];
+                                    case 7:
+                                        _r.sent();
+                                        _r.label = 8;
+                                    case 8: return [4 /*yield*/, cartServiceTx.update(cart.id, { payment_authorized_at: null })];
+                                    case 9:
+                                        _r.sent();
+                                        throw err_1;
+                                    case 10:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 3];
+                                    case 11: return [3 /*break*/, 14];
+                                    case 12:
+                                        e_1_1 = _r.sent();
+                                        e_1 = { error: e_1_1 };
+                                        return [3 /*break*/, 14];
+                                    case 13:
+                                        try {
+                                            if (_b && !_b.done && (_l = _a.return)) _l.call(_a);
+                                        }
+                                        finally { if (e_1) throw e_1.error; }
+                                        return [7 /*endfinally*/];
+                                    case 14: return [4 /*yield*/, this.existsByCartId(cart.id)];
+                                    case 15:
+                                        exists = _r.sent();
+                                        if (exists) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.DUPLICATE_ERROR, "Order from cart already exists");
+                                        }
+                                        if (!(total !== 0)) return [3 /*break*/, 17];
+                                        if (!payment) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_ARGUMENT, "Cart does not contain a payment method");
+                                        }
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .getStatus(payment)];
+                                    case 16:
+                                        paymentStatus = _r.sent();
+                                        if (paymentStatus !== "authorized") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_ARGUMENT, "Payment method is not authorized");
+                                        }
+                                        _r.label = 17;
+                                    case 17:
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        toCreate = {
+                                            payment_status: "awaiting",
+                                            discounts: cart.discounts,
+                                            gift_cards: cart.gift_cards,
+                                            shipping_methods: cart.shipping_methods,
+                                            shipping_address_id: cart.shipping_address_id,
+                                            billing_address_id: cart.billing_address_id,
+                                            region_id: cart.region_id,
+                                            email: cart.email,
+                                            customer_id: cart.customer_id,
+                                            cart_id: cart.id,
+                                            currency_code: region.currency_code,
+                                            metadata: cart.metadata || {},
+                                        };
+                                        if (!(cart.type === "draft_order")) return [3 /*break*/, 19];
+                                        return [4 /*yield*/, this.draftOrderService_
+                                                .withTransaction(manager)
+                                                .retrieveByCartId(cart.id)];
+                                    case 18:
+                                        draft = _r.sent();
+                                        toCreate.draft_order_id = draft.id;
+                                        toCreate.no_notification = draft.no_notification_order;
+                                        _r.label = 19;
+                                    case 19:
+                                        o = orderRepo.create(toCreate);
+                                        return [4 /*yield*/, orderRepo.save(o)];
+                                    case 20:
+                                        result = _r.sent();
+                                        if (!(total !== 0 && payment)) return [3 /*break*/, 22];
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .updatePayment(payment.id, {
+                                                order_id: result.id,
+                                            })];
+                                    case 21:
+                                        _r.sent();
+                                        _r.label = 22;
+                                    case 22: return [4 /*yield*/, this.totalsService_.getGiftCardableAmount(cart)];
+                                    case 23:
+                                        gcBalance = _r.sent();
+                                        gcService = this.giftCardService_.withTransaction(manager);
+                                        _r.label = 24;
+                                    case 24:
+                                        _r.trys.push([24, 30, 31, 32]);
+                                        _c = __values(cart.gift_cards), _d = _c.next();
+                                        _r.label = 25;
+                                    case 25:
+                                        if (!!_d.done) return [3 /*break*/, 29];
+                                        g = _d.value;
+                                        newBalance = Math.max(0, g.balance - gcBalance);
+                                        usage = g.balance - newBalance;
+                                        return [4 /*yield*/, gcService.update(g.id, {
+                                                balance: newBalance,
+                                                is_disabled: newBalance === 0,
+                                            })];
+                                    case 26:
+                                        _r.sent();
+                                        return [4 /*yield*/, gcService.createTransaction({
+                                                gift_card_id: g.id,
+                                                order_id: result.id,
+                                                amount: usage,
+                                                is_taxable: cart.region.gift_cards_taxable,
+                                                tax_rate: cart.region.gift_cards_taxable
+                                                    ? cart.region.tax_rate
+                                                    : null,
+                                            })];
+                                    case 27:
+                                        _r.sent();
+                                        gcBalance = gcBalance - usage;
+                                        _r.label = 28;
+                                    case 28:
+                                        _d = _c.next();
+                                        return [3 /*break*/, 25];
+                                    case 29: return [3 /*break*/, 32];
+                                    case 30:
+                                        e_2_1 = _r.sent();
+                                        e_2 = { error: e_2_1 };
+                                        return [3 /*break*/, 32];
+                                    case 31:
+                                        try {
+                                            if (_d && !_d.done && (_m = _c.return)) _m.call(_c);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                        return [7 /*endfinally*/];
+                                    case 32:
+                                        _r.trys.push([32, 37, 38, 39]);
+                                        _e = __values(cart.shipping_methods), _f = _e.next();
+                                        _r.label = 33;
+                                    case 33:
+                                        if (!!_f.done) return [3 /*break*/, 36];
+                                        method = _f.value;
+                                        return [4 /*yield*/, this.shippingOptionService_
+                                                .withTransaction(manager)
+                                                .updateShippingMethod(method.id, { order_id: result.id })];
+                                    case 34:
+                                        _r.sent();
+                                        _r.label = 35;
+                                    case 35:
+                                        _f = _e.next();
+                                        return [3 /*break*/, 33];
+                                    case 36: return [3 /*break*/, 39];
+                                    case 37:
+                                        e_3_1 = _r.sent();
+                                        e_3 = { error: e_3_1 };
+                                        return [3 /*break*/, 39];
+                                    case 38:
+                                        try {
+                                            if (_f && !_f.done && (_o = _e.return)) _o.call(_e);
+                                        }
+                                        finally { if (e_3) throw e_3.error; }
+                                        return [7 /*endfinally*/];
+                                    case 39:
+                                        lineItemServiceTx = this.lineItemService_.withTransaction(manager);
+                                        _r.label = 40;
+                                    case 40:
+                                        _r.trys.push([40, 45, 46, 47]);
+                                        _g = __values(cart.items), _h = _g.next();
+                                        _r.label = 41;
+                                    case 41:
+                                        if (!!_h.done) return [3 /*break*/, 44];
+                                        item = _h.value;
+                                        return [4 /*yield*/, lineItemServiceTx.update(item.id, { order_id: result.id })];
+                                    case 42:
+                                        _r.sent();
+                                        _r.label = 43;
+                                    case 43:
+                                        _h = _g.next();
+                                        return [3 /*break*/, 41];
+                                    case 44: return [3 /*break*/, 47];
+                                    case 45:
+                                        e_4_1 = _r.sent();
+                                        e_4 = { error: e_4_1 };
+                                        return [3 /*break*/, 47];
+                                    case 46:
+                                        try {
+                                            if (_h && !_h.done && (_p = _g.return)) _p.call(_g);
+                                        }
+                                        finally { if (e_4) throw e_4.error; }
+                                        return [7 /*endfinally*/];
+                                    case 47:
+                                        _r.trys.push([47, 52, 53, 54]);
+                                        _j = __values(cart.items), _k = _j.next();
+                                        _r.label = 48;
+                                    case 48:
+                                        if (!!_k.done) return [3 /*break*/, 51];
+                                        item = _k.value;
+                                        return [4 /*yield*/, inventoryServiceTx.adjustInventory(item.variant_id, -item.quantity)];
+                                    case 49:
+                                        _r.sent();
+                                        _r.label = 50;
+                                    case 50:
+                                        _k = _j.next();
+                                        return [3 /*break*/, 48];
+                                    case 51: return [3 /*break*/, 54];
+                                    case 52:
+                                        e_5_1 = _r.sent();
+                                        e_5 = { error: e_5_1 };
+                                        return [3 /*break*/, 54];
+                                    case 53:
+                                        try {
+                                            if (_k && !_k.done && (_q = _j.return)) _q.call(_j);
+                                        }
+                                        finally { if (e_5) throw e_5.error; }
+                                        return [7 /*endfinally*/];
+                                    case 54: return [4 /*yield*/, this.eventBus_
                                             .withTransaction(manager)
-                                            .updatePayment(payment.id, {
-                                            order_id: result.id,
-                                        })];
-                                case 22:
-                                    _r.sent();
-                                    _r.label = 23;
-                                case 23:
-                                    gcBalance = cart.subtotal;
-                                    _r.label = 24;
-                                case 24:
-                                    _r.trys.push([24, 30, 31, 32]);
-                                    _c = __values(cart.gift_cards), _d = _c.next();
-                                    _r.label = 25;
-                                case 25:
-                                    if (!!_d.done) return [3 /*break*/, 29];
-                                    g = _d.value;
-                                    newBalance = Math.max(0, g.balance - gcBalance);
-                                    usage = g.balance - newBalance;
-                                    return [4 /*yield*/, this.giftCardService_.withTransaction(manager).update(g.id, {
-                                            balance: newBalance,
-                                            disabled: newBalance === 0,
-                                        })];
-                                case 26:
-                                    _r.sent();
-                                    return [4 /*yield*/, this.giftCardService_.withTransaction(manager).createTransaction({
-                                            gift_card_id: g.id,
-                                            order_id: result.id,
-                                            amount: usage,
+                                            .emit(OrderService.Events.PLACED, {
+                                            id: result.id,
+                                            no_notification: result.no_notification,
                                         })];
-                                case 27:
-                                    _r.sent();
-                                    gcBalance = gcBalance - usage;
-                                    _r.label = 28;
-                                case 28:
-                                    _d = _c.next();
-                                    return [3 /*break*/, 25];
-                                case 29: return [3 /*break*/, 32];
-                                case 30:
-                                    e_2_1 = _r.sent();
-                                    e_2 = { error: e_2_1 };
-                                    return [3 /*break*/, 32];
-                                case 31:
-                                    try {
-                                        if (_d && !_d.done && (_m = _c.return)) _m.call(_c);
-                                    }
-                                    finally { if (e_2) throw e_2.error; }
-                                    return [7 /*endfinally*/];
-                                case 32:
-                                    _r.trys.push([32, 37, 38, 39]);
-                                    _e = __values(cart.shipping_methods), _f = _e.next();
-                                    _r.label = 33;
-                                case 33:
-                                    if (!!_f.done) return [3 /*break*/, 36];
-                                    method = _f.value;
-                                    return [4 /*yield*/, this.shippingOptionService_
-                                            .withTransaction(manager)
-                                            .updateShippingMethod(method.id, { order_id: result.id })];
-                                case 34:
-                                    _r.sent();
-                                    _r.label = 35;
-                                case 35:
-                                    _f = _e.next();
-                                    return [3 /*break*/, 33];
-                                case 36: return [3 /*break*/, 39];
-                                case 37:
-                                    e_3_1 = _r.sent();
-                                    e_3 = { error: e_3_1 };
-                                    return [3 /*break*/, 39];
-                                case 38:
-                                    try {
-                                        if (_f && !_f.done && (_o = _e.return)) _o.call(_e);
-                                    }
-                                    finally { if (e_3) throw e_3.error; }
-                                    return [7 /*endfinally*/];
-                                case 39:
-                                    _r.trys.push([39, 44, 45, 46]);
-                                    _g = __values(cart.items), _h = _g.next();
-                                    _r.label = 40;
-                                case 40:
-                                    if (!!_h.done) return [3 /*break*/, 43];
-                                    item = _h.value;
-                                    return [4 /*yield*/, this.lineItemService_
-                                            .withTransaction(manager)
-                                            .update(item.id, { order_id: result.id })];
-                                case 41:
-                                    _r.sent();
-                                    _r.label = 42;
-                                case 42:
-                                    _h = _g.next();
-                                    return [3 /*break*/, 40];
-                                case 43: return [3 /*break*/, 46];
-                                case 44:
-                                    e_4_1 = _r.sent();
-                                    e_4 = { error: e_4_1 };
-                                    return [3 /*break*/, 46];
-                                case 45:
-                                    try {
-                                        if (_h && !_h.done && (_p = _g.return)) _p.call(_g);
-                                    }
-                                    finally { if (e_4) throw e_4.error; }
-                                    return [7 /*endfinally*/];
-                                case 46:
-                                    _r.trys.push([46, 51, 52, 53]);
-                                    _j = __values(cart.items), _k = _j.next();
-                                    _r.label = 47;
-                                case 47:
-                                    if (!!_k.done) return [3 /*break*/, 50];
-                                    item = _k.value;
-                                    return [4 /*yield*/, this.inventoryService_
-                                            .withTransaction(manager)
-                                            .adjustInventory(item.variant_id, -item.quantity)];
-                                case 48:
-                                    _r.sent();
-                                    _r.label = 49;
-                                case 49:
-                                    _k = _j.next();
-                                    return [3 /*break*/, 47];
-                                case 50: return [3 /*break*/, 53];
-                                case 51:
-                                    e_5_1 = _r.sent();
-                                    e_5 = { error: e_5_1 };
-                                    return [3 /*break*/, 53];
-                                case 52:
-                                    try {
-                                        if (_k && !_k.done && (_q = _j.return)) _q.call(_j);
-                                    }
-                                    finally { if (e_5) throw e_5.error; }
-                                    return [7 /*endfinally*/];
-                                case 53: return [4 /*yield*/, this.eventBus_
-                                        .withTransaction(manager)
-                                        .emit(OrderService.Events.PLACED, {
-                                        id: result.id,
-                                        no_notification: result.no_notification,
-                                    })];
-                                case 54:
-                                    _r.sent();
-                                    return [4 /*yield*/, this.cartService_
-                                            .withTransaction(manager)
-                                            .update(cart.id, { completed_at: new Date() })];
-                                case 55:
-                                    _r.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                    case 55:
+                                        _r.sent();
+                                        return [4 /*yield*/, cartServiceTx.update(cart.id, { completed_at: new Date() })];
+                                    case 56:
+                                        _r.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
@@ -810,14 +758,12 @@ var OrderService = /** @class */ (function (_super) {
      * Adds a shipment to the order to indicate that an order has left the
      * warehouse. Will ask the fulfillment provider for any documents that may
      * have been created in regards to the shipment.
-     * @param {string} orderId - the id of the order that has been shipped
-     * @param {string} fulfillmentId - the fulfillment that has now been shipped
-     * @param {TrackingLink[] | undefined} trackingLinks - array of tracking numebers
+     * @param orderId - the id of the order that has been shipped
+     * @param fulfillmentId - the fulfillment that has now been shipped
+     * @param trackingLinks - array of tracking numebers
      *   associated with the shipment
-     * @param {Object} config - the config of the order that has been shipped
-     * @param {Dictionary<String, String>} metadata - optional metadata to add to
-     *   the fulfillment
-     * @return {order} the resulting order following the update.
+     * @param config - the config of the order that has been shipped
+     * @return the resulting order following the update.
      */
     OrderService.prototype.createShipment = function (orderId, fulfillmentId, trackingLinks, config) {
         if (config === void 0) { config = {
@@ -828,187 +774,162 @@ var OrderService = /** @class */ (function (_super) {
             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 order, shipment, evaluatedNoNotification, shipmentRes, _loop_1, this_1, _a, _b, item, e_6_1, orderRepo, result;
-                        var e_6, _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId, { relations: ["items"] })];
-                                case 1:
-                                    order = _d.sent();
-                                    return [4 /*yield*/, this.fulfillmentService_.retrieve(fulfillmentId)];
-                                case 2:
-                                    shipment = _d.sent();
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be fulfilled as shipped");
-                                    }
-                                    if (!shipment || shipment.order_id !== orderId) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Could not find fulfillment");
-                                    }
-                                    evaluatedNoNotification = no_notification !== undefined
-                                        ? no_notification
-                                        : shipment.no_notification;
-                                    return [4 /*yield*/, this.fulfillmentService_
-                                            .withTransaction(manager)
-                                            .createShipment(fulfillmentId, trackingLinks, {
-                                            metadata: metadata,
-                                            no_notification: evaluatedNoNotification,
-                                        })];
-                                case 3:
-                                    shipmentRes = _d.sent();
-                                    order.fulfillment_status = "shipped";
-                                    _loop_1 = function (item) {
-                                        var shipped, shippedQty;
-                                        return __generator(this, function (_e) {
-                                            switch (_e.label) {
-                                                case 0:
-                                                    shipped = shipmentRes.items.find(function (si) { return si.item_id === item.id; });
-                                                    if (!shipped) return [3 /*break*/, 2];
-                                                    shippedQty = (item.shipped_quantity || 0) + shipped.quantity;
-                                                    if (shippedQty !== item.quantity) {
-                                                        order.fulfillment_status = "partially_shipped";
-                                                    }
-                                                    return [4 /*yield*/, this_1.lineItemService_.withTransaction(manager).update(item.id, {
-                                                            shipped_quantity: shippedQty,
-                                                        })];
-                                                case 1:
-                                                    _e.sent();
-                                                    return [3 /*break*/, 3];
-                                                case 2:
-                                                    if (item.shipped_quantity !== item.quantity) {
-                                                        order.fulfillment_status = "partially_shipped";
+                switch (_a.label) {
+                    case 0:
+                        metadata = config.metadata, no_notification = config.no_notification;
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var order, shipment, evaluatedNoNotification, shipmentRes, lineItemServiceTx, _loop_1, _a, _b, item, e_6_1, orderRepo, result;
+                                var e_6, _c;
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0: return [4 /*yield*/, this.retrieve(orderId, { relations: ["items"] })];
+                                        case 1:
+                                            order = _d.sent();
+                                            return [4 /*yield*/, this.fulfillmentService_
+                                                    .withTransaction(manager)
+                                                    .retrieve(fulfillmentId)];
+                                        case 2:
+                                            shipment = _d.sent();
+                                            if (order.status === "canceled") {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be fulfilled as shipped");
+                                            }
+                                            if (!shipment || shipment.order_id !== orderId) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Could not find fulfillment");
+                                            }
+                                            evaluatedNoNotification = no_notification !== undefined
+                                                ? no_notification
+                                                : shipment.no_notification;
+                                            return [4 /*yield*/, this.fulfillmentService_
+                                                    .withTransaction(manager)
+                                                    .createShipment(fulfillmentId, trackingLinks, {
+                                                    metadata: metadata,
+                                                    no_notification: evaluatedNoNotification,
+                                                })];
+                                        case 3:
+                                            shipmentRes = _d.sent();
+                                            lineItemServiceTx = this.lineItemService_.withTransaction(manager);
+                                            order.fulfillment_status = models_1.FulfillmentStatus.SHIPPED;
+                                            _loop_1 = function (item) {
+                                                var shipped, shippedQty;
+                                                return __generator(this, function (_e) {
+                                                    switch (_e.label) {
+                                                        case 0:
+                                                            shipped = shipmentRes.items.find(function (si) { return si.item_id === item.id; });
+                                                            if (!shipped) return [3 /*break*/, 2];
+                                                            shippedQty = (item.shipped_quantity || 0) + shipped.quantity;
+                                                            if (shippedQty !== item.quantity) {
+                                                                order.fulfillment_status = models_1.FulfillmentStatus.PARTIALLY_SHIPPED;
+                                                            }
+                                                            return [4 /*yield*/, lineItemServiceTx.update(item.id, {
+                                                                    shipped_quantity: shippedQty,
+                                                                })];
+                                                        case 1:
+                                                            _e.sent();
+                                                            return [3 /*break*/, 3];
+                                                        case 2:
+                                                            if (item.shipped_quantity !== item.quantity) {
+                                                                order.fulfillment_status = models_1.FulfillmentStatus.PARTIALLY_SHIPPED;
+                                                            }
+                                                            _e.label = 3;
+                                                        case 3: return [2 /*return*/];
                                                     }
-                                                    _e.label = 3;
-                                                case 3: return [2 /*return*/];
+                                                });
+                                            };
+                                            _d.label = 4;
+                                        case 4:
+                                            _d.trys.push([4, 9, 10, 11]);
+                                            _a = __values(order.items), _b = _a.next();
+                                            _d.label = 5;
+                                        case 5:
+                                            if (!!_b.done) return [3 /*break*/, 8];
+                                            item = _b.value;
+                                            return [5 /*yield**/, _loop_1(item)];
+                                        case 6:
+                                            _d.sent();
+                                            _d.label = 7;
+                                        case 7:
+                                            _b = _a.next();
+                                            return [3 /*break*/, 5];
+                                        case 8: return [3 /*break*/, 11];
+                                        case 9:
+                                            e_6_1 = _d.sent();
+                                            e_6 = { error: e_6_1 };
+                                            return [3 /*break*/, 11];
+                                        case 10:
+                                            try {
+                                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                                             }
-                                        });
-                                    };
-                                    this_1 = this;
-                                    _d.label = 4;
-                                case 4:
-                                    _d.trys.push([4, 9, 10, 11]);
-                                    _a = __values(order.items), _b = _a.next();
-                                    _d.label = 5;
-                                case 5:
-                                    if (!!_b.done) return [3 /*break*/, 8];
-                                    item = _b.value;
-                                    return [5 /*yield**/, _loop_1(item)];
-                                case 6:
-                                    _d.sent();
-                                    _d.label = 7;
-                                case 7:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 5];
-                                case 8: return [3 /*break*/, 11];
-                                case 9:
-                                    e_6_1 = _d.sent();
-                                    e_6 = { error: e_6_1 };
-                                    return [3 /*break*/, 11];
-                                case 10:
-                                    try {
-                                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                            finally { if (e_6) throw e_6.error; }
+                                            return [7 /*endfinally*/];
+                                        case 11:
+                                            orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                            return [4 /*yield*/, orderRepo.save(order)];
+                                        case 12:
+                                            result = _d.sent();
+                                            return [4 /*yield*/, this.eventBus_
+                                                    .withTransaction(manager)
+                                                    .emit(OrderService.Events.SHIPMENT_CREATED, {
+                                                    id: orderId,
+                                                    fulfillment_id: shipmentRes.id,
+                                                    no_notification: evaluatedNoNotification,
+                                                })];
+                                        case 13:
+                                            _d.sent();
+                                            return [2 /*return*/, result];
                                     }
-                                    finally { if (e_6) throw e_6.error; }
-                                    return [7 /*endfinally*/];
-                                case 11:
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 12:
-                                    result = _d.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(OrderService.Events.SHIPMENT_CREATED, {
-                                            id: orderId,
-                                            fulfillment_id: shipmentRes.id,
-                                            no_notification: evaluatedNoNotification,
-                                        })];
-                                case 13:
-                                    _d.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
-    /**
-     * Creates an order
-     * @param {object} data - the data to create an order
-     * @return {Promise} resolves to the creation result.
-     */
-    OrderService.prototype.create = function (data) {
-        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 orderRepo, order, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    order = orderRepo.create(data);
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 1:
-                                    result = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(OrderService.Events.PLACED, {
-                                            id: result.id,
-                                            no_notification: order.no_notification,
-                                        })];
-                                case 2:
-                                    _a.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Updates the order's billing address.
-     * @param {object} order - the order to update
-     * @param {object} address - the value to set the billing address to
-     * @return {Promise} the result of the update operation
+     * @param order - the order to update
+     * @param address - the value to set the billing address to
+     * @return the result of the update operation
      */
-    OrderService.prototype.updateBillingAddress_ = function (order, address) {
+    OrderService.prototype.updateBillingAddress = function (order, address) {
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function () {
             var addrRepo, region, addr, created;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         addrRepo = this.manager_.getCustomRepository(this.addressRepository_);
-                        address.country_code = address.country_code.toLowerCase();
-                        return [4 /*yield*/, this.regionService_.retrieve(order.region_id, {
+                        address.country_code = (_b = (_a = address.country_code) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : null;
+                        return [4 /*yield*/, this.regionService_
+                                .withTransaction(this.manager_)
+                                .retrieve(order.region_id, {
                                 relations: ["countries"],
                             })];
                     case 1:
-                        region = _a.sent();
+                        region = _e.sent();
                         if (!region.countries.find(function (_a) {
                             var iso_2 = _a.iso_2;
                             return address.country_code === iso_2;
                         })) {
                             throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.INVALID_DATA, "Shipping country must be in the order region");
                         }
-                        address.country_code = address.country_code.toLowerCase();
+                        address.country_code = (_d = (_c = address.country_code) === null || _c === void 0 ? void 0 : _c.toLowerCase()) !== null && _d !== void 0 ? _d : null;
                         if (!order.billing_address_id) return [3 /*break*/, 4];
                         return [4 /*yield*/, addrRepo.findOne({
                                 where: { id: order.billing_address_id },
                             })];
                     case 2:
-                        addr = _a.sent();
+                        addr = _e.sent();
                         return [4 /*yield*/, addrRepo.save(__assign(__assign({}, addr), address))];
                     case 3:
-                        _a.sent();
+                        _e.sent();
                         return [3 /*break*/, 7];
                     case 4: return [4 /*yield*/, addrRepo.create(__assign({}, address))];
                     case 5:
-                        created = _a.sent();
+                        created = _e.sent();
                         return [4 /*yield*/, addrRepo.save(created)];
                     case 6:
-                        _a.sent();
-                        _a.label = 7;
+                        _e.sent();
+                        _e.label = 7;
                     case 7: return [2 /*return*/];
                 }
             });
@@ -1016,23 +937,26 @@ var OrderService = /** @class */ (function (_super) {
     };
     /**
      * Updates the order's shipping address.
-     * @param {object} order - the order to update
-     * @param {object} address - the value to set the shipping address to
-     * @return {Promise} the result of the update operation
+     * @param order - the order to update
+     * @param address - the value to set the shipping address to
+     * @return the result of the update operation
      */
-    OrderService.prototype.updateShippingAddress_ = function (order, address) {
+    OrderService.prototype.updateShippingAddress = function (order, address) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function () {
             var addrRepo, region, addr, created;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         addrRepo = this.manager_.getCustomRepository(this.addressRepository_);
-                        address.country_code = address.country_code.toLowerCase();
-                        return [4 /*yield*/, this.regionService_.retrieve(order.region_id, {
+                        address.country_code = (_b = (_a = address.country_code) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== null && _b !== void 0 ? _b : null;
+                        return [4 /*yield*/, this.regionService_
+                                .withTransaction(this.manager_)
+                                .retrieve(order.region_id, {
                                 relations: ["countries"],
                             })];
                     case 1:
-                        region = _a.sent();
+                        region = _c.sent();
                         if (!region.countries.find(function (_a) {
                             var iso_2 = _a.iso_2;
                             return address.country_code === iso_2;
@@ -1044,17 +968,17 @@ var OrderService = /** @class */ (function (_super) {
                                 where: { id: order.shipping_address_id },
                             })];
                     case 2:
-                        addr = _a.sent();
+                        addr = _c.sent();
                         return [4 /*yield*/, addrRepo.save(__assign(__assign({}, addr), address))];
                     case 3:
-                        _a.sent();
+                        _c.sent();
                         return [3 /*break*/, 6];
                     case 4:
                         created = addrRepo.create(__assign({}, address));
                         return [4 /*yield*/, addrRepo.save(created)];
                     case 5:
-                        _a.sent();
-                        _a.label = 6;
+                        _c.sent();
+                        _c.label = 6;
                     case 6: return [2 /*return*/];
                 }
             });
@@ -1065,79 +989,81 @@ var OrderService = /** @class */ (function (_super) {
         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 order, shipping_methods, newMethod, methods, shipping_methods_1, shipping_methods_1_1, sm, e_7_1, result;
-                        var e_7, _a;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId, {
-                                        select: ["subtotal"],
-                                        relations: [
-                                            "shipping_methods",
-                                            "shipping_methods.shipping_option",
-                                            "items",
-                                            "items.variant",
-                                            "items.variant.product",
-                                        ],
-                                    })];
-                                case 1:
-                                    order = _b.sent();
-                                    shipping_methods = order.shipping_methods;
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A shipping method cannot be added to a canceled order");
-                                    }
-                                    return [4 /*yield*/, this.shippingOptionService_
-                                            .withTransaction(manager)
-                                            .createShippingMethod(optionId, data, __assign({ order: order }, config))];
-                                case 2:
-                                    newMethod = _b.sent();
-                                    methods = [newMethod];
-                                    if (!shipping_methods.length) return [3 /*break*/, 11];
-                                    _b.label = 3;
-                                case 3:
-                                    _b.trys.push([3, 9, 10, 11]);
-                                    shipping_methods_1 = __values(shipping_methods), shipping_methods_1_1 = shipping_methods_1.next();
-                                    _b.label = 4;
-                                case 4:
-                                    if (!!shipping_methods_1_1.done) return [3 /*break*/, 8];
-                                    sm = shipping_methods_1_1.value;
-                                    if (!(sm.shipping_option.profile_id ===
-                                        newMethod.shipping_option.profile_id)) return [3 /*break*/, 6];
-                                    return [4 /*yield*/, this.shippingOptionService_
-                                            .withTransaction(manager)
-                                            .deleteShippingMethods(sm)];
-                                case 5:
-                                    _b.sent();
-                                    return [3 /*break*/, 7];
-                                case 6:
-                                    methods.push(sm);
-                                    _b.label = 7;
-                                case 7:
-                                    shipping_methods_1_1 = shipping_methods_1.next();
-                                    return [3 /*break*/, 4];
-                                case 8: return [3 /*break*/, 11];
-                                case 9:
-                                    e_7_1 = _b.sent();
-                                    e_7 = { error: e_7_1 };
-                                    return [3 /*break*/, 11];
-                                case 10:
-                                    try {
-                                        if (shipping_methods_1_1 && !shipping_methods_1_1.done && (_a = shipping_methods_1.return)) _a.call(shipping_methods_1);
-                                    }
-                                    finally { if (e_7) throw e_7.error; }
-                                    return [7 /*endfinally*/];
-                                case 11: return [4 /*yield*/, this.retrieve(orderId)];
-                                case 12:
-                                    result = _b.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(OrderService.Events.UPDATED, { id: result.id })];
-                                case 13:
-                                    _b.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 order, shipping_methods, newMethod, shippingOptionServiceTx, methods, shipping_methods_1, shipping_methods_1_1, sm, e_7_1, result;
+                            var e_7, _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(orderId, {
+                                            select: ["subtotal"],
+                                            relations: [
+                                                "shipping_methods",
+                                                "shipping_methods.shipping_option",
+                                                "items",
+                                                "items.variant",
+                                                "items.variant.product",
+                                            ],
+                                        })];
+                                    case 1:
+                                        order = _b.sent();
+                                        shipping_methods = order.shipping_methods;
+                                        if (order.status === "canceled") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A shipping method cannot be added to a canceled order");
+                                        }
+                                        return [4 /*yield*/, this.shippingOptionService_
+                                                .withTransaction(manager)
+                                                .createShippingMethod(optionId, data !== null && data !== void 0 ? data : {}, __assign({ order: order }, config))];
+                                    case 2:
+                                        newMethod = _b.sent();
+                                        shippingOptionServiceTx = this.shippingOptionService_.withTransaction(manager);
+                                        methods = [newMethod];
+                                        if (!shipping_methods.length) return [3 /*break*/, 11];
+                                        _b.label = 3;
+                                    case 3:
+                                        _b.trys.push([3, 9, 10, 11]);
+                                        shipping_methods_1 = __values(shipping_methods), shipping_methods_1_1 = shipping_methods_1.next();
+                                        _b.label = 4;
+                                    case 4:
+                                        if (!!shipping_methods_1_1.done) return [3 /*break*/, 8];
+                                        sm = shipping_methods_1_1.value;
+                                        if (!(sm.shipping_option.profile_id ===
+                                            newMethod.shipping_option.profile_id)) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, shippingOptionServiceTx.deleteShippingMethods(sm)];
+                                    case 5:
+                                        _b.sent();
+                                        return [3 /*break*/, 7];
+                                    case 6:
+                                        methods.push(sm);
+                                        _b.label = 7;
+                                    case 7:
+                                        shipping_methods_1_1 = shipping_methods_1.next();
+                                        return [3 /*break*/, 4];
+                                    case 8: return [3 /*break*/, 11];
+                                    case 9:
+                                        e_7_1 = _b.sent();
+                                        e_7 = { error: e_7_1 };
+                                        return [3 /*break*/, 11];
+                                    case 10:
+                                        try {
+                                            if (shipping_methods_1_1 && !shipping_methods_1_1.done && (_a = shipping_methods_1.return)) _a.call(shipping_methods_1);
+                                        }
+                                        finally { if (e_7) throw e_7.error; }
+                                        return [7 /*endfinally*/];
+                                    case 11: return [4 /*yield*/, this.retrieve(orderId)];
+                                    case 12:
+                                        result = _b.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(OrderService.Events.UPDATED, { id: result.id })];
+                                    case 13:
+                                        _b.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
@@ -1145,111 +1071,115 @@ var OrderService = /** @class */ (function (_super) {
      * Updates an order. Metadata updates should
      * use dedicated method, e.g. `setMetadata` etc. The function
      * will throw errors if metadata updates are attempted.
-     * @param {string} orderId - the id of the order. Must be a string that
+     * @param orderId - the id of the order. Must be a string that
      *   can be casted to an ObjectId
-     * @param {object} update - an object with the update values.
-     * @return {Promise} resolves to the update result.
+     * @param update - an object with the update values.
+     * @return resolves to the update result.
      */
     OrderService.prototype.update = function (orderId, 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 order, metadata, shipping_address, billing_address, no_notification, items, rest, items_1, items_1_1, item, e_8_1, _a, _b, _c, key, value, orderRepo, result;
-                        var e_8, _d, e_9, _e;
-                        return __generator(this, function (_f) {
-                            switch (_f.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId)];
-                                case 1:
-                                    order = _f.sent();
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be updated");
-                                    }
-                                    if ((update.payment || update.items) &&
-                                        (order.fulfillment_status !== "not_fulfilled" ||
-                                            order.payment_status !== "awaiting" ||
-                                            order.status !== "pending")) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Can't update shipping, billing, items and payment method when order is processed");
-                                    }
-                                    if (update.status || update.fulfillment_status || update.payment_status) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Can't update order statuses. This will happen automatically. Use metadata in order for additional statuses");
-                                    }
-                                    metadata = update.metadata, shipping_address = update.shipping_address, billing_address = update.billing_address, no_notification = update.no_notification, items = update.items, rest = __rest(update, ["metadata", "shipping_address", "billing_address", "no_notification", "items"]);
-                                    if (update.metadata) {
-                                        order.metadata = this.setMetadata_(order, metadata);
-                                    }
-                                    if (!update.shipping_address) return [3 /*break*/, 3];
-                                    return [4 /*yield*/, this.updateShippingAddress_(order, shipping_address)];
-                                case 2:
-                                    _f.sent();
-                                    _f.label = 3;
-                                case 3:
-                                    if (!update.billing_address) return [3 /*break*/, 5];
-                                    return [4 /*yield*/, this.updateBillingAddress_(order, billing_address)];
-                                case 4:
-                                    _f.sent();
-                                    _f.label = 5;
-                                case 5:
-                                    if (update.no_notification) {
-                                        order.no_notification = no_notification;
-                                    }
-                                    if (!update.items) return [3 /*break*/, 13];
-                                    _f.label = 6;
-                                case 6:
-                                    _f.trys.push([6, 11, 12, 13]);
-                                    items_1 = __values(items), items_1_1 = items_1.next();
-                                    _f.label = 7;
-                                case 7:
-                                    if (!!items_1_1.done) return [3 /*break*/, 10];
-                                    item = items_1_1.value;
-                                    return [4 /*yield*/, this.lineItemService_.withTransaction(manager).create(__assign(__assign({}, item), { order_id: orderId }))];
-                                case 8:
-                                    _f.sent();
-                                    _f.label = 9;
-                                case 9:
-                                    items_1_1 = items_1.next();
-                                    return [3 /*break*/, 7];
-                                case 10: return [3 /*break*/, 13];
-                                case 11:
-                                    e_8_1 = _f.sent();
-                                    e_8 = { error: e_8_1 };
-                                    return [3 /*break*/, 13];
-                                case 12:
-                                    try {
-                                        if (items_1_1 && !items_1_1.done && (_d = items_1.return)) _d.call(items_1);
-                                    }
-                                    finally { if (e_8) throw e_8.error; }
-                                    return [7 /*endfinally*/];
-                                case 13:
-                                    try {
-                                        for (_a = __values(Object.entries(rest)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                            _c = __read(_b.value, 2), key = _c[0], value = _c[1];
-                                            order[key] = value;
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var order, metadata, shipping_address, billing_address, no_notification, items, rest, lineItemServiceTx, _a, _b, item, e_8_1, _c, _d, _e, key, value, orderRepo, result;
+                            var e_8, _f, e_9, _g;
+                            return __generator(this, function (_h) {
+                                switch (_h.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(orderId)];
+                                    case 1:
+                                        order = _h.sent();
+                                        if (order.status === "canceled") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be updated");
                                         }
-                                    }
-                                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                                    finally {
+                                        if ((update.payment || update.items) &&
+                                            (order.fulfillment_status !== "not_fulfilled" ||
+                                                order.payment_status !== "awaiting" ||
+                                                order.status !== "pending")) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Can't update shipping, billing, items and payment method when order is processed");
+                                        }
+                                        if (update.status || update.fulfillment_status || update.payment_status) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Can't update order statuses. This will happen automatically. Use metadata in order for additional statuses");
+                                        }
+                                        metadata = update.metadata, shipping_address = update.shipping_address, billing_address = update.billing_address, no_notification = update.no_notification, items = update.items, rest = __rest(update, ["metadata", "shipping_address", "billing_address", "no_notification", "items"]);
+                                        if (update.metadata) {
+                                            order.metadata = (0, utils_1.setMetadata)(order, metadata !== null && metadata !== void 0 ? metadata : {});
+                                        }
+                                        if (!update.shipping_address) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this.updateShippingAddress(order, shipping_address)];
+                                    case 2:
+                                        _h.sent();
+                                        _h.label = 3;
+                                    case 3:
+                                        if (!update.billing_address) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, this.updateBillingAddress(order, billing_address)];
+                                    case 4:
+                                        _h.sent();
+                                        _h.label = 5;
+                                    case 5:
+                                        if (update.no_notification) {
+                                            order.no_notification = no_notification !== null && no_notification !== void 0 ? no_notification : false;
+                                        }
+                                        lineItemServiceTx = this.lineItemService_.withTransaction(manager);
+                                        if (!update.items) return [3 /*break*/, 13];
+                                        _h.label = 6;
+                                    case 6:
+                                        _h.trys.push([6, 11, 12, 13]);
+                                        _a = __values(items), _b = _a.next();
+                                        _h.label = 7;
+                                    case 7:
+                                        if (!!_b.done) return [3 /*break*/, 10];
+                                        item = _b.value;
+                                        return [4 /*yield*/, lineItemServiceTx.create(__assign(__assign({}, item), { order_id: orderId }))];
+                                    case 8:
+                                        _h.sent();
+                                        _h.label = 9;
+                                    case 9:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 7];
+                                    case 10: return [3 /*break*/, 13];
+                                    case 11:
+                                        e_8_1 = _h.sent();
+                                        e_8 = { error: e_8_1 };
+                                        return [3 /*break*/, 13];
+                                    case 12:
                                         try {
-                                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                                            if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
                                         }
-                                        finally { if (e_9) throw e_9.error; }
-                                    }
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 14:
-                                    result = _f.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(OrderService.Events.UPDATED, {
-                                            id: orderId,
-                                            no_notification: order.no_notification,
-                                        })];
-                                case 15:
-                                    _f.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                        finally { if (e_8) throw e_8.error; }
+                                        return [7 /*endfinally*/];
+                                    case 13:
+                                        try {
+                                            for (_c = __values(Object.entries(rest)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                                                _e = __read(_d.value, 2), key = _e[0], value = _e[1];
+                                                order[key] = value;
+                                            }
+                                        }
+                                        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                                        finally {
+                                            try {
+                                                if (_d && !_d.done && (_g = _c.return)) _g.call(_c);
+                                            }
+                                            finally { if (e_9) throw e_9.error; }
+                                        }
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        return [4 /*yield*/, orderRepo.save(order)];
+                                    case 14:
+                                        result = _h.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(OrderService.Events.UPDATED, {
+                                                id: orderId,
+                                                no_notification: order.no_notification,
+                                            })];
+                                    case 15:
+                                        _h.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
@@ -1257,229 +1187,234 @@ var OrderService = /** @class */ (function (_super) {
      * Cancels an order.
      * Throws if fulfillment process has been initiated.
      * Throws if payment process has been initiated.
-     * @param {string} orderId - id of order to cancel.
-     * @return {Promise} result of the update operation.
+     * @param orderId - id of order to cancel.
+     * @return result of the update operation.
      */
     OrderService.prototype.cancel = function (orderId) {
         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 order, throwErrorIf, notCanceled, _a, _b, item, e_10_1, _c, _d, p, e_11_1, orderRepo, result;
-                        var e_10, _e, e_11, _f;
-                        var _g;
-                        return __generator(this, function (_h) {
-                            switch (_h.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId, {
-                                        relations: [
-                                            "fulfillments",
-                                            "payments",
-                                            "returns",
-                                            "claims",
-                                            "swaps",
-                                            "items",
-                                        ],
-                                    })];
-                                case 1:
-                                    order = _h.sent();
-                                    if (((_g = order.refunds) === null || _g === void 0 ? void 0 : _g.length) > 0) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Order with refund(s) cannot be canceled");
-                                    }
-                                    throwErrorIf = function (arr, pred, type) {
-                                        return arr === null || arr === void 0 ? void 0 : arr.filter(pred).find(function (_) {
-                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "All ".concat(type, " must be canceled before canceling an order"));
-                                        });
-                                    };
-                                    notCanceled = function (o) { return !o.canceled_at; };
-                                    throwErrorIf(order.fulfillments, notCanceled, "fulfillments");
-                                    throwErrorIf(order.returns, function (r) { return r.status !== "canceled"; }, "returns");
-                                    throwErrorIf(order.swaps, notCanceled, "swaps");
-                                    throwErrorIf(order.claims, notCanceled, "claims");
-                                    _h.label = 2;
-                                case 2:
-                                    _h.trys.push([2, 7, 8, 9]);
-                                    _a = __values(order.items), _b = _a.next();
-                                    _h.label = 3;
-                                case 3:
-                                    if (!!_b.done) return [3 /*break*/, 6];
-                                    item = _b.value;
-                                    return [4 /*yield*/, this.inventoryService_
-                                            .withTransaction(manager)
-                                            .adjustInventory(item.variant_id, item.quantity)];
-                                case 4:
-                                    _h.sent();
-                                    _h.label = 5;
-                                case 5:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 3];
-                                case 6: return [3 /*break*/, 9];
-                                case 7:
-                                    e_10_1 = _h.sent();
-                                    e_10 = { error: e_10_1 };
-                                    return [3 /*break*/, 9];
-                                case 8:
-                                    try {
-                                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
-                                    }
-                                    finally { if (e_10) throw e_10.error; }
-                                    return [7 /*endfinally*/];
-                                case 9:
-                                    _h.trys.push([9, 14, 15, 16]);
-                                    _c = __values(order.payments), _d = _c.next();
-                                    _h.label = 10;
-                                case 10:
-                                    if (!!_d.done) return [3 /*break*/, 13];
-                                    p = _d.value;
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .cancelPayment(p)];
-                                case 11:
-                                    _h.sent();
-                                    _h.label = 12;
-                                case 12:
-                                    _d = _c.next();
-                                    return [3 /*break*/, 10];
-                                case 13: return [3 /*break*/, 16];
-                                case 14:
-                                    e_11_1 = _h.sent();
-                                    e_11 = { error: e_11_1 };
-                                    return [3 /*break*/, 16];
-                                case 15:
-                                    try {
-                                        if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
-                                    }
-                                    finally { if (e_11) throw e_11.error; }
-                                    return [7 /*endfinally*/];
-                                case 16:
-                                    order.status = "canceled";
-                                    order.fulfillment_status = "canceled";
-                                    order.payment_status = "canceled";
-                                    order.canceled_at = new Date();
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 17:
-                                    result = _h.sent();
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(OrderService.Events.CANCELED, {
-                                            id: order.id,
-                                            no_notification: order.no_notification,
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var order, throwErrorIf, notCanceled, inventoryServiceTx, _a, _b, item, e_10_1, paymentProviderServiceTx, _c, _d, p, e_11_1, orderRepo, result;
+                            var e_10, _e, e_11, _f;
+                            var _g;
+                            return __generator(this, function (_h) {
+                                switch (_h.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(orderId, {
+                                            relations: [
+                                                "fulfillments",
+                                                "payments",
+                                                "returns",
+                                                "claims",
+                                                "swaps",
+                                                "items",
+                                            ],
                                         })];
-                                case 18:
-                                    _h.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                    case 1:
+                                        order = _h.sent();
+                                        if (((_g = order.refunds) === null || _g === void 0 ? void 0 : _g.length) > 0) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Order with refund(s) cannot be canceled");
+                                        }
+                                        throwErrorIf = function (arr, pred, type) {
+                                            if (arr === null || arr === void 0 ? void 0 : arr.filter(pred).length) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "All ".concat(type, " must be canceled before canceling an order"));
+                                            }
+                                        };
+                                        notCanceled = function (o) { return !o.canceled_at; };
+                                        throwErrorIf(order.fulfillments, notCanceled, "fulfillments");
+                                        throwErrorIf(order.returns, function (r) { return r.status !== "canceled"; }, "returns");
+                                        throwErrorIf(order.swaps, notCanceled, "swaps");
+                                        throwErrorIf(order.claims, notCanceled, "claims");
+                                        inventoryServiceTx = this.inventoryService_.withTransaction(manager);
+                                        _h.label = 2;
+                                    case 2:
+                                        _h.trys.push([2, 7, 8, 9]);
+                                        _a = __values(order.items), _b = _a.next();
+                                        _h.label = 3;
+                                    case 3:
+                                        if (!!_b.done) return [3 /*break*/, 6];
+                                        item = _b.value;
+                                        return [4 /*yield*/, inventoryServiceTx.adjustInventory(item.variant_id, item.quantity)];
+                                    case 4:
+                                        _h.sent();
+                                        _h.label = 5;
+                                    case 5:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 3];
+                                    case 6: return [3 /*break*/, 9];
+                                    case 7:
+                                        e_10_1 = _h.sent();
+                                        e_10 = { error: e_10_1 };
+                                        return [3 /*break*/, 9];
+                                    case 8:
+                                        try {
+                                            if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                                        }
+                                        finally { if (e_10) throw e_10.error; }
+                                        return [7 /*endfinally*/];
+                                    case 9:
+                                        paymentProviderServiceTx = this.paymentProviderService_.withTransaction(manager);
+                                        _h.label = 10;
+                                    case 10:
+                                        _h.trys.push([10, 15, 16, 17]);
+                                        _c = __values(order.payments), _d = _c.next();
+                                        _h.label = 11;
+                                    case 11:
+                                        if (!!_d.done) return [3 /*break*/, 14];
+                                        p = _d.value;
+                                        return [4 /*yield*/, paymentProviderServiceTx.cancelPayment(p)];
+                                    case 12:
+                                        _h.sent();
+                                        _h.label = 13;
+                                    case 13:
+                                        _d = _c.next();
+                                        return [3 /*break*/, 11];
+                                    case 14: return [3 /*break*/, 17];
+                                    case 15:
+                                        e_11_1 = _h.sent();
+                                        e_11 = { error: e_11_1 };
+                                        return [3 /*break*/, 17];
+                                    case 16:
+                                        try {
+                                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                                        }
+                                        finally { if (e_11) throw e_11.error; }
+                                        return [7 /*endfinally*/];
+                                    case 17:
+                                        order.status = models_1.OrderStatus.CANCELED;
+                                        order.fulfillment_status = models_1.FulfillmentStatus.CANCELED;
+                                        order.payment_status = models_1.PaymentStatus.CANCELED;
+                                        order.canceled_at = new Date();
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        return [4 /*yield*/, orderRepo.save(order)];
+                                    case 18:
+                                        result = _h.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(OrderService.Events.CANCELED, {
+                                                id: order.id,
+                                                no_notification: order.no_notification,
+                                            })];
+                                    case 19:
+                                        _h.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Captures payment for an order.
-     * @param {string} orderId - id of order to capture payment for.
-     * @return {Promise} result of the update operation.
+     * @param orderId - id of order to capture payment for.
+     * @return result of the update operation.
      */
     OrderService.prototype.capturePayment = function (orderId) {
         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 orderRepo, order, payments, _loop_2, this_2, _a, _b, p, e_12_1, result;
-                        var e_12, _c;
-                        var _this = this;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0:
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    return [4 /*yield*/, this.retrieve(orderId, { relations: ["payments"] })];
-                                case 1:
-                                    order = _d.sent();
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot capture payment");
-                                    }
-                                    payments = [];
-                                    _loop_2 = function (p) {
-                                        var result_1;
-                                        return __generator(this, function (_e) {
-                                            switch (_e.label) {
-                                                case 0:
-                                                    if (!(p.captured_at === null)) return [3 /*break*/, 2];
-                                                    return [4 /*yield*/, this_2.paymentProviderService_
-                                                            .withTransaction(manager)
-                                                            .capturePayment(p)
-                                                            .catch(function (err) {
-                                                            _this.eventBus_
-                                                                .withTransaction(manager)
-                                                                .emit(OrderService.Events.PAYMENT_CAPTURE_FAILED, {
-                                                                id: orderId,
-                                                                payment_id: p.id,
-                                                                error: err,
-                                                                no_notification: order.no_notification,
-                                                            });
-                                                        })];
-                                                case 1:
-                                                    result_1 = _e.sent();
-                                                    if (result_1) {
-                                                        payments.push(result_1);
-                                                    }
-                                                    else {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var orderRepo, order, paymentProviderServiceTx, payments, _loop_2, _a, _b, p, e_12_1, result;
+                            var e_12, _c;
+                            var _this = this;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        return [4 /*yield*/, this.retrieve(orderId, { relations: ["payments"] })];
+                                    case 1:
+                                        order = _d.sent();
+                                        if (order.status === "canceled") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot capture payment");
+                                        }
+                                        paymentProviderServiceTx = this.paymentProviderService_.withTransaction(manager);
+                                        payments = [];
+                                        _loop_2 = function (p) {
+                                            var result_1;
+                                            return __generator(this, function (_e) {
+                                                switch (_e.label) {
+                                                    case 0:
+                                                        if (!(p.captured_at === null)) return [3 /*break*/, 2];
+                                                        return [4 /*yield*/, paymentProviderServiceTx
+                                                                .capturePayment(p)
+                                                                .catch(function (err) {
+                                                                _this.eventBus_
+                                                                    .withTransaction(manager)
+                                                                    .emit(OrderService.Events.PAYMENT_CAPTURE_FAILED, {
+                                                                    id: orderId,
+                                                                    payment_id: p.id,
+                                                                    error: err,
+                                                                    no_notification: order.no_notification,
+                                                                });
+                                                            })];
+                                                    case 1:
+                                                        result_1 = _e.sent();
+                                                        if (result_1) {
+                                                            payments.push(result_1);
+                                                        }
+                                                        else {
+                                                            payments.push(p);
+                                                        }
+                                                        return [3 /*break*/, 3];
+                                                    case 2:
                                                         payments.push(p);
-                                                    }
-                                                    return [3 /*break*/, 3];
-                                                case 2:
-                                                    payments.push(p);
-                                                    _e.label = 3;
-                                                case 3: return [2 /*return*/];
-                                            }
-                                        });
-                                    };
-                                    this_2 = this;
-                                    _d.label = 2;
-                                case 2:
-                                    _d.trys.push([2, 7, 8, 9]);
-                                    _a = __values(order.payments), _b = _a.next();
-                                    _d.label = 3;
-                                case 3:
-                                    if (!!_b.done) return [3 /*break*/, 6];
-                                    p = _b.value;
-                                    return [5 /*yield**/, _loop_2(p)];
-                                case 4:
-                                    _d.sent();
-                                    _d.label = 5;
-                                case 5:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 3];
-                                case 6: return [3 /*break*/, 9];
-                                case 7:
-                                    e_12_1 = _d.sent();
-                                    e_12 = { error: e_12_1 };
-                                    return [3 /*break*/, 9];
-                                case 8:
-                                    try {
-                                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                                    }
-                                    finally { if (e_12) throw e_12.error; }
-                                    return [7 /*endfinally*/];
-                                case 9:
-                                    order.payments = payments;
-                                    order.payment_status = payments.every(function (p) { return p.captured_at !== null; })
-                                        ? "captured"
-                                        : "requires_action";
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 10:
-                                    result = _d.sent();
-                                    if (order.payment_status === "captured") {
-                                        this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(OrderService.Events.PAYMENT_CAPTURED, {
-                                            id: result.id,
-                                            no_notification: order.no_notification,
-                                        });
-                                    }
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                                        _e.label = 3;
+                                                    case 3: return [2 /*return*/];
+                                                }
+                                            });
+                                        };
+                                        _d.label = 2;
+                                    case 2:
+                                        _d.trys.push([2, 7, 8, 9]);
+                                        _a = __values(order.payments), _b = _a.next();
+                                        _d.label = 3;
+                                    case 3:
+                                        if (!!_b.done) return [3 /*break*/, 6];
+                                        p = _b.value;
+                                        return [5 /*yield**/, _loop_2(p)];
+                                    case 4:
+                                        _d.sent();
+                                        _d.label = 5;
+                                    case 5:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 3];
+                                    case 6: return [3 /*break*/, 9];
+                                    case 7:
+                                        e_12_1 = _d.sent();
+                                        e_12 = { error: e_12_1 };
+                                        return [3 /*break*/, 9];
+                                    case 8:
+                                        try {
+                                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                        }
+                                        finally { if (e_12) throw e_12.error; }
+                                        return [7 /*endfinally*/];
+                                    case 9:
+                                        order.payments = payments;
+                                        order.payment_status = payments.every(function (p) { return p.captured_at !== null; })
+                                            ? models_1.PaymentStatus.CAPTURED
+                                            : models_1.PaymentStatus.REQUIRES_ACTION;
+                                        return [4 /*yield*/, orderRepo.save(order)];
+                                    case 10:
+                                        result = _d.sent();
+                                        if (order.payment_status === models_1.PaymentStatus.CAPTURED) {
+                                            this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(OrderService.Events.PAYMENT_CAPTURED, {
+                                                id: result.id,
+                                                no_notification: order.no_notification,
+                                            });
+                                        }
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
@@ -1488,13 +1423,13 @@ var OrderService = /** @class */ (function (_super) {
      * fulfillable quantity is lower than the requested fulfillment quantity.
      * Fulfillable quantity is calculated by subtracting the already fulfilled
      * quantity from the quantity that was originally purchased.
-     * @param {LineItem} item - the line item to check has sufficient fulfillable
+     * @param item - the line item to check has sufficient fulfillable
      *   quantity.
-     * @param {number} quantity - the quantity that is requested to be fulfilled.
-     * @return {LineItem} a line item that has the requested fulfillment quantity
+     * @param quantity - the quantity that is requested to be fulfilled.
+     * @return a line item that has the requested fulfillment quantity
      *   set.
      */
-    OrderService.prototype.validateFulfillmentLineItem_ = function (item, quantity) {
+    OrderService.prototype.validateFulfillmentLineItem = function (item, quantity) {
         if (!item) {
             // This will in most cases be called by a webhook so to ensure that
             // things go through smoothly in instances where extra items outside
@@ -1511,10 +1446,10 @@ var OrderService = /** @class */ (function (_super) {
      * In a situation where the order has more than one shipping method,
      * we need to partition the order items, such that they can be sent
      * to their respective fulfillment provider.
-     * @param {string} orderId - id of order to cancel.
-     * @param {Object} itemsToFulfill - items to fulfil.
-     * @param {Object} config - the config to cancel.
-     * @return {Promise} result of the update operation.
+     * @param orderId - id of order to cancel.
+     * @param itemsToFulfill - items to fulfil.
+     * @param config - the config to cancel.
+     * @return result of the update operation.
      */
     OrderService.prototype.createFulfillment = function (orderId, itemsToFulfill, config) {
         if (config === void 0) { config = {
@@ -1525,228 +1460,234 @@ var OrderService = /** @class */ (function (_super) {
             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 order, fulfillments, successfullyFulfilled, fulfillments_1, fulfillments_1_1, f, _loop_3, this_3, _a, _b, item, e_13_1, orderRepo, result, evaluatedNoNotification, fulfillments_2, fulfillments_2_1, fulfillment, e_14_1;
-                        var e_15, _c, e_13, _d, e_14, _e;
-                        var _f;
-                        return __generator(this, function (_g) {
-                            switch (_g.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId, {
-                                        select: [
-                                            "subtotal",
-                                            "shipping_total",
-                                            "discount_total",
-                                            "tax_total",
-                                            "gift_card_total",
-                                            "total",
-                                        ],
-                                        relations: [
-                                            "discounts",
-                                            "discounts.rule",
-                                            "region",
-                                            "fulfillments",
-                                            "shipping_address",
-                                            "billing_address",
-                                            "shipping_methods",
-                                            "shipping_methods.shipping_option",
-                                            "items",
-                                            "items.variant",
-                                            "items.variant.product",
-                                            "payments",
-                                        ],
-                                    })];
-                                case 1:
-                                    order = _g.sent();
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be fulfilled");
-                                    }
-                                    if (!((_f = order.shipping_methods) === null || _f === void 0 ? void 0 : _f.length)) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot fulfill an order that lacks shipping methods");
-                                    }
-                                    return [4 /*yield*/, this.fulfillmentService_
-                                            .withTransaction(manager)
-                                            .createFulfillment(order, itemsToFulfill, {
-                                            metadata: metadata,
-                                            no_notification: no_notification,
-                                            order_id: orderId,
-                                        })];
-                                case 2:
-                                    fulfillments = _g.sent();
-                                    successfullyFulfilled = [];
-                                    try {
-                                        for (fulfillments_1 = __values(fulfillments), fulfillments_1_1 = fulfillments_1.next(); !fulfillments_1_1.done; fulfillments_1_1 = fulfillments_1.next()) {
-                                            f = fulfillments_1_1.value;
-                                            successfullyFulfilled = __spreadArray(__spreadArray([], __read(successfullyFulfilled), false), __read(f.items), false);
-                                        }
-                                    }
-                                    catch (e_15_1) { e_15 = { error: e_15_1 }; }
-                                    finally {
-                                        try {
-                                            if (fulfillments_1_1 && !fulfillments_1_1.done && (_c = fulfillments_1.return)) _c.call(fulfillments_1);
-                                        }
-                                        finally { if (e_15) throw e_15.error; }
-                                    }
-                                    order.fulfillment_status = "fulfilled";
-                                    _loop_3 = function (item) {
-                                        var fulfillmentItem, fulfilledQuantity;
-                                        return __generator(this, function (_h) {
-                                            switch (_h.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*/, this_3.lineItemService_.withTransaction(manager).update(item.id, {
-                                                            fulfilled_quantity: fulfilledQuantity,
-                                                        })];
-                                                case 1:
-                                                    // Update the fulfilled quantity
-                                                    _h.sent();
-                                                    if (item.quantity !== fulfilledQuantity) {
-                                                        order.fulfillment_status = "partially_fulfilled";
-                                                    }
-                                                    return [3 /*break*/, 3];
-                                                case 2:
-                                                    if (item.quantity !== item.fulfilled_quantity) {
-                                                        order.fulfillment_status = "partially_fulfilled";
+                switch (_a.label) {
+                    case 0:
+                        metadata = config.metadata, no_notification = config.no_notification;
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var order, fulfillments, successfullyFulfilled, fulfillments_1, fulfillments_1_1, f, _loop_3, this_1, _a, _b, item, e_13_1, orderRepo, result, evaluatedNoNotification, eventBusTx, fulfillments_2, fulfillments_2_1, fulfillment, e_14_1;
+                                var e_15, _c, e_13, _d, e_14, _e;
+                                var _f;
+                                return __generator(this, function (_g) {
+                                    switch (_g.label) {
+                                        case 0: return [4 /*yield*/, this.retrieve(orderId, {
+                                                select: [
+                                                    "subtotal",
+                                                    "shipping_total",
+                                                    "discount_total",
+                                                    "tax_total",
+                                                    "gift_card_total",
+                                                    "total",
+                                                ],
+                                                relations: [
+                                                    "discounts",
+                                                    "discounts.rule",
+                                                    "region",
+                                                    "fulfillments",
+                                                    "shipping_address",
+                                                    "billing_address",
+                                                    "shipping_methods",
+                                                    "shipping_methods.shipping_option",
+                                                    "items",
+                                                    "items.adjustments",
+                                                    "items.variant",
+                                                    "items.variant.product",
+                                                    "payments",
+                                                ],
+                                            })];
+                                        case 1:
+                                            order = _g.sent();
+                                            if (order.status === models_1.OrderStatus.CANCELED) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be fulfilled");
+                                            }
+                                            if (!((_f = order.shipping_methods) === null || _f === void 0 ? void 0 : _f.length)) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot fulfill an order that lacks shipping methods");
+                                            }
+                                            return [4 /*yield*/, this.fulfillmentService_
+                                                    .withTransaction(manager)
+                                                    .createFulfillment(order, itemsToFulfill, {
+                                                    metadata: metadata,
+                                                    no_notification: no_notification,
+                                                    order_id: orderId,
+                                                })];
+                                        case 2:
+                                            fulfillments = _g.sent();
+                                            successfullyFulfilled = [];
+                                            try {
+                                                for (fulfillments_1 = __values(fulfillments), fulfillments_1_1 = fulfillments_1.next(); !fulfillments_1_1.done; fulfillments_1_1 = fulfillments_1.next()) {
+                                                    f = fulfillments_1_1.value;
+                                                    successfullyFulfilled = __spreadArray(__spreadArray([], __read(successfullyFulfilled), false), __read(f.items), false);
+                                                }
+                                            }
+                                            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                                            finally {
+                                                try {
+                                                    if (fulfillments_1_1 && !fulfillments_1_1.done && (_c = fulfillments_1.return)) _c.call(fulfillments_1);
+                                                }
+                                                finally { if (e_15) throw e_15.error; }
+                                            }
+                                            order.fulfillment_status = models_1.FulfillmentStatus.FULFILLED;
+                                            _loop_3 = function (item) {
+                                                var fulfillmentItem, fulfilledQuantity;
+                                                return __generator(this, function (_h) {
+                                                    switch (_h.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*/, this_1.lineItemService_.withTransaction(manager).update(item.id, {
+                                                                    fulfilled_quantity: fulfilledQuantity,
+                                                                })];
+                                                        case 1:
+                                                            // Update the fulfilled quantity
+                                                            _h.sent();
+                                                            if (item.quantity !== fulfilledQuantity) {
+                                                                order.fulfillment_status = models_1.FulfillmentStatus.PARTIALLY_FULFILLED;
+                                                            }
+                                                            return [3 /*break*/, 3];
+                                                        case 2:
+                                                            if (item.quantity !== item.fulfilled_quantity) {
+                                                                order.fulfillment_status = models_1.FulfillmentStatus.PARTIALLY_FULFILLED;
+                                                            }
+                                                            _h.label = 3;
+                                                        case 3: return [2 /*return*/];
                                                     }
-                                                    _h.label = 3;
-                                                case 3: return [2 /*return*/];
+                                                });
+                                            };
+                                            this_1 = this;
+                                            _g.label = 3;
+                                        case 3:
+                                            _g.trys.push([3, 8, 9, 10]);
+                                            _a = __values(order.items), _b = _a.next();
+                                            _g.label = 4;
+                                        case 4:
+                                            if (!!_b.done) return [3 /*break*/, 7];
+                                            item = _b.value;
+                                            return [5 /*yield**/, _loop_3(item)];
+                                        case 5:
+                                            _g.sent();
+                                            _g.label = 6;
+                                        case 6:
+                                            _b = _a.next();
+                                            return [3 /*break*/, 4];
+                                        case 7: return [3 /*break*/, 10];
+                                        case 8:
+                                            e_13_1 = _g.sent();
+                                            e_13 = { error: e_13_1 };
+                                            return [3 /*break*/, 10];
+                                        case 9:
+                                            try {
+                                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
                                             }
-                                        });
-                                    };
-                                    this_3 = this;
-                                    _g.label = 3;
-                                case 3:
-                                    _g.trys.push([3, 8, 9, 10]);
-                                    _a = __values(order.items), _b = _a.next();
-                                    _g.label = 4;
-                                case 4:
-                                    if (!!_b.done) return [3 /*break*/, 7];
-                                    item = _b.value;
-                                    return [5 /*yield**/, _loop_3(item)];
-                                case 5:
-                                    _g.sent();
-                                    _g.label = 6;
-                                case 6:
-                                    _b = _a.next();
-                                    return [3 /*break*/, 4];
-                                case 7: return [3 /*break*/, 10];
-                                case 8:
-                                    e_13_1 = _g.sent();
-                                    e_13 = { error: e_13_1 };
-                                    return [3 /*break*/, 10];
-                                case 9:
-                                    try {
-                                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                                    }
-                                    finally { if (e_13) throw e_13.error; }
-                                    return [7 /*endfinally*/];
-                                case 10:
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    order.fulfillments = __spreadArray(__spreadArray([], __read(order.fulfillments), false), __read(fulfillments), false);
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 11:
-                                    result = _g.sent();
-                                    evaluatedNoNotification = no_notification !== undefined ? no_notification : order.no_notification;
-                                    _g.label = 12;
-                                case 12:
-                                    _g.trys.push([12, 17, 18, 19]);
-                                    fulfillments_2 = __values(fulfillments), fulfillments_2_1 = fulfillments_2.next();
-                                    _g.label = 13;
-                                case 13:
-                                    if (!!fulfillments_2_1.done) return [3 /*break*/, 16];
-                                    fulfillment = fulfillments_2_1.value;
-                                    return [4 /*yield*/, this.eventBus_
-                                            .withTransaction(manager)
-                                            .emit(OrderService.Events.FULFILLMENT_CREATED, {
-                                            id: orderId,
-                                            fulfillment_id: fulfillment.id,
-                                            no_notification: evaluatedNoNotification,
-                                        })];
-                                case 14:
-                                    _g.sent();
-                                    _g.label = 15;
-                                case 15:
-                                    fulfillments_2_1 = fulfillments_2.next();
-                                    return [3 /*break*/, 13];
-                                case 16: return [3 /*break*/, 19];
-                                case 17:
-                                    e_14_1 = _g.sent();
-                                    e_14 = { error: e_14_1 };
-                                    return [3 /*break*/, 19];
-                                case 18:
-                                    try {
-                                        if (fulfillments_2_1 && !fulfillments_2_1.done && (_e = fulfillments_2.return)) _e.call(fulfillments_2);
+                                            finally { if (e_13) throw e_13.error; }
+                                            return [7 /*endfinally*/];
+                                        case 10:
+                                            orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                            order.fulfillments = __spreadArray(__spreadArray([], __read(order.fulfillments), false), __read(fulfillments), false);
+                                            return [4 /*yield*/, orderRepo.save(order)];
+                                        case 11:
+                                            result = _g.sent();
+                                            evaluatedNoNotification = no_notification !== undefined ? no_notification : order.no_notification;
+                                            eventBusTx = this.eventBus_.withTransaction(manager);
+                                            _g.label = 12;
+                                        case 12:
+                                            _g.trys.push([12, 17, 18, 19]);
+                                            fulfillments_2 = __values(fulfillments), fulfillments_2_1 = fulfillments_2.next();
+                                            _g.label = 13;
+                                        case 13:
+                                            if (!!fulfillments_2_1.done) return [3 /*break*/, 16];
+                                            fulfillment = fulfillments_2_1.value;
+                                            return [4 /*yield*/, eventBusTx.emit(OrderService.Events.FULFILLMENT_CREATED, {
+                                                    id: orderId,
+                                                    fulfillment_id: fulfillment.id,
+                                                    no_notification: evaluatedNoNotification,
+                                                })];
+                                        case 14:
+                                            _g.sent();
+                                            _g.label = 15;
+                                        case 15:
+                                            fulfillments_2_1 = fulfillments_2.next();
+                                            return [3 /*break*/, 13];
+                                        case 16: return [3 /*break*/, 19];
+                                        case 17:
+                                            e_14_1 = _g.sent();
+                                            e_14 = { error: e_14_1 };
+                                            return [3 /*break*/, 19];
+                                        case 18:
+                                            try {
+                                                if (fulfillments_2_1 && !fulfillments_2_1.done && (_e = fulfillments_2.return)) _e.call(fulfillments_2);
+                                            }
+                                            finally { if (e_14) throw e_14.error; }
+                                            return [7 /*endfinally*/];
+                                        case 19: return [2 /*return*/, result];
                                     }
-                                    finally { if (e_14) throw e_14.error; }
-                                    return [7 /*endfinally*/];
-                                case 19: return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Cancels a fulfillment (if related to an order)
-     * @param {string} fulfillmentId - the ID of the fulfillment to cancel
-     * @return {Promise} updated order
+     * @param fulfillmentId - the ID of the fulfillment to cancel
+     * @return updated order
      */
     OrderService.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, order, orderRepo, 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.order_id) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Fufillment not related to an order");
-                                    }
-                                    return [4 /*yield*/, this.retrieve(canceled.order_id)];
-                                case 2:
-                                    order = _a.sent();
-                                    order.fulfillment_status = "canceled";
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 3:
-                                    updated = _a.sent();
-                                    return [4 /*yield*/, this.eventBus_
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var canceled, order, orderRepo, updated;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.fulfillmentService_
                                             .withTransaction(manager)
-                                            .emit(OrderService.Events.FULFILLMENT_CANCELED, {
-                                            id: order.id,
-                                            fulfillment_id: canceled.id,
-                                            no_notification: canceled.no_notification,
-                                        })];
-                                case 4:
-                                    _a.sent();
-                                    return [2 /*return*/, updated];
-                            }
-                        });
-                    }); })];
+                                            .cancelFulfillment(fulfillmentId)];
+                                    case 1:
+                                        canceled = _a.sent();
+                                        if (!canceled.order_id) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Fufillment not related to an order");
+                                        }
+                                        return [4 /*yield*/, this.retrieve(canceled.order_id)];
+                                    case 2:
+                                        order = _a.sent();
+                                        order.fulfillment_status = models_1.FulfillmentStatus.CANCELED;
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        return [4 /*yield*/, orderRepo.save(order)];
+                                    case 3:
+                                        updated = _a.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(OrderService.Events.FULFILLMENT_CANCELED, {
+                                                id: order.id,
+                                                fulfillment_id: canceled.id,
+                                                no_notification: canceled.no_notification,
+                                            })];
+                                    case 4:
+                                        _a.sent();
+                                        return [2 /*return*/, updated];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Retrieves the order line items, given an array of items.
-     * @param {Order} order - the order to get line items from
-     * @param {{ item_id: string, quantity: number }} items - the items to get
-     * @param {function} transformer - a function to apply to each of the items
+     * @param order - the order to get line items from
+     * @param items - the items to get
+     * @param transformer - a function to apply to each of the items
      *    retrieved from the order, should return a line item. If the transformer
      *    returns an undefined value the line item will be filtered from the
      *    returned array.
-     * @return {Promise<Array<LineItem>>} the line items generated by the transformer.
+     * @return the line items generated by the transformer.
      */
-    OrderService.prototype.getFulfillmentItems_ = function (order, items, transformer) {
+    OrderService.prototype.getFulfillmentItems = function (order, items, transformer) {
         return __awaiter(this, void 0, void 0, function () {
-            var toReturn;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -1755,14 +1696,12 @@ var OrderService = /** @class */ (function (_super) {
                             return __awaiter(_this, void 0, void 0, function () {
                                 var item;
                                 return __generator(this, function (_b) {
-                                    item = order.items.find(function (i) { return i.id.equals(item_id); });
+                                    item = order.items.find(function (i) { return i.id === item_id; });
                                     return [2 /*return*/, transformer(item, quantity)];
                                 });
                             });
                         }))];
-                    case 1:
-                        toReturn = _a.sent();
-                        return [2 /*return*/, toReturn.filter(function (i) { return !!i; })];
+                    case 1: return [2 /*return*/, (_a.sent()).filter(function (i) { return !!i; })];
                 }
             });
         });
@@ -1770,43 +1709,44 @@ var OrderService = /** @class */ (function (_super) {
     /**
      * Archives an order. It only alloved, if the order has been fulfilled
      * and payment has been captured.
-     * @param {string} orderId - the order to archive
-     * @return {Promise} the result of the update operation
+     * @param orderId - the order to archive
+     * @return the result of the update operation
      */
     OrderService.prototype.archive = function (orderId) {
         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 order, orderRepo, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId)];
-                                case 1:
-                                    order = _a.sent();
-                                    if (order.status !== ("completed" || "refunded")) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Can't archive an unprocessed order");
-                                    }
-                                    order.status = "archived";
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 2:
-                                    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 order, orderRepo;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(orderId)];
+                                    case 1:
+                                        order = _a.sent();
+                                        if (order.status !== ("completed" || "refunded")) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Can't archive an unprocessed order");
+                                        }
+                                        order.status = models_1.OrderStatus.ARCHIVED;
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        return [4 /*yield*/, orderRepo.save(order)];
+                                    case 2: return [2 /*return*/, _a.sent()];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
     /**
      * Refunds a given amount back to the customer.
-     * @param {string} orderId - id of the order to refund.
-     * @param {float} refundAmount - the amount to refund.
-     * @param {string} reason - the reason to refund.
-     * @param {string | undefined} note - note for refund.
-     * @param {Object} config - the config for refund.
-     * @return {Promise} the result of the refund operation.
+     * @param orderId - id of the order to refund.
+     * @param refundAmount - the amount to refund.
+     * @param reason - the reason to refund.
+     * @param note - note for refund.
+     * @param config - the config for refund.
+     * @return the result of the refund operation.
      */
     OrderService.prototype.createRefund = function (orderId, refundAmount, reason, note, config) {
         if (config === void 0) { config = {
@@ -1816,48 +1756,52 @@ var OrderService = /** @class */ (function (_super) {
             var no_notification;
             var _this = this;
             return __generator(this, function (_a) {
-                no_notification = config.no_notification;
-                return [2 /*return*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
-                        var order, refund, result, evaluatedNoNotification;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId, {
-                                        select: ["refundable_amount", "total", "refunded_total"],
-                                        relations: ["payments"],
-                                    })];
-                                case 1:
-                                    order = _a.sent();
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be refunded");
-                                    }
-                                    if (refundAmount > order.refundable_amount) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot refund more than the original order amount");
+                switch (_a.label) {
+                    case 0:
+                        no_notification = config.no_notification;
+                        return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                                var order, refund, result, evaluatedNoNotification;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.retrieve(orderId, {
+                                                select: ["refundable_amount", "total", "refunded_total"],
+                                                relations: ["payments"],
+                                            })];
+                                        case 1:
+                                            order = _a.sent();
+                                            if (order.status === "canceled") {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be refunded");
+                                            }
+                                            if (refundAmount > order.refundable_amount) {
+                                                throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "Cannot refund more than the original order amount");
+                                            }
+                                            return [4 /*yield*/, this.paymentProviderService_
+                                                    .withTransaction(manager)
+                                                    .refundPayment(order.payments, refundAmount, reason, note)];
+                                        case 2:
+                                            refund = _a.sent();
+                                            return [4 /*yield*/, this.retrieve(orderId)];
+                                        case 3:
+                                            result = _a.sent();
+                                            evaluatedNoNotification = no_notification !== undefined ? no_notification : order.no_notification;
+                                            this.eventBus_.emit(OrderService.Events.REFUND_CREATED, {
+                                                id: result.id,
+                                                refund_id: refund.id,
+                                                no_notification: evaluatedNoNotification,
+                                            });
+                                            return [2 /*return*/, result];
                                     }
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .refundPayment(order.payments, refundAmount, reason, note)];
-                                case 2:
-                                    refund = _a.sent();
-                                    return [4 /*yield*/, this.retrieve(orderId)];
-                                case 3:
-                                    result = _a.sent();
-                                    evaluatedNoNotification = no_notification !== undefined ? no_notification : order.no_notification;
-                                    this.eventBus_.emit(OrderService.Events.REFUND_CREATED, {
-                                        id: result.id,
-                                        refund_id: refund.id,
-                                        no_notification: evaluatedNoNotification,
-                                    });
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
             });
         });
     };
-    OrderService.prototype.decorateTotals_ = function (order, totalsFields) {
+    OrderService.prototype.decorateTotals = function (order, totalsFields) {
         if (totalsFields === void 0) { totalsFields = []; }
         return __awaiter(this, void 0, void 0, function () {
-            var totalsFields_1, totalsFields_1_1, totalField, _a, _b, _c, paid_total, refunded_total, _d, _e, s, _f, _g, c, e_16_1;
+            var totalsFields_1, totalsFields_1_1, totalField, _a, giftCardBreakdown, _b, _c, paid_total, refunded_total, _d, _e, s, _f, _g, c, e_16_1;
             var e_16, _h, e_17, _j, e_18, _k;
             var _this = this;
             return __generator(this, function (_l) {
@@ -1893,7 +1837,9 @@ var OrderService = /** @class */ (function (_super) {
                         _l.label = 3;
                     case 3:
                         {
-                            order.gift_card_total = this.totalsService_.getGiftCardTotal(order);
+                            giftCardBreakdown = this.totalsService_.getGiftCardTotal(order);
+                            order.gift_card_total = giftCardBreakdown.total;
+                            order.gift_card_tax_total = giftCardBreakdown.tax_total;
                             return [3 /*break*/, 17];
                         }
                         _l.label = 4;
@@ -1917,7 +1863,9 @@ var OrderService = /** @class */ (function (_super) {
                         _l.label = 8;
                     case 8:
                         _c = order;
-                        return [4 /*yield*/, this.totalsService_.getTotal(order)];
+                        return [4 /*yield*/, this.totalsService_
+                                .withTransaction(this.manager_)
+                                .getTotal(order)];
                     case 9:
                         _c.total = _l.sent();
                         return [3 /*break*/, 17];
@@ -2015,119 +1963,98 @@ var OrderService = /** @class */ (function (_super) {
      * retuned items are not matching the requested items. Setting the
      * allowMismatch argument to true, will process the return, ignoring any
      * mismatches.
-     * @param {string} orderId - the order to return.
-     * @param {object} receivedReturn - the received return
-     * @param {float} customRefundAmount - the custom refund amount return
-     * @return {Promise} the result of the update operation
+     * @param orderId - the order to return.
+     * @param receivedReturn - the received return
+     * @param customRefundAmount - the custom refund amount return
+     * @return the result of the update operation
      */
     OrderService.prototype.registerReturnReceived = function (orderId, receivedReturn, customRefundAmount) {
         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 order, refundAmount, orderRepo, result_2, isFullReturn, _a, _b, i, refund, result;
-                        var e_19, _c;
-                        return __generator(this, function (_d) {
-                            switch (_d.label) {
-                                case 0: return [4 /*yield*/, this.retrieve(orderId, {
-                                        select: ["total", "refunded_total", "refundable_amount"],
-                                        relations: ["items", "returns", "payments"],
-                                    })];
-                                case 1:
-                                    order = _d.sent();
-                                    if (order.status === "canceled") {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be registered as received");
-                                    }
-                                    if (!receivedReturn || receivedReturn.order_id !== orderId) {
-                                        throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Received return does not exist");
-                                    }
-                                    refundAmount = customRefundAmount || receivedReturn.refund_amount;
-                                    orderRepo = manager.getCustomRepository(this.orderRepository_);
-                                    if (!(refundAmount > order.refundable_amount)) return [3 /*break*/, 3];
-                                    order.fulfillment_status = "requires_action";
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 2:
-                                    result_2 = _d.sent();
-                                    this.eventBus_
-                                        .withTransaction(manager)
-                                        .emit(OrderService.Events.RETURN_ACTION_REQUIRED, {
-                                        id: result_2.id,
-                                        return_id: receivedReturn.id,
-                                        no_notification: receivedReturn.no_notification,
-                                    });
-                                    return [2 /*return*/, result_2];
-                                case 3:
-                                    isFullReturn = true;
-                                    try {
-                                        for (_a = __values(order.items), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                            i = _b.value;
-                                            if (i.returned_quantity !== i.quantity) {
-                                                isFullReturn = false;
-                                            }
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.atomicPhase_(function (manager) { return __awaiter(_this, void 0, void 0, function () {
+                            var order, refundAmount, orderRepo, result_2, isFullReturn, _a, _b, i, refund, result;
+                            var e_19, _c;
+                            return __generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0: return [4 /*yield*/, this.retrieve(orderId, {
+                                            select: ["total", "refunded_total", "refundable_amount"],
+                                            relations: ["items", "returns", "payments"],
+                                        })];
+                                    case 1:
+                                        order = _d.sent();
+                                        if (order.status === "canceled") {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_ALLOWED, "A canceled order cannot be registered as received");
                                         }
-                                    }
-                                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
-                                    finally {
-                                        try {
-                                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                        if (!receivedReturn || receivedReturn.order_id !== orderId) {
+                                            throw new medusa_core_utils_1.MedusaError(medusa_core_utils_1.MedusaError.Types.NOT_FOUND, "Received return does not exist");
                                         }
-                                        finally { if (e_19) throw e_19.error; }
-                                    }
-                                    if (!(receivedReturn.refund_amount > 0)) return [3 /*break*/, 5];
-                                    return [4 /*yield*/, this.paymentProviderService_
-                                            .withTransaction(manager)
-                                            .refundPayment(order.payments, receivedReturn.refund_amount, "return")];
-                                case 4:
-                                    refund = _d.sent();
-                                    order.refunds = __spreadArray(__spreadArray([], __read((order.refunds || [])), false), [refund], false);
-                                    _d.label = 5;
-                                case 5:
-                                    if (isFullReturn) {
-                                        order.fulfillment_status = "returned";
-                                    }
-                                    else {
-                                        order.fulfillment_status = "partially_returned";
-                                    }
-                                    return [4 /*yield*/, orderRepo.save(order)];
-                                case 6:
-                                    result = _d.sent();
-                                    return [4 /*yield*/, this.eventBus_
+                                        refundAmount = customRefundAmount || receivedReturn.refund_amount;
+                                        orderRepo = manager.getCustomRepository(this.orderRepository_);
+                                        if (!(refundAmount > order.refundable_amount)) return [3 /*break*/, 3];
+                                        order.fulfillment_status = models_1.FulfillmentStatus.REQUIRES_ACTION;
+                                        return [4 /*yield*/, orderRepo.save(order)];
+                                    case 2:
+                                        result_2 = _d.sent();
+                                        this.eventBus_
                                             .withTransaction(manager)
-                                            .emit(OrderService.Events.ITEMS_RETURNED, {
-                                            id: order.id,
+                                            .emit(OrderService.Events.RETURN_ACTION_REQUIRED, {
+                                            id: result_2.id,
                                             return_id: receivedReturn.id,
                                             no_notification: receivedReturn.no_notification,
-                                        })];
-                                case 7:
-                                    _d.sent();
-                                    return [2 /*return*/, result];
-                            }
-                        });
-                    }); })];
-            });
-        });
-    };
-    /**
-     * Dedicated method to delete metadata for an order.
-     * @param {string} orderId - the order to delete metadata from.
-     * @param {string} key - key for metadata field
-     * @return {Promise} resolves to the updated result.
-     */
-    OrderService.prototype.deleteMetadata = function (orderId, key) {
-        return __awaiter(this, void 0, void 0, function () {
-            var validatedId, keyPath;
-            var _a;
-            return __generator(this, function (_b) {
-                validatedId = this.validateId_(orderId);
-                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");
+                                        });
+                                        return [2 /*return*/, result_2];
+                                    case 3:
+                                        isFullReturn = true;
+                                        try {
+                                            for (_a = __values(order.items), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                i = _b.value;
+                                                if (i.returned_quantity !== i.quantity) {
+                                                    isFullReturn = false;
+                                                }
+                                            }
+                                        }
+                                        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+                                        finally {
+                                            try {
+                                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                            }
+                                            finally { if (e_19) throw e_19.error; }
+                                        }
+                                        if (!(receivedReturn.refund_amount > 0)) return [3 /*break*/, 5];
+                                        return [4 /*yield*/, this.paymentProviderService_
+                                                .withTransaction(manager)
+                                                .refundPayment(order.payments, receivedReturn.refund_amount, "return")];
+                                    case 4:
+                                        refund = _d.sent();
+                                        order.refunds = __spreadArray(__spreadArray([], __read((order.refunds || [])), false), [refund], false);
+                                        _d.label = 5;
+                                    case 5:
+                                        if (isFullReturn) {
+                                            order.fulfillment_status = models_1.FulfillmentStatus.RETURNED;
+                                        }
+                                        else {
+                                            order.fulfillment_status = models_1.FulfillmentStatus.PARTIALLY_RETURNED;
+                                        }
+                                        return [4 /*yield*/, orderRepo.save(order)];
+                                    case 6:
+                                        result = _d.sent();
+                                        return [4 /*yield*/, this.eventBus_
+                                                .withTransaction(manager)
+                                                .emit(OrderService.Events.ITEMS_RETURNED, {
+                                                id: order.id,
+                                                return_id: receivedReturn.id,
+                                                no_notification: receivedReturn.no_notification,
+                                            })];
+                                    case 7:
+                                        _d.sent();
+                                        return [2 /*return*/, result];
+                                }
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
-                keyPath = "metadata.".concat(key);
-                return [2 /*return*/, this.orderModel_
-                        .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);
-                    })];
             });
         });
     };
@@ -2150,6 +2077,6 @@ var OrderService = /** @class */ (function (_super) {
         COMPLETED: "order.completed",
     };
     return OrderService;
-}(medusa_interfaces_1.BaseService));
+}(interfaces_1.TransactionBaseService));
 exports.default = OrderService;
 //# sourceMappingURL=order.js.map