@vendure/core 2.0.0-next.9 → 2.0.1

package/dist/service/helpers/order-modifier/order-modifier.js

@@ -17,17 +17,20 @@ const error_result_1 = require("../../../common/error/error-result");
 const errors_1 = require("../../../common/error/errors");
 const generated_graphql_admin_errors_1 = require("../../../common/error/generated-graphql-admin-errors");
 const generated_graphql_shop_errors_1 = require("../../../common/error/generated-graphql-shop-errors");
-const adjustment_source_1 = require("../../../common/types/adjustment-source");
 const utils_1 = require("../../../common/utils");
 const config_service_1 = require("../../../config/config.service");
 const transactional_connection_1 = require("../../../connection/transactional-connection");
-const order_item_entity_1 = require("../../../entity/order-item/order-item.entity");
+const order_entity_1 = require("../../../entity/order/order.entity");
 const order_line_entity_1 = require("../../../entity/order-line/order-line.entity");
+const fulfillment_line_entity_1 = require("../../../entity/order-line-reference/fulfillment-line.entity");
+const order_modification_line_entity_1 = require("../../../entity/order-line-reference/order-modification-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 promotion_entity_1 = require("../../../entity/promotion/promotion.entity");
 const shipping_line_entity_1 = require("../../../entity/shipping-line/shipping-line.entity");
+const allocation_entity_1 = require("../../../entity/stock-movement/allocation.entity");
+const cancellation_entity_1 = require("../../../entity/stock-movement/cancellation.entity");
+const release_entity_1 = require("../../../entity/stock-movement/release.entity");
+const sale_entity_1 = require("../../../entity/stock-movement/sale.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");
@@ -40,8 +43,9 @@ const stock_movement_service_1 = require("../../services/stock-movement.service"
 const custom_field_relation_service_1 = require("../custom-field-relation/custom-field-relation.service");
 const entity_hydrator_service_1 = require("../entity-hydrator/entity-hydrator.service");
 const order_calculator_1 = require("../order-calculator/order-calculator");
+const translator_service_1 = require("../translator/translator.service");
+const order_utils_1 = require("../utils/order-utils");
 const patch_entity_1 = require("../utils/patch-entity");
-const translate_entity_1 = require("../utils/translate-entity");
 /**
  * @description
  * This helper is responsible for modifying the contents of an Order.
@@ -52,9 +56,11 @@ const translate_entity_1 = require("../utils/translate-entity");
  * So this helper was mainly extracted to isolate the huge `modifyOrder` method since the
  * OrderService was just growing too large. Future refactoring could improve the organization
  * of these Order-related methods into a more clearly-delineated set of classes.
+ *
+ * @docsCategory service-helpers
  */
 let OrderModifier = class OrderModifier {
-    constructor(connection, configService, orderCalculator, paymentService, countryService, stockMovementService, productVariantService, customFieldRelationService, promotionService, eventBus, entityHydrator, historyService) {
+    constructor(connection, configService, orderCalculator, paymentService, countryService, stockMovementService, productVariantService, customFieldRelationService, promotionService, eventBus, entityHydrator, historyService, translator) {
         this.connection = connection;
         this.configService = configService;
         this.orderCalculator = orderCalculator;
@@ -67,8 +73,10 @@ let OrderModifier = class OrderModifier {
         this.eventBus = eventBus;
         this.entityHydrator = entityHydrator;
         this.historyService = historyService;
+        this.translator = translator;
     }
     /**
+     * @description
      * Ensure that the ProductVariant has sufficient saleable stock to add the given
      * quantity to an Order.
      */
@@ -80,6 +88,11 @@ let OrderModifier = class OrderModifier {
         }
         return correctedQuantity;
     }
+    /**
+     * @description
+     * Given a ProductVariant ID and optional custom fields, this method will return an existing OrderLine that
+     * matches, or `undefined` if no match is found.
+     */
     async getExistingOrderLine(ctx, order, productVariantId, customFields) {
         for (const line of order.lines) {
             const match = (0, utils_1.idsAreEqual)(line.productVariant.id, productVariantId) &&
@@ -90,8 +103,9 @@ let OrderModifier = class OrderModifier {
         }
     }
     /**
-     * Returns the OrderLine to which a new OrderItem belongs, creating a new OrderLine
-     * if no existing line is found.
+     * @description
+     * Returns the OrderLine containing the given {@link ProductVariant}, taking into account any custom field values. If no existing
+     * OrderLine is found, a new OrderLine will be created.
      */
     async getOrCreateOrderLine(ctx, order, productVariantId, customFields) {
         var _a;
@@ -104,102 +118,195 @@ let OrderModifier = class OrderModifier {
             productVariant,
             taxCategory: productVariant.taxCategory,
             featuredAsset: (_a = productVariant.featuredAsset) !== null && _a !== void 0 ? _a : productVariant.product.featuredAsset,
+            listPrice: productVariant.listPrice,
+            listPriceIncludesTax: productVariant.listPriceIncludesTax,
+            adjustments: [],
+            taxLines: [],
             customFields,
+            quantity: 0,
         }));
+        const { orderSellerStrategy } = this.configService.orderOptions;
+        if (typeof orderSellerStrategy.setOrderLineSellerChannel === 'function') {
+            orderLine.sellerChannel = await orderSellerStrategy.setOrderLineSellerChannel(ctx, orderLine);
+            await this.connection
+                .getRepository(ctx, order_line_entity_1.OrderLine)
+                .createQueryBuilder()
+                .relation('sellerChannel')
+                .of(orderLine)
+                .set(orderLine.sellerChannel);
+        }
         await this.customFieldRelationService.updateRelations(ctx, order_line_entity_1.OrderLine, { customFields }, orderLine);
         const lineWithRelations = await this.connection.getEntityOrThrow(ctx, order_line_entity_1.OrderLine, orderLine.id, {
             relations: [
-                'items',
                 'taxCategory',
                 'productVariant',
                 'productVariant.productVariantPrices',
                 'productVariant.taxCategory',
             ],
         });
-        lineWithRelations.productVariant = (0, translate_entity_1.translateDeep)(await this.productVariantService.applyChannelPriceAndTax(lineWithRelations.productVariant, ctx, order), ctx.languageCode);
+        lineWithRelations.productVariant = this.translator.translate(await this.productVariantService.applyChannelPriceAndTax(lineWithRelations.productVariant, ctx, order), ctx);
         order.lines.push(lineWithRelations);
         await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
         this.eventBus.publish(new index_1.OrderLineEvent(ctx, order, lineWithRelations, 'created'));
         return lineWithRelations;
     }
     /**
+     * @description
      * Updates the quantity of an OrderLine, taking into account the available saleable stock level.
      * Returns the actual quantity that the OrderLine was updated to (which may be less than the
      * `quantity` argument if insufficient stock was available.
      */
     async updateOrderLineQuantity(ctx, orderLine, quantity, order) {
         const currentQuantity = orderLine.quantity;
+        orderLine.quantity = quantity;
         if (currentQuantity < quantity) {
-            if (!orderLine.items) {
-                orderLine.items = [];
-            }
-            const newOrderItems = [];
-            for (let i = currentQuantity; i < quantity; i++) {
-                newOrderItems.push(new order_item_entity_1.OrderItem({
-                    listPrice: orderLine.productVariant.listPrice,
-                    listPriceIncludesTax: orderLine.productVariant.listPriceIncludesTax,
-                    adjustments: [],
-                    taxLines: [],
-                    lineId: orderLine.id,
-                }));
-            }
-            const { identifiers } = await this.connection
-                .getRepository(ctx, order_item_entity_1.OrderItem)
-                .createQueryBuilder()
-                .insert()
-                .into(order_item_entity_1.OrderItem)
-                .values(newOrderItems)
-                .execute();
-            newOrderItems.forEach((item, i) => (item.id = identifiers[i].id));
-            orderLine.items = await this.connection
-                .getRepository(ctx, order_item_entity_1.OrderItem)
-                .find({ where: { line: orderLine } });
-            if (!order.active) {
+            if (!order.active && order.state !== 'Draft') {
                 await this.stockMovementService.createAllocationsForOrderLines(ctx, [
                     {
-                        orderLine,
+                        orderLineId: orderLine.id,
                         quantity: quantity - currentQuantity,
                     },
                 ]);
             }
         }
         else if (quantity < currentQuantity) {
-            if (order.active) {
-                // When an Order is still active, it is fine to just delete
-                // any OrderItems that are no longer needed
-                const keepItems = orderLine.items.slice(0, quantity);
-                const removeItems = orderLine.items.slice(quantity);
-                orderLine.items = keepItems;
-                await this.connection
-                    .getRepository(ctx, order_item_entity_1.OrderItem)
-                    .createQueryBuilder()
-                    .delete()
-                    .whereInIds(removeItems.map(i => i.id))
-                    .execute();
-            }
-            else {
+            if (!order.active && order.state !== 'Draft') {
                 // When an Order is not active (i.e. Customer checked out), then we don't want to just
                 // delete the OrderItems - instead we will cancel them
-                const toSetAsCancelled = orderLine.items.filter(i => !i.cancelled).slice(quantity);
-                const fulfilledItems = toSetAsCancelled.filter(i => !!i.fulfillment);
-                const allocatedItems = toSetAsCancelled.filter(i => !i.fulfillment);
-                await this.stockMovementService.createCancellationsForOrderItems(ctx, fulfilledItems);
-                await this.stockMovementService.createReleasesForOrderItems(ctx, allocatedItems);
-                toSetAsCancelled.forEach(i => (i.cancelled = true));
-                await this.connection.getRepository(ctx, order_item_entity_1.OrderItem).save(toSetAsCancelled, { reload: false });
+                // const toSetAsCancelled = orderLine.items.filter(i => !i.cancelled).slice(quantity);
+                // const fulfilledItems = toSetAsCancelled.filter(i => !!i.fulfillment);
+                // const allocatedItems = toSetAsCancelled.filter(i => !i.fulfillment);
+                await this.stockMovementService.createCancellationsForOrderLines(ctx, [
+                    { orderLineId: orderLine.id, quantity },
+                ]);
+                await this.stockMovementService.createReleasesForOrderLines(ctx, [
+                    { orderLineId: orderLine.id, quantity },
+                ]);
             }
         }
         await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).save(orderLine);
         this.eventBus.publish(new index_1.OrderLineEvent(ctx, order, orderLine, 'updated'));
         return orderLine;
     }
+    async cancelOrderByOrderLines(ctx, input, lineInputs) {
+        if (lineInputs.length === 0 || (0, shared_utils_1.summate)(lineInputs, 'quantity') === 0) {
+            return new generated_graphql_admin_errors_1.EmptyOrderLineSelectionError();
+        }
+        const orders = await (0, order_utils_1.getOrdersFromLines)(ctx, this.connection, lineInputs);
+        if (1 < orders.length) {
+            return new generated_graphql_admin_errors_1.MultipleOrderError();
+        }
+        const order = orders[0];
+        if (!(0, utils_1.idsAreEqual)(order.id, input.orderId)) {
+            return new generated_graphql_admin_errors_1.MultipleOrderError();
+        }
+        if (order.active) {
+            return new generated_graphql_admin_errors_1.CancelActiveOrderError({ orderState: order.state });
+        }
+        const fullOrder = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, order.id, {
+            relations: ['lines'],
+        });
+        const allocatedLines = [];
+        const fulfilledLines = [];
+        for (const lineInput of lineInputs) {
+            const orderLine = fullOrder.lines.find(l => (0, utils_1.idsAreEqual)(l.id, lineInput.orderLineId));
+            if (orderLine && orderLine.quantity < lineInput.quantity) {
+                return new generated_graphql_admin_errors_1.QuantityTooGreatError();
+            }
+            const allocationsForLine = await this.connection
+                .getRepository(ctx, allocation_entity_1.Allocation)
+                .createQueryBuilder('allocation')
+                .leftJoinAndSelect('allocation.orderLine', 'orderLine')
+                .where('orderLine.id = :orderLineId', { orderLineId: lineInput.orderLineId })
+                .getMany();
+            const salesForLine = await this.connection
+                .getRepository(ctx, sale_entity_1.Sale)
+                .createQueryBuilder('sale')
+                .leftJoinAndSelect('sale.orderLine', 'orderLine')
+                .where('orderLine.id = :orderLineId', { orderLineId: lineInput.orderLineId })
+                .getMany();
+            const releasesForLine = await this.connection
+                .getRepository(ctx, release_entity_1.Release)
+                .createQueryBuilder('release')
+                .leftJoinAndSelect('release.orderLine', 'orderLine')
+                .where('orderLine.id = :orderLineId', { orderLineId: lineInput.orderLineId })
+                .getMany();
+            const totalAllocated = (0, shared_utils_1.summate)(allocationsForLine, 'quantity') +
+                (0, shared_utils_1.summate)(salesForLine, 'quantity') -
+                (0, shared_utils_1.summate)(releasesForLine, 'quantity');
+            if (0 < totalAllocated) {
+                allocatedLines.push({
+                    orderLineId: lineInput.orderLineId,
+                    quantity: Math.min(totalAllocated, lineInput.quantity),
+                });
+            }
+            const fulfillmentsForLine = await this.connection
+                .getRepository(ctx, fulfillment_line_entity_1.FulfillmentLine)
+                .createQueryBuilder('fulfillmentLine')
+                .leftJoinAndSelect('fulfillmentLine.orderLine', 'orderLine')
+                .where('orderLine.id = :orderLineId', { orderLineId: lineInput.orderLineId })
+                .getMany();
+            const cancellationsForLine = await this.connection
+                .getRepository(ctx, cancellation_entity_1.Cancellation)
+                .createQueryBuilder('cancellation')
+                .leftJoinAndSelect('cancellation.orderLine', 'orderLine')
+                .where('orderLine.id = :orderLineId', { orderLineId: lineInput.orderLineId })
+                .getMany();
+            const totalFulfilled = (0, shared_utils_1.summate)(fulfillmentsForLine, 'quantity') - (0, shared_utils_1.summate)(cancellationsForLine, 'quantity');
+            if (0 < totalFulfilled) {
+                fulfilledLines.push({
+                    orderLineId: lineInput.orderLineId,
+                    quantity: Math.min(totalFulfilled, lineInput.quantity),
+                });
+            }
+        }
+        await this.stockMovementService.createCancellationsForOrderLines(ctx, fulfilledLines);
+        await this.stockMovementService.createReleasesForOrderLines(ctx, allocatedLines);
+        for (const line of lineInputs) {
+            const orderLine = fullOrder.lines.find(l => (0, utils_1.idsAreEqual)(l.id, line.orderLineId));
+            if (orderLine) {
+                await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).update(line.orderLineId, {
+                    quantity: orderLine.quantity - line.quantity,
+                });
+            }
+        }
+        const orderWithLines = await this.connection.getEntityOrThrow(ctx, order_entity_1.Order, order.id, {
+            relations: ['lines', 'surcharges', 'shippingLines'],
+        });
+        if (input.cancelShipping === true) {
+            for (const shippingLine of orderWithLines.shippingLines) {
+                shippingLine.adjustments.push({
+                    adjustmentSource: 'CANCEL_ORDER',
+                    type: generated_types_1.AdjustmentType.OTHER,
+                    description: 'shipping cancellation',
+                    amount: -shippingLine.discountedPriceWithTax,
+                    data: {},
+                });
+                await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(shippingLine, { reload: false });
+            }
+        }
+        // Update totals after cancellation
+        this.orderCalculator.calculateOrderTotals(orderWithLines);
+        await this.connection.getRepository(ctx, order_entity_1.Order).save(orderWithLines, { reload: false });
+        await this.historyService.createHistoryEntryForOrder({
+            ctx,
+            orderId: order.id,
+            type: generated_types_1.HistoryEntryType.ORDER_CANCELLATION,
+            data: {
+                lines: lineInputs,
+                reason: input.reason || undefined,
+                shippingCancelled: !!input.cancelShipping,
+            },
+        });
+        return (0, order_utils_1.orderLinesAreAllCancelled)(orderWithLines);
+    }
     async modifyOrder(ctx, input, order) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const { dryRun } = input;
         const modification = new order_modification_entity_1.OrderModification({
             order,
             note: input.note || '',
-            orderItems: [],
+            lines: [],
             surcharges: [],
         });
         const initialTotalWithTax = order.totalWithTax;
@@ -219,7 +326,6 @@ let OrderModifier = class OrderModifier {
             shipping: 0,
             paymentId: ((_a = input.refund) === null || _a === void 0 ? void 0 : _a.paymentId) || '',
             reason: ((_b = input.refund) === null || _b === void 0 ? void 0 : _b.reason) || input.note,
-            orderItems: [],
         };
         for (const row of (_c = input.addItems) !== null && _c !== void 0 ? _c : []) {
             const { productVariantId, quantity } = row;
@@ -241,7 +347,10 @@ let OrderModifier = class OrderModifier {
             updatedOrderLineIds.push(orderLine.id);
             const initialQuantity = orderLine.quantity;
             await this.updateOrderLineQuantity(ctx, orderLine, initialQuantity + correctedQuantity, order);
-            modification.orderItems.push(...orderLine.items.slice(initialQuantity));
+            const orderModificationLine = await this.connection
+                .getRepository(ctx, order_modification_line_entity_1.OrderModificationLine)
+                .save(new order_modification_line_entity_1.OrderModificationLine({ orderLine, quantity: quantity - initialQuantity }));
+            modification.lines.push(orderModificationLine);
         }
         for (const row of (_d = input.adjustOrderLines) !== null && _d !== void 0 ? _d : []) {
             const { orderLineId, quantity } = row;
@@ -250,7 +359,7 @@ let OrderModifier = class OrderModifier {
             }
             const orderLine = order.lines.find(line => (0, utils_1.idsAreEqual)(line.id, orderLineId));
             if (!orderLine) {
-                throw new errors_1.UserInputError(`error.order-does-not-contain-line-with-id`, { id: orderLineId });
+                throw new errors_1.UserInputError('error.order-does-not-contain-line-with-id', { id: orderLineId });
             }
             const initialLineQuantity = orderLine.quantity;
             let correctedQuantity = quantity;
@@ -273,27 +382,34 @@ let OrderModifier = class OrderModifier {
                 if (customFields) {
                     (0, patch_entity_1.patchEntity)(orderLine, { customFields });
                 }
-                await this.updateOrderLineQuantity(ctx, orderLine, quantity, order);
+                if (quantity < initialLineQuantity) {
+                    const cancelLinesInput = [
+                        {
+                            orderLineId,
+                            quantity: initialLineQuantity - quantity,
+                        },
+                    ];
+                    await this.cancelOrderByOrderLines(ctx, { orderId: order.id }, cancelLinesInput);
+                    orderLine.quantity = quantity;
+                }
+                else {
+                    await this.updateOrderLineQuantity(ctx, orderLine, quantity, order);
+                }
+                const orderModificationLine = await this.connection
+                    .getRepository(ctx, order_modification_line_entity_1.OrderModificationLine)
+                    .save(new order_modification_line_entity_1.OrderModificationLine({ orderLine, quantity: quantity - initialLineQuantity }));
+                modification.lines.push(orderModificationLine);
                 if (correctedQuantity < initialLineQuantity) {
                     const qtyDelta = initialLineQuantity - correctedQuantity;
-                    refundInput.lines.push({
+                    (_e = refundInput.lines) === null || _e === void 0 ? void 0 : _e.push({
                         orderLineId: orderLine.id,
-                        quantity,
+                        quantity: qtyDelta,
                     });
-                    const cancelledOrderItems = orderLine.items.filter(i => i.cancelled).slice(0, qtyDelta);
-                    refundInput.orderItems.push(...cancelledOrderItems);
-                    modification.orderItems.push(...cancelledOrderItems);
-                }
-                else {
-                    const addedOrderItems = orderLine.items
-                        .filter(i => !i.cancelled)
-                        .slice(initialLineQuantity);
-                    modification.orderItems.push(...addedOrderItems);
                 }
             }
             updatedOrderLineIds.push(orderLine.id);
         }
-        for (const surchargeInput of (_e = input.surcharges) !== null && _e !== void 0 ? _e : []) {
+        for (const surchargeInput of (_f = input.surcharges) !== null && _f !== void 0 ? _f : []) {
             const taxLines = surchargeInput.taxRate != null
                 ? [
                     {
@@ -316,7 +432,7 @@ let OrderModifier = class OrderModifier {
                 refundInput.adjustment += Math.abs(surcharge.priceWithTax);
             }
         }
-        if ((_f = input.surcharges) === null || _f === void 0 ? void 0 : _f.length) {
+        if ((_g = input.surcharges) === null || _g === void 0 ? void 0 : _g.length) {
             await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
         }
         if (input.updateShippingAddress) {
@@ -367,17 +483,17 @@ let OrderModifier = class OrderModifier {
             order.couponCodes = input.couponCodes;
         }
         const updatedOrderLines = order.lines.filter(l => updatedOrderLineIds.includes(l.id));
-        const promotions = await this.connection.getRepository(ctx, promotion_entity_1.Promotion).find({
-            where: { enabled: true, deletedAt: null },
-            order: { priorityScore: 'ASC' },
-        });
+        const promotions = await this.promotionService.getActivePromotionsInChannel(ctx);
+        const activePromotionsPre = await this.promotionService.getActivePromotionsOnOrder(ctx, order.id);
         await this.orderCalculator.applyPriceAdjustments(ctx, order, promotions, updatedOrderLines, {
-            recalculateShipping: (_g = input.options) === null || _g === void 0 ? void 0 : _g.recalculateShipping,
+            recalculateShipping: (_h = input.options) === null || _h === void 0 ? void 0 : _h.recalculateShipping,
         });
+        await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).save(order.lines, { reload: false });
         const orderCustomFields = input.customFields;
         if (orderCustomFields) {
             (0, patch_entity_1.patchEntity)(order, { customFields: orderCustomFields });
         }
+        await this.promotionService.runPromotionSideEffects(ctx, order, activePromotionsPre);
         if (dryRun) {
             return { order, modification };
         }
@@ -392,11 +508,11 @@ let OrderModifier = class OrderModifier {
             if (shippingDelta < 0) {
                 refundInput.shipping = shippingDelta * -1;
             }
-            refundInput.adjustment += await this.getAdjustmentFromNewlyAppliedPromotions(ctx, order);
+            refundInput.adjustment += await this.calculateRefundAdjustment(ctx, delta, refundInput);
             const existingPayments = await this.getOrderPayments(ctx, order.id);
             const payment = existingPayments.find(p => { var _a; return (0, utils_1.idsAreEqual)(p.id, (_a = input.refund) === null || _a === void 0 ? void 0 : _a.paymentId); });
             if (payment) {
-                const refund = await this.paymentService.createRefund(ctx, refundInput, order, refundInput.orderItems, payment);
+                const refund = await this.paymentService.createRefund(ctx, refundInput, order, payment);
                 if (!(0, error_result_1.isGraphQlErrorResult)(refund)) {
                     modification.refund = refund;
                 }
@@ -410,19 +526,6 @@ let OrderModifier = class OrderModifier {
             .getRepository(ctx, order_modification_entity_1.OrderModification)
             .save(modification);
         await this.connection.getRepository(ctx, order_entity_1.Order).save(order);
-        if (input.couponCodes) {
-            // When coupon codes have changed, this will likely affect the adjustments applied to
-            // OrderItems. So in this case we need to save all of them.
-            const orderItems = order.lines.reduce((all, line) => all.concat(line.items), []);
-            await this.connection.getRepository(ctx, order_item_entity_1.OrderItem).save(orderItems, { reload: false });
-            await this.promotionService.addPromotionsToOrder(ctx, order);
-        }
-        else {
-            // Otherwise, just save those OrderItems that were specifically added/removed
-            await this.connection
-                .getRepository(ctx, order_item_entity_1.OrderItem)
-                .save(modification.orderItems, { reload: false });
-        }
         await this.connection.getRepository(ctx, shipping_line_entity_1.ShippingLine).save(order.shippingLines, { reload: false });
         return { order, modification: createdModification };
     }
@@ -437,28 +540,22 @@ let OrderModifier = class OrderModifier {
             !input.customFields;
         return noChanges;
     }
-    async getAdjustmentFromNewlyAppliedPromotions(ctx, order) {
-        await this.entityHydrator.hydrate(ctx, order, { relations: ['promotions'] });
-        const existingPromotions = order.promotions;
-        const newPromotionDiscounts = order.discounts
-            .filter(discount => {
-            const promotionId = adjustment_source_1.AdjustmentSource.decodeSourceId(discount.adjustmentSource).id;
-            return !existingPromotions.find(p => (0, utils_1.idsAreEqual)(p.id, promotionId));
-        })
-            .filter(discount => {
-            // Filter out any discounts that originate from ShippingLine discounts,
-            // since they are already correctly accounted for in the refund calculation.
-            for (const shippingLine of order.shippingLines) {
-                if (shippingLine.discounts.find(shippingDiscount => shippingDiscount.adjustmentSource === discount.adjustmentSource)) {
-                    return false;
-                }
-            }
-            return true;
-        });
-        if (newPromotionDiscounts.length) {
-            return -(0, shared_utils_1.summate)(newPromotionDiscounts, 'amountWithTax');
+    /**
+     * @description
+     * Because a Refund's amount is calculated based on the orderItems changed, plus shipping change,
+     * we need to make sure the amount gets adjusted to match any changes caused by other factors,
+     * i.e. promotions that were previously active but are no longer.
+     */
+    async calculateRefundAdjustment(ctx, delta, refundInput) {
+        const existingAdjustment = refundInput.adjustment;
+        let itemAmount = 0; // TODO: figure out what this should be
+        for (const lineInput of refundInput.lines) {
+            const orderLine = await this.connection.getEntityOrThrow(ctx, order_line_entity_1.OrderLine, lineInput.orderLineId);
+            itemAmount += orderLine.proratedUnitPriceWithTax * lineInput.quantity;
         }
-        return 0;
+        const calculatedDelta = itemAmount + refundInput.shipping + existingAdjustment;
+        const absDelta = Math.abs(delta);
+        return absDelta !== calculatedDelta ? absDelta - calculatedDelta : 0;
     }
     getOrderPayments(ctx, orderId) {
         return this.connection.getRepository(ctx, payment_entity_1.Payment).find({
@@ -469,12 +566,27 @@ let OrderModifier = class OrderModifier {
         });
     }
     async customFieldsAreEqual(ctx, orderLine, inputCustomFields, existingCustomFields) {
+        const customFieldDefs = this.configService.customFields.OrderLine;
         if (inputCustomFields == null && typeof existingCustomFields === 'object') {
             // A null value for an OrderLine customFields input is the equivalent
-            // of every property of an existing customFields object being null.
-            return Object.values(existingCustomFields).every(v => v === null);
+            // of every property of an existing customFields object being null
+            // or equal to the defaultValue
+            for (const def of customFieldDefs) {
+                const key = def.name;
+                const existingValue = this.coerceValue(def, existingCustomFields);
+                if (existingValue != null && (!def.list || (existingValue === null || existingValue === void 0 ? void 0 : existingValue.length) !== 0)) {
+                    if (def.defaultValue != null) {
+                        if (existingValue !== def.defaultValue) {
+                            return false;
+                        }
+                    }
+                    else {
+                        return false;
+                    }
+                }
+            }
+            return true;
         }
-        const customFieldDefs = this.configService.customFields.OrderLine;
         const customFieldRelations = customFieldDefs.filter(d => d.type === 'relation');
         let lineWithCustomFieldRelations;
         if (customFieldRelations.length) {
@@ -482,32 +594,52 @@ let OrderModifier = class OrderModifier {
             // existing entity assigned.
             lineWithCustomFieldRelations = await this.connection
                 .getRepository(ctx, order_line_entity_1.OrderLine)
-                .findOne(orderLine.id, {
+                .findOne({
+                where: { id: orderLine.id },
                 relations: customFieldRelations.map(r => `customFields.${r.name}`),
-            });
+            })
+                .then(result => result !== null && result !== void 0 ? result : undefined);
         }
         for (const def of customFieldDefs) {
             const key = def.name;
-            const existingValue = existingCustomFields === null || existingCustomFields === void 0 ? void 0 : existingCustomFields[key];
-            if (existingValue !== undefined) {
+            const existingValue = this.coerceValue(def, existingCustomFields);
+            if (def.type !== 'relation' && existingValue !== undefined) {
                 const valuesMatch = JSON.stringify(inputCustomFields === null || inputCustomFields === void 0 ? void 0 : inputCustomFields[key]) === JSON.stringify(existingValue);
                 const undefinedMatchesNull = existingValue === null && (inputCustomFields === null || inputCustomFields === void 0 ? void 0 : inputCustomFields[key]) === undefined;
-                if (!valuesMatch && !undefinedMatchesNull) {
+                const defaultValueMatch = (inputCustomFields === null || inputCustomFields === void 0 ? void 0 : inputCustomFields[key]) === undefined && def.defaultValue === existingValue;
+                if (!valuesMatch && !undefinedMatchesNull && !defaultValueMatch) {
                     return false;
                 }
             }
             else if (def.type === 'relation') {
-                const inputId = `${key}Id`;
+                const inputId = (0, shared_utils_1.getGraphQlInputName)(def);
                 const inputValue = inputCustomFields === null || inputCustomFields === void 0 ? void 0 : inputCustomFields[inputId];
-                // tslint:disable-next-line:no-non-null-assertion
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 const existingRelation = lineWithCustomFieldRelations.customFields[key];
-                if (inputValue && inputValue !== (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.id)) {
-                    return false;
+                if (inputValue) {
+                    const customFieldNotEqual = def.list
+                        ? JSON.stringify(inputValue.sort()) !==
+                            JSON.stringify(existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.map((relation) => relation.id).sort())
+                        : inputValue !== (existingRelation === null || existingRelation === void 0 ? void 0 : existingRelation.id);
+                    if (customFieldNotEqual) {
+                        return false;
+                    }
                 }
             }
         }
         return true;
     }
+    /**
+     * This function is required because with the MySQL driver, boolean customFields with a default
+     * of `false` were being represented as `0`, thus causing the equality check to fail.
+     * So if it's a boolean, we'll explicitly coerce the value to a boolean.
+     */
+    coerceValue(def, existingCustomFields) {
+        const key = def.name;
+        return def.type === 'boolean' && typeof (existingCustomFields === null || existingCustomFields === void 0 ? void 0 : existingCustomFields[key]) === 'number'
+            ? !!(existingCustomFields === null || existingCustomFields === void 0 ? void 0 : existingCustomFields[key])
+            : existingCustomFields === null || existingCustomFields === void 0 ? void 0 : existingCustomFields[key];
+    }
     async getProductVariantOrThrow(ctx, productVariantId) {
         const productVariant = await this.productVariantService.findOne(ctx, productVariantId);
         if (!productVariant) {
@@ -529,7 +661,8 @@ OrderModifier = __decorate([
         promotion_service_1.PromotionService,
         event_bus_1.EventBus,
         entity_hydrator_service_1.EntityHydrator,
-        history_service_1.HistoryService])
+        history_service_1.HistoryService,
+        translator_service_1.TranslatorService])
 ], OrderModifier);
 exports.OrderModifier = OrderModifier;
 //# sourceMappingURL=order-modifier.js.map