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

package/dist/service/services/order.service.d.ts

@@ -2,6 +2,7 @@ import { AddPaymentToOrderResult, ApplyCouponCodeResult, PaymentInput, PaymentMe
 import { AddFulfillmentToOrderResult, AddManualPaymentToOrderResult, AddNoteToOrderInput, CancelOrderInput, CancelOrderResult, CreateAddressInput, DeletionResponse, FulfillOrderInput, ManualPaymentInput, ModifyOrderInput, ModifyOrderResult, OrderListOptions, OrderProcessState, RefundOrderInput, RefundOrderResult, SettlePaymentResult, SettleRefundInput, ShippingMethodQuote, TransitionPaymentToStateResult, UpdateOrderNoteInput } from '@vendure/common/lib/generated-types';
 import { ID, PaginatedList } from '@vendure/common/lib/shared-types';
 import { RequestContext } from '../../api/common/request-context';
+import { RelationPaths } from '../../api/decorators/relations.decorator';
 import { RequestContextCacheService } from '../../cache/request-context-cache.service';
 import { ErrorResultUnion } from '../../common/error/error-result';
 import { FulfillmentStateTransitionError } from '../../common/error/generated-graphql-admin-errors';
@@ -13,6 +14,7 @@ import { Customer } from '../../entity/customer/customer.entity';
 import { Fulfillment } from '../../entity/fulfillment/fulfillment.entity';
 import { HistoryEntry } from '../../entity/history-entry/history-entry.entity';
 import { OrderItem } from '../../entity/order-item/order-item.entity';
+import { OrderLine } from '../../entity/order-line/order-line.entity';
 import { OrderModification } from '../../entity/order-modification/order-modification.entity';
 import { Order } from '../../entity/order/order.entity';
 import { Payment } from '../../entity/payment/payment.entity';
@@ -81,10 +83,11 @@ export declare class OrderService {
      * defined in the {@link OrderOptions} `process` array.
      */
     getOrderProcessStates(): OrderProcessState[];
-    findAll(ctx: RequestContext, options?: OrderListOptions): Promise<PaginatedList<Order>>;
-    findOne(ctx: RequestContext, orderId: ID): Promise<Order | undefined>;
-    findOneByCode(ctx: RequestContext, orderCode: string): Promise<Order | undefined>;
-    findByCustomerId(ctx: RequestContext, customerId: ID, options?: ListQueryOptions<Order>): Promise<PaginatedList<Order>>;
+    findAll(ctx: RequestContext, options?: OrderListOptions, relations?: RelationPaths<Order>): Promise<PaginatedList<Order>>;
+    findOne(ctx: RequestContext, orderId: ID, relations?: RelationPaths<Order>): Promise<Order | undefined>;
+    findOneByCode(ctx: RequestContext, orderCode: string, relations?: RelationPaths<Order>): Promise<Order | undefined>;
+    findOneByOrderLineId(ctx: RequestContext, orderLineId: ID, relations?: RelationPaths<Order>): Promise<Order | undefined>;
+    findByCustomerId(ctx: RequestContext, customerId: ID, options?: ListQueryOptions<Order>, relations?: RelationPaths<Order>): Promise<PaginatedList<Order>>;
     /**
      * @description
      * Returns all {@link Payment} entities associated with the Order.
@@ -229,7 +232,10 @@ export declare 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.__
+     *
      */
     modifyOrder(ctx: RequestContext, input: ModifyOrderInput): Promise<ErrorResultUnion<ModifyOrderResult, Order>>;
     private handleFulfillmentStateTransitByOrder;
@@ -246,6 +252,13 @@ export declare class OrderService {
      * state will get automatically transitioned to the `PaymentSettled` or `PaymentAuthorized` state.
      */
     addPaymentToOrder(ctx: RequestContext, orderId: ID, input: PaymentInput): Promise<ErrorResultUnion<AddPaymentToOrderResult, 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`
+     */
+    private canAddPaymentToOrder;
     private transitionOrderIfTotalIsCovered;
     /**
      * @description
@@ -287,6 +300,7 @@ export declare class OrderService {
     cancelOrder(ctx: RequestContext, input: CancelOrderInput): Promise<ErrorResultUnion<CancelOrderResult, Order>>;
     private cancelOrderById;
     private cancelOrderByOrderLines;
+    private getAllocatedItems;
     /**
      * @description
      * Creates a {@link Refund} against the order and in doing so invokes the `createRefund()` method of the
@@ -310,6 +324,13 @@ export declare class OrderService {
     addNoteToOrder(ctx: RequestContext, input: AddNoteToOrderInput): Promise<Order>;
     updateOrderNote(ctx: RequestContext, input: UpdateOrderNoteInput): Promise<HistoryEntry>;
     deleteOrderNote(ctx: RequestContext, id: ID): Promise<DeletionResponse>;
+    /**
+     * @description
+     * Deletes an Order, ensuring that any Sessions that reference this Order are dereferenced before deletion.
+     *
+     * @since 1.5.0
+     */
+    deleteOrder(ctx: RequestContext, orderOrId: ID | Order): Promise<void>;
     /**
      * @description
      * When a guest user with an anonymous Order signs in and has an existing Order associated with that Customer,
@@ -339,9 +360,11 @@ export declare class OrderService {
      */
     private assertNotOverOrderLineItemsLimit;
     /**
-     * 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}.
      */
-    private applyPriceAdjustments;
+    applyPriceAdjustments(ctx: RequestContext, order: Order, updatedOrderLines?: OrderLine[]): Promise<Order>;
     private getOrderWithFulfillments;
     private getOrdersAndItemsFromLines;
     private mergePaymentMetadata;

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

@@ -24,6 +24,7 @@ const tax_utils_1 = require("../../common/tax-utils");
 const utils_1 = require("../../common/utils");
 const config_service_1 = require("../../config/config.service");
 const transactional_connection_1 = require("../../connection/transactional-connection");
+const index_1 = require("../../entity/index");
 const order_item_entity_1 = require("../../entity/order-item/order-item.entity");
 const order_line_entity_1 = require("../../entity/order-line/order-line.entity");
 const order_modification_entity_1 = require("../../entity/order-modification/order-modification.entity");
@@ -32,13 +33,14 @@ 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 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");
@@ -105,11 +107,11 @@ 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',
@@ -130,72 +132,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 = (0, translate_entity_1.translateDeep)(await this.productVariantService.applyChannelPriceAndTax(line.productVariant, ctx, order), ctx.languageCode);
+                }
             }
             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 +310,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 +327,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 +399,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 +428,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 +495,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 +519,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 +660,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 +692,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 +714,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 +763,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 +783,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') {
@@ -983,7 +1007,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 +1041,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 +1109,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 +1177,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'] });
+        // 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 +1222,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 +1311,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;