@vendure/core 2.0.0-next.2 → 2.0.0-next.21

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

@@ -1,7 +1,8 @@
 import { AddPaymentToOrderResult, ApplyCouponCodeResult, PaymentInput, PaymentMethodQuote, RemoveOrderItemsResult, SetOrderShippingMethodResult, UpdateOrderItemsResult } from '@vendure/common/lib/generated-shop-types';
-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 { AddFulfillmentToOrderResult, AddManualPaymentToOrderResult, AddNoteToOrderInput, CancelOrderInput, CancelOrderResult, CancelPaymentResult, 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';
@@ -33,6 +35,7 @@ import { PaymentState } from '../helpers/payment-state-machine/payment-state';
 import { PaymentStateMachine } from '../helpers/payment-state-machine/payment-state-machine';
 import { RefundStateMachine } from '../helpers/refund-state-machine/refund-state-machine';
 import { ShippingCalculator } from '../helpers/shipping-calculator/shipping-calculator';
+import { TranslatorService } from '../helpers/translator/translator.service';
 import { ChannelService } from './channel.service';
 import { CountryService } from './country.service';
 import { CustomerService } from './customer.service';
@@ -73,7 +76,8 @@ export declare class OrderService {
     private orderModifier;
     private customFieldRelationService;
     private requestCache;
-    constructor(connection: TransactionalConnection, configService: ConfigService, productVariantService: ProductVariantService, customerService: CustomerService, countryService: CountryService, orderCalculator: OrderCalculator, shippingCalculator: ShippingCalculator, orderStateMachine: OrderStateMachine, orderMerger: OrderMerger, paymentService: PaymentService, paymentStateMachine: PaymentStateMachine, paymentMethodService: PaymentMethodService, fulfillmentService: FulfillmentService, listQueryBuilder: ListQueryBuilder, stockMovementService: StockMovementService, refundStateMachine: RefundStateMachine, historyService: HistoryService, promotionService: PromotionService, eventBus: EventBus, channelService: ChannelService, orderModifier: OrderModifier, customFieldRelationService: CustomFieldRelationService, requestCache: RequestContextCacheService);
+    private translator;
+    constructor(connection: TransactionalConnection, configService: ConfigService, productVariantService: ProductVariantService, customerService: CustomerService, countryService: CountryService, orderCalculator: OrderCalculator, shippingCalculator: ShippingCalculator, orderStateMachine: OrderStateMachine, orderMerger: OrderMerger, paymentService: PaymentService, paymentStateMachine: PaymentStateMachine, paymentMethodService: PaymentMethodService, fulfillmentService: FulfillmentService, listQueryBuilder: ListQueryBuilder, stockMovementService: StockMovementService, refundStateMachine: RefundStateMachine, historyService: HistoryService, promotionService: PromotionService, eventBus: EventBus, channelService: ChannelService, orderModifier: OrderModifier, customFieldRelationService: CustomFieldRelationService, requestCache: RequestContextCacheService, translator: TranslatorService);
     /**
      * @description
      * Returns an array of all the configured states and transitions of the order process. This is
@@ -81,10 +85,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.
@@ -117,6 +122,8 @@ export declare class OrderService {
      * User's Customer account.
      */
     create(ctx: RequestContext, userId?: ID): Promise<Order>;
+    createDraft(ctx: RequestContext): Promise<Order>;
+    private createEmptyOrderEntity;
     /**
      * @description
      * Updates the custom fields of an Order.
@@ -229,7 +236,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;
@@ -270,6 +280,12 @@ export declare class OrderService {
      * transitions the Order state if all Payments are settled.
      */
     settlePayment(ctx: RequestContext, paymentId: ID): Promise<ErrorResultUnion<SettlePaymentResult, Payment>>;
+    /**
+     * @description
+     * Cancels a payment by invoking the {@link PaymentMethodHandler}'s `cancelPayment()` method (if defined), and transitions the Payment to
+     * the `Cancelled` state.
+     */
+    cancelPayment(ctx: RequestContext, paymentId: ID): Promise<ErrorResultUnion<CancelPaymentResult, Payment>>;
     /**
      * @description
      * Creates a new Fulfillment associated with the given Order and OrderItems.
@@ -294,6 +310,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
@@ -339,7 +356,7 @@ export declare class OrderService {
      */
     private assertQuantityIsPositive;
     /**
-     * Returns error if the Order is not in the "AddingItems" state.
+     * Returns error if the Order is not in the "AddingItems" or "Draft" state.
      */
     private assertAddingItemsState;
     /**
@@ -353,9 +370,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

@@ -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,6 +23,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 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");
@@ -33,6 +33,7 @@ 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_2 = require("../../event-bus/index");
@@ -49,9 +50,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");
@@ -69,7 +70,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;
@@ -93,6 +94,7 @@ let OrderService = class OrderService {
         this.orderModifier = orderModifier;
         this.customFieldRelationService = customFieldRelationService;
         this.requestCache = requestCache;
+        this.translator = translator;
     }
     /**
      * @description
@@ -106,21 +108,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: 'payments.transactionId',
             },
         })
             .getManyAndCount()
@@ -131,72 +135,82 @@ 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.state != :draftState', { draftState: 'Draft' })
             .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,
@@ -279,19 +293,7 @@ let OrderService = class OrderService {
      * User's Customer account.
      */
     async create(ctx, userId) {
-        const newOrder = new order_entity_1.Order({
-            code: await this.configService.orderOptions.orderCodeStrategy.generate(ctx),
-            state: this.orderStateMachine.getInitialState(),
-            lines: [],
-            surcharges: [],
-            couponCodes: [],
-            modifications: [],
-            shippingAddress: {},
-            billingAddress: {},
-            subTotal: 0,
-            subTotalWithTax: 0,
-            currencyCode: ctx.channel.currencyCode,
-        });
+        const newOrder = await this.createEmptyOrderEntity(ctx);
         if (userId) {
             const customer = await this.customerService.findOneByUserId(ctx, userId);
             if (customer) {
@@ -308,6 +310,34 @@ let OrderService = class OrderService {
         }
         return transitionResult;
     }
+    async createDraft(ctx) {
+        const newOrder = await this.createEmptyOrderEntity(ctx);
+        newOrder.active = false;
+        await this.channelService.assignToCurrentChannel(newOrder, ctx);
+        const order = await this.connection.getRepository(ctx, order_entity_1.Order).save(newOrder);
+        this.eventBus.publish(new index_3.OrderEvent(ctx, order, 'created'));
+        const transitionResult = await this.transitionToState(ctx, order.id, 'Draft');
+        if ((0, error_result_1.isGraphQlErrorResult)(transitionResult)) {
+            // this should never occur, so we will throw rather than return
+            throw transitionResult;
+        }
+        return transitionResult;
+    }
+    async createEmptyOrderEntity(ctx) {
+        return new order_entity_1.Order({
+            code: await this.configService.orderOptions.orderCodeStrategy.generate(ctx),
+            state: this.orderStateMachine.getInitialState(),
+            lines: [],
+            surcharges: [],
+            couponCodes: [],
+            modifications: [],
+            shippingAddress: {},
+            billingAddress: {},
+            subTotal: 0,
+            subTotalWithTax: 0,
+            currencyCode: ctx.channel.currencyCode,
+        });
+    }
     /**
      * @description
      * Updates the custom fields of an Order.
@@ -544,10 +574,16 @@ let OrderService = class OrderService {
     async setShippingAddress(ctx, orderId, input) {
         const order = await this.getOrderOrThrow(ctx, orderId);
         const country = await this.countryService.findOneByCode(ctx, input.countryCode);
-        order.shippingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
+        const shippingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .update(order_entity_1.Order)
+            .set({ shippingAddress })
+            .where('id = :id', { id: order.id });
+        order.shippingAddress = shippingAddress;
         // Since a changed ShippingAddress could alter the activeTaxZone,
-        // we will remove any cached activeTaxZone so it can be re-calculated
+        // we will remove any cached activeTaxZone, so it can be re-calculated
         // as needed.
         this.requestCache.set(ctx, 'activeTaxZone', undefined);
         return this.applyPriceAdjustments(ctx, order, order.lines);
@@ -559,10 +595,16 @@ let OrderService = class OrderService {
     async setBillingAddress(ctx, orderId, input) {
         const order = await this.getOrderOrThrow(ctx, orderId);
         const country = await this.countryService.findOneByCode(ctx, input.countryCode);
-        order.billingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
-        await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
-        // Since a changed ShippingAddress could alter the activeTaxZone,
-        // we will remove any cached activeTaxZone so it can be re-calculated
+        const billingAddress = Object.assign(Object.assign({}, input), { countryCode: input.countryCode, country: country.name });
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .update(order_entity_1.Order)
+            .set({ billingAddress })
+            .where('id = :id', { id: order.id });
+        order.billingAddress = billingAddress;
+        // Since a changed BillingAddress could alter the activeTaxZone,
+        // we will remove any cached activeTaxZone, so it can be re-calculated
         // as needed.
         this.requestCache.set(ctx, 'activeTaxZone', undefined);
         return this.applyPriceAdjustments(ctx, order, order.lines);
@@ -682,20 +724,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,
@@ -704,7 +746,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) {
@@ -854,6 +895,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.
@@ -898,7 +953,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,
@@ -912,22 +967,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
@@ -998,7 +1052,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));
@@ -1032,6 +1086,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
@@ -1160,7 +1233,7 @@ let OrderService = class OrderService {
             ? orderOrId
             : await this.connection
                 .getRepository(ctx, order_entity_1.Order)
-                .findOneOrFail(orderOrId, { relations: ['lines'] });
+                .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
@@ -1253,10 +1326,10 @@ let OrderService = class OrderService {
         }
     }
     /**
-     * Returns error if the Order is not in the "AddingItems" state.
+     * Returns error if the Order is not in the "AddingItems" or "Draft" state.
      */
     assertAddingItemsState(order) {
-        if (order.state !== 'AddingItems') {
+        if (order.state !== 'AddingItems' && order.state !== 'Draft') {
             return new generated_graphql_shop_errors_1.OrderModificationError();
         }
     }
@@ -1283,18 +1356,22 @@ 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;
+        const promotions = await this.promotionService.getActivePromotionsInChannel(ctx);
+        const activePromotionsPre = await this.promotionService.getActivePromotionsOnOrder(ctx, order.id);
         if (updatedOrderLines === null || updatedOrderLines === void 0 ? void 0 : updatedOrderLines.length) {
             const { orderItemPriceCalculationStrategy, changedPriceHandlingStrategy } = this.configService.orderOptions;
             for (const updatedOrderLine of updatedOrderLines) {
                 const variant = await this.productVariantService.applyChannelPriceAndTax(updatedOrderLine.productVariant, ctx, order);
-                let priceResult = await orderItemPriceCalculationStrategy.calculateUnitPrice(ctx, variant, updatedOrderLine.customFields || {});
+                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;
                 if (initialListPrice !== priceResult.price) {
-                    priceResult = await changedPriceHandlingStrategy.handlePriceChange(ctx, priceResult, updatedOrderLine.items);
+                    priceResult = await changedPriceHandlingStrategy.handlePriceChange(ctx, priceResult, updatedOrderLine.items, order);
                 }
                 for (const item of updatedOrderLine.items) {
                     if (item.initialListPrice == null) {
@@ -1305,10 +1382,6 @@ let OrderService = class OrderService {
                 }
             }
         }
-        const { items: promotions } = await this.promotionService.findAll(ctx, {
-            filter: { enabled: { eq: true } },
-            sort: { priorityScore: 'ASC' },
-        });
         const updatedItems = await this.orderCalculator.applyPriceAdjustments(ctx, order, promotions, updatedOrderLines !== null && updatedOrderLines !== void 0 ? updatedOrderLines : []);
         const updateFields = [
             'initialListPrice',
@@ -1331,7 +1404,8 @@ let OrderService = class OrderService {
             .execute();
         await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
         await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(order.shippingLines, { reload: false });
-        return order;
+        await this.promotionService.runPromotionSideEffects(ctx, order, activePromotionsPre);
+        return (0, utils_1.assertFound)(this.findOne(ctx, order.id));
     }
     async getOrderWithFulfillments(ctx, orderId) {
         return await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, orderId, {
@@ -1361,7 +1435,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);
             });
         }
@@ -1427,7 +1508,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