@vendure/core 2.0.0-next.9 → 2.0.0

package/dist/service/services/order.service.js

@@ -12,8 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrderService = void 0;
 const common_1 = require("@nestjs/common");
 const generated_types_1 = require("@vendure/common/lib/generated-types");
+const omit_1 = require("@vendure/common/lib/omit");
 const shared_utils_1 = require("@vendure/common/lib/shared-utils");
-const unique_1 = require("@vendure/common/lib/unique");
+const typeorm_1 = require("typeorm");
 const FindOptionsUtils_1 = require("typeorm/find-options/FindOptionsUtils");
 const request_context_cache_service_1 = require("../../cache/request-context-cache.service");
 const error_result_1 = require("../../common/error/error-result");
@@ -24,22 +25,18 @@ const tax_utils_1 = require("../../common/tax-utils");
 const utils_1 = require("../../common/utils");
 const config_service_1 = require("../../config/config.service");
 const transactional_connection_1 = require("../../connection/transactional-connection");
-const index_1 = require("../../entity/index");
-const order_item_entity_1 = require("../../entity/order-item/order-item.entity");
+const order_entity_1 = require("../../entity/order/order.entity");
 const order_line_entity_1 = require("../../entity/order-line/order-line.entity");
+const fulfillment_line_entity_1 = require("../../entity/order-line-reference/fulfillment-line.entity");
 const order_modification_entity_1 = require("../../entity/order-modification/order-modification.entity");
-const order_entity_1 = require("../../entity/order/order.entity");
 const payment_entity_1 = require("../../entity/payment/payment.entity");
 const product_variant_entity_1 = require("../../entity/product-variant/product-variant.entity");
 const refund_entity_1 = require("../../entity/refund/refund.entity");
+const session_entity_1 = require("../../entity/session/session.entity");
 const shipping_line_entity_1 = require("../../entity/shipping-line/shipping-line.entity");
 const surcharge_entity_1 = require("../../entity/surcharge/surcharge.entity");
 const event_bus_1 = require("../../event-bus/event-bus");
-const index_2 = require("../../event-bus/index");
-const index_3 = require("../../event-bus/index");
-const index_4 = require("../../event-bus/index");
-const index_5 = require("../../event-bus/index");
-const index_6 = require("../../event-bus/index");
+const index_1 = require("../../event-bus/index");
 const custom_field_relation_service_1 = require("../helpers/custom-field-relation/custom-field-relation.service");
 const list_query_builder_1 = require("../helpers/list-query-builder/list-query-builder");
 const order_calculator_1 = require("../helpers/order-calculator/order-calculator");
