fix(core): Unassigning shipping lines from a channel breaks active orders

packages/core/e2e/shipping-method.e2e-spec.ts

@@ -13,16 +13,30 @@ import { initialData } from '../../../e2e-common/e2e-initial-data';
 import { TEST_SETUP_TIMEOUT_MS, testConfig } from '../../../e2e-common/test-config';
 import { manualFulfillmentHandler } from '../src/config/fulfillment/manual-fulfillment-handler';
 
+import { testSuccessfulPaymentMethod } from './fixtures/test-payment-methods';
 import { SHIPPING_METHOD_FRAGMENT } from './graphql/fragments';
 import * as Codegen from './graphql/generated-e2e-admin-types';
 import { DeletionResult, LanguageCode } from './graphql/generated-e2e-admin-types';
 import {
+    ASSIGN_PRODUCTVARIANT_TO_CHANNEL,
+    CREATE_CHANNEL,
     CREATE_SHIPPING_METHOD,
     DELETE_SHIPPING_METHOD,
+    GET_ORDER,
     GET_SHIPPING_METHOD_LIST,
     UPDATE_SHIPPING_METHOD,
 } from './graphql/shared-definitions';
-import { GET_ACTIVE_SHIPPING_METHODS } from './graphql/shop-definitions';
+import {
+    ADD_ITEM_TO_ORDER,
+    ADD_PAYMENT,
+    GET_ACTIVE_ORDER,
+    GET_ACTIVE_SHIPPING_METHODS,
+    SET_CUSTOMER,
+    SET_SHIPPING_ADDRESS,
+    SET_SHIPPING_METHOD,
+    TRANSITION_TO_STATE,
+} from './graphql/shop-definitions';
+import { CREATE_PAYMENT_METHOD } from './payment-method.e2e-spec';
 
 const TEST_METADATA = {
     foo: 'bar',
@@ -46,6 +60,9 @@ const calculatorWithMetadata = new ShippingCalculator({
 describe('ShippingMethod resolver', () => {
     const { server, adminClient, shopClient } = createTestEnvironment({
         ...testConfig(),
+        paymentOptions: {
+            paymentMethodHandlers: [testSuccessfulPaymentMethod],
+        },
         shippingOptions: {
             shippingEligibilityCheckers: [defaultShippingEligibilityChecker],
             shippingCalculators: [defaultShippingCalculator, calculatorWithMetadata],
@@ -54,7 +71,15 @@ describe('ShippingMethod resolver', () => {
 
     beforeAll(async () => {
         await server.init({
-            initialData,
+            initialData: {
+                ...initialData,
+                paymentMethods: [
+                    {
+                        name: testSuccessfulPaymentMethod.code,
+                        handler: { code: testSuccessfulPaymentMethod.code, arguments: [] },
+                    },
+                ],
+            },
             productsCsvPath: path.join(__dirname, 'fixtures/e2e-products-full.csv'),
             customerCount: 1,
         });
@@ -515,6 +540,184 @@ describe('ShippingMethod resolver', () => {
         expect(activeShippingMethods[0].name).toBe('Active Method');
         expect(activeShippingMethods[0].description).toBe('This is an active shipping method');
     });
+
+    // https://github.com/vendure-ecommerce/vendure/issues/4492
+    describe('shipping line removal on channel unassign', () => {
+        let channelId: string;
+        let shippingMethodId: string;
+
+        beforeAll(async () => {
+            // Create a new channel
+            const { createChannel } = await adminClient.query(CREATE_CHANNEL, {
+                input: {
+                    code: 'shipping-test-channel',
+                    token: 'shipping-test-channel-token',
+                    defaultLanguageCode: LanguageCode.en,
+                    currencyCode: 'USD',
+                    pricesIncludeTax: false,
+                    defaultShippingZoneId: 'T_1',
+                    defaultTaxZoneId: 'T_1',
+                },
+            });
+            channelId = createChannel.id;
+
+            // Create a shipping method and assign it to the new channel
+            const { createShippingMethod } = await adminClient.query<
+                Codegen.CreateShippingMethodMutation,
+                Codegen.CreateShippingMethodMutationVariables
+            >(CREATE_SHIPPING_METHOD, {
+                input: {
+                    code: 'channel-test-method',
+                    fulfillmentHandler: manualFulfillmentHandler.code,
+                    checker: {
+                        code: defaultShippingEligibilityChecker.code,
+                        arguments: [{ name: 'orderMinimum', value: '0' }],
+                    },
+                    calculator: {
+                        code: defaultShippingCalculator.code,
+                        arguments: [
+                            { name: 'rate', value: '500' },
+                            { name: 'includesTax', value: 'auto' },
+                            { name: 'taxRate', value: '0' },
+                        ],
+                    },
+                    translations: [
+                        { languageCode: LanguageCode.en, name: 'Channel Test Method', description: '' },
+                    ],
+                },
+            });
+            shippingMethodId = createShippingMethod.id;
+
+            await adminClient.query(ASSIGN_SHIPPING_METHODS_TO_CHANNEL, {
+                input: {
+                    channelId,
+                    shippingMethodIds: [shippingMethodId],
+                },
+            });
+
+            // Assign product variant to the new channel
+            await adminClient.query(ASSIGN_PRODUCTVARIANT_TO_CHANNEL, {
+                input: {
+                    channelId,
+                    productVariantIds: ['T_1'],
+                },
+            });
+        });
+
+        it('recalculates active orders when shipping method is unassigned from channel', async () => {
+            // Create an active order in the new channel with the shipping method
+            shopClient.setChannelToken('shipping-test-channel-token');
+            await shopClient.asAnonymousUser();
+            await shopClient.query(ADD_ITEM_TO_ORDER, {
+                productVariantId: 'T_1',
+                quantity: 1,
+            });
+            await shopClient.query(SET_SHIPPING_METHOD, { id: [shippingMethodId] });
+
+            // Verify shipping line is present and totals include shipping
+            const { activeOrder: orderBefore } = await shopClient.query(GET_ACTIVE_ORDER);
+            expect(orderBefore.shippingLines).toHaveLength(1);
+            expect(orderBefore.shippingLines[0].shippingMethod.id).toBe(shippingMethodId);
+            expect(orderBefore.shipping).toBe(500);
+            expect(orderBefore.total).toBe(Number(orderBefore.subTotal) + 500);
+
+            // Remove the shipping method from the channel
+            await adminClient.query(REMOVE_SHIPPING_METHODS_FROM_CHANNEL, {
+                input: {
+                    channelId,
+                    shippingMethodIds: [shippingMethodId],
+                },
+            });
+
+            // Verify the shipping line has been removed and totals recalculated
+            const { activeOrder: orderAfter } = await shopClient.query(GET_ACTIVE_ORDER);
+            expect(orderAfter.shippingLines).toHaveLength(0);
+            expect(orderAfter.shipping).toBe(0);
+            expect(orderAfter.shippingWithTax).toBe(0);
+            expect(orderAfter.total).toBe(orderAfter.subTotal);
+            expect(orderAfter.totalWithTax).toBe(orderAfter.subTotalWithTax);
+
+            // Reset shop client to default channel
+            shopClient.setChannelToken('e2e-default-channel');
+        });
+
+        it('historical orders still resolve shipping method after unassignment', async () => {
+            // Re-assign the shipping method to the channel so we can create a completed order
+            await adminClient.query(ASSIGN_SHIPPING_METHODS_TO_CHANNEL, {
+                input: {
+                    channelId,
+                    shippingMethodIds: [shippingMethodId],
+                },
+            });
+
+            // Create a payment method in the test channel
+            adminClient.setChannelToken('shipping-test-channel-token');
+            await adminClient.query(CREATE_PAYMENT_METHOD, {
+                input: {
+                    code: 'test-payment-method',
+                    translations: [
+                        { languageCode: LanguageCode.en, name: 'Test Payment Method', description: '' },
+                    ],
+                    enabled: true,
+                    handler: {
+                        code: testSuccessfulPaymentMethod.code,
+                        arguments: [],
+                    },
+                },
+            });
+            adminClient.setChannelToken('e2e-default-channel');
+
+            // Create and complete an order
+            shopClient.setChannelToken('shipping-test-channel-token');
+            await shopClient.asAnonymousUser();
+            await shopClient.query(ADD_ITEM_TO_ORDER, {
+                productVariantId: 'T_1',
+                quantity: 1,
+            });
+            await shopClient.query(SET_SHIPPING_METHOD, { id: [shippingMethodId] });
+            await shopClient.query(SET_CUSTOMER, {
+                input: {
+                    firstName: 'Test',
+                    lastName: 'Customer',
+                    emailAddress: 'shipping-test@test.com',
+                },
+            });
+            await shopClient.query(SET_SHIPPING_ADDRESS, {
+                input: {
+                    streetLine1: '1 Test Street',
+                    countryCode: 'GB',
+                },
+            });
+            await shopClient.query(TRANSITION_TO_STATE, { state: 'ArrangingPayment' });
+            const { addPaymentToOrder: completedOrder } = await shopClient.query(ADD_PAYMENT, {
+                input: {
+                    method: testSuccessfulPaymentMethod.code,
+                    metadata: {},
+                },
+            });
+
+            // Remove the shipping method from the channel again
+            await adminClient.query(REMOVE_SHIPPING_METHODS_FROM_CHANNEL, {
+                input: {
+                    channelId,
+                    shippingMethodIds: [shippingMethodId],
+                },
+            });
+
+            // Verify the historical order still resolves the shipping method
+            adminClient.setChannelToken('shipping-test-channel-token');
+            const { order } = await adminClient.query(GET_ORDER, {
+                id: completedOrder.id,
+            });
+            expect(order.shippingLines).toHaveLength(1);
+            expect(order.shippingLines[0].shippingMethod.id).toBe(shippingMethodId);
+            expect(order.shippingLines[0].shippingMethod.name).toBe('Channel Test Method');
+
+            // Reset clients to default channel
+            shopClient.setChannelToken('e2e-default-channel');
+            adminClient.setChannelToken('e2e-default-channel');
+        });
+    });
 });
 
 const GET_SHIPPING_METHOD = gql`
@@ -583,3 +786,21 @@ export const TEST_ELIGIBLE_SHIPPING_METHODS = gql`
         }
     }
 `;
+
+const ASSIGN_SHIPPING_METHODS_TO_CHANNEL = gql`
+    mutation AssignShippingMethodsToChannel($input: AssignShippingMethodsToChannelInput!) {
+        assignShippingMethodsToChannel(input: $input) {
+            id
+            name
+        }
+    }
+`;
+
+const REMOVE_SHIPPING_METHODS_FROM_CHANNEL = gql`
+    mutation RemoveShippingMethodsFromChannel($input: RemoveShippingMethodsFromChannelInput!) {
+        removeShippingMethodsFromChannel(input: $input) {
+            id
+            name
+        }
+    }
+`;

packages/core/src/api/resolvers/entity/shipping-line-entity.resolver.ts

@@ -15,7 +15,7 @@ export class ShippingLineEntityResolver {
             // Does not need to be decoded because it is an internal property
             // which is never exposed to the outside world.
             const shippingMethodId = shippingLine.shippingMethodId;
-            return this.shippingMethodService.findOne(ctx, shippingMethodId, true);
+            return this.shippingMethodService.findOne(ctx, shippingMethodId, true, [], false);
         } else {
             return null;
         }

packages/core/src/service/services/order.service.ts

@@ -94,9 +94,11 @@ import { Promotion } from '../../entity/promotion/promotion.entity';
 import { Refund } from '../../entity/refund/refund.entity';
 import { Session } from '../../entity/session/session.entity';
 import { ShippingLine } from '../../entity/shipping-line/shipping-line.entity';
+import { ShippingMethod } from '../../entity/shipping-method/shipping-method.entity';
 import { Surcharge } from '../../entity/surcharge/surcharge.entity';
 import { User } from '../../entity/user/user.entity';
 import { EventBus } from '../../event-bus/event-bus';
+import { ChangeChannelEvent } from '../../event-bus/events/change-channel-event';
 import { CouponCodeEvent } from '../../event-bus/events/coupon-code-event';
 import { OrderEvent } from '../../event-bus/events/order-event';
 import { OrderLineEvent } from '../../event-bus/events/order-line-event';
@@ -164,7 +166,19 @@ export class OrderService {
         private requestCache: RequestContextCacheService,
         private translator: TranslatorService,
         private stockLevelService: StockLevelService,
-    ) {}
+    ) {
+        this.eventBus.registerBlockingEventHandler({
+            id: 'order-service-remove-shipping-method-from-active-orders',
+            event: ChangeChannelEvent,
+            handler: async event => {
+                if (event.entityType === ShippingMethod && event.type === 'removed') {
+                    await this.removeShippingMethodFromActiveOrders(
+                        event as ChangeChannelEvent<ShippingMethod>,
+                    );
+                }
+            },
+        });
+    }
 
     /**
      * @description
@@ -2192,4 +2206,43 @@ export class OrderService {
                 .add(idToAdd);
         }
     }
+
+    private async removeShippingMethodFromActiveOrders(event: ChangeChannelEvent<ShippingMethod>) {
+        const shippingMethodId = event.entity.id;
+        const { ctx } = event;
+
+        const affectedOrders = await this.connection
+            .getRepository(ctx, Order)
+            .createQueryBuilder('order')
+            .innerJoin('order.channels', 'channel', 'channel.id IN (:...channelIds)', {
+                channelIds: event.channelIds,
+            })
+            .innerJoin(
+                'order.shippingLines',
+                'shippingLine',
+                'shippingLine.shippingMethodId = :shippingMethodId',
+                { shippingMethodId },
+            )
+            .where('order.active = :active', { active: true })
+            .getMany();
+
+        if (affectedOrders.length === 0) {
+            return;
+        }
+
+        const orders = await this.connection.getRepository(ctx, Order).find({
+            where: { id: In(affectedOrders.map(o => o.id)) },
+            relations: [
+                'lines',
+                'lines.productVariant',
+                'lines.productVariant.productVariantPrices',
+                'shippingLines',
+                'surcharges',
+            ],
+        });
+
+        for (const order of orders) {
+            await this.applyPriceAdjustments(ctx, order);
+        }
+    }
 }

packages/core/src/service/services/shipping-method.service.ts

@@ -93,17 +93,31 @@ export class ShippingMethodService {
         shippingMethodId: ID,
         includeDeleted = false,
         relations: RelationPaths<ShippingMethod> = [],
+        filterOnChannel = true,
     ): Promise<Translated<ShippingMethod> | undefined> {
-        const shippingMethod = await this.connection.findOneInChannel(
-            ctx,
-            ShippingMethod,
-            shippingMethodId,
-            ctx.channelId,
-            {
+        let shippingMethod: ShippingMethod | undefined | null;
+
+        if (!filterOnChannel) {
+            shippingMethod = await this.connection.getRepository(ctx, ShippingMethod).findOne({
+                where: {
+                    id: shippingMethodId,
+                    deletedAt: includeDeleted ? undefined : IsNull(),
+                },
                 relations,
-                ...(includeDeleted === false ? { where: { deletedAt: IsNull() } } : {}),
-            },
-        );
+            });
+        } else {
+            shippingMethod = await this.connection.findOneInChannel(
+                ctx,
+                ShippingMethod,
+                shippingMethodId,
+                ctx.channelId,
+                {
+                    relations,
+                    ...(includeDeleted === false ? { where: { deletedAt: IsNull() } } : {}),
+                },
+            );
+        }
+
         return (shippingMethod && this.translator.translate(shippingMethod, ctx)) ?? undefined;
     }