@vendure/core 2.0.0-next.1 → 2.0.0-next.12

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

@@ -13,7 +13,6 @@ exports.OrderService = void 0;
 const common_1 = require("@nestjs/common");
 const generated_types_1 = require("@vendure/common/lib/generated-types");
 const shared_utils_1 = require("@vendure/common/lib/shared-utils");
-const unique_1 = require("@vendure/common/lib/unique");
 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,21 +23,25 @@ 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 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_line_entity_1 = require("../../entity/order-line/order-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 promotion_entity_1 = require("../../entity/promotion/promotion.entity");
 const refund_entity_1 = require("../../entity/refund/refund.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_1 = require("../../event-bus/index");
 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 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");
@@ -48,9 +51,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");
@@ -68,7 +71,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) {
         this.connection = connection;
         this.configService = configService;
         this.productVariantService = productVariantService;
@@ -92,6 +95,7 @@ let OrderService = class OrderService {
         this.orderModifier = orderModifier;
         this.customFieldRelationService = customFieldRelationService;
         this.requestCache = requestCache;
+        this.translator = translator;
     }
     /**
      * @description
@@ -105,21 +109,23 @@ let OrderService = class OrderService {
             to,
         }));
     }
-    findAll(ctx, options) {
+    findAll(ctx, options, relations) {
         return this.listQueryBuilder
             .build(order_entity_1.Order, options, {
             ctx,
-            relations: [
+            relations: relations !== null && relations !== void 0 ? relations : [
                 'lines',
                 'customer',
                 'lines.productVariant',
                 'lines.items',
                 'channels',
                 'shippingLines',
+                'payments',
             ],
             channelId: ctx.channelId,
             customPropertyMap: {
                 customerLastName: 'customer.lastName',
+                transactionId: 'payment.transactionId',
             },
         })
             .getManyAndCount()
@@ -130,72 +136,81 @@ let OrderService = class OrderService {
             };
         });
     }
-    async findOne(ctx, orderId) {
-        const qb = this.connection
-            .getRepository(ctx, order_entity_1.Order)
-            .createQueryBuilder('order')
-            .leftJoin('order.channels', 'channel')
-            .leftJoinAndSelect('order.customer', 'customer')
-            .leftJoinAndSelect('order.shippingLines', 'shippingLines')
-            .leftJoinAndSelect('order.surcharges', 'surcharges')
-            .leftJoinAndSelect('customer.user', 'user')
-            .leftJoinAndSelect('order.lines', 'lines')
-            .leftJoinAndSelect('lines.productVariant', 'productVariant')
-            .leftJoinAndSelect('productVariant.taxCategory', 'prodVariantTaxCategory')
-            .leftJoinAndSelect('productVariant.productVariantPrices', 'prices')
-            .leftJoinAndSelect('productVariant.translations', 'translations')
-            .leftJoinAndSelect('lines.featuredAsset', 'featuredAsset')
-            .leftJoinAndSelect('lines.items', 'items')
-            .leftJoinAndSelect('items.fulfillments', 'fulfillments')
-            .leftJoinAndSelect('lines.taxCategory', 'lineTaxCategory')
+    async findOne(ctx, orderId, relations) {
+        const qb = this.connection.getRepository(ctx, order_entity_1.Order).createQueryBuilder('order');
+        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',
+            'lines.productVariant.translations',
+            'lines.featuredAsset',
+            'lines.taxCategory',
+            'shippingLines',
+            'surcharges',
+        ];
+        if (relations &&
+            effectiveRelations.includes('lines.productVariant') &&
+            !effectiveRelations.includes('lines.productVariant.taxCategory')) {
+            effectiveRelations.push('lines.productVariant.taxCategory');
+        }
+        FindOptionsUtils_1.FindOptionsUtils.applyFindManyOptionsOrConditionsToQueryBuilder(qb, {
+            relations: effectiveRelations,
+        });
+        qb.leftJoin('order.channels', 'channel')
             .where('order.id = :orderId', { orderId })
-            .andWhere('channel.id = :channelId', { channelId: ctx.channelId })
-            .addOrderBy('lines.createdAt', 'ASC')
-            .addOrderBy('items.createdAt', 'ASC');
+            .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');
+        }
         // tslint:disable-next-line:no-non-null-assertion
         FindOptionsUtils_1.FindOptionsUtils.joinEagerRelations(qb, qb.alias, qb.expressionMap.mainAlias.metadata);
         const order = await qb.getOne();
         if (order) {
-            for (const line of order.lines) {
-                line.productVariant = (0, translate_entity_1.translateDeep)(await this.productVariantService.applyChannelPriceAndTax(line.productVariant, ctx, order), ctx.languageCode);
+            if (effectiveRelations.includes('lines.productVariant')) {
+                for (const line of order.lines) {
+                    line.productVariant = this.translator.translate(await this.productVariantService.applyChannelPriceAndTax(line.productVariant, ctx, order), ctx);
+                }
             }
             return order;
         }
     }
-    async findOneByCode(ctx, orderCode) {
+    async findOneByCode(ctx, orderCode, relations) {
         const order = await this.connection.getRepository(ctx, order_entity_1.Order).findOne({
             relations: ['customer'],
             where: {
                 code: orderCode,
             },
         });
-        return order ? this.findOne(ctx, order.id) : undefined;
+        return order ? this.findOne(ctx, order.id, relations) : undefined;
     }
-    async findByCustomerId(ctx, customerId, options) {
+    async findOneByOrderLineId(ctx, orderLineId, relations) {
+        const order = await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .innerJoin('order.lines', 'line', 'line.id = :orderLineId', { orderLineId })
+            .getOne();
+        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 => 
+        // 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: [
-                'lines',
-                'lines.items',
-                'lines.productVariant',
-                'lines.productVariant.options',
-                'customer',
-                'channels',
-                'shippingLines',
-            ],
+            relations: relations !== null && relations !== void 0 ? relations : ['lines', 'lines.items', 'customer', 'channels', 'shippingLines'],
             channelId: ctx.channelId,
             ctx,
         })
             .andWhere('order.customer.id = :customerId', { customerId })
             .getManyAndCount()
             .then(([items, totalItems]) => {
-            items.forEach(item => {
-                item.lines.forEach(line => {
-                    line.productVariant = (0, translate_entity_1.translateDeep)(line.productVariant, ctx.languageCode, [
-                        'options',
-                    ]);
-                });
-            });
             return {
                 items,
                 totalItems,
@@ -299,7 +314,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_2.OrderEvent(ctx, order, 'created'));
+        this.eventBus.publish(new index_3.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
@@ -316,7 +331,7 @@ 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_2.OrderEvent(ctx, updatedOrder, 'updated'));
+        this.eventBus.publish(new index_3.OrderEvent(ctx, updatedOrder, 'updated'));
         return updatedOrder;
     }
     /**
@@ -388,7 +403,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_5.OrderLineEvent(ctx, order, orderLine, 'deleted'));
+            this.eventBus.publish(new index_6.OrderLineEvent(ctx, order, orderLine, 'deleted'));
             updatedOrderLines = [];
         }
         else {
@@ -417,7 +432,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_5.OrderLineEvent(ctx, order, orderLine, 'deleted'));
+        this.eventBus.publish(new index_6.OrderLineEvent(ctx, order, orderLine, 'deleted'));
         return updatedOrder;
     }
     /**
@@ -484,7 +499,7 @@ let OrderService = class OrderService {
             type: generated_types_1.HistoryEntryType.ORDER_COUPON_APPLIED,
             data: { couponCode, promotionId: validationResult.id },
         });
-        this.eventBus.publish(new index_1.CouponCodeEvent(ctx, couponCode, orderId, 'assigned'));
+        this.eventBus.publish(new index_2.CouponCodeEvent(ctx, couponCode, orderId, 'assigned'));
         return this.applyPriceAdjustments(ctx, order);
     }
     /**
@@ -508,7 +523,7 @@ let OrderService = class OrderService {
                 type: generated_types_1.HistoryEntryType.ORDER_COUPON_REMOVED,
                 data: { couponCode },
             });
-            this.eventBus.publish(new index_1.CouponCodeEvent(ctx, couponCode, orderId, 'removed'));
+            this.eventBus.publish(new index_2.CouponCodeEvent(ctx, couponCode, orderId, 'removed'));
             const result = await this.applyPriceAdjustments(ctx, order);
             await this.connection.getRepository(ctx, order_item_entity_1.OrderItem).save(affectedOrderItems);
             return result;
@@ -649,7 +664,7 @@ let OrderService = class OrderService {
             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_3.OrderStateTransitionEvent(fromState, state, ctx, order));
+        this.eventBus.publish(new index_4.OrderStateTransitionEvent(fromState, state, ctx, order));
         return order;
     }
     /**
@@ -681,20 +696,20 @@ let OrderService = class OrderService {
      * * Shipping or billing address changes
      *
      * Setting the `dryRun` input property to `true` will apply all changes, including updating the price of the
-     * Order, but will not actually persist any of those changes to the database.
+     * Order, except history entry and additional payment actions.
+     *
+     * __Using dryRun option, you must wrap function call in transaction manually.__
+     *
      */
     async modifyOrder(ctx, input) {
-        await this.connection.startTransaction(ctx);
         const order = await this.getOrderOrThrow(ctx, input.orderId);
         const result = await this.orderModifier.modifyOrder(ctx, input, order);
-        if (input.dryRun) {
-            await this.connection.rollBackTransaction(ctx);
-            return (0, error_result_1.isGraphQlErrorResult)(result) ? result : result.order;
-        }
         if ((0, error_result_1.isGraphQlErrorResult)(result)) {
-            await this.connection.rollBackTransaction(ctx);
             return result;
         }
+        if (input.dryRun) {
+            return result.order;
+        }
         await this.historyService.createHistoryEntryForOrder({
             ctx,
             orderId: input.orderId,
@@ -703,7 +718,6 @@ let OrderService = class OrderService {
                 modificationId: result.modification.id,
             },
         });
-        await this.connection.commitOpenTransaction(ctx);
         return this.getOrderOrThrow(ctx, input.orderId);
     }
     async handleFulfillmentStateTransitByOrder(ctx, order, fromState, toState) {
@@ -753,7 +767,7 @@ let OrderService = class OrderService {
      */
     async addPaymentToOrder(ctx, orderId, input) {
         const order = await this.getOrderOrThrow(ctx, orderId);
-        if (order.state !== 'ArrangingPayment') {
+        if (!this.canAddPaymentToOrder(order)) {
             return new generated_graphql_shop_errors_1.OrderPaymentStateError();
         }
         order.payments = await this.getOrderPayments(ctx, order.id);
@@ -773,6 +787,20 @@ let OrderService = class OrderService {
         }
         return this.transitionOrderIfTotalIsCovered(ctx, order);
     }
+    /**
+     * @description
+     * We can add a Payment to the order if:
+     * 1. the Order is in the `ArrangingPayment` state or
+     * 2. the Order's current state can transition to `PaymentAuthorized` and `PaymentSettled`
+     */
+    canAddPaymentToOrder(order) {
+        if (order.state === 'ArrangingPayment') {
+            return true;
+        }
+        const canTransitionToPaymentAuthorized = this.orderStateMachine.canTransition(order.state, 'PaymentAuthorized');
+        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') {
@@ -839,6 +867,20 @@ let OrderService = class OrderService {
         }
         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;
+    }
     /**
      * @description
      * Creates a new Fulfillment associated with the given Order and OrderItems.
@@ -883,7 +925,7 @@ let OrderService = class OrderService {
             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 productVariant = this.translator.translate(line.productVariant, ctx);
                 return new generated_graphql_admin_errors_1.InsufficientStockOnHandError({
                     productVariantId: productVariant.id,
                     productVariantName: productVariant.name,
@@ -897,22 +939,21 @@ 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 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();
+        return fulfillments;
     }
     /**
      * @description
@@ -983,7 +1024,7 @@ let OrderService = class OrderService {
         }
         const fullOrder = await this.findOne(ctx, order.id);
         const soldItems = items.filter(i => !!i.fulfillment);
-        const allocatedItems = 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));
@@ -1017,6 +1058,25 @@ let OrderService = class OrderService {
         });
         return (0, 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
@@ -1066,7 +1126,7 @@ let OrderService = class OrderService {
         const toState = 'Settled';
         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_4.RefundStateTransitionEvent(fromState, toState, ctx, refund, refund.payment.order));
+        this.eventBus.publish(new index_5.RefundStateTransitionEvent(fromState, toState, ctx, refund, refund.payment.order));
         return refund;
     }
     /**
@@ -1134,6 +1194,34 @@ let OrderService = class OrderService {
             };
         }
     }
+    /**
+     * @description
+     * Deletes an Order, ensuring that any Sessions that reference this Order are dereferenced before deletion.
+     *
+     * @since 1.5.0
+     */
+    async deleteOrder(ctx, orderOrId) {
+        const orderToDelete = orderOrId instanceof order_entity_1.Order
+            ? orderOrId
+            : await this.connection
+                .getRepository(ctx, order_entity_1.Order)
+                .findOneOrFail(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)
+            .find({ where: { activeOrderId: orderToDelete.id } });
+        if (sessions.length) {
+            await this.connection
+                .getRepository(ctx, index_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);
+    }
     /**
      * @description
      * When a guest user with an anonymous Order signs in and has an existing Order associated with that Customer,
@@ -1151,11 +1239,7 @@ let OrderService = class OrderService {
         const { orderToDelete, linesToInsert, linesToDelete, linesToModify } = mergeResult;
         let { order } = mergeResult;
         if (orderToDelete) {
-            // 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);
+            await this.deleteOrder(ctx, orderToDelete);
         }
         if (order && linesToInsert) {
             const orderId = order.id;
@@ -1244,7 +1328,9 @@ let OrderService = class OrderService {
         }
     }
     /**
-     * Applies promotions, taxes and shipping to the Order.
+     * @description
+     * Applies promotions, taxes and shipping to the Order. If the `updatedOrderLines` argument is passed in,
+     * then all of those OrderLines will have their prices re-calculated using the configured {@link OrderItemPriceCalculationStrategy}.
      */
     async applyPriceAdjustments(ctx, order, updatedOrderLines) {
         var _a, _b;
@@ -1266,10 +1352,15 @@ let OrderService = class OrderService {
                 }
             }
         }
-        const { items: promotions } = await this.promotionService.findAll(ctx, {
-            filter: { enabled: { eq: true } },
-            sort: { priorityScore: 'ASC' },
-        });
+        const promotions = await this.connection
+            .getRepository(ctx, promotion_entity_1.Promotion)
+            .createQueryBuilder('promotion')
+            .leftJoin('promotion.channels', 'channel')
+            .where('channel.id = :channelId', { channelId: ctx.channelId })
+            .andWhere('promotion.deletedAt IS NULL')
+            .andWhere('promotion.enabled = :enabled', { enabled: true })
+            .orderBy('promotion.priorityScore', 'ASC')
+            .getMany();
         const updatedItems = await this.orderCalculator.applyPriceAdjustments(ctx, order, promotions, updatedOrderLines !== null && updatedOrderLines !== void 0 ? updatedOrderLines : []);
         const updateFields = [
             'initialListPrice',
@@ -1322,7 +1413,14 @@ let OrderService = class OrderService {
             if (matchingItems.length < inputLine.quantity) {
                 return false;
             }
-            matchingItems.slice(0, inputLine.quantity).forEach(item => {
+            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);
             });
         }
@@ -1388,7 +1486,8 @@ 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])
 ], OrderService);
 exports.OrderService = OrderService;
 //# sourceMappingURL=order.service.js.map