feat(core): Pass RequestContext to ShippingCalculator functions

BREAKING CHANGE: The ShippingCalculator `calculate()`
function signature has changed: the first argument is now the
RequestContext of the current request.

packages/core/src/config/shipping-method/default-shipping-calculator.ts

@@ -17,7 +17,7 @@ export const defaultShippingCalculator = new ShippingCalculator({
             label: [{ languageCode: LanguageCode.en, value: 'Tax rate' }],
         },
     },
-    calculate: (order, args) => {
+    calculate: (ctx, order, args) => {
         return { price: args.rate, priceWithTax: args.rate * ((100 + args.taxRate) / 100) };
     },
 });

packages/core/src/config/shipping-method/shipping-calculator.ts

@@ -1,5 +1,6 @@
 import { ConfigArg } from '@vendure/common/lib/generated-types';
 
+import { RequestContext } from '../../api/common/request-context';
 import {
     ConfigArgs,
     ConfigArgValues,
@@ -50,8 +51,8 @@ export class ShippingCalculator<T extends ConfigArgs = ConfigArgs> extends Confi
      *
      * @internal
      */
-    calculate(order: Order, args: ConfigArg[]): CalculateShippingFnResult {
-        return this.calculateFn(order, this.argsArrayToHash(args));
+    calculate(ctx: RequestContext, order: Order, args: ConfigArg[]): CalculateShippingFnResult {
+        return this.calculateFn(ctx, order, this.argsArrayToHash(args));
     }
 }
 
@@ -97,6 +98,7 @@ export type CalculateShippingFnResult =
  * @docsPage ShippingCalculator
  */
 export type CalculateShippingFn<T extends ConfigArgs> = (
+    ctx: RequestContext,
     order: Order,
     args: ConfigArgValues<T>,
 ) => CalculateShippingFnResult;

packages/core/src/entity/shipping-method/shipping-method.entity.ts

@@ -2,6 +2,7 @@ import { ConfigurableOperation } from '@vendure/common/lib/generated-types';
 import { DeepPartial } from '@vendure/common/lib/shared-types';
 import { Column, Entity, JoinTable, ManyToMany } from 'typeorm';
 
+import { RequestContext } from '../../api/common/request-context';
 import { ChannelAware, SoftDeletable } from '../../common/types/common-types';
 import { getConfig } from '../../config/config-helpers';
 import { HasCustomFields } from '../../config/custom-field/custom-field-types';
@@ -49,17 +50,17 @@ export class ShippingMethod extends VendureEntity implements ChannelAware, SoftD
 
     @Column('simple-json') calculator: ConfigurableOperation;
 
-    @ManyToMany((type) => Channel)
+    @ManyToMany(type => Channel)
     @JoinTable()
     channels: Channel[];
 
-    @Column((type) => CustomShippingMethodFields)
+    @Column(type => CustomShippingMethodFields)
     customFields: CustomShippingMethodFields;
 
-    async apply(order: Order): Promise<ShippingCalculationResult | undefined> {
+    async apply(ctx: RequestContext, order: Order): Promise<ShippingCalculationResult | undefined> {
         const calculator = this.allCalculators[this.calculator.code];
         if (calculator) {
-            const response = await calculator.calculate(order, this.calculator.args);
+            const response = await calculator.calculate(ctx, order, this.calculator.args);
             if (response) {
                 const { price, priceWithTax, metadata } = response;
                 return {

packages/core/src/service/helpers/shipping-calculator/shipping-calculator.ts

@@ -23,8 +23,8 @@ export class ShippingCalculator {
     async getEligibleShippingMethods(ctx: RequestContext, order: Order): Promise<EligibleShippingMethod[]> {
         const shippingMethods = this.shippingMethodService.getActiveShippingMethods(ctx.channel);
 
-        const checkEligibilityPromises = shippingMethods.map((method) =>
-            this.checkEligibilityByShippingMethod(order, method),
+        const checkEligibilityPromises = shippingMethods.map(method =>
+            this.checkEligibilityByShippingMethod(ctx, order, method),
         );
         const eligibleMethods = await Promise.all(checkEligibilityPromises);
 
@@ -32,12 +32,13 @@ export class ShippingCalculator {
     }
 
     private async checkEligibilityByShippingMethod(
+        ctx: RequestContext,
         order: Order,
         method: ShippingMethod,
     ): Promise<EligibleShippingMethod | undefined> {
         const eligible = await method.test(order);
         if (eligible) {
-            const result = await method.apply(order);
+            const result = await method.apply(ctx, order);
             if (result) {
                 return { method, result };
             }

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

@@ -46,7 +46,7 @@ export class OrderTestingService {
         });
         const mockOrder = await this.buildMockOrder(ctx, input.shippingAddress, input.lines);
         const eligible = await shippingMethod.test(mockOrder);
-        const result = eligible ? await shippingMethod.apply(mockOrder) : undefined;
+        const result = eligible ? await shippingMethod.apply(ctx, mockOrder) : undefined;
         return {
             eligible,
             quote: result && {