@unchainedshop/core 4.0.0-rc.16 → 4.0.0-rc.18

package/src/directors/DeliveryDirector.ts

@@ -6,7 +6,7 @@ import {
   DeliveryError,
 } from './DeliveryAdapter.js';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { OrderDelivery, OrderDeliveryStatus } from '@unchainedshop/core-orders';
+import { Order, OrderDeliveryStatus } from '@unchainedshop/core-orders';
 import { Modules } from '../modules.js';
 import { createLogger } from '@unchainedshop/logger';
 
@@ -14,10 +14,10 @@ const logger = createLogger('unchained:core');
 
 export type IDeliveryDirector = IBaseDirector<IDeliveryAdapter> & {
   sendOrderDelivery: (
-    orderDelivery: OrderDelivery,
+    order: Order,
     transactionContext: Record<string, any>,
     unchainedAPI: { modules: Modules },
-  ) => Promise<OrderDelivery>;
+  ) => Promise<void>;
   actions: (
     deliveryProvider: DeliveryProvider,
     deliveryContext: DeliveryContext,
@@ -33,21 +33,24 @@ export const DeliveryDirector: IDeliveryDirector = {
   actions: async (deliveryProvider, deliveryContext, unchainedAPI) => {
     const Adapter = baseDirector.getAdapter(deliveryProvider.adapterKey);
 
+    if (!Adapter) {
+      throw new Error(`Delivery Plugin ${deliveryProvider.adapterKey} not available`);
+    }
+
     const context = { ...deliveryContext, ...unchainedAPI };
-    const adapter = Adapter?.actions(deliveryProvider.configuration, context);
+    const adapter = Adapter.actions(deliveryProvider.configuration, context);
 
     return {
       configurationError: () => {
-        try {
-          return adapter.configurationError();
-        } catch {
+        if (!adapter) {
           return DeliveryError.ADAPTER_NOT_FOUND;
         }
+        return adapter.configurationError();
       },
 
       estimatedDeliveryThroughput: async (warehousingThroughputTime) => {
         try {
-          const throughput = await adapter.estimatedDeliveryThroughput(warehousingThroughputTime);
+          const throughput = await adapter?.estimatedDeliveryThroughput(warehousingThroughputTime);
           return throughput;
         } catch (error) {
           logger.warn('Delivery Director -> Error while estimating delivery throughput', {
@@ -58,6 +61,7 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       isActive: () => {
+        if (!adapter) return false;
         try {
           return adapter.isActive();
         } catch (error) {
@@ -69,6 +73,7 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       isAutoReleaseAllowed: () => {
+        if (!adapter) return false;
         try {
           return adapter.isAutoReleaseAllowed();
         } catch (error) {
@@ -80,39 +85,47 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       send: async () => {
+        if (!adapter) throw new Error('Delivery adapter not found');
         return adapter.send();
       },
 
       pickUpLocationById: async (locationId) => {
-        return adapter.pickUpLocationById(locationId);
+        if (!adapter) throw new Error('Delivery adapter not found');
+        return adapter?.pickUpLocationById(locationId);
       },
 
       pickUpLocations: async () => {
+        if (!adapter) throw new Error('Delivery adapter not found');
         return adapter.pickUpLocations();
       },
     };
   },
 
-  sendOrderDelivery: async (orderDelivery, transactionContext, unchainedAPI) => {
+  sendOrderDelivery: async (order, transactionContext, unchainedAPI) => {
+    const orderDelivery = await unchainedAPI.modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId!,
+    });
+
     if (
-      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN
+      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery!) !==
+      OrderDeliveryStatus.OPEN
     )
-      return orderDelivery;
+      return;
 
-    const order = await unchainedAPI.modules.orders.findOrder({ orderId: orderDelivery.orderId });
     const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
-      deliveryProviderId: orderDelivery.deliveryProviderId,
+      deliveryProviderId: orderDelivery!.deliveryProviderId,
     });
-    const address = orderDelivery.context?.address || order || order.billingAddress;
+
+    const address = orderDelivery!.context?.address || order!.billingAddress;
 
     const adapter = await DeliveryDirector.actions(
-      deliveryProvider,
+      deliveryProvider!,
       {
-        order,
-        orderDelivery,
+        order: order!,
+        orderDelivery: orderDelivery!,
         transactionContext: {
           ...(transactionContext || {}),
-          ...(orderDelivery.context || {}),
+          ...(orderDelivery!.context || {}),
           ...(address || {}),
         },
       },
@@ -120,14 +133,11 @@ export const DeliveryDirector: IDeliveryDirector = {
     );
 
     const arbitraryResponseData = await adapter.send();
-
     if (arbitraryResponseData) {
-      return await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery._id, {
+      await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery!._id, {
         status: OrderDeliveryStatus.DELIVERED,
         info: JSON.stringify(arbitraryResponseData),
       });
     }
-
-    return orderDelivery;
   },
 };

package/src/directors/DeliveryPricingAdapter.ts

@@ -42,7 +42,7 @@ export interface DeliveryPricingAdapterContext extends BasePricingAdapterContext
   provider: DeliveryProvider;
   providerContext?: any;
   order: Order;
-  orderDelivery: OrderDelivery;
+  orderDelivery?: OrderDelivery;
   user: User;
   discounts: OrderDiscount[];
 }

package/src/directors/DeliveryPricingDirector.ts

@@ -52,18 +52,18 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
       const provider = await modules.delivery.findProvider({
         deliveryProviderId: item.deliveryProviderId,
       });
-      const user = await modules.users.findUserById(order.userId);
+      const user = await modules.users.findUserById(order!.userId);
       const discounts = await modules.orders.discounts.findOrderDiscounts({
         orderId: item.orderId,
       });
 
       return {
         ...unchainedAPI,
-        countryCode: order.countryCode,
+        countryCode: order!.countryCode,
         currencyCode,
-        order,
-        provider,
-        user,
+        order: order!,
+        provider: provider!,
+        user: user!,
         discounts,
         orderDelivery: item,
         providerContext: null,
@@ -78,7 +78,6 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
       provider: context.provider,
       user: context.user,
       discounts: [],
-      orderDelivery: null,
       providerContext: context.providerContext,
     };
   },

package/src/directors/DeliveryPricingSheet.ts

@@ -61,7 +61,8 @@ export const DeliveryPricingSheet = (
           category: DeliveryPricingRowCategory.Discount,
           discountId: explicitDiscountId,
         })
-        .map(({ discountId }) => discountId);
+        .map(({ discountId }) => discountId)
+        .filter(Boolean) as string[];
 
       return [...new Set(discountIds)]
         .map((discountId) => {
@@ -78,7 +79,7 @@ export const DeliveryPricingSheet = (
             currencyCode,
           };
         })
-        .filter(Boolean);
+        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
     },
   };
 

package/src/directors/EnrollmentAdapter.ts

@@ -1,6 +1,7 @@
 import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
 import {
   Enrollment,
+  EnrollmentOrderPositionTemplate,
   EnrollmentPeriod,
   EnrollmentPlan,
   addToDate,
@@ -10,13 +11,17 @@ import type { OrderPosition } from '@unchainedshop/core-orders';
 
 export interface EnrollmentContext {
   enrollment: Enrollment;
+  product: Product;
 }
 
 export interface EnrollmentAdapterActions {
-  configurationForOrder: (params: { period: EnrollmentPeriod; products: Product[] }) => Promise<any>;
+  configurationForOrder: (params: { period: EnrollmentPeriod }) => Promise<{
+    orderContext?: Record<string, any>;
+    orderPositionTemplates: EnrollmentOrderPositionTemplate[];
+  } | null>;
   isOverdue: () => Promise<boolean>;
   isValidForActivation: () => Promise<boolean>;
-  nextPeriod: () => Promise<EnrollmentPeriod>;
+  nextPeriod: () => Promise<EnrollmentPeriod | null>;
 }
 
 export type IEnrollmentAdapter = IBaseAdapter & {
@@ -71,10 +76,8 @@ export const EnrollmentAdapter: Omit<IEnrollmentAdapter, 'key' | 'label' | 'vers
       isValidForActivation: async () => false,
 
       nextPeriod: async () => {
-        const { enrollment } = context;
-        const product = await (context as any).modules.products.findProduct({
-          productId: enrollment.productId,
-        });
+        const { enrollment, product } = context;
+
         const plan = product?.plan;
         const referenceDate = new Date();
         if (!plan) return null;

package/src/directors/EnrollmentDirector.ts

@@ -10,9 +10,15 @@ const logger = createLogger('unchained:core');
 export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
   transformOrderItemToEnrollment: (
     item: { orderPosition: OrderPosition; product: Product },
-    doc: Omit<Enrollment, 'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log'>,
+    doc: Omit<
+      Enrollment,
+      'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log' | '_id' | 'created'
+    >,
     unchainedAPI,
-  ) => Promise<Omit<Enrollment, 'status' | 'periods' | 'log'>>;
+  ) => Promise<
+    Omit<Enrollment, 'status' | 'periods' | 'log' | '_id' | 'created'> &
+      Pick<Partial<Enrollment>, '_id' | 'created'>
+  >;
 
   actions: (enrollmentContext: EnrollmentContext, unchainedAPI) => Promise<EnrollmentAdapterActions>;
 };
@@ -53,12 +59,7 @@ export const EnrollmentDirector: IEnrollmentDirector = {
   actions: async (enrollmentContext, unchainedAPI) => {
     const context = { ...enrollmentContext, ...unchainedAPI };
 
-    // Resolve adapter
-    const product = await context.modules.products.findProduct({
-      productId: context.enrollment.productId,
-    });
-
-    const Adapter = findAppropriateAdapters(product?.plan)?.[0];
+    const Adapter = findAppropriateAdapters(enrollmentContext.product.plan)?.[0];
 
     if (!Adapter) {
       throw new Error('No suitable enrollment plugin available for this plan configuration');

package/src/directors/FilterAdapter.ts

@@ -21,7 +21,7 @@ export interface FilterAdapterActions {
 
   searchAssortments: (
     params: {
-      assortmentIds: string[];
+      assortmentIds?: string[];
     },
     options: {
       filterSelector: mongodb.Filter<Filter>;
@@ -29,7 +29,7 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<string[]>;
+  ) => Promise<string[] | undefined>;
 
   searchProducts: (
     params: {
@@ -41,7 +41,7 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<string[] | null>;
+  ) => Promise<string[] | undefined>;
 
   transformFilterSelector: (
     query: mongodb.Filter<Filter>,

package/src/directors/FilterDirector.ts

@@ -12,7 +12,7 @@ import {
 import { Product } from '@unchainedshop/core-products';
 import { Modules } from '../modules.js';
 
-export const parseQueryArray = (query: SearchFilterQuery): Record<string, string[]> =>
+export const parseQueryArray = (query?: SearchFilterQuery): Record<string, string[]> =>
   (query || []).reduce(
     (accumulator, { key, value }) => ({
       ...accumulator,
@@ -96,14 +96,14 @@ export const FilterDirector: IFilterDirector = {
       },
 
       searchAssortments: async (params, options) => {
-        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
           const assortmentIds = await lastSearchPromise;
           return adapter.searchAssortments({ assortmentIds }, options);
         }, params.assortmentIds);
       },
 
       searchProducts: async (params, options) => {
-        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
           const productIds = await lastSearchPromise;
           return adapter.searchProducts({ productIds }, options);
         }, params.productIds);
@@ -187,7 +187,7 @@ export const FilterDirector: IFilterDirector = {
       values,
       Object.keys(keyToProductIdMap),
     );
-    const result = [];
+    const result: string[] = [];
     for (const key of filteredKeys) {
       const additionalValues = key === undefined ? allProductIds : keyToProductIdMap[key];
       if (additionalValues) {
@@ -244,7 +244,7 @@ export const FilterDirector: IFilterDirector = {
   async filterFacets(filter, params, unchainedAPI) {
     const { allProductIds, searchQuery, forceLiveCollection, otherFilters } = params;
 
-    const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
+    const filterQueryParsed = parseQueryArray(searchQuery.filterQuery);
 
     // The examinedProductIdSet is a set of product id's that:
     // - Fit this filter generally

package/src/directors/OrderDiscountAdapter.ts

@@ -4,7 +4,7 @@ import {
   OrderDiscountConfiguration,
 } from '../directors/index.js';
 
-export const OrderDiscountAdapter: Omit<
+export const OrderDiscountAdapter = BaseDiscountAdapter as Omit<
   IDiscountAdapter<OrderDiscountConfiguration>,
   'key' | 'label' | 'version'
-> = BaseDiscountAdapter;
+>;

package/src/directors/OrderPricingAdapter.ts

@@ -20,9 +20,9 @@ export interface OrderPricingAdapterContext extends BasePricingAdapterContext {
   currencyCode?: string;
   discounts: OrderDiscount[];
   order: Order;
-  orderDelivery: OrderDelivery;
   orderPositions: OrderPosition[];
-  orderPayment: OrderPayment;
+  orderDelivery: OrderDelivery | null;
+  orderPayment: OrderPayment | null;
   user: User;
 }
 

package/src/directors/OrderPricingDirector.ts

@@ -13,9 +13,9 @@ import { Order, OrderDelivery, OrderPayment, OrderPosition } from '@unchainedsho
 export interface OrderPricingContext {
   currencyCode: string;
   order: Order;
-  orderDelivery: OrderDelivery;
+  orderDelivery: OrderDelivery | null;
   orderPositions: OrderPosition[];
-  orderPayment: OrderPayment;
+  orderPayment: OrderPayment | null;
 }
 
 export type OrderPricingDiscount = PricingDiscount & {
@@ -61,7 +61,7 @@ export const OrderPricingDirector: IOrderPricingDirector<any> = {
       orderDelivery: context.orderDelivery,
       orderPayment: context.orderPayment,
       orderPositions: context.orderPositions,
-      user,
+      user: user!,
     };
   },
 

package/src/directors/OrderPricingSheet.ts

@@ -122,7 +122,8 @@ export const OrderPricingSheet = (
           category: OrderPricingRowCategory.Discounts,
           discountId: explicitDiscountId,
         })
-        .map(({ discountId }) => discountId);
+        .map(({ discountId }) => discountId)
+        .filter(Boolean) as string[];
 
       return [...new Set(discountIds)]
         .map((discountId) => {
@@ -139,7 +140,7 @@ export const OrderPricingSheet = (
             currencyCode: basePricingSheet.currencyCode,
           };
         })
-        .filter(Boolean);
+        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
     },
   };
 

package/src/directors/PaymentAdapter.ts

@@ -23,11 +23,11 @@ export type PaymentChargeActionResult = ChargeResult & {
 };
 export interface IPaymentActions {
   charge: (transactionContext?: any) => Promise<PaymentChargeActionResult | false>;
-  configurationError: (transactionContext?: any) => PaymentError;
+  configurationError: (transactionContext?: any) => PaymentError | null;
   isActive: (transactionContext?: any) => boolean;
   isPayLaterAllowed: (transactionContext?: any) => boolean;
   register: (transactionContext?: any) => Promise<any>;
-  sign: (transactionContext?: any) => Promise<string>;
+  sign: (transactionContext?: any) => Promise<string | null>;
   validate: (token?: any) => Promise<boolean>;
   cancel: (transactionContext?: any) => Promise<boolean>;
   confirm: (transactionContext?: any) => Promise<boolean>;

package/src/directors/PaymentDirector.ts

@@ -2,7 +2,7 @@ import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
 import { createLogger } from '@unchainedshop/logger';
 import { PaymentError, IPaymentActions, IPaymentAdapter, PaymentContext } from './PaymentAdapter.js';
 import { PaymentProvider } from '@unchainedshop/core-payment';
-import { OrderPayment, OrderPaymentStatus } from '@unchainedshop/core-orders';
+import { Order, OrderPayment, OrderPaymentStatus } from '@unchainedshop/core-orders';
 
 const buildPaymentProviderActionsContext = (
   orderPayment: OrderPayment,
@@ -19,7 +19,7 @@ const buildPaymentProviderActionsContext = (
 
 export type IPaymentDirector = IBaseDirector<IPaymentAdapter> & {
   confirmOrderPayment: (
-    orderPayment: OrderPayment,
+    order: Order,
     paymentContext: {
       transactionContext: any;
       userId: string;
@@ -28,7 +28,7 @@ export type IPaymentDirector = IBaseDirector<IPaymentAdapter> & {
   ) => Promise<OrderPayment>;
 
   cancelOrderPayment: (
-    orderPayment: OrderPayment,
+    order: Order,
     paymentContext: {
       transactionContext: any;
       userId: string;
@@ -37,7 +37,7 @@ export type IPaymentDirector = IBaseDirector<IPaymentAdapter> & {
   ) => Promise<OrderPayment>;
 
   chargeOrderPayment: (
-    orderPayment: OrderPayment,
+    order: Order,
     context: {
       transactionContext: any;
       userId: string;
@@ -51,7 +51,7 @@ export type IPaymentDirector = IBaseDirector<IPaymentAdapter> & {
     unchainedAPI,
   ) => Promise<IPaymentActions>;
 };
-const logger = createLogger('unchained:core-payment');
+const logger = createLogger('unchained:core:payment');
 const baseDirector = BaseDirector<IPaymentAdapter>('PaymentDirector');
 
 export const PaymentDirector: IPaymentDirector = {
@@ -143,7 +143,7 @@ export const PaymentDirector: IPaymentDirector = {
   },
 
   confirmOrderPayment: async (
-    orderPayment: OrderPayment,
+    order: Order,
     paymentContext: {
       transactionContext: any;
       userId: string;
@@ -152,6 +152,14 @@ export const PaymentDirector: IPaymentDirector = {
   ): Promise<OrderPayment> => {
     const { modules } = unchainedAPI;
 
+    const orderPayment =
+      order.paymentId &&
+      (await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      }));
+
+    if (!orderPayment) throw new Error('Order payment not set');
+
     if (modules.orders.payments.normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
       return orderPayment;
     }
@@ -178,7 +186,7 @@ export const PaymentDirector: IPaymentDirector = {
   },
 
   cancelOrderPayment: async (
-    orderPayment: OrderPayment,
+    order: Order,
     paymentContext: {
       transactionContext: any;
       userId: string;
@@ -187,6 +195,14 @@ export const PaymentDirector: IPaymentDirector = {
   ): Promise<OrderPayment> => {
     const { modules } = unchainedAPI;
 
+    const orderPayment =
+      order.paymentId &&
+      (await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      }));
+
+    if (!orderPayment) throw new Error('Order payment not set');
+
     if (modules.orders.payments.normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
       return orderPayment;
     }
@@ -212,7 +228,7 @@ export const PaymentDirector: IPaymentDirector = {
   },
 
   chargeOrderPayment: async (
-    orderPayment: OrderPayment,
+    order: Order,
     context: {
       transactionContext: any;
       userId: string;
@@ -221,6 +237,14 @@ export const PaymentDirector: IPaymentDirector = {
   ): Promise<OrderPayment> => {
     const { modules } = unchainedAPI;
 
+    const orderPayment =
+      order.paymentId &&
+      (await modules.orders.payments.findOrderPayment({
+        orderPaymentId: order.paymentId,
+      }));
+
+    if (!orderPayment) throw new Error('Order payment not set');
+
     if (modules.orders.payments.normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) {
       return orderPayment;
     }

package/src/directors/PaymentPricingAdapter.ts

@@ -20,8 +20,8 @@ export interface PaymentPricingCalculation extends PricingCalculation {
 export interface PaymentPricingAdapterContext extends BasePricingAdapterContext {
   countryCode?: string;
   currency?: string;
-  user: User;
-  orderPayment: OrderPayment;
+  user: User | null;
+  orderPayment?: OrderPayment;
   order: Order;
   provider: PaymentProvider;
   discounts: OrderDiscount[];

package/src/directors/PaymentPricingDirector.ts

@@ -15,7 +15,7 @@ export type PaymentPricingContext =
   | {
       countryCode?: string;
       currencyCode?: string;
-      user: User;
+      user?: User;
       order: Order;
       provider: PaymentProvider;
       providerContext?: any;
@@ -54,21 +54,20 @@ export const PaymentPricingDirector: IPaymentPricingDirector<any> = {
       const provider = await modules.payment.paymentProviders.findProvider({
         paymentProviderId: item.paymentProviderId,
       });
-      const user = await modules.users.findUserById(order.userId);
+      const user = await modules.users.findUserById(order!.userId);
       const discounts = await modules.orders.discounts.findOrderDiscounts({
         orderId: item.orderId,
       });
 
       return {
         ...unchainedAPI,
-        countryCode: order.countryCode,
+        countryCode: order!.countryCode,
         currencyCode,
-        order,
-        provider,
+        order: order!,
+        provider: provider!,
         user,
         discounts,
         orderPayment: item,
-        providerContext: null,
       };
     }
 
@@ -78,9 +77,8 @@ export const PaymentPricingDirector: IPaymentPricingDirector<any> = {
       currencyCode: context.currencyCode,
       order: context.order,
       provider: context.provider,
-      user: context.user,
+      user: context.user || null,
       discounts: [],
-      orderPayment: null,
       providerContext: context.providerContext,
     };
   },

package/src/directors/PaymentPricingSheet.ts

@@ -66,7 +66,8 @@ export const PaymentPricingSheet = (
           category: PaymentPricingRowCategory.Discount,
           discountId: explicitDiscountId,
         })
-        .map(({ discountId }) => discountId);
+        .map(({ discountId }) => discountId)
+        .filter(Boolean) as string[];
 
       return [...new Set(discountIds)]
         .map((discountId) => {
@@ -83,7 +84,7 @@ export const PaymentPricingSheet = (
             currencyCode: basePricingSheet.currencyCode,
           };
         })
-        .filter(Boolean);
+        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
     },
   };
 

package/src/directors/ProductDiscountAdapter.ts

@@ -4,7 +4,7 @@ import {
   ProductDiscountConfiguration,
 } from '../directors/index.js';
 
-export const ProductDiscountAdapter: Omit<
+export const ProductDiscountAdapter = BaseDiscountAdapter as Omit<
   IDiscountAdapter<ProductDiscountConfiguration>,
   'key' | 'label' | 'version'
-> = BaseDiscountAdapter;
+>;

package/src/directors/ProductDiscountConfiguration.ts

@@ -10,7 +10,7 @@ type ResolvedConfiguration = {
 export type PriceConfigurationResolver = (
   product: Product,
   quantity: number,
-  configuration: ProductConfiguration[],
+  configuration?: ProductConfiguration[],
 ) => ResolvedConfiguration | null;
 
 export interface ProductDiscountConfiguration extends ResolvedConfiguration {

package/src/directors/ProductPricingAdapter.ts

@@ -16,7 +16,7 @@ export interface ProductPricingAdapterContext extends BasePricingAdapterContext
   currencyCode: string;
   product: Product;
   quantity: number;
-  configuration: ProductConfiguration[];
+  configuration?: ProductConfiguration[];
   order?: Order;
   user?: User;
 }