@vendure/core 3.1.0-next.3 → 3.1.0

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

@@ -25,6 +25,7 @@ const generated_graphql_shop_errors_1 = require("../../common/error/generated-gr
 const tax_utils_1 = require("../../common/tax-utils");
 const utils_1 = require("../../common/utils");
 const config_service_1 = require("../../config/config.service");
+const vendure_logger_1 = require("../../config/logger/vendure-logger");
 const transactional_connection_1 = require("../../connection/transactional-connection");
 const order_entity_1 = require("../../entity/order/order.entity");
 const order_line_entity_1 = require("../../entity/order-line/order-line.entity");
@@ -407,113 +408,249 @@ let OrderService = class OrderService {
      * @description
      * Adds an item to the Order, either creating a new OrderLine or
      * incrementing an existing one.
+     *
+     * If you need to add multiple items to an Order, use `addItemsToOrder()` instead.
      */
     async addItemToOrder(ctx, orderId, productVariantId, quantity, customFields, relations) {
-        const order = await this.getOrderOrThrow(ctx, orderId);
-        const existingOrderLine = await this.orderModifier.getExistingOrderLine(ctx, order, productVariantId, customFields);
-        const validationError = this.assertQuantityIsPositive(quantity) ||
-            this.assertAddingItemsState(order) ||
-            this.assertNotOverOrderItemsLimit(order, quantity) ||
-            this.assertNotOverOrderLineItemsLimit(existingOrderLine, quantity);
-        if (validationError) {
-            return validationError;
-        }
-        const variant = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, productVariantId, {
-            relations: ['product'],
-            where: {
-                enabled: true,
-                deletedAt: (0, typeorm_1.IsNull)(),
-            },
-            loadEagerRelations: false,
-        });
-        if (variant.product.enabled === false) {
-            throw new errors_1.EntityNotFoundError('ProductVariant', productVariantId);
-        }
-        const existingQuantityInOtherLines = (0, shared_utils_1.summate)(order.lines.filter(l => (0, utils_1.idsAreEqual)(l.productVariantId, productVariantId) &&
-            !(0, utils_1.idsAreEqual)(l.id, existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.id)), 'quantity');
-        const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, variant, quantity, existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.quantity, existingQuantityInOtherLines);
-        if (correctedQuantity === 0) {
-            return new generated_graphql_shop_errors_1.InsufficientStockError({ order, quantityAvailable: correctedQuantity });
-        }
-        const orderLine = await this.orderModifier.getOrCreateOrderLine(ctx, order, productVariantId, customFields);
-        if (correctedQuantity < quantity) {
-            const newQuantity = (existingOrderLine ? existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.quantity : 0) + correctedQuantity;
-            await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, newQuantity, order);
+        const result = await this.addItemsToOrder(ctx, orderId, [{ productVariantId, quantity, customFields }], relations);
+        if (result.errorResults.length) {
+            return result.errorResults[0];
         }
         else {
-            await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, correctedQuantity, order);
+            return result.order;
         }
