@unchainedshop/core-orders 3.0.0-alpha7 → 3.0.0-rc1

package/src/module/configureOrderDiscountsModule.ts

@@ -1,63 +1,14 @@
-import { UnchainedCore } from '@unchainedshop/core';
 import { emit, registerEvents } from '@unchainedshop/events';
 import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { OrderDiscountTrigger } from '../db/OrderDiscountTrigger.js';
-import { OrderDiscountDirector } from '../director/OrderDiscountDirector.js';
-import { Order, OrderDiscount } from '../types.js';
-import {
-  IPricingSheet,
-  PricingCalculation,
-  DiscountAdapterActions,
-  DiscountContext,
-} from '@unchainedshop/utils';
-
-export type OrderDiscountsModule = {
-  // Queries
-  findOrderDiscount: (
-    params: { discountId: string },
-    options?: mongodb.FindOptions,
-  ) => Promise<OrderDiscount>;
-  findOrderDiscounts: (params: { orderId: string }) => Promise<Array<OrderDiscount>>;
-
-  // Transformations
-  interface: (
-    orderDiscount: OrderDiscount,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<DiscountAdapterActions<any>>;
-
-  isValid: (orderDiscount: OrderDiscount, unchainedAPI: UnchainedCore) => Promise<boolean>;
-
-  // Adapter
-  configurationForPricingAdapterKey: (
-    orderDiscount: OrderDiscount,
-    adapterKey: string,
-    calculationSheet: IPricingSheet<PricingCalculation>,
-    pricingContext: DiscountContext & UnchainedCore,
-  ) => Promise<any>;
-
-  // Mutations
-  createManualOrderDiscount: (
-    params: { code: string; order: Order },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<OrderDiscount>;
-
-  create: (doc: OrderDiscount) => Promise<OrderDiscount>;
-  update: (orderDiscountId: string, doc: OrderDiscount) => Promise<OrderDiscount>;
-  delete: (orderDiscountId: string, unchainedAPI: UnchainedCore) => Promise<OrderDiscount>;
-};
+import { OrderDiscount } from '../types.js';
 
 const ORDER_DISCOUNT_EVENTS: string[] = [
   'ORDER_CREATE_DISCOUNT',
   'ORDER_UPDATE_DISCOUNT',
   'ORDER_REMOVE_DISCOUNT',
-  'ORDER_ADD_DISCOUNT',
 ];
 
-const OrderDiscountErrorCode = {
-  CODE_ALREADY_PRESENT: 'CODE_ALREADY_PRESENT',
-  CODE_NOT_VALID: 'CODE_NOT_VALID',
-};
-
 export const buildFindByIdSelector = (orderDiscountId: string) =>
   generateDbFilterById(orderDiscountId) as mongodb.Filter<OrderDiscount>;
 
@@ -65,187 +16,64 @@ export const configureOrderDiscountsModule = ({
   OrderDiscounts,
 }: {
   OrderDiscounts: mongodb.Collection<OrderDiscount>;
-}): OrderDiscountsModule => {
+}) => {
   registerEvents(ORDER_DISCOUNT_EVENTS);
 
-  const getAdapter = async (orderDiscount: OrderDiscount, unchainedAPI: UnchainedCore) => {
-    const order = await unchainedAPI.modules.orders.findOrder({
-      orderId: orderDiscount.orderId,
-    });
-    const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
-    if (!Adapter) return null;
-    const adapter = await Adapter.actions({
-      context: { order, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
-    });
-    return adapter;
-  };
-
-  const createDiscount: OrderDiscountsModule['create'] = async (doc) => {
-    const normalizedTrigger = doc.trigger || OrderDiscountTrigger.USER;
-    const { insertedId: discountId } = await OrderDiscounts.insertOne({
-      _id: generateDbObjectId(),
-      created: new Date(),
-      ...doc,
-      trigger: normalizedTrigger,
-    });
-    const discount = await OrderDiscounts.findOne(buildFindByIdSelector(discountId));
-    return discount;
-  };
-
-  const deleteDiscount: OrderDiscountsModule['delete'] = async (orderDiscountId, unchainedAPI) => {
-    const selector = buildFindByIdSelector(orderDiscountId);
-    const discount = await OrderDiscounts.findOne(selector, {});
-    if (discount.trigger === OrderDiscountTrigger.USER) {
-      // Release
-      const adapter = await getAdapter(discount, unchainedAPI);
-      if (!adapter) return null;
-      await adapter.release();
-    }
-    await OrderDiscounts.deleteOne(selector);
-    await emit('ORDER_REMOVE_DISCOUNT', { discount });
-    return discount;
-  };
-
-  const updateDiscount: OrderDiscountsModule['update'] = async (orderDiscountId, doc) => {
-    const discount = await OrderDiscounts.findOneAndUpdate(
-      generateDbFilterById(orderDiscountId),
-      {
-        $set: {
-          updated: new Date(),
-          ...doc,
-        },
-      },
-      { returnDocument: 'after' },
-    );
-    await emit('ORDER_UPDATE_DISCOUNT', { discount });
-    return discount;
-  };
-
-  const reserveDiscount = async (orderDiscount: OrderDiscount, unchainedAPI: UnchainedCore) => {
-    const adapter = await getAdapter(orderDiscount, unchainedAPI);
-    if (!adapter) return null;
-
-    const reservation = await adapter.reserve({
-      code: orderDiscount.code,
-    });
-
-    return updateDiscount(orderDiscount._id, { orderId: orderDiscount.orderId, reservation });
-  };
-
-  const grabDiscount = async (
-    { code, orderId }: { code: string; orderId: string },
-    unchainedAPI: UnchainedCore,
-  ) => {
-    const existingDiscount = await OrderDiscounts.findOne({ code, orderId });
-    if (existingDiscount) throw new Error(OrderDiscountErrorCode.CODE_ALREADY_PRESENT);
-    const discount = await OrderDiscounts.findOne({ code, orderId: null });
-    if (!discount) return null;
-    const discountId = discount._id;
-    try {
-      const updatedDiscount = await updateDiscount(discountId, { orderId });
-      const reservedDiscount = await reserveDiscount(updatedDiscount, unchainedAPI);
-      return reservedDiscount;
-    } catch (error) {
-      // Rollback
-      await updateDiscount(discountId, { orderId: discount.orderId });
-
-      throw error;
-    }
-  };
-
   return {
     // Queries
-    findOrderDiscount: async ({ discountId }, options) => {
+    findOrderDiscount: async (
+      { discountId }: { discountId: string },
+      options?: mongodb.FindOptions,
+    ): Promise<OrderDiscount> => {
       return OrderDiscounts.findOne(buildFindByIdSelector(discountId), options);
     },
-    findOrderDiscounts: async ({ orderId }) => {
+
+    findOrderDiscounts: async ({ orderId }: { orderId: string }): Promise<Array<OrderDiscount>> => {
       const discounts = OrderDiscounts.find({ orderId });
       return discounts.toArray();
     },
 
-    // Transformations
-    interface: async (orderDiscount, unchainedAPI) => {
-      const adapter = await getAdapter(orderDiscount, unchainedAPI);
-      return adapter;
-    },
-
-    isValid: async (orderDiscount, unchainedAPI) => {
-      const adapter = await getAdapter(orderDiscount, unchainedAPI);
-      if (!adapter) return null;
-
-      if (orderDiscount.trigger === OrderDiscountTrigger.SYSTEM) {
-        return adapter.isValidForSystemTriggering();
-      }
-
-      return adapter.isValidForCodeTriggering({
-        code: orderDiscount.code,
+    create: async (doc: OrderDiscount): Promise<OrderDiscount> => {
+      const normalizedTrigger = doc.trigger || OrderDiscountTrigger.USER;
+      const { insertedId: discountId } = await OrderDiscounts.insertOne({
+        _id: generateDbObjectId(),
+        created: new Date(),
+        ...doc,
+        trigger: normalizedTrigger,
       });
-    },
-
-    // Adapter
-    configurationForPricingAdapterKey: async (
-      orderDiscount,
-      adapterKey,
-      calculationSheet,
-      unchainedAPI,
-    ) => {
-      const adapter = await getAdapter(orderDiscount, unchainedAPI);
-      if (!adapter) return null;
-
-      return adapter.discountForPricingAdapterKey({
-        pricingAdapterKey: adapterKey,
-        calculationSheet,
+      const discount = await OrderDiscounts.findOne({
+        _id: discountId,
       });
+      await emit('ORDER_CREATE_DISCOUNT', { discount });
+      return discount;
     },
 
-    // Mutations
-    createManualOrderDiscount: async ({ order, code }, unchainedAPI) => {
-      // Try to grab single-usage-discount
-      if (!code) throw new Error(OrderDiscountErrorCode.CODE_NOT_VALID);
-
-      const fetchedDiscount = await grabDiscount({ code, orderId: order._id }, unchainedAPI);
-      if (fetchedDiscount) return fetchedDiscount;
-
-      const director = await OrderDiscountDirector.actions({ order, code }, unchainedAPI);
-      const discountKey = await director.resolveDiscountKeyFromStaticCode({
-        code,
-      });
+    delete: async (orderDiscountId: string): Promise<OrderDiscount> => {
+      const selector = buildFindByIdSelector(orderDiscountId);
+      const orderDiscount = await OrderDiscounts.findOneAndDelete(selector);
+      await emit('ORDER_REMOVE_DISCOUNT', { discount: orderDiscount });
+      return orderDiscount;
+    },
 
-      if (discountKey) {
-        const newDiscount = await createDiscount({
-          orderId: order._id,
+    isDiscountCodeUsed: async ({ code, orderId }): Promise<boolean> => {
+      return (
+        (await OrderDiscounts.countDocuments({
           code,
-          discountKey,
-        });
-
-        try {
-          const reservedDiscount = await reserveDiscount(newDiscount, unchainedAPI);
-          await emit('ORDER_ADD_DISCOUNT', { discount: reserveDiscount });
-          return reservedDiscount;
-        } catch (error) {
-          await deleteDiscount(newDiscount._id, unchainedAPI);
-          throw error;
-        }
-      }
-
-      throw new Error(OrderDiscountErrorCode.CODE_NOT_VALID);
+          orderId,
+        })) > 0
+      );
     },
 
-    create: async (doc) => {
-      const discount = await createDiscount(doc);
-
-      if (discount.trigger === OrderDiscountTrigger.USER) {
-        await emit('ORDER_CREATE_DISCOUNT', { discount });
-      }
-
-      return discount;
+    findSpareDiscount: async ({ code }): Promise<OrderDiscount> => {
+      return OrderDiscounts.findOne({
+        code,
+        orderId: { $in: [undefined, null] },
+      });
     },
 
-    delete: deleteDiscount,
-
-    update: async (orderDiscountId, doc) => {
+    update: async (orderDiscountId: string, doc: OrderDiscount): Promise<OrderDiscount> => {
       const discount = await OrderDiscounts.findOneAndUpdate(
-        generateDbFilterById(orderDiscountId),
+        { _id: orderDiscountId },
         {
           $set: {
             updated: new Date(),
@@ -258,5 +86,11 @@ export const configureOrderDiscountsModule = ({
       await emit('ORDER_UPDATE_DISCOUNT', { discount });
       return discount;
     },
+    deleteOrderDiscounts: async (orderId: string) => {
+      const { deletedCount } = await OrderDiscounts.deleteMany({ orderId });
+      return deletedCount;
+    },
   };
 };
+
+export type OrderDiscountsModule = ReturnType<typeof configureOrderDiscountsModule>;

package/src/module/configureOrderPaymentsModule.ts

@@ -1,94 +1,7 @@
-import { UnchainedCore } from '@unchainedshop/core';
 import { emit, registerEvents } from '@unchainedshop/events';
 import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
-import { Order, OrderDiscount, OrderPayment, OrderPaymentStatus } from '../types.js';
-import { IPaymentPricingSheet } from '@unchainedshop/core-payment';
-import { OrderPricingDiscount } from '../director/OrderPricingDirector.js';
-
-export type OrderPaymentsModule = {
-  // Queries
-  findOrderPayment: (
-    params: {
-      orderPaymentId: string;
-    },
-    options?: mongodb.FindOptions,
-  ) => Promise<OrderPayment>;
-
-  findOrderPaymentByContextData: (
-    params: {
-      context: any;
-    },
-    options?: mongodb.FindOptions,
-  ) => Promise<OrderPayment>;
-
-  countOrderPaymentsByContextData: (
-    params: {
-      context: any;
-    },
-    options?: mongodb.FindOptions,
-  ) => Promise<number>;
-
-  // Transformations
-  discounts: (
-    orderPayment: OrderPayment,
-    params: { order: Order; orderDiscount: OrderDiscount },
-    unchainedAPI: UnchainedCore,
-  ) => Array<OrderPricingDiscount>;
-  isBlockingOrderConfirmation: (
-    orderPayment: OrderPayment,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<boolean>;
-  isBlockingOrderFullfillment: (orderPayment: OrderPayment) => boolean;
-  normalizedStatus: (orderPayment: OrderPayment) => string;
-  pricingSheet: (
-    orderPayment: OrderPayment,
-    currency: string,
-    unchainedAPI: UnchainedCore,
-  ) => IPaymentPricingSheet;
-
-  // Mutations
-  create: (doc: OrderPayment) => Promise<OrderPayment>;
-
-  cancel: (
-    orderPayment: OrderPayment,
-    paymentContext: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<OrderPayment>;
-
-  confirm: (
-    orderPayment: OrderPayment,
-    paymentContext: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<OrderPayment>;
-
-  charge: (
-    orderPayment: OrderPayment,
-    paymentContext: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<OrderPayment>;
-
-  logEvent: (orderPaymentId: string, event: any) => Promise<boolean>;
-
-  markAsPaid: (payment: OrderPayment, meta: any) => Promise<void>;
-
-  updateContext: (orderPaymentId: string, context: any) => Promise<OrderPayment | null>;
-
-  updateStatus: (
-    orderPaymentId: string,
-    params: { transactionId?: string; status: OrderPaymentStatus; info?: string },
-  ) => Promise<OrderPayment>;
-
-  updateCalculation: (orderPayment: OrderPayment, unchainedAPI: UnchainedCore) => Promise<OrderPayment>;
-};
+import { OrderPayment, OrderPaymentStatus } from '../types.js';
+import { PricingCalculation } from '@unchainedshop/utils';
 
 const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
 
@@ -117,32 +30,23 @@ export const configureOrderPaymentsModule = ({
   OrderPayments,
 }: {
   OrderPayments: mongodb.Collection<OrderPayment>;
-}): OrderPaymentsModule => {
+}) => {
   registerEvents(ORDER_PAYMENT_EVENTS);
 
-  const normalizedStatus: OrderPaymentsModule['normalizedStatus'] = (orderPayment) => {
+  const normalizedStatus = (orderPayment: OrderPayment) => {
     return orderPayment.status === null
       ? OrderPaymentStatus.OPEN
       : (orderPayment.status as OrderPaymentStatus);
   };
 
-  const buildPaymentProviderActionsContext = (
-    orderPayment: OrderPayment,
-    { transactionContext, ...rest }: { transactionContext: any; userId: string },
-  ) => ({
-    ...rest,
-    orderPayment,
-    paymentProviderId: orderPayment.paymentProviderId,
-    transactionContext: {
-      ...(transactionContext || {}),
-      ...(orderPayment.context || {}),
-    },
-  });
-
-  const updateStatus: OrderPaymentsModule['updateStatus'] = async (
-    orderPaymentId,
-    { status, transactionId, info },
-  ) => {
+  const updateStatus = async (
+    orderPaymentId: string,
+    {
+      transactionId,
+      status,
+      info,
+    }: { transactionId?: string; status: OrderPaymentStatus; info?: string },
+  ): Promise<OrderPayment> => {
     const date = new Date();
     const modifier: mongodb.UpdateFilter<OrderPayment> = {
       $set: { status, updated: new Date() },
@@ -171,61 +75,46 @@ export const configureOrderPaymentsModule = ({
 
   return {
     // Queries
-    findOrderPayment: async ({ orderPaymentId }, options) => {
+    findOrderPayment: async (
+      {
+        orderPaymentId,
+      }: {
+        orderPaymentId: string;
+      },
+      options?: mongodb.FindOptions,
+    ): Promise<OrderPayment> => {
       return OrderPayments.findOne(buildFindByIdSelector(orderPaymentId), options);
     },
-    findOrderPaymentByContextData: async ({ context }, options) => {
+    findOrderPaymentByContextData: async (
+      {
+        context,
+      }: {
+        context: any;
+      },
+      options?: mongodb.FindOptions,
+    ): Promise<OrderPayment> => {
       const selector = buildFindByContextDataSelector(context);
 
       return OrderPayments.findOne(selector, options);
     },
-    countOrderPaymentsByContextData: async ({ context }, options) => {
+    countOrderPaymentsByContextData: async (
+      {
+        context,
+      }: {
+        context: any;
+      },
+      options?: mongodb.FindOptions,
+    ) => {
       const selector = buildFindByContextDataSelector(context);
 
       return OrderPayments.countDocuments(selector, options);
     },
-    // Transformations
-    discounts: (orderPayment, { order, orderDiscount }, context) => {
-      const { modules } = context;
-      if (!orderPayment) return [];
-      const pricingSheet = modules.orders.payments.pricingSheet(orderPayment, order.currency, context);
-      return pricingSheet.discountPrices(orderDiscount._id).map((discount) => ({
-        payment: orderPayment,
-        ...discount,
-      }));
-    },
-
-    isBlockingOrderConfirmation: async (orderPayment, unchainedAPI) => {
-      if (orderPayment.status === OrderPaymentStatus.PAID) return false;
-
-      const provider = await unchainedAPI.modules.payment.paymentProviders.findProvider({
-        paymentProviderId: orderPayment.paymentProviderId,
-      });
-
-      const isPayLaterAllowed = await unchainedAPI.modules.payment.paymentProviders.isPayLaterAllowed(
-        provider,
-        unchainedAPI,
-      );
-
-      return !isPayLaterAllowed;
-    },
-    isBlockingOrderFullfillment: (orderPayment) => {
-      if (orderPayment.status === OrderPaymentStatus.PAID) return false;
-      return true;
-    },
 
     normalizedStatus,
 
-    pricingSheet: (orderPayment, currency, { modules }) => {
-      return modules.payment.paymentProviders.pricingSheet({
-        calculation: orderPayment.calculation,
-        currency,
-      });
-    },
-
     // Mutations
 
-    create: async (doc) => {
+    create: async (doc: OrderPayment): Promise<OrderPayment> => {
       const { insertedId: orderPaymentId } = await OrderPayments.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
@@ -239,108 +128,7 @@ export const configureOrderPaymentsModule = ({
       return orderPayment;
     },
 
-    confirm: async (orderPayment, paymentContext, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-
-      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
-        return orderPayment;
-      }
-
-      const arbitraryResponseData = await modules.payment.paymentProviders.confirm(
-        orderPayment.paymentProviderId,
-        buildPaymentProviderActionsContext(orderPayment, paymentContext),
-        unchainedAPI,
-      );
-
-      if (arbitraryResponseData) {
-        return updateStatus(orderPayment._id, {
-          status: OrderPaymentStatus.PAID,
-          info: JSON.stringify(arbitraryResponseData),
-        });
-      }
-
-      return orderPayment;
-    },
-
-    cancel: async (orderPayment, paymentContext, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-
-      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
-        return orderPayment;
-      }
-
-      const arbitraryResponseData = await modules.payment.paymentProviders.cancel(
-        orderPayment.paymentProviderId,
-        buildPaymentProviderActionsContext(orderPayment, paymentContext),
-        unchainedAPI,
-      );
-
-      if (arbitraryResponseData) {
-        return updateStatus(orderPayment._id, {
-          status: OrderPaymentStatus.REFUNDED,
-          info: JSON.stringify(arbitraryResponseData),
-        });
-      }
-
-      return orderPayment;
-    },
-
-    charge: async (orderPayment, context, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-
-      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) {
-        return orderPayment;
-      }
-
-      const paymentCredentials =
-        context.transactionContext?.paymentCredentials ||
-        (await modules.payment.paymentCredentials.findPaymentCredential({
-          userId: context.userId,
-          paymentProviderId: orderPayment.paymentProviderId,
-          isPreferred: true,
-        }));
-
-      const paymentContext = buildPaymentProviderActionsContext(orderPayment, {
-        ...context,
-        transactionContext: {
-          ...context.transactionContext,
-          paymentCredentials,
-        },
-      });
-
-      const result = await modules.payment.paymentProviders.charge(
-        orderPayment.paymentProviderId,
-        paymentContext,
-        unchainedAPI,
-      );
-
-      if (!result) return orderPayment;
-
-      const { credentials, ...arbitraryResponseData } = result;
-
-      if (credentials) {
-        const { token, ...meta } = credentials;
-        await modules.payment.paymentCredentials.upsertCredentials({
-          userId: paymentContext.userId,
-          paymentProviderId: orderPayment.paymentProviderId,
-          token,
-          ...meta,
-        });
-      }
-
-      if (arbitraryResponseData) {
-        const { transactionId, ...info } = arbitraryResponseData;
-        return updateStatus(orderPayment._id, {
-          transactionId,
-          status: OrderPaymentStatus.PAID,
-          info: JSON.stringify(info),
-        });
-      }
-
-      return orderPayment;
-    },
-
-    logEvent: async (orderPaymentId, event) => {
+    logEvent: async (orderPaymentId: string, event: any): Promise<boolean> => {
       const date = new Date();
       const modifier = {
         $push: {
@@ -356,7 +144,7 @@ export const configureOrderPaymentsModule = ({
       return true;
     },
 
-    markAsPaid: async (orderPayment, meta) => {
+    markAsPaid: async (orderPayment: OrderPayment, meta: any) => {
       if (normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) return;
 
       await updateStatus(orderPayment._id, {
@@ -366,7 +154,7 @@ export const configureOrderPaymentsModule = ({
       await emit('ORDER_PAY', { orderPayment });
     },
 
-    updateContext: async (orderPaymentId, context) => {
+    updateContext: async (orderPaymentId: string, context: any): Promise<OrderPayment> => {
       const selector = buildFindByIdSelector(orderPaymentId);
       if (!context || Object.keys(context).length === 0) return OrderPayments.findOne(selector, {});
 
@@ -396,16 +184,12 @@ export const configureOrderPaymentsModule = ({
 
     updateStatus,
 
-    updateCalculation: async (orderPayment, unchainedAPI) => {
-      const calculation = await unchainedAPI.modules.payment.paymentProviders.calculate(
-        {
-          item: orderPayment,
-        },
-        unchainedAPI,
-      );
-
+    updateCalculation: async <T extends PricingCalculation>(
+      orderPaymentId: string,
+      calculation: Array<T>,
+    ) => {
       return OrderPayments.findOneAndUpdate(
-        buildFindByIdSelector(orderPayment._id),
+        buildFindByIdSelector(orderPaymentId),
         {
           $set: {
             calculation,
@@ -417,5 +201,11 @@ export const configureOrderPaymentsModule = ({
         },
       );
     },
+    deleteOrderPayments: async (orderId: string) => {
+      const { deletedCount } = await OrderPayments.deleteMany({ orderId });
+      return deletedCount;
+    },
   };
 };
+
+export type OrderPaymentsModule = ReturnType<typeof configureOrderPaymentsModule>;