@vendure/core 1.9.4 → 2.0.0-beta.0

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

@@ -12,7 +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 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");
@@ -22,26 +24,19 @@ const generated_graphql_shop_errors_1 = require("../../common/error/generated-gr
 const tax_utils_1 = require("../../common/tax-utils");
 const utils_1 = require("../../common/utils");
 const config_service_1 = require("../../config/config.service");
-const remove_custom_fields_with_eager_relations_1 = require("../../connection/remove-custom-fields-with-eager-relations");
 const transactional_connection_1 = require("../../connection/transactional-connection");
-const fulfillment_entity_1 = require("../../entity/fulfillment/fulfillment.entity");
-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 allocation_entity_1 = require("../../entity/stock-movement/allocation.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");
@@ -63,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
@@ -71,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, translator) {
+    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;
@@ -96,6 +92,7 @@ let OrderService = class OrderService {
         this.customFieldRelationService = customFieldRelationService;
         this.requestCache = requestCache;
         this.translator = translator;
+        this.stockLevelService = stockLevelService;
     }
     /**
      * @description
@@ -117,7 +114,6 @@ let OrderService = class OrderService {
                 'lines',
                 'customer',
                 'lines.productVariant',
-                'lines.items',
                 'channels',
                 'shippingLines',
                 'payments',
@@ -138,13 +134,11 @@ let OrderService = class OrderService {
     }
     async findOne(ctx, orderId, relations) {
         const qb = this.connection.getRepository(ctx, order_entity_1.Order).createQueryBuilder('order');
-        let effectiveRelations = relations !== null && relations !== void 0 ? relations : [
+        const effectiveRelations = relations !== null && relations !== void 0 ? relations : [
             'channels',
             'customer',
             'customer.user',
             'lines',
-            'lines.items',
-            'lines.items.fulfillments',
             'lines.productVariant',
             'lines.productVariant.taxCategory',
             'lines.productVariant.productVariantPrices',
@@ -159,19 +153,14 @@ let OrderService = class OrderService {
             !effectiveRelations.includes('lines.productVariant.taxCategory')) {
             effectiveRelations.push('lines.productVariant.taxCategory');
         }
-        effectiveRelations = remove_custom_fields_with_eager_relations_1.removeCustomFieldsWithEagerRelations(qb, effectiveRelations);
-        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')
-                .addOrderBy('order__lines.productVariantId', '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) {
@@ -201,13 +190,13 @@ 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,
         })
@@ -233,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.
@@ -250,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'],
         });
     }
     /**
@@ -266,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
@@ -306,9 +309,9 @@ 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 (error_result_1.isGraphQlErrorResult(transitionResult)) {
+        if ((0, error_result_1.isGraphQlErrorResult)(transitionResult)) {
             // this should never occur, so we will throw rather than return
             throw transitionResult;
         }
@@ -319,9 +322,9 @@ let OrderService = class OrderService {
         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_3.OrderEvent(ctx, order, 'created'));
+        this.eventBus.publish(new index_1.OrderEvent(ctx, order, 'created'));
         const transitionResult = await this.transitionToState(ctx, order.id, 'Draft');
-        if (error_result_1.isGraphQlErrorResult(transitionResult)) {
+        if ((0, error_result_1.isGraphQlErrorResult)(transitionResult)) {
             // this should never occur, so we will throw rather than return
             throw transitionResult;
         }
@@ -329,6 +332,7 @@ let OrderService = class OrderService {
     }
     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: [],
@@ -339,7 +343,7 @@ let OrderService = class OrderService {
             billingAddress: {},
             subTotal: 0,
             subTotalWithTax: 0,
-            currencyCode: ctx.channel.currencyCode,
+            currencyCode: ctx.currencyCode,
         });
     }
     /**
@@ -348,10 +352,10 @@ let OrderService = class OrderService {
      */
     async updateCustomFields(ctx, orderId, customFields) {
         let order = await this.getOrderOrThrow(ctx, orderId);
-        order = patch_entity_1.patchEntity(order, { customFields });
+        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;
     }
     /**
@@ -373,7 +377,7 @@ let OrderService = class OrderService {
             relations: ['product'],
             where: {
                 enabled: true,
-                deletedAt: null,
+                deletedAt: (0, typeorm_1.IsNull)(),
             },
         });
         if (variant.product.enabled === false) {
@@ -381,7 +385,7 @@ let OrderService = class OrderService {
         }
         const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, variant, quantity, existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.quantity);
         if (correctedQuantity === 0) {
-            return new generated_graphql_shop_errors_1.InsufficientStockError(correctedQuantity, order);
+            return new generated_graphql_shop_errors_1.InsufficientStockError({ order, quantityAvailable: correctedQuantity });
         }
         const orderLine = await this.orderModifier.getOrCreateOrderLine(ctx, order, productVariantId, customFields);
         if (correctedQuantity < quantity) {
@@ -394,7 +398,7 @@ let OrderService = class OrderService {
         const quantityWasAdjustedDown = correctedQuantity < quantity;
         const updatedOrder = await this.applyPriceAdjustments(ctx, order, [orderLine]);
         if (quantityWasAdjustedDown) {
-            return new generated_graphql_shop_errors_1.InsufficientStockError(correctedQuantity, updatedOrder);
+            return new generated_graphql_shop_errors_1.InsufficientStockError({ quantityAvailable: correctedQuantity, order: updatedOrder });
         }
         else {
             return updatedOrder;
@@ -421,9 +425,9 @@ let OrderService = class OrderService {
         const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, orderLine.productVariant, quantity);
         let updatedOrderLines = [orderLine];
         if (correctedQuantity === 0) {
-            order.lines = order.lines.filter(l => !utils_1.idsAreEqual(l.id, orderLine.id));
+            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 {
@@ -432,7 +436,7 @@ let OrderService = class OrderService {
         const quantityWasAdjustedDown = correctedQuantity < quantity;
         const updatedOrder = await this.applyPriceAdjustments(ctx, order, updatedOrderLines);
         if (quantityWasAdjustedDown) {
-            return new generated_graphql_shop_errors_1.InsufficientStockError(correctedQuantity, updatedOrder);
+            return new generated_graphql_shop_errors_1.InsufficientStockError({ quantityAvailable: correctedQuantity, order: updatedOrder });
         }
         else {
             return updatedOrder;
@@ -449,10 +453,10 @@ let OrderService = class OrderService {
             return validationError;
         }
         const orderLine = this.getOrderLineOrThrow(order, orderLineId);
-        order.lines = order.lines.filter(line => !utils_1.idsAreEqual(line.id, orderLineId));
+        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;
     }
     /**
@@ -488,8 +492,8 @@ let OrderService = class OrderService {
     async removeSurchargeFromOrder(ctx, orderId, surchargeId) {
         const order = await this.getOrderOrThrow(ctx, orderId);
         const surcharge = await this.connection.getEntityOrThrow(ctx, surcharge_entity_1.Surcharge, surchargeId);
-        if (order.surcharges.find(s => utils_1.idsAreEqual(s.id, surcharge.id))) {
-            order.surcharges = order.surcharges.filter(s => !utils_1.idsAreEqual(s.id, surchargeId));
+        if (order.surcharges.find(s => (0, utils_1.idsAreEqual)(s.id, surcharge.id))) {
+            order.surcharges = order.surcharges.filter(s => !(0, utils_1.idsAreEqual)(s.id, surchargeId));
             const updatedOrder = await this.applyPriceAdjustments(ctx, order);
             await this.connection.getRepository(ctx, surcharge_entity_1.Surcharge).remove(surcharge);
             return updatedOrder;
@@ -509,7 +513,7 @@ let OrderService = class OrderService {
             return order;
         }
         const validationResult = await this.promotionService.validateCouponCode(ctx, couponCode, order.customer && order.customer.id);
-        if (error_result_1.isGraphQlErrorResult(validationResult)) {
+        if ((0, error_result_1.isGraphQlErrorResult)(validationResult)) {
             return validationResult;
         }
         order.couponCodes.push(couponCode);
@@ -519,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);
     }
     /**
@@ -531,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({
@@ -543,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 {
@@ -562,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
@@ -584,7 +586,8 @@ let OrderService = class OrderService {
             .createQueryBuilder('order')
             .update(order_entity_1.Order)
             .set({ shippingAddress })
-            .where('id = :id', { id: order.id });
+            .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
@@ -605,7 +608,8 @@ let OrderService = class OrderService {
             .createQueryBuilder('order')
             .update(order_entity_1.Order)
             .set({ billingAddress })
-            .where('id = :id', { id: order.id });
+            .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
@@ -628,8 +632,8 @@ let OrderService = class OrderService {
             const { price, taxRate, priceIncludesTax, metadata } = eligible.result;
             return {
                 id: eligible.method.id,
-                price: priceIncludesTax ? tax_utils_1.netPriceOf(price, taxRate) : price,
-                priceWithTax: priceIncludesTax ? price : tax_utils_1.grossPriceOf(price, taxRate),
+                price: priceIncludesTax ? (0, tax_utils_1.netPriceOf)(price, taxRate) : price,
+                priceWithTax: priceIncludesTax ? price : (0, tax_utils_1.grossPriceOf)(price, taxRate),
                 description: eligible.method.description,
                 name: eligible.method.name,
                 code: eligible.method.code,
@@ -650,32 +654,61 @@ 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({ shippingLine })
+                .whereInIds(orderLinesForShippingLine.map(l => l.id))
+                .execute();
         }
-        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 });
         await this.applyPriceAdjustments(ctx, order);
         return this.connection.getRepository(ctx, order_entity_1.Order).save(order);
@@ -688,15 +721,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, 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;
     }
     /**
@@ -706,17 +743,10 @@ let OrderService = class OrderService {
      */
     async transitionFulfillmentToState(ctx, fulfillmentId, state) {
         const result = await this.fulfillmentService.transitionToState(ctx, fulfillmentId, state);
-        if (error_result_1.isGraphQlErrorResult(result)) {
+        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
@@ -736,7 +766,7 @@ let OrderService = class OrderService {
     async modifyOrder(ctx, input) {
         const order = await this.getOrderOrThrow(ctx, input.orderId);
         const result = await this.orderModifier.modifyOrder(ctx, input, order);
-        if (error_result_1.isGraphQlErrorResult(result)) {
+        if ((0, error_result_1.isGraphQlErrorResult)(result)) {
             return result;
         }
         if (input.dryRun) {
@@ -752,28 +782,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 (order_utils_1.orderItemsAreShipped(orderWithFulfillment)) {
-                await transitionOrderIfStateAvailable('Shipped');
-            }
-            else {
-                await transitionOrderIfStateAvailable('PartiallyShipped');
-            }
-        }
-        if (toState === 'Delivered') {
-            const orderWithFulfillment = await this.getOrderWithFulfillments(ctx, order.id);
-            if (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
@@ -782,14 +790,9 @@ let OrderService = class OrderService {
      */
     async transitionPaymentToState(ctx, paymentId, state) {
         const result = await this.paymentService.transitionToState(ctx, paymentId, state);
-        if (error_result_1.isGraphQlErrorResult(result)) {
+        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;
     }
     /**
@@ -803,21 +806,24 @@ let OrderService = class OrderService {
             return new generated_graphql_shop_errors_1.OrderPaymentStateError();
         }
         order.payments = await this.getOrderPayments(ctx, order.id);
-        const amountToPay = order.totalWithTax - order_utils_1.totalCoveredByPayments(order);
+        const amountToPay = order.totalWithTax - (0, order_utils_1.totalCoveredByPayments)(order);
         const payment = await this.paymentService.createPayment(ctx, order, amountToPay, input.method, input.metadata);
-        if (error_result_1.isGraphQlErrorResult(payment)) {
+        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(payment.errorMessage || '');
+            return new generated_graphql_shop_errors_1.PaymentFailedError({ paymentErrorMessage: payment.errorMessage || '' });
         }
         if (payment.state === 'Declined') {
-            return new generated_graphql_shop_errors_1.PaymentDeclinedError(payment.errorMessage || '');
+            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
@@ -833,16 +839,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 (order_utils_1.orderTotalIsCovered(order, 'Settled') && order.state !== 'PaymentSettled') {
-            return this.transitionToState(ctx, orderId, 'PaymentSettled');
-        }
-        if (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
@@ -859,11 +855,11 @@ let OrderService = class OrderService {
         }
         const existingPayments = await this.getOrderPayments(ctx, order.id);
         order.payments = existingPayments;
-        const amount = order.totalWithTax - order_utils_1.totalCoveredByPayments(order);
+        const amount = order.totalWithTax - (0, order_utils_1.totalCoveredByPayments)(order);
         const modifications = await this.getOrderModifications(ctx, order.id);
         const unsettledModifications = modifications.filter(m => !m.isSettled);
         if (0 < unsettledModifications.length) {
-            const outstandingModificationsTotal = shared_utils_1.summate(unsettledModifications, 'priceChange');
+            const outstandingModificationsTotal = (0, shared_utils_1.summate)(unsettledModifications, 'priceChange');
             if (outstandingModificationsTotal !== amount) {
                 throw new errors_1.InternalServerError(`The outstanding order amount (${amount}) should equal the unsettled OrderModifications total (${outstandingModificationsTotal})`);
             }
@@ -875,7 +871,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
@@ -884,17 +880,9 @@ let OrderService = class OrderService {
      */
     async settlePayment(ctx, paymentId) {
         const payment = await this.paymentService.settlePayment(ctx, paymentId);
-        if (!error_result_1.isGraphQlErrorResult(payment)) {
+        if (!(0, error_result_1.isGraphQlErrorResult)(payment)) {
             if (payment.state !== 'Settled') {
-                return new generated_graphql_admin_errors_1.SettlePaymentError(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 (error_result_1.isGraphQlErrorResult(orderTransitionResult)) {
-                    return orderTransitionResult;
-                }
+                return new generated_graphql_admin_errors_1.SettlePaymentError({ paymentErrorMessage: payment.errorMessage || '' });
             }
         }
         return payment;
@@ -906,9 +894,9 @@ let OrderService = class OrderService {
      */
     async cancelPayment(ctx, paymentId) {
         const payment = await this.paymentService.cancelPayment(ctx, paymentId);
-        if (!error_result_1.isGraphQlErrorResult(payment)) {
+        if (!(0, error_result_1.isGraphQlErrorResult)(payment)) {
             if (payment.state !== 'Cancelled') {
-                return new generated_graphql_admin_errors_1.CancelPaymentError(payment.errorMessage || '');
+                return new generated_graphql_admin_errors_1.CancelPaymentError({ paymentErrorMessage: payment.errorMessage || '' });
             }
         }
         return payment;
@@ -918,23 +906,28 @@ let OrderService = class OrderService {
      * Creates a new Fulfillment associated with the given Order and OrderItems.
      */
     async createFulfillment(ctx, input) {
-        if (!input.lines || input.lines.length === 0 || shared_utils_1.summate(input.lines, 'quantity') === 0) {
+        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 (error_result_1.isGraphQlErrorResult(stockCheckResult)) {
+        if ((0, error_result_1.isGraphQlErrorResult)(stockCheckResult)) {
             return stockCheckResult;
         }
-        const fulfillment = await this.fulfillmentService.create(ctx, ordersAndItems.orders, ordersAndItems.items, input.handler);
-        if (error_result_1.isGraphQlErrorResult(fulfillment)) {
+        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,
@@ -945,20 +938,51 @@ let OrderService = class OrderService {
             });
         }
         const result = await this.fulfillmentService.transitionToState(ctx, fulfillment.id, 'Pending');
-        if (error_result_1.isGraphQlErrorResult(result)) {
+        if ((0, error_result_1.isGraphQlErrorResult)(result)) {
             return result;
         }
         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
-            const lineInput = input.lines.find(l => utils_1.idsAreEqual(l.orderLineId, line.id));
+            // 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 { 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(productVariant.id, productVariant.name, productVariant.stockOnHand);
+                return new generated_graphql_admin_errors_1.InsufficientStockOnHandError({
+                    productVariantId: productVariant.id,
+                    productVariantName: productVariant.name,
+                    stockOnHand,
+                });
             }
         }
     }
@@ -967,20 +991,9 @@ let OrderService = class OrderService {
      * Returns an array of all Fulfillments associated with the Order.
      */
     async getOrderFulfillments(ctx, order) {
-        const itemIdsQb = await this.connection
-            .getRepository(ctx, order_item_entity_1.OrderItem)
-            .createQueryBuilder('item')
-            .select('item.id', 'id')
-            .leftJoin('item.line', 'line')
-            .leftJoin('line.order', 'order')
-            .where('order.id = :orderId', { orderId: order.id });
-        const fulfillments = await this.connection
-            .getRepository(ctx, fulfillment_entity_1.Fulfillment)
-            .createQueryBuilder('fulfillment')
-            .leftJoinAndSelect('fulfillment.orderItems', 'item')
-            .where(`item.id IN (${itemIdsQb.getQuery()})`)
-            .setParameters(itemIdsQb.getParameters())
-            .getMany();
+        const { fulfillments } = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, order.id, {
+            relations: ['fulfillments'],
+        });
         return fulfillments;
     }
     /**
@@ -1002,9 +1015,9 @@ 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 (error_result_1.isGraphQlErrorResult(cancelResult)) {
+        if ((0, error_result_1.isGraphQlErrorResult)(cancelResult)) {
             return cancelResult;
         }
         else {
@@ -1012,11 +1025,11 @@ let OrderService = class OrderService {
         }
         if (allOrderItemsCancelled) {
             const transitionResult = await this.transitionToState(ctx, input.orderId, 'Cancelled');
-            if (error_result_1.isGraphQlErrorResult(transitionResult)) {
+            if ((0, error_result_1.isGraphQlErrorResult)(transitionResult)) {
                 return transitionResult;
             }
         }
-        return utils_1.assertFound(this.findOne(ctx, input.orderId));
+        return (0, utils_1.assertFound)(this.findOne(ctx, input.orderId));
     }
     async cancelOrderById(ctx, input) {
         const order = await this.getOrderOrThrow(ctx, input.orderId);
@@ -1028,118 +1041,37 @@ 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 || 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 (!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(order.state);
-        }
-        const fullOrder = await this.findOne(ctx, order.id);
-        const soldItems = items.filter(i => !!i.fulfillment);
-        const allocatedItems = await this.getAllocatedItems(ctx, items);
-        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 order_utils_1.orderItemsAreAllCancelled(orderWithItems);
-    }
-    async getAllocatedItems(ctx, items) {
-        const allocatedItems = [];
-        const allocationMap = new Map();
-        for (const item of items) {
-            let allocation = allocationMap.get(item.lineId);
-            if (!allocation) {
-                allocation = await this.connection
-                    .getRepository(ctx, allocation_entity_1.Allocation)
-                    .createQueryBuilder('allocation')
-                    .where('allocation.orderLine = :lineId', { lineId: item.lineId })
-                    .getOne();
-                allocationMap.set(item.lineId, allocation || false);
-            }
-            if (allocation && !item.fulfillment) {
-                allocatedItems.push(item);
-            }
-        }
-        return allocatedItems;
-    }
     /**
      * @description
      * Creates a {@link Refund} against the order and in doing so invokes the `createRefund()` method of the
      * {@link PaymentMethodHandler}.
      */
     async refundOrder(ctx, input) {
-        if ((!input.lines || input.lines.length === 0 || shared_utils_1.summate(input.lines, 'quantity') === 0) &&
+        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();
         }
         const payment = await this.connection.getEntityOrThrow(ctx, payment_entity_1.Payment, input.paymentId, {
             relations: ['order'],
         });
-        if (orders && orders.length && !utils_1.idsAreEqual(payment.order.id, orders[0].id)) {
+        if (orders && orders.length && !(0, utils_1.idsAreEqual)(payment.order.id, orders[0].id)) {
             return new generated_graphql_admin_errors_1.PaymentOrderMismatchError();
         }
         const order = payment.order;
         if (order.state === 'AddingItems' ||
             order.state === 'ArrangingPayment' ||
             order.state === 'PaymentAuthorized') {
-            return new generated_graphql_admin_errors_1.RefundOrderStateError(order.state);
+            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(alreadyRefunded.refundId);
-        }
-        return await this.paymentService.createRefund(ctx, input, order, items, payment);
+        return await this.paymentService.createRefund(ctx, input, order, payment);
     }
     /**
      * @description
@@ -1152,9 +1084,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;
     }
     /**
@@ -1167,20 +1100,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 (error_result_1.isGraphQlErrorResult(validationResult)) {
-                    order.couponCodes = order.couponCodes.filter(c => c !== couponCode);
-                    codesRemoved = true;
+                if ((0, error_result_1.isGraphQlErrorResult)(validationResult)) {
+                    updatedOrder = await this.removeCouponCode(ctx, orderId, couponCode);
                 }
             }
-            if (codesRemoved) {
-                return this.applyPriceAdjustments(ctx, order);
-            }
         }
-        return order;
+        return updatedOrder;
     }
     /**
      * @description
@@ -1233,15 +1162,15 @@ let OrderService = class OrderService {
             ? orderOrId
             : await this.connection
                 .getRepository(ctx, order_entity_1.Order)
-                .findOneOrFail(orderOrId, { relations: ['lines', 'shippingLines'] });
+                .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
@@ -1263,7 +1192,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) {
@@ -1273,7 +1202,7 @@ let OrderService = class OrderService {
             const orderId = order.id;
             for (const line of linesToInsert) {
                 const result = await this.addItemToOrder(ctx, orderId, line.productVariantId, line.quantity, line.customFields);
-                if (!error_result_1.isGraphQlErrorResult(result)) {
+                if (!(0, error_result_1.isGraphQlErrorResult)(result)) {
                     order = result;
                 }
             }
@@ -1282,7 +1211,7 @@ let OrderService = class OrderService {
             const orderId = order.id;
             for (const line of linesToModify) {
                 const result = await this.adjustOrderLine(ctx, orderId, line.orderLineId, line.quantity, line.customFields);
-                if (!error_result_1.isGraphQlErrorResult(result)) {
+                if (!(0, error_result_1.isGraphQlErrorResult)(result)) {
                     order = result;
                 }
             }
@@ -1291,7 +1220,7 @@ let OrderService = class OrderService {
             const orderId = order.id;
             for (const line of linesToDelete) {
                 const result = await this.removeItemFromOrder(ctx, orderId, line.orderLineId);
-                if (!error_result_1.isGraphQlErrorResult(result)) {
+                if (!(0, error_result_1.isGraphQlErrorResult)(result)) {
                     order = result;
                 }
             }
@@ -1311,9 +1240,9 @@ let OrderService = class OrderService {
         return order;
     }
     getOrderLineOrThrow(order, orderLineId) {
-        const orderLine = order.lines.find(line => utils_1.idsAreEqual(line.id, 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;
     }
@@ -1338,10 +1267,10 @@ let OrderService = class OrderService {
      * maximum limit specified in the config.
      */
     assertNotOverOrderItemsLimit(order, quantityToAdd) {
-        const currentItemsCount = shared_utils_1.summate(order.lines, 'quantity');
+        const currentItemsCount = (0, shared_utils_1.summate)(order.lines, 'quantity');
         const { orderItemsLimit } = this.configService.orderOptions;
         if (orderItemsLimit < currentItemsCount + quantityToAdd) {
-            return new generated_graphql_shop_errors_1.OrderLimitError(orderItemsLimit);
+            return new generated_graphql_shop_errors_1.OrderLimitError({ maxItems: orderItemsLimit });
         }
     }
     /**
@@ -1352,7 +1281,7 @@ let OrderService = class OrderService {
         const currentQuantity = (orderLine === null || orderLine === void 0 ? void 0 : orderLine.quantity) || 0;
         const { orderLineItemsLimit } = this.configService.orderOptions;
         if (orderLineItemsLimit < currentQuantity + quantityToAdd) {
-            return new generated_graphql_shop_errors_1.OrderLimitError(orderLineItemsLimit);
+            return new generated_graphql_shop_errors_1.OrderLimitError({ maxItems: orderLineItemsLimit });
         }
     }
     /**
@@ -1361,7 +1290,7 @@ 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) {
@@ -1369,123 +1298,32 @@ let OrderService = class OrderService {
             for (const updatedOrderLine of updatedOrderLines) {
                 const variant = await this.productVariantService.applyChannelPriceAndTax(updatedOrderLine.productVariant, ctx, order);
                 let priceResult = await orderItemPriceCalculationStrategy.calculateUnitPrice(ctx, variant, updatedOrderLine.customFields || {}, order);
-                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;
+                const initialListPrice = (_a = updatedOrderLine.initialListPrice) !== null && _a !== void 0 ? _a : priceResult.price;
                 if (initialListPrice !== priceResult.price) {
-                    priceResult = await changedPriceHandlingStrategy.handlePriceChange(ctx, priceResult, updatedOrderLine.items, order);
+                    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 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 });
         await this.promotionService.runPromotionSideEffects(ctx, order, activePromotionsPre);
-        return utils_1.assertFound(this.findOne(ctx, order.id));
-    }
-    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 => 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)
-                .sort((a, b) => 
-            // sort the OrderItems so that those without Fulfillments come first, as
-            // it makes sense to cancel these prior to cancelling fulfilled items.
-            !a.fulfillment && b.fulfillment ? -1 : a.fulfillment && !b.fulfillment ? 1 : 0)
-                .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),
-        }));
+        return (0, utils_1.assertFound)(this.findOne(ctx, order.id));
     }
 };
 OrderService = __decorate([
-    common_1.Injectable(),
+    (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [transactional_connection_1.TransactionalConnection,
         config_service_1.ConfigService,
         product_variant_service_1.ProductVariantService,
@@ -1509,7 +1347,8 @@ OrderService = __decorate([
         order_modifier_1.OrderModifier,
         custom_field_relation_service_1.CustomFieldRelationService,
         request_context_cache_service_1.RequestContextCacheService,
-        translator_service_1.TranslatorService])
+        translator_service_1.TranslatorService,
+        stock_level_service_1.StockLevelService])
 ], OrderService);
 exports.OrderService = OrderService;
 //# sourceMappingURL=order.service.js.map