-        const quantityWasAdjustedDown = correctedQuantity < quantity;
-        const updatedOrder = await this.applyPriceAdjustments(ctx, order, [orderLine], relations);
-        if (quantityWasAdjustedDown) {
-            return new generated_graphql_shop_errors_1.InsufficientStockError({ quantityAvailable: correctedQuantity, order: updatedOrder });
+    }
+    /**
+     * @description
+     * Adds multiple items to an Order. This method is more efficient than calling `addItemToOrder`
+     * multiple times, as it only needs to fetch the entire Order once, and only performs
+     * price adjustments once at the end.
+     *
+     * Since this method can return multiple error results, it is recommended to check the `errorResults`
+     * array to determine if any errors occurred.
+     *
+     * @since 3.1.0
+     */
+    async addItemsToOrder(ctx, orderId, items, relations) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const errorResults = [];
+        const updatedOrderLines = [];
+        addItem: for (const item of items) {
+            const { productVariantId, quantity, customFields } = item;
+            const existingOrderLine = await this.orderModifier.getExistingOrderLine(ctx, order, productVariantId, customFields);
+            const validationError = this.assertQuantityIsPositive(quantity) ||
+                this.assertAddingItemsState(order) ||
+                this.assertNotOverOrderItemsLimit(order, quantity) ||
+                this.assertNotOverOrderLineItemsLimit(existingOrderLine, quantity);
+            if (validationError) {
+                errorResults.push(validationError);
+                continue;
+            }
+            const variant = await this.connection.getEntityOrThrow(ctx, product_variant_entity_1.ProductVariant, productVariantId, {
+                relations: ['product'],
+                where: {
+                    enabled: true,
+                    deletedAt: (0, typeorm_1.IsNull)(),
+                },
+                loadEagerRelations: false,
+            });
+            if (variant.product.enabled === false) {
+                throw new errors_1.EntityNotFoundError('ProductVariant', productVariantId);
+            }
+            const existingQuantityInOtherLines = (0, shared_utils_1.summate)(order.lines.filter(l => (0, utils_1.idsAreEqual)(l.productVariantId, productVariantId) &&
+                !(0, utils_1.idsAreEqual)(l.id, existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.id)), 'quantity');
+            const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, variant, quantity, existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.quantity, existingQuantityInOtherLines);
+            if (correctedQuantity === 0) {
+                errorResults.push(new generated_graphql_shop_errors_1.InsufficientStockError({ order, quantityAvailable: correctedQuantity }));
+                continue;
+            }
+            const { orderInterceptors } = this.configService.orderOptions;
+            for (const interceptor of orderInterceptors) {
+                if (interceptor.willAddItemToOrder) {
+                    const error = await interceptor.willAddItemToOrder(ctx, order, {
+                        productVariant: variant,
+                        quantity: correctedQuantity,
+                        customFields,
+                    });
+                    if (error) {
+                        errorResults.push(new generated_graphql_shop_errors_1.OrderInterceptorError({ interceptorError: error }));
+                        continue addItem;
+                    }
+                }
+            }
+            const orderLine = await this.orderModifier.getOrCreateOrderLine(ctx, order, productVariantId, customFields);
+            if (correctedQuantity < quantity) {
+                const newQuantity = (existingOrderLine ? existingOrderLine === null || existingOrderLine === void 0 ? void 0 : existingOrderLine.quantity : 0) + correctedQuantity;
+                await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, newQuantity, order);
+            }
+            else {
+                await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, correctedQuantity, order);
+            }
+            updatedOrderLines.push(orderLine);
+            const quantityWasAdjustedDown = correctedQuantity < quantity;
+            if (quantityWasAdjustedDown) {
+                errorResults.push(new generated_graphql_shop_errors_1.InsufficientStockError({ quantityAvailable: correctedQuantity, order }));
+                continue;
+            }
         }
-        else {
-            return updatedOrder;
+        const updatedOrder = await this.applyPriceAdjustments(ctx, order, updatedOrderLines, relations);
+        // for any InsufficientStockError errors, we want to make sure we use the final updatedOrder
+        // after having applied all price adjustments
+        for (const [i, errorResult] of Object.entries(errorResults)) {
+            if (errorResult.__typename === 'InsufficientStockError') {
+                errorResults[+i] = new generated_graphql_shop_errors_1.InsufficientStockError({
+                    quantityAvailable: errorResult.quantityAvailable,
+                    order: updatedOrder,
+                });
+            }
         }
+        return {
+            order: updatedOrder,
+            errorResults,
+        };
     }
     /**
      * @description
      * Adjusts the quantity and/or custom field values of an existing OrderLine.
+     *
+     * If you need to adjust multiple OrderLines, use `adjustOrderLines()` instead.
      */
     async adjustOrderLine(ctx, orderId, orderLineId, quantity, customFields, relations) {
-        const order = await this.getOrderOrThrow(ctx, orderId);
-        const orderLine = this.getOrderLineOrThrow(order, orderLineId);
-        const validationError = this.assertAddingItemsState(order) ||
-            this.assertQuantityIsPositive(quantity) ||
-            this.assertNotOverOrderItemsLimit(order, quantity - orderLine.quantity) ||
-            this.assertNotOverOrderLineItemsLimit(orderLine, quantity - orderLine.quantity);
-        if (validationError) {
-            return validationError;
-        }
-        if (customFields != null) {
-            orderLine.customFields = customFields;
-            await this.customFieldRelationService.updateRelations(ctx, order_line_entity_1.OrderLine, { customFields }, orderLine);
-        }
-        const existingQuantityInOtherLines = (0, shared_utils_1.summate)(order.lines.filter(l => (0, utils_1.idsAreEqual)(l.productVariantId, orderLine.productVariantId) &&
-            !(0, utils_1.idsAreEqual)(l.id, orderLineId)), 'quantity');
-        const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, orderLine.productVariant, quantity, 0, existingQuantityInOtherLines);
-        let updatedOrderLines = [orderLine];
-        if (correctedQuantity === 0) {
-            order.lines = order.lines.filter(l => !(0, utils_1.idsAreEqual)(l.id, orderLine.id));
-            const deletedOrderLine = new order_line_entity_1.OrderLine(orderLine);
-            await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
-            await this.eventBus.publish(new order_line_event_1.OrderLineEvent(ctx, order, deletedOrderLine, 'deleted'));
-            updatedOrderLines = [];
+        const result = await this.adjustOrderLines(ctx, orderId, [{ orderLineId, quantity, customFields }], relations);
+        if (result.errorResults.length) {
+            return result.errorResults[0];
         }
         else {
-            await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, correctedQuantity, order);
+            return result.order;
         }