@@ -49,9 +46,9 @@ const order_state_machine_1 = require("../helpers/order-state-machine/order-stat
 const payment_state_machine_1 = require("../helpers/payment-state-machine/payment-state-machine");
 const refund_state_machine_1 = require("../helpers/refund-state-machine/refund-state-machine");
 const shipping_calculator_1 = require("../helpers/shipping-calculator/shipping-calculator");
+const translator_service_1 = require("../helpers/translator/translator.service");
 const order_utils_1 = require("../helpers/utils/order-utils");
 const patch_entity_1 = require("../helpers/utils/patch-entity");
-const translate_entity_1 = require("../helpers/utils/translate-entity");
 const channel_service_1 = require("./channel.service");
 const country_service_1 = require("./country.service");
 const customer_service_1 = require("./customer.service");
@@ -61,6 +58,7 @@ const payment_method_service_1 = require("./payment-method.service");
 const payment_service_1 = require("./payment.service");
 const product_variant_service_1 = require("./product-variant.service");
 const promotion_service_1 = require("./promotion.service");
+const stock_level_service_1 = require("./stock-level.service");
 const stock_movement_service_1 = require("./stock-movement.service");
 /**
  * @description
@@ -69,7 +67,7 @@ const stock_movement_service_1 = require("./stock-movement.service");
  * @docsCategory services
  */
 let OrderService = class OrderService {
-    constructor(connection, configService, productVariantService, customerService, countryService, orderCalculator, shippingCalculator, orderStateMachine, orderMerger, paymentService, paymentStateMachine, paymentMethodService, fulfillmentService, listQueryBuilder, stockMovementService, refundStateMachine, historyService, promotionService, eventBus, channelService, orderModifier, customFieldRelationService, requestCache) {
+    constructor(connection, configService, productVariantService, customerService, countryService, orderCalculator, shippingCalculator, orderStateMachine, orderMerger, paymentService, paymentStateMachine, paymentMethodService, fulfillmentService, listQueryBuilder, stockMovementService, refundStateMachine, historyService, promotionService, eventBus, channelService, orderModifier, customFieldRelationService, requestCache, translator, stockLevelService) {
         this.connection = connection;
         this.configService = configService;
         this.productVariantService = productVariantService;
@@ -93,11 +91,13 @@ let OrderService = class OrderService {
         this.orderModifier = orderModifier;
         this.customFieldRelationService = customFieldRelationService;
         this.requestCache = requestCache;
+        this.translator = translator;
+        this.stockLevelService = stockLevelService;
     }
     /**
      * @description
      * Returns an array of all the configured states and transitions of the order process. This is
-     * based on the default order process plus all configured {@link CustomOrderProcess} objects
+     * based on the default order process plus all configured {@link OrderProcess} objects
      * defined in the {@link OrderOptions} `process` array.
      */
     getOrderProcessStates() {
@@ -114,13 +114,14 @@ let OrderService = class OrderService {
                 'lines',
                 'customer',
                 'lines.productVariant',
-                'lines.items',
                 'channels',
                 'shippingLines',
+                'payments',
             ],
             channelId: ctx.channelId,
             customPropertyMap: {
                 customerLastName: 'customer.lastName',
+                transactionId: 'payments.transactionId',
             },
         })
             .getManyAndCount()
@@ -138,8 +139,6 @@ let OrderService = class OrderService {
             'customer',
             'customer.user',
             'lines',
-            'lines.items',
-            'lines.items.fulfillments',
             'lines.productVariant',
             'lines.productVariant.taxCategory',
             'lines.productVariant.productVariantPrices',
@@ -154,22 +153,20 @@ let OrderService = class OrderService {
             !effectiveRelations.includes('lines.productVariant.taxCategory')) {
             effectiveRelations.push('lines.productVariant.taxCategory');
         }
-        FindOptionsUtils_1.FindOptionsUtils.applyFindManyOptionsOrConditionsToQueryBuilder(qb, {
-            relations: effectiveRelations,
-        });
-        qb.leftJoin('order.channels', 'channel')
+        qb.setFindOptions({ relations: effectiveRelations })
+            .leftJoin('order.channels', 'channel')
             .where('order.id = :orderId', { orderId })
             .andWhere('channel.id = :channelId', { channelId: ctx.channelId });
-        if (effectiveRelations.includes('lines') && effectiveRelations.includes('lines.items')) {
-            qb.addOrderBy('order__lines.createdAt', 'ASC').addOrderBy('order__lines__items.createdAt', 'ASC');
+        if (effectiveRelations.includes('lines')) {
+            qb.addOrderBy(`order__order_lines.${qb.escape('createdAt')}`, 'ASC').addOrderBy(`order__order_lines.${qb.escape('productVariantId')}`, 'ASC');
         }
-        // tslint:disable-next-line:no-non-null-assertion
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
         const order = await qb.getOne();
         if (order) {
             if (effectiveRelations.includes('lines.productVariant')) {
                 for (const line of order.lines) {
-                    line.productVariant = (0, translate_entity_1.translateDeep)(await this.productVariantService.applyChannelPriceAndTax(line.productVariant, ctx, order), ctx.languageCode);
+                    line.productVariant = this.translator.translate(await this.productVariantService.applyChannelPriceAndTax(line.productVariant, ctx, order), ctx);
                 }
             }
             return order;
@@ -193,16 +190,17 @@ let OrderService = class OrderService {
         return order ? this.findOne(ctx, order.id, relations) : undefined;
     }
     async findByCustomerId(ctx, customerId, options, relations) {
-        const effectiveRelations = (relations !== null && relations !== void 0 ? relations : ['lines', 'lines.items', 'customer', 'channels', 'shippingLines']).filter(r => 
+        const effectiveRelations = (relations !== null && relations !== void 0 ? relations : ['lines', 'customer', 'channels', 'shippingLines']).filter(r => 
         // Don't join productVariant because it messes with the
         // price calculation in certain edge-case field resolver scenarios
         !r.includes('productVariant'));
         return this.listQueryBuilder
             .build(order_entity_1.Order, options, {
-            relations: relations !== null && relations !== void 0 ? relations : ['lines', 'lines.items', 'customer', 'channels', 'shippingLines'],
+            relations: relations !== null && relations !== void 0 ? relations : ['lines', 'customer', 'channels', 'shippingLines'],
             channelId: ctx.channelId,
             ctx,
         })
+            .andWhere('order.state != :draftState', { draftState: 'Draft' })
             .andWhere('order.customer.id = :customerId', { customerId })
             .getManyAndCount()
             .then(([items, totalItems]) => {
@@ -224,16 +222,6 @@ let OrderService = class OrderService {
             },
         });
     }
-    /**
-     * @description
-     * Returns all OrderItems associated with the given {@link Refund}.
-     */
-    async getRefundOrderItems(ctx, refundId) {
-        const refund = await this.connection.getEntityOrThrow(ctx, refund_entity_1.Refund, refundId, {
-            relations: ['orderItems'],
-        });
-        return refund.orderItems;
-    }
     /**
      * @description
      * Returns an array of any {@link OrderModification} entities associated with the Order.
@@ -241,9 +229,9 @@ let OrderService = class OrderService {
     getOrderModifications(ctx, orderId) {
         return this.connection.getRepository(ctx, order_modification_entity_1.OrderModification).find({
             where: {
-                order: orderId,
+                order: { id: orderId },
             },
-            relations: ['orderItems', 'payment', 'refund', 'surcharges'],
+            relations: ['lines', 'payment', 'refund', 'surcharges'],
         });
     }
     /**
@@ -257,6 +245,30 @@ let OrderService = class OrderService {
             },
         });
     }
+    getSellerOrders(ctx, order) {
+        return this.connection.getRepository(ctx, order_entity_1.Order).find({
+            where: {
+                aggregateOrderId: order.id,
+            },
+            relations: ['channels'],
+        });
+    }
+    async getAggregateOrder(ctx, order) {
+        return order.aggregateOrderId == null
+            ? undefined
+            : this.connection
+                .getRepository(ctx, order_entity_1.Order)
+                .findOne({ where: { id: order.aggregateOrderId }, relations: ['channels', 'lines'] })
+                .then(result => result !== null && result !== void 0 ? result : undefined);
+    }
+    getOrderChannels(ctx, order) {
+        return this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .relation('channels')
+            .of(order)
+            .loadMany();
+    }
     /**
      * @description
      * Returns any Order associated with the specified User's Customer account
@@ -288,19 +300,7 @@ let OrderService = class OrderService {
      * User's Customer account.
      */
     async create(ctx, userId) {
-        const newOrder = new order_entity_1.Order({
-            code: await this.configService.orderOptions.orderCodeStrategy.generate(ctx),
-            state: this.orderStateMachine.getInitialState(),
-            lines: [],
-            surcharges: [],
-            couponCodes: [],
-            modifications: [],
-            shippingAddress: {},
-            billingAddress: {},
-            subTotal: 0,
-            subTotalWithTax: 0,
-            currencyCode: ctx.channel.currencyCode,
-        });
+        const newOrder = await this.createEmptyOrderEntity(ctx);
         if (userId) {
             const customer = await this.customerService.findOneByUserId(ctx, userId);
             if (customer) {
@@ -309,7 +309,7 @@ let OrderService = class OrderService {
         }
         await this.channelService.assignToCurrentChannel(newOrder, ctx);
         const order = await this.connection.getRepository(ctx, order_entity_1.Order).save(newOrder);
-        this.eventBus.publish(new index_3.OrderEvent(ctx, order, 'created'));
+        this.eventBus.publish(new index_1.OrderEvent(ctx, order, 'created'));
         const transitionResult = await this.transitionToState(ctx, order.id, 'AddingItems');
         if ((0, error_result_1.isGraphQlErrorResult)(transitionResult)) {
             // this should never occur, so we will throw rather than return
@@ -317,6 +317,35 @@ let OrderService = class OrderService {
         }
         return transitionResult;
     }
+    async createDraft(ctx) {
+        const newOrder = await this.createEmptyOrderEntity(ctx);
+        newOrder.active = false;
+        await this.channelService.assignToCurrentChannel(newOrder, ctx);
+        const order = await this.connection.getRepository(ctx, order_entity_1.Order).save(newOrder);
+        this.eventBus.publish(new index_1.OrderEvent(ctx, order, 'created'));
+        const transitionResult = await this.transitionToState(ctx, order.id, 'Draft');
+        if ((0, error_result_1.isGraphQlErrorResult)(transitionResult)) {
+            // this should never occur, so we will throw rather than return
+            throw transitionResult;
+        }
+        return transitionResult;
+    }
+    async createEmptyOrderEntity(ctx) {
+        return new order_entity_1.Order({
+            type: generated_types_1.OrderType.Regular,
+            code: await this.configService.orderOptions.orderCodeStrategy.generate(ctx),
+            state: this.orderStateMachine.getInitialState(),
+            lines: [],
+            surcharges: [],
+            couponCodes: [],
+            modifications: [],
+            shippingAddress: {},
+            billingAddress: {},
+            subTotal: 0,
+            subTotalWithTax: 0,
+            currencyCode: ctx.currencyCode,
+        });
+    }
     /**
      * @description
      * Updates the custom fields of an Order.
@@ -326,12 +355,12 @@ let OrderService = class OrderService {
         order = (0, patch_entity_1.patchEntity)(order, { customFields });
         await this.customFieldRelationService.updateRelations(ctx, order_entity_1.Order, { customFields }, order);
         const updatedOrder = await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
-        this.eventBus.publish(new index_3.OrderEvent(ctx, updatedOrder, 'updated'));
+        this.eventBus.publish(new index_1.OrderEvent(ctx, updatedOrder, 'updated'));
         return updatedOrder;
     }
     /**
      * @description
-     * Adds an OrderItem to the Order, either creating a new OrderLine or
+     * Adds an item to the Order, either creating a new OrderLine or
      * incrementing an existing one.
      */
     async addItemToOrder(ctx, orderId, productVariantId, quantity, customFields) {
@@ -348,7 +377,7 @@ let OrderService = class OrderService {
             relations: ['product'],
             where: {
                 enabled: true,
-                deletedAt: null,
+                deletedAt: (0, typeorm_1.IsNull)(),
             },
         });
         if (variant.product.enabled === false) {
@@ -398,7 +427,7 @@ let OrderService = class OrderService {
         if (correctedQuantity === 0) {
             order.lines = order.lines.filter(l => !(0, utils_1.idsAreEqual)(l.id, orderLine.id));
             await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
-            this.eventBus.publish(new index_6.OrderLineEvent(ctx, order, orderLine, 'deleted'));
+            this.eventBus.publish(new index_1.OrderLineEvent(ctx, order, orderLine, 'deleted'));
             updatedOrderLines = [];
         }
         else {
@@ -427,7 +456,7 @@ let OrderService = class OrderService {
         order.lines = order.lines.filter(line => !(0, utils_1.idsAreEqual)(line.id, orderLineId));
         const updatedOrder = await this.applyPriceAdjustments(ctx, order);
         await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
-        this.eventBus.publish(new index_6.OrderLineEvent(ctx, order, orderLine, 'deleted'));
+        this.eventBus.publish(new index_1.OrderLineEvent(ctx, order, orderLine, 'deleted'));
         return updatedOrder;
     }
     /**
@@ -494,7 +523,7 @@ let OrderService = class OrderService {
             type: generated_types_1.HistoryEntryType.ORDER_COUPON_APPLIED,
             data: { couponCode, promotionId: validationResult.id },
         });
-        this.eventBus.publish(new index_2.CouponCodeEvent(ctx, couponCode, orderId, 'assigned'));
+        this.eventBus.publish(new index_1.CouponCodeEvent(ctx, couponCode, orderId, 'assigned'));
         return this.applyPriceAdjustments(ctx, order);
     }
     /**
@@ -506,10 +535,8 @@ let OrderService = class OrderService {
         if (order.couponCodes.includes(couponCode)) {
             // When removing a couponCode which has triggered an Order-level discount
             // we need to make sure we persist the changes to the adjustments array of
-            // any affected OrderItems.
-            const affectedOrderItems = order.lines
-                .reduce((items, l) => [...items, ...l.items], [])
-                .filter(i => i.adjustments.filter(a => a.type === generated_types_1.AdjustmentType.DISTRIBUTED_ORDER_PROMOTION)
+            // any affected OrderLines.
+            const affectedOrderLines = order.lines.filter(line => line.adjustments.filter(a => a.type === generated_types_1.AdjustmentType.DISTRIBUTED_ORDER_PROMOTION)
                 .length);
             order.couponCodes = order.couponCodes.filter(cc => cc !== couponCode);
             await this.historyService.createHistoryEntryForOrder({
@@ -518,9 +545,9 @@ let OrderService = class OrderService {
                 type: generated_types_1.HistoryEntryType.ORDER_COUPON_REMOVED,
                 data: { couponCode },
             });
-            this.eventBus.publish(new index_2.CouponCodeEvent(ctx, couponCode, orderId, 'removed'));
+            this.eventBus.publish(new index_1.CouponCodeEvent(ctx, couponCode, orderId, 'removed'));
             const result = await this.applyPriceAdjustments(ctx, order);
-            await this.connection.getRepository(ctx, order_item_entity_1.OrderItem).save(affectedOrderItems);
+            await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).save(affectedOrderLines);
             return result;
         }
         else {
@@ -537,7 +564,7 @@ let OrderService = class OrderService {
             channelId: ctx.channelId,
             relations: ['promotions'],
         });
-        return order.promotions || [];
+        return order.promotions.map(p => this.translator.translate(p, ctx)) || [];
     }
     /**
      * @description
@@ -553,10 +580,17 @@ let OrderService = class OrderService {
     async setShippingAddress(ctx, orderId, input) {
         const order = await this.getOrderOrThrow(ctx, orderId);
         const country = await this.countryService.findOneByCode(ctx, input.countryCode);
-        order.shippingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
+        const shippingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .update(order_entity_1.Order)
+            .set({ shippingAddress })
+            .where('id = :id', { id: order.id })
+            .execute();
+        order.shippingAddress = shippingAddress;
         // Since a changed ShippingAddress could alter the activeTaxZone,
-        // we will remove any cached activeTaxZone so it can be re-calculated
+        // we will remove any cached activeTaxZone, so it can be re-calculated
         // as needed.
         this.requestCache.set(ctx, 'activeTaxZone', undefined);
         return this.applyPriceAdjustments(ctx, order, order.lines);
@@ -568,10 +602,17 @@ let OrderService = class OrderService {
     async setBillingAddress(ctx, orderId, input) {
         const order = await this.getOrderOrThrow(ctx, orderId);
         const country = await this.countryService.findOneByCode(ctx, input.countryCode);
-        order.billingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
-        // Since a changed ShippingAddress could alter the activeTaxZone,
-        // we will remove any cached activeTaxZone so it can be re-calculated
+        const billingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .update(order_entity_1.Order)
+            .set({ billingAddress })
+            .where('id = :id', { id: order.id })
+            .execute();
+        order.billingAddress = billingAddress;
+        // Since a changed BillingAddress could alter the activeTaxZone,
+        // we will remove any cached activeTaxZone, so it can be re-calculated
         // as needed.
         this.requestCache.set(ctx, 'activeTaxZone', undefined);
         return this.applyPriceAdjustments(ctx, order, order.lines);
@@ -613,33 +654,65 @@ let OrderService = class OrderService {
      * @description
      * Sets the ShippingMethod to be used on this Order.
      */
-    async setShippingMethod(ctx, orderId, shippingMethodId) {
+    async setShippingMethod(ctx, orderId, shippingMethodIds) {
         const order = await this.getOrderOrThrow(ctx, orderId);
         const validationError = this.assertAddingItemsState(order);
         if (validationError) {
             return validationError;
         }
-        const shippingMethod = await this.shippingCalculator.getMethodIfEligible(ctx, order, shippingMethodId);
-        if (!shippingMethod) {
-            return new generated_graphql_shop_errors_1.IneligibleShippingMethodError();
+        for (const [i, shippingMethodId] of shippingMethodIds.entries()) {
+            const shippingMethod = await this.shippingCalculator.getMethodIfEligible(ctx, order, shippingMethodId);
+            if (!shippingMethod) {
+                return new generated_graphql_shop_errors_1.IneligibleShippingMethodError();
+            }
+            let shippingLine = order.shippingLines[i];
+            if (shippingLine) {
+                shippingLine.shippingMethod = shippingMethod;
+            }
+            else {
+                shippingLine = await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(new shipping_line_entity_1.ShippingLine({
+                    shippingMethod,
+                    order,
+                    adjustments: [],
+                    listPrice: 0,
+                    listPriceIncludesTax: ctx.channel.pricesIncludeTax,
+                    taxLines: [],
+                }));
+                if (order.shippingLines) {
+                    order.shippingLines.push(shippingLine);
+                }
+                else {
+                    order.shippingLines = [shippingLine];
+                }
+            }
+            await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(shippingLine);
         }
-        let shippingLine = order.shippingLines[0];
-        if (shippingLine) {
-            shippingLine.shippingMethod = shippingMethod;
+        // remove any now-unused ShippingLines
+        if (shippingMethodIds.length < order.shippingLines.length) {
+            const shippingLinesToDelete = order.shippingLines.splice(shippingMethodIds.length - 1);
+            await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).remove(shippingLinesToDelete);
         }
-        else {
-            shippingLine = await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(new shipping_line_entity_1.ShippingLine({
-                shippingMethod,
-                order,
-                adjustments: [],
-                listPrice: 0,
-                listPriceIncludesTax: ctx.channel.pricesIncludeTax,
-                taxLines: [],
-            }));
-            order.shippingLines = [shippingLine];
+        // assign the ShippingLines to the OrderLines
+        await this.connection
+            .getRepository(ctx, order_line_entity_1.OrderLine)
+            .createQueryBuilder('line')
+            .update({ shippingLine: undefined })
+            .whereInIds(order.lines.map(l => l.id))
+            .execute();
+        const { shippingLineAssignmentStrategy } = this.configService.shippingOptions;
+        for (const shippingLine of order.shippingLines) {
+            const orderLinesForShippingLine = await shippingLineAssignmentStrategy.assignShippingLineToOrderLines(ctx, shippingLine, order);
+            await this.connection
+                .getRepository(ctx, order_line_entity_1.OrderLine)
+                .createQueryBuilder('line')
+                .update({ shippingLineId: shippingLine.id })
+                .whereInIds(orderLinesForShippingLine.map(l => l.id))
+                .execute();
+            orderLinesForShippingLine.forEach(line => {
+                line.shippingLine = shippingLine;
+            });
         }
-        await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(shippingLine);
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        const updatedOrder = await this.getOrderOrThrow(ctx, orderId);
         await this.applyPriceAdjustments(ctx, order);
         return this.connection.getRepository(ctx, order_entity_1.Order).save(order);
     }
@@ -651,15 +724,19 @@ let OrderService = class OrderService {
         const order = await this.getOrderOrThrow(ctx, orderId);
         order.payments = await this.getOrderPayments(ctx, orderId);
         const fromState = order.state;
+        let finalize;
         try {
-            await this.orderStateMachine.transition(ctx, order, state);
+            const result = await this.orderStateMachine.transition(ctx, order, state);
+            finalize = result.finalize;
         }
         catch (e) {
             const transitionError = ctx.translate(e.message, { fromState, toState: state });
             return new generated_graphql_shop_errors_1.OrderStateTransitionError({ transitionError, fromState, toState: state });
         }
         await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
-        this.eventBus.publish(new index_4.OrderStateTransitionEvent(fromState, state, ctx, order));
+        this.eventBus.publish(new index_1.OrderStateTransitionEvent(fromState, state, ctx, order));
+        await finalize();
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
         return order;
     }
     /**
@@ -672,14 +749,7 @@ let OrderService = class OrderService {
         if ((0, error_result_1.isGraphQlErrorResult)(result)) {
             return result;
         }
-        const { fulfillment, fromState, toState, orders } = result;
-        if (toState === 'Cancelled') {
-            await this.stockMovementService.createCancellationsForOrderItems(ctx, fulfillment.orderItems);
-            const lines = await this.groupOrderItemsIntoLines(ctx, fulfillment.orderItems);
-            await this.stockMovementService.createAllocationsForOrderLines(ctx, lines);
-        }
-        await Promise.all(orders.map(order => this.handleFulfillmentStateTransitByOrder(ctx, order, fromState, toState)));
-        return fulfillment;
+        return result.fulfillment;
     }
     /**
      * @description
@@ -715,28 +785,6 @@ let OrderService = class OrderService {
         });
         return this.getOrderOrThrow(ctx, input.orderId);
     }
-    async handleFulfillmentStateTransitByOrder(ctx, order, fromState, toState) {
-        const nextOrderStates = this.getNextOrderStates(order);
-        const transitionOrderIfStateAvailable = (state) => nextOrderStates.includes(state) && this.transitionToState(ctx, order.id, state);
-        if (toState === 'Shipped') {
-            const orderWithFulfillment = await this.getOrderWithFulfillments(ctx, order.id);
-            if ((0, order_utils_1.orderItemsAreShipped)(orderWithFulfillment)) {
-                await transitionOrderIfStateAvailable('Shipped');
-            }
-            else {
-                await transitionOrderIfStateAvailable('PartiallyShipped');
-            }
-        }
-        if (toState === 'Delivered') {
-            const orderWithFulfillment = await this.getOrderWithFulfillments(ctx, order.id);
-            if ((0, order_utils_1.orderItemsAreDelivered)(orderWithFulfillment)) {
-                await transitionOrderIfStateAvailable('Delivered');
-            }
-            else {
-                await transitionOrderIfStateAvailable('PartiallyDelivered');
-            }
-        }
-    }
     /**
      * @description
      * Transitions the given {@link Payment} to a new state. If the order totalWithTax price is then
@@ -748,11 +796,6 @@ let OrderService = class OrderService {
         if ((0, error_result_1.isGraphQlErrorResult)(result)) {
             return result;
         }
-        const order = await this.findOne(ctx, result.order.id);
-        if (order) {
-            order.payments = await this.getOrderPayments(ctx, order.id);
-            await this.transitionOrderIfTotalIsCovered(ctx, order);
-        }
         return result;
     }
     /**
@@ -771,16 +814,19 @@ let OrderService = class OrderService {
         if ((0, error_result_1.isGraphQlErrorResult)(payment)) {
             return payment;
         }
-        const existingPayments = await this.getOrderPayments(ctx, orderId);
-        order.payments = [...existingPayments, payment];
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder()
+            .relation('payments')
+            .of(order)
+            .add(payment);
         if (payment.state === 'Error') {
             return new generated_graphql_shop_errors_1.PaymentFailedError({ paymentErrorMessage: payment.errorMessage || '' });
         }
         if (payment.state === 'Declined') {
             return new generated_graphql_shop_errors_1.PaymentDeclinedError({ paymentErrorMessage: payment.errorMessage || '' });
         }
-        return this.transitionOrderIfTotalIsCovered(ctx, order);
+        return (0, utils_1.assertFound)(this.findOne(ctx, order.id));
     }
     /**
      * @description
@@ -796,16 +842,6 @@ let OrderService = class OrderService {
         const canTransitionToPaymentSettled = this.orderStateMachine.canTransition(order.state, 'PaymentSettled');
         return canTransitionToPaymentAuthorized && canTransitionToPaymentSettled;
     }
-    async transitionOrderIfTotalIsCovered(ctx, order) {
-        const orderId = order.id;
-        if ((0, order_utils_1.orderTotalIsCovered)(order, 'Settled') && order.state !== 'PaymentSettled') {
-            return this.transitionToState(ctx, orderId, 'PaymentSettled');
-        }
-        if ((0, order_utils_1.orderTotalIsCovered)(order, ['Authorized', 'Settled']) && order.state !== 'PaymentAuthorized') {
-            return this.transitionToState(ctx, orderId, 'PaymentAuthorized');
-        }
-        return order;
-    }
     /**
      * @description
      * This method is used after modifying an existing completed order using the `modifyOrder()` method. If the modifications
@@ -838,7 +874,7 @@ let OrderService = class OrderService {
             modification.payment = payment;
             await this.connection.getRepository(ctx, order_modification_entity_1.OrderModification).save(modification);
         }
-        return order;
+        return (0, utils_1.assertFound)(this.findOne(ctx, order.id));
     }
     /**
      * @description
@@ -851,13 +887,19 @@ let OrderService = class OrderService {
             if (payment.state !== 'Settled') {
                 return new generated_graphql_admin_errors_1.SettlePaymentError({ paymentErrorMessage: payment.errorMessage || '' });
             }
-            const order = await this.findOne(ctx, payment.order.id);
-            if (order) {
-                order.payments = await this.getOrderPayments(ctx, order.id);
-                const orderTransitionResult = await this.transitionOrderIfTotalIsCovered(ctx, order);
-                if ((0, error_result_1.isGraphQlErrorResult)(orderTransitionResult)) {
-                    return orderTransitionResult;
-                }
+        }
+        return payment;
+    }
+    /**
+     * @description
+     * Cancels a payment by invoking the {@link PaymentMethodHandler}'s `cancelPayment()` method (if defined), and transitions the Payment to
+     * the `Cancelled` state.
+     */
+    async cancelPayment(ctx, paymentId) {
+        const payment = await this.paymentService.cancelPayment(ctx, paymentId);
+        if (!(0, error_result_1.isGraphQlErrorResult)(payment)) {
+            if (payment.state !== 'Cancelled') {
+                return new generated_graphql_admin_errors_1.CancelPaymentError({ paymentErrorMessage: payment.errorMessage || '' });
             }
         }
         return payment;
@@ -870,20 +912,25 @@ let OrderService = class OrderService {
         if (!input.lines || input.lines.length === 0 || (0, shared_utils_1.summate)(input.lines, 'quantity') === 0) {
             return new generated_graphql_admin_errors_1.EmptyOrderLineSelectionError();
         }
-        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, input.lines, i => !i.fulfillment && !i.cancelled);
-        if (!ordersAndItems) {
+        const orders = await (0, order_utils_1.getOrdersFromLines)(ctx, this.connection, input.lines);
+        if (await this.requestedFulfillmentQuantityExceedsLineQuantity(ctx, input)) {
             return new generated_graphql_admin_errors_1.ItemsAlreadyFulfilledError();
         }
         const stockCheckResult = await this.ensureSufficientStockForFulfillment(ctx, input);
         if ((0, error_result_1.isGraphQlErrorResult)(stockCheckResult)) {
             return stockCheckResult;
         }
-        const fulfillment = await this.fulfillmentService.create(ctx, ordersAndItems.orders, ordersAndItems.items, input.handler);
+        const fulfillment = await this.fulfillmentService.create(ctx, orders, input.lines, input.handler);
         if ((0, error_result_1.isGraphQlErrorResult)(fulfillment)) {
             return fulfillment;
         }
-        await this.stockMovementService.createSalesForOrder(ctx, ordersAndItems.items);
-        for (const order of ordersAndItems.orders) {
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder()
+            .relation('fulfillments')
+            .of(orders)
+            .add(fulfillment);
+        for (const order of orders) {
             await this.historyService.createHistoryEntryForOrder({
                 ctx,
                 orderId: order.id,
@@ -899,18 +946,45 @@ let OrderService = class OrderService {
         }
         return result.fulfillment;
     }
+    async requestedFulfillmentQuantityExceedsLineQuantity(ctx, input) {
+        var _a;
+        const linesToBeFulfilled = await this.connection
+            .getRepository(ctx, fulfillment_line_entity_1.FulfillmentLine)
+            .createQueryBuilder('fulfillmentLine')
+            .leftJoinAndSelect('fulfillmentLine.orderLine', 'orderLine')
+            .leftJoinAndSelect('fulfillmentLine.fulfillment', 'fulfillment')
+            .where('fulfillmentLine.orderLineId IN (:...orderLineIds)', {
+            orderLineIds: input.lines.map(l => l.orderLineId),
+        })
+            .andWhere('fulfillment.state != :state', { state: 'Cancelled' })
+            .getMany();
+        for (const lineToBeFulfilled of linesToBeFulfilled) {
+            const unfulfilledQuantity = lineToBeFulfilled.orderLine.quantity - lineToBeFulfilled.quantity;
+            const lineInput = input.lines.find(l => (0, utils_1.idsAreEqual)(l.orderLineId, lineToBeFulfilled.orderLine.id));
+            if (unfulfilledQuantity < ((_a = lineInput === null || lineInput === void 0 ? void 0 : lineInput.quantity) !== null && _a !== void 0 ? _a : 0)) {
+                return true;
+            }
+        }
+        return false;
+    }
     async ensureSufficientStockForFulfillment(ctx, input) {
-        const lines = await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).findByIds(input.lines.map(l => l.orderLineId), { relations: ['productVariant'] });
+        const lines = await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).find({
+            where: {
+                id: (0, typeorm_1.In)(input.lines.map(l => l.orderLineId)),
+            },
+            relations: ['productVariant'],
+        });
         for (const line of lines) {
-            // tslint:disable-next-line:no-non-null-assertion
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const lineInput = input.lines.find(l => (0, utils_1.idsAreEqual)(l.orderLineId, line.id));
             const fulfillableStockLevel = await this.productVariantService.getFulfillableStockLevel(ctx, line.productVariant);
             if (fulfillableStockLevel < lineInput.quantity) {
-                const productVariant = (0, translate_entity_1.translateDeep)(line.productVariant, ctx.languageCode);
+                const { stockOnHand } = await this.stockLevelService.getAvailableStock(ctx, line.productVariant.id);
+                const productVariant = this.translator.translate(line.productVariant, ctx);
                 return new generated_graphql_admin_errors_1.InsufficientStockOnHandError({
                     productVariantId: productVariant.id,
                     productVariantName: productVariant.name,
-                    stockOnHand: productVariant.stockOnHand,
+                    stockOnHand,
                 });
             }
         }
@@ -920,22 +994,10 @@ let OrderService = class OrderService {
      * Returns an array of all Fulfillments associated with the Order.
      */
     async getOrderFulfillments(ctx, order) {
-        var _a, _b, _c, _d;
-        let lines;
-        if (((_d = (_c = (_b = (_a = order.lines) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.items) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.fulfillments) !== undefined) {
-            lines = order.lines;
-        }
-        else {
-            lines = await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).find({
-                where: {
-                    order: order.id,
-                },
-                relations: ['items', 'items.fulfillments'],
-            });
-        }
-        const items = lines.reduce((acc, l) => [...acc, ...l.items], []);
-        const fulfillments = items.reduce((acc, i) => [...acc, ...(i.fulfillments || [])], []);
-        return (0, unique_1.unique)(fulfillments, 'id');
+        const { fulfillments } = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, order.id, {
+            relations: ['fulfillments'],
+        });
+        return fulfillments;
     }
     /**
      * @description
@@ -956,7 +1018,7 @@ let OrderService = class OrderService {
     async cancelOrder(ctx, input) {
         let allOrderItemsCancelled = false;
         const cancelResult = input.lines != null
-            ? await this.cancelOrderByOrderLines(ctx, input, input.lines)
+            ? await this.orderModifier.cancelOrderByOrderLines(ctx, input, input.lines)
             : await this.cancelOrderById(ctx, input);
         if ((0, error_result_1.isGraphQlErrorResult)(cancelResult)) {
             return cancelResult;
@@ -982,79 +1044,21 @@ let OrderService = class OrderService {
                 orderLineId: l.id,
                 quantity: l.quantity,
             }));
-            return this.cancelOrderByOrderLines(ctx, input, lines);
+            return this.orderModifier.cancelOrderByOrderLines(ctx, input, lines);
         }
     }
-    async cancelOrderByOrderLines(ctx, input, lines) {
-        if (lines.length === 0 || (0, shared_utils_1.summate)(lines, 'quantity') === 0) {
-            return new generated_graphql_admin_errors_1.EmptyOrderLineSelectionError();
-        }
-        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, lines, i => !i.cancelled);
-        if (!ordersAndItems) {
-            return new generated_graphql_admin_errors_1.QuantityTooGreatError();
-        }
-        if (1 < ordersAndItems.orders.length) {
-            return new generated_graphql_admin_errors_1.MultipleOrderError();
-        }
-        const { orders, items } = ordersAndItems;
-        const order = orders[0];
-        if (!(0, utils_1.idsAreEqual)(order.id, input.orderId)) {
-            return new generated_graphql_admin_errors_1.MultipleOrderError();
-        }
-        if (order.active) {
-            return new generated_graphql_admin_errors_1.CancelActiveOrderError({ orderState: order.state });
-        }
-        const fullOrder = await this.findOne(ctx, order.id);
-        const soldItems = items.filter(i => !!i.fulfillment);
-        const allocatedItems = items.filter(i => !i.fulfillment);
-        await this.stockMovementService.createCancellationsForOrderItems(ctx, soldItems);
-        await this.stockMovementService.createReleasesForOrderItems(ctx, allocatedItems);
-        items.forEach(i => (i.cancelled = true));
-        await this.connection.getRepository(ctx, order_item_entity_1.OrderItem).save(items, { reload: false });
-        const orderWithItems = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, order.id, {
-            relations: ['lines', 'lines.items', 'surcharges', 'shippingLines'],
-        });
-        if (input.cancelShipping === true) {
-            for (const shippingLine of orderWithItems.shippingLines) {
-                shippingLine.adjustments.push({
-                    adjustmentSource: 'CANCEL_ORDER',
-                    type: generated_types_1.AdjustmentType.OTHER,
-                    description: 'shipping cancellation',
-                    amount: -shippingLine.discountedPriceWithTax,
-                });
-                this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(shippingLine, { reload: false });
-            }
-        }
-        // Update totals after cancellation
-        this.orderCalculator.calculateOrderTotals(orderWithItems);
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(orderWithItems, { reload: false });
-        await this.historyService.createHistoryEntryForOrder({
-            ctx,
-            orderId: order.id,
-            type: generated_types_1.HistoryEntryType.ORDER_CANCELLATION,
-            data: {
-                orderItemIds: items.map(i => i.id),
-                reason: input.reason || undefined,
-                shippingCancelled: !!input.cancelShipping,
-            },
-        });
-        return (0, order_utils_1.orderItemsAreAllCancelled)(orderWithItems);
-    }
     /**
      * @description
      * Creates a {@link Refund} against the order and in doing so invokes the `createRefund()` method of the
      * {@link PaymentMethodHandler}.
      */
     async refundOrder(ctx, input) {
+        var _a;
         if ((!input.lines || input.lines.length === 0 || (0, shared_utils_1.summate)(input.lines, 'quantity') === 0) &&
             input.shipping === 0) {
             return new generated_graphql_admin_errors_1.NothingToRefundError();
         }
-        const ordersAndItems = await this.getOrdersAndItemsFromLines(ctx, input.lines, i => { var _a; return ((_a = i.refund) === null || _a === void 0 ? void 0 : _a.state) !== 'Settled'; });
-        if (!ordersAndItems) {
-            return new generated_graphql_admin_errors_1.QuantityTooGreatError();
-        }
-        const { orders, items } = ordersAndItems;
+        const orders = await (0, order_utils_1.getOrdersFromLines)(ctx, this.connection, (_a = input.lines) !== null && _a !== void 0 ? _a : []);
         if (1 < orders.length) {
             return new generated_graphql_admin_errors_1.MultipleOrderError();
         }
@@ -1070,11 +1074,7 @@ let OrderService = class OrderService {
             order.state === 'PaymentAuthorized') {
             return new generated_graphql_admin_errors_1.RefundOrderStateError({ orderState: order.state });
         }
-        const alreadyRefunded = items.find(i => { var _a, _b; return ((_a = i.refund) === null || _a === void 0 ? void 0 : _a.state) === 'Pending' || ((_b = i.refund) === null || _b === void 0 ? void 0 : _b.state) === 'Settled'; });
-        if (alreadyRefunded) {
-            return new generated_graphql_admin_errors_1.AlreadyRefundedError({ refundId: alreadyRefunded.refundId });
-        }
-        return await this.paymentService.createRefund(ctx, input, order, items, payment);
+        return await this.paymentService.createRefund(ctx, input, order, payment);
     }
     /**
      * @description
@@ -1087,9 +1087,10 @@ let OrderService = class OrderService {
         refund.transactionId = input.transactionId;
         const fromState = refund.state;
         const toState = 'Settled';
-        await this.refundStateMachine.transition(ctx, refund.payment.order, refund, toState);
+        const { finalize } = await this.refundStateMachine.transition(ctx, refund.payment.order, refund, toState);
         await this.connection.getRepository(ctx, refund_entity_1.Refund).save(refund);
-        this.eventBus.publish(new index_5.RefundStateTransitionEvent(fromState, toState, ctx, refund, refund.payment.order));
+        await finalize();
+        this.eventBus.publish(new index_1.RefundStateTransitionEvent(fromState, toState, ctx, refund, refund.payment.order));
         return refund;
     }
     /**
@@ -1102,20 +1103,16 @@ let OrderService = class OrderService {
         await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
         // Check that any applied couponCodes are still valid now that
         // we know the Customer.
+        let updatedOrder = order;
         if (order.couponCodes) {
-            let codesRemoved = false;
             for (const couponCode of order.couponCodes.slice()) {
                 const validationResult = await this.promotionService.validateCouponCode(ctx, couponCode, customer.id);
                 if ((0, error_result_1.isGraphQlErrorResult)(validationResult)) {
-                    order.couponCodes = order.couponCodes.filter(c => c !== couponCode);
-                    codesRemoved = true;
+                    updatedOrder = await this.removeCouponCode(ctx, orderId, couponCode);
                 }
             }
-            if (codesRemoved) {
-                return this.applyPriceAdjustments(ctx, order);
-            }
         }
-        return order;
+        return updatedOrder;
     }
     /**
      * @description
@@ -1168,21 +1165,17 @@ let OrderService = class OrderService {
             ? orderOrId
             : await this.connection
                 .getRepository(ctx, order_entity_1.Order)
-                .findOneOrFail(orderOrId, { relations: ['lines'] });
+                .findOneOrFail({ where: { id: orderOrId }, relations: ['lines', 'shippingLines'] });
         // If there is a Session referencing the Order to be deleted, we must first remove that
         // reference in order to avoid a foreign key error. See https://github.com/vendure-ecommerce/vendure/issues/1454
         const sessions = await this.connection
-            .getRepository(ctx, index_1.Session)
+            .getRepository(ctx, session_entity_1.Session)
             .find({ where: { activeOrderId: orderToDelete.id } });
         if (sessions.length) {
             await this.connection
-                .getRepository(ctx, index_1.Session)
+                .getRepository(ctx, session_entity_1.Session)
                 .update(sessions.map(s => s.id), { activeOrder: null });
         }
-        // TODO: v2 - Will not be needed after adding `{ onDelete: 'CASCADE' }` constraint to ShippingLine.order
-        for (const shippingLine of orderToDelete.shippingLines) {
-            await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).delete(shippingLine.id);
-        }
         await this.connection.getRepository(ctx, order_entity_1.Order).delete(orderToDelete.id);
     }
     /**
@@ -1198,7 +1191,7 @@ let OrderService = class OrderService {
             // so we do not want to merge at all. See https://github.com/vendure-ecommerce/vendure/issues/263
             return existingOrder;
         }
-        const mergeResult = await this.orderMerger.merge(ctx, guestOrder, existingOrder);
+        const mergeResult = this.orderMerger.merge(ctx, guestOrder, existingOrder);
         const { orderToDelete, linesToInsert, linesToDelete, linesToModify } = mergeResult;
         let { order } = mergeResult;
         if (orderToDelete) {
@@ -1248,7 +1241,7 @@ let OrderService = class OrderService {
     getOrderLineOrThrow(order, orderLineId) {
         const orderLine = order.lines.find(line => (0, utils_1.idsAreEqual)(line.id, orderLineId));
         if (!orderLine) {
-            throw new errors_1.UserInputError(`error.order-does-not-contain-line-with-id`, { id: orderLineId });
+            throw new errors_1.UserInputError('error.order-does-not-contain-line-with-id', { id: orderLineId });
         }
         return orderLine;
     }
@@ -1261,10 +1254,10 @@ let OrderService = class OrderService {
         }
     }
     /**
-     * Returns error if the Order is not in the "AddingItems" state.
+     * Returns error if the Order is not in the "AddingItems" or "Draft" state.
      */
     assertAddingItemsState(order) {
-        if (order.state !== 'AddingItems') {
+        if (order.state !== 'AddingItems' && order.state !== 'Draft') {
             return new generated_graphql_shop_errors_1.OrderModificationError();
         }
     }
@@ -1296,121 +1289,36 @@ let OrderService = class OrderService {
      * then all of those OrderLines will have their prices re-calculated using the configured {@link OrderItemPriceCalculationStrategy}.
      */
     async applyPriceAdjustments(ctx, order, updatedOrderLines) {
-        var _a, _b;
+        var _a;
+        const promotions = await this.promotionService.getActivePromotionsInChannel(ctx);
+        const activePromotionsPre = await this.promotionService.getActivePromotionsOnOrder(ctx, order.id);
         if (updatedOrderLines === null || updatedOrderLines === void 0 ? void 0 : updatedOrderLines.length) {
             const { orderItemPriceCalculationStrategy, changedPriceHandlingStrategy } = this.configService.orderOptions;
             for (const updatedOrderLine of updatedOrderLines) {
                 const variant = await this.productVariantService.applyChannelPriceAndTax(updatedOrderLine.productVariant, ctx, order);
-                let priceResult = await orderItemPriceCalculationStrategy.calculateUnitPrice(ctx, variant, updatedOrderLine.customFields || {});
-                const initialListPrice = (_b = (_a = updatedOrderLine.items.find(i => i.initialListPrice != null)) === null || _a === void 0 ? void 0 : _a.initialListPrice) !== null && _b !== void 0 ? _b : priceResult.price;
+                let priceResult = await orderItemPriceCalculationStrategy.calculateUnitPrice(ctx, variant, updatedOrderLine.customFields || {}, order, updatedOrderLine.quantity);
+                const initialListPrice = (_a = updatedOrderLine.initialListPrice) !== null && _a !== void 0 ? _a : priceResult.price;
                 if (initialListPrice !== priceResult.price) {
-                    priceResult = await changedPriceHandlingStrategy.handlePriceChange(ctx, priceResult, updatedOrderLine.items);
+                    priceResult = await changedPriceHandlingStrategy.handlePriceChange(ctx, priceResult, updatedOrderLine, order);
                 }
-                for (const item of updatedOrderLine.items) {
-                    if (item.initialListPrice == null) {
-                        item.initialListPrice = initialListPrice;
-                    }
-                    item.listPrice = priceResult.price;
-                    item.listPriceIncludesTax = priceResult.priceIncludesTax;
+                if (updatedOrderLine.initialListPrice == null) {
+                    updatedOrderLine.initialListPrice = initialListPrice;
                 }
+                updatedOrderLine.listPrice = priceResult.price;
+                updatedOrderLine.listPriceIncludesTax = priceResult.priceIncludesTax;
             }
         }
-        const { items: promotions } = await this.promotionService.findAll(ctx, {
-            filter: { enabled: { eq: true } },
-            sort: { priorityScore: 'ASC' },
-        });
-        const updatedItems = await this.orderCalculator.applyPriceAdjustments(ctx, order, promotions, updatedOrderLines !== null && updatedOrderLines !== void 0 ? updatedOrderLines : []);
-        const updateFields = [
-            'initialListPrice',
-            'listPrice',
-            'listPriceIncludesTax',
-            'adjustments',
-            'taxLines',
-        ];
+        const updatedOrder = await this.orderCalculator.applyPriceAdjustments(ctx, order, promotions, updatedOrderLines !== null && updatedOrderLines !== void 0 ? updatedOrderLines : []);
         await this.connection
-            .getRepository(ctx, order_item_entity_1.OrderItem)
-            .createQueryBuilder()
-            .insert()
-            .into(order_item_entity_1.OrderItem, [...updateFields, 'id', 'lineId'])
-            .values(updatedItems)
-            .orUpdate({
-            conflict_target: ['id'],
-            overwrite: updateFields,
-        })
-            .updateEntity(false)
-            .execute();
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
+            .getRepository(ctx, order_entity_1.Order)
+            // Explicitly omit the shippingAddress and billingAddress properties to avoid
+            // a race condition where changing one or the other in parallel can
+            // overwrite the other's changes.
+            .save((0, omit_1.omit)(updatedOrder, ['shippingAddress', 'billingAddress']), { reload: false });
+        await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).save(updatedOrder.lines, { reload: false });
         await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(order.shippingLines, { reload: false });
-        return order;
-    }
-    async getOrderWithFulfillments(ctx, orderId) {
-        return await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, orderId, {
-            relations: ['lines', 'lines.items', 'lines.items.fulfillments'],
-        });
-    }
-    async getOrdersAndItemsFromLines(ctx, orderLinesInput, itemMatcher) {
-        const orders = new Map();
-        const items = new Map();
-        const lines = await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).findByIds(orderLinesInput.map(l => l.orderLineId), {
-            relations: ['order', 'items', 'items.fulfillments', 'order.channels', 'items.refund'],
-            order: { id: 'ASC' },
-        });
-        for (const line of lines) {
-            const inputLine = orderLinesInput.find(l => (0, utils_1.idsAreEqual)(l.orderLineId, line.id));
-            if (!inputLine) {
-                continue;
-            }
-            const order = line.order;
-            if (!order.channels.some(channel => channel.id === ctx.channelId)) {
-                throw new errors_1.EntityNotFoundError('Order', order.id);
-            }
-            if (!orders.has(order.id)) {
-                orders.set(order.id, order);
-            }
-            const matchingItems = line.items.sort((a, b) => (a.id < b.id ? -1 : 1)).filter(itemMatcher);
-            if (matchingItems.length < inputLine.quantity) {
-                return false;
-            }
-            matchingItems.slice(0, inputLine.quantity).forEach(item => {
-                items.set(item.id, item);
-            });
-        }
-        return {
-            orders: Array.from(orders.values()),
-            items: Array.from(items.values()),
-        };
-    }
-    mergePaymentMetadata(m1, m2) {
-        if (!m2) {
-            return m1;
-        }
-        const merged = Object.assign(Object.assign({}, m1), m2);
-        if (m1.public && m1.public) {
-            merged.public = Object.assign(Object.assign({}, m1.public), m2.public);
-        }
-        return merged;
-    }
-    async groupOrderItemsIntoLines(ctx, orderItems) {
-        const orderLineIdQuantityMap = new Map();
-        for (const item of orderItems) {
-            const quantity = orderLineIdQuantityMap.get(item.lineId);
-            if (quantity == null) {
-                orderLineIdQuantityMap.set(item.lineId, 1);
-            }
-            else {
-                orderLineIdQuantityMap.set(item.lineId, quantity + 1);
-            }
-        }
-        const orderLines = await this.connection
-            .getRepository(ctx, order_line_entity_1.OrderLine)
-            .findByIds([...orderLineIdQuantityMap.keys()], {
-            relations: ['productVariant'],
-        });
-        return orderLines.map(orderLine => ({
-            orderLine,
-            // tslint:disable-next-line:no-non-null-assertion
-            quantity: orderLineIdQuantityMap.get(orderLine.id),
-        }));
+        await this.promotionService.runPromotionSideEffects(ctx, order, activePromotionsPre);
+        return (0, utils_1.assertFound)(this.findOne(ctx, order.id));
     }
 };
 OrderService = __decorate([
@@ -1437,7 +1345,9 @@ OrderService = __decorate([
         channel_service_1.ChannelService,
         order_modifier_1.OrderModifier,
         custom_field_relation_service_1.CustomFieldRelationService,
-        request_context_cache_service_1.RequestContextCacheService])
+        request_context_cache_service_1.RequestContextCacheService,
+        translator_service_1.TranslatorService,
+        stock_level_service_1.StockLevelService])
 ], OrderService);
 exports.OrderService = OrderService;
 //# sourceMappingURL=order.service.js.map