-        const quantityWasAdjustedDown = correctedQuantity < quantity;
-        const updatedOrder = await this.applyPriceAdjustments(ctx, order, updatedOrderLines, relations);
-        if (quantityWasAdjustedDown) {
-            return new generated_graphql_shop_errors_1.InsufficientStockError({ quantityAvailable: correctedQuantity, order: updatedOrder });
+    }
+    /**
+     * @description
+     * Adjusts the quantity and/or custom field values of existing OrderLines.
+     * This method is more efficient than calling `adjustOrderLine` multiple times, as it only needs to fetch
+     * the entire Order once, and only performs price adjustments once at the end.
+     * Since this method can return multiple error results, it is recommended to check the `errorResults`
+     * array to determine if any errors occurred.
+     *
+     * @since 3.1.0
+     */
+    async adjustOrderLines(ctx, orderId, lines, relations) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        const errorResults = [];
+        const updatedOrderLines = [];
+        adjustLine: for (const line of lines) {
+            const { orderLineId, quantity, customFields } = line;
+            const orderLine = this.getOrderLineOrThrow(order, orderLineId);
+            const validationError = this.assertAddingItemsState(order) ||
+                this.assertQuantityIsPositive(quantity) ||
+                this.assertNotOverOrderItemsLimit(order, quantity - orderLine.quantity) ||
+                this.assertNotOverOrderLineItemsLimit(orderLine, quantity - orderLine.quantity);
+            if (validationError) {
+                errorResults.push(validationError);
+                continue;
+            }
+            const { orderInterceptors } = this.configService.orderOptions;
+            for (const interceptor of orderInterceptors) {
+                if (interceptor.willAdjustOrderLine) {
+                    const error = await interceptor.willAdjustOrderLine(ctx, order, {
+                        orderLine,
+                        quantity,
+                        customFields,
+                    });
+                    if (error) {
+                        errorResults.push(new generated_graphql_shop_errors_1.OrderInterceptorError({ interceptorError: error }));
+                        continue adjustLine;
+                    }
+                }
+            }
+            if (customFields != null) {
+                orderLine.customFields = customFields;
+                await this.customFieldRelationService.updateRelations(ctx, order_line_entity_1.OrderLine, { customFields }, orderLine);
+            }
+            const existingQuantityInOtherLines = (0, shared_utils_1.summate)(order.lines.filter(l => (0, utils_1.idsAreEqual)(l.productVariantId, orderLine.productVariantId) &&
+                !(0, utils_1.idsAreEqual)(l.id, orderLineId)), 'quantity');
+            const correctedQuantity = await this.orderModifier.constrainQuantityToSaleable(ctx, orderLine.productVariant, quantity, 0, existingQuantityInOtherLines);
+            if (correctedQuantity === 0) {
+                order.lines = order.lines.filter(l => !(0, utils_1.idsAreEqual)(l.id, orderLine.id));
+                const deletedOrderLine = new order_line_entity_1.OrderLine(orderLine);
+                await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
+                await this.eventBus.publish(new order_line_event_1.OrderLineEvent(ctx, order, deletedOrderLine, 'deleted'));
+            }
+            else {
+                await this.orderModifier.updateOrderLineQuantity(ctx, orderLine, correctedQuantity, order);
+                updatedOrderLines.push(orderLine);
+            }
+            const quantityWasAdjustedDown = correctedQuantity < quantity;
+            if (quantityWasAdjustedDown) {
+                errorResults.push(new generated_graphql_shop_errors_1.InsufficientStockError({
+                    quantityAvailable: correctedQuantity,
+                    order,
+                }));
+            }
         }
-        else {
-            return updatedOrder;
+        const updatedOrder = await this.applyPriceAdjustments(ctx, order, updatedOrderLines, relations);
+        for (const [i, errorResult] of Object.entries(errorResults)) {
+            if (errorResult.__typename === 'InsufficientStockError') {
+                errorResults[+i] = new generated_graphql_shop_errors_1.InsufficientStockError({
+                    quantityAvailable: errorResult.quantityAvailable,
+                    order: updatedOrder,
+                });
+            }
         }
+        return {
+            order: updatedOrder,
+            errorResults,
+        };
     }
     /**
      * @description
      * Removes the specified OrderLine from the Order.
+     *
+     * If you need to remove multiple OrderLines, use `removeItemsFromOrder()` instead.
      */
     async removeItemFromOrder(ctx, orderId, orderLineId) {
+        return this.removeItemsFromOrder(ctx, orderId, [orderLineId]);
+    }
+    /**
+     * @description
+     * Removes the specified OrderLines from the Order.
+     * This method is more efficient than calling `removeItemFromOrder` multiple times, as it only needs to fetch
+     * the entire Order once, and only performs price adjustments once at the end.
+     *
+     * @since 3.1.0
+     */
+    async removeItemsFromOrder(ctx, orderId, orderLineIds) {
         const order = await this.getOrderOrThrow(ctx, orderId);
         const validationError = this.assertAddingItemsState(order);
         if (validationError) {
             return validationError;
         }
-        const orderLine = this.getOrderLineOrThrow(order, orderLineId);
-        order.lines = order.lines.filter(line => !(0, utils_1.idsAreEqual)(line.id, orderLineId));
+        const orderLinesToDelete = [];
+        for (const orderLineId of orderLineIds) {
+            const orderLine = this.getOrderLineOrThrow(order, orderLineId);
+            const { orderInterceptors } = this.configService.orderOptions;
+            for (const interceptor of orderInterceptors) {
+                if (interceptor.willRemoveItemFromOrder) {
+                    const error = await interceptor.willRemoveItemFromOrder(ctx, order, orderLine);
+                    if (error) {
+                        return new generated_graphql_shop_errors_1.OrderInterceptorError({ interceptorError: error });
+                    }
+                }
+            }
+            orderLinesToDelete.push(orderLine);
+        }
+        order.lines = order.lines.filter(line => !orderLineIds.find(olId => (0, utils_1.idsAreEqual)(line.id, olId)));
         // Persist the orderLine removal before applying price adjustments
         // so that any hydration of the Order entity during the course of the
         // `applyPriceAdjustments()` (e.g. in a ShippingEligibilityChecker etc)
         // will not re-add the OrderLine.
         await this.connection.getRepository(ctx, order_entity_1.Order).save(order, { reload: false });
         const updatedOrder = await this.applyPriceAdjustments(ctx, order);
-        const deletedOrderLine = new order_line_entity_1.OrderLine(orderLine);
-        await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
-        await this.eventBus.publish(new order_line_event_1.OrderLineEvent(ctx, order, deletedOrderLine, 'deleted'));
+        for (const orderLine of orderLinesToDelete) {
+            const deletedOrderLine = new order_line_entity_1.OrderLine(orderLine);
+            await this.connection.getRepository(ctx, order_line_entity_1.OrderLine).remove(orderLine);
+            await this.eventBus.publish(new order_line_event_1.OrderLineEvent(ctx, order, deletedOrderLine, 'deleted'));
+        }
         return updatedOrder;
     }
     /**
@@ -675,6 +812,52 @@ let OrderService = class OrderService {
         this.requestCache.set(ctx, constants_1.CacheKey.ActiveTaxZone_PPA, undefined);
         return this.applyPriceAdjustments(ctx, order, order.lines);
     }
+    /**
+     * @description
+     * Unsets the shipping address for the Order.
+     *
+     * @since 3.1.0
+     */
+    async unsetShippingAddress(ctx, orderId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .update(order_entity_1.Order)
+            .set({ shippingAddress: {} })
+            .where('id = :id', { id: order.id })
+            .execute();
+        order.shippingAddress = {};
+        // Since a changed ShippingAddress could alter the activeTaxZone,
+        // we will remove any cached activeTaxZone, so it can be re-calculated
+        // as needed.
+        this.requestCache.set(ctx, constants_1.CacheKey.ActiveTaxZone, undefined);
+        this.requestCache.set(ctx, constants_1.CacheKey.ActiveTaxZone_PPA, undefined);
+        return this.applyPriceAdjustments(ctx, order, order.lines);
+    }
+    /**
+     * @description
+     * Unsets the billing address for the Order.
+     *
+     * @since 3.1.0
+     */
+    async unsetBillingAddress(ctx, orderId) {
+        const order = await this.getOrderOrThrow(ctx, orderId);
+        await this.connection
+            .getRepository(ctx, order_entity_1.Order)
+            .createQueryBuilder('order')
+            .update(order_entity_1.Order)
+            .set({ billingAddress: {} })
+            .where('id = :id', { id: order.id })
+            .execute();
+        order.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, constants_1.CacheKey.ActiveTaxZone, undefined);
+        this.requestCache.set(ctx, constants_1.CacheKey.ActiveTaxZone_PPA, undefined);
+        return this.applyPriceAdjustments(ctx, order, order.lines);
+    }
     /**
      * @description
      * Returns an array of quotes stating which {@link ShippingMethod}s may be applied to this Order.
@@ -1246,32 +1429,36 @@ let OrderService = class OrderService {
         if (orderToDelete) {
             await this.deleteOrder(ctx, orderToDelete);
         }
-        if (order && linesToInsert) {
+        if (order && linesToDelete) {
             const orderId = order.id;
-            for (const line of linesToInsert) {
-                const result = await this.addItemToOrder(ctx, orderId, line.productVariantId, line.quantity, line.customFields);
+            for (const line of linesToDelete) {
+                const result = await this.removeItemFromOrder(ctx, orderId, line.orderLineId);
                 if (!(0, error_result_1.isGraphQlErrorResult)(result)) {
                     order = result;
                 }
             }
         }
+        if (order && linesToInsert) {
+            const orderId = order.id;
+            const result = await this.addItemsToOrder(ctx, orderId, linesToInsert);
+            order = result.order;
+        }
         if (order && linesToModify) {
             const orderId = order.id;
-            for (const line of linesToModify) {
-                const result = await this.adjustOrderLine(ctx, orderId, line.orderLineId, line.quantity, line.customFields);
-                if (!(0, error_result_1.isGraphQlErrorResult)(result)) {
-                    order = result;
-                }
-            }
+            const result = await this.adjustOrderLines(ctx, orderId, linesToModify);
+            order = result.order;
         }
         if (order && linesToDelete) {
             const orderId = order.id;
-            for (const line of linesToDelete) {
-                const result = await this.removeItemFromOrder(ctx, orderId, line.orderLineId);
+            try {
+                const result = await this.removeItemsFromOrder(ctx, orderId, linesToDelete.map(l => l.orderLineId));
                 if (!(0, error_result_1.isGraphQlErrorResult)(result)) {
                     order = result;
                 }
             }
+            catch (e) {
+                vendure_logger_1.Logger.error(e.message, undefined, e.stack);
+            }
         }
         const customer = await this.customerService.findOneByUserId(ctx, user.id);
         if (order && customer) {