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

package/src/module/configureOrderPaymentsModule.ts

@@ -1,98 +1,11 @@
-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 { PricingCalculation } from '@unchainedshop/utils';
+import { OrderPayment, OrderPaymentStatus } from '../db/OrderPaymentsCollection.js';
 
 const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
 
-export const buildFindByIdSelector = (orderPaymentId: string) =>
+export const buildFindOrderPaymentByIdSelector = (orderPaymentId: string) =>
   generateDbFilterById(orderPaymentId) as mongodb.Filter<OrderPayment>;
 
 export const buildFindByContextDataSelector = (context: any): mongodb.Filter<OrderPayment> => {
@@ -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() },
@@ -165,67 +69,52 @@ export const configureOrderPaymentsModule = ({
       modifier.$set.paid = date;
     }
 
-    const selector = buildFindByIdSelector(orderPaymentId);
+    const selector = buildFindOrderPaymentByIdSelector(orderPaymentId);
     return OrderPayments.findOneAndUpdate(selector, modifier, { returnDocument: 'after' });
   };
 
   return {
     // Queries
-    findOrderPayment: async ({ orderPaymentId }, options) => {
-      return OrderPayments.findOne(buildFindByIdSelector(orderPaymentId), options);
-    },
-    findOrderPaymentByContextData: async ({ context }, options) => {
+    findOrderPayment: async (
+      {
+        orderPaymentId,
+      }: {
+        orderPaymentId: string;
+      },
+      options?: mongodb.FindOptions,
+    ): Promise<OrderPayment> => {
+      return OrderPayments.findOne(buildFindOrderPaymentByIdSelector(orderPaymentId), 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(),
@@ -234,113 +123,14 @@ export const configureOrderPaymentsModule = ({
         context: doc.context || {},
       });
 
-      const orderPayment = await OrderPayments.findOne(buildFindByIdSelector(orderPaymentId));
-
-      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,
+      const orderPayment = await OrderPayments.findOne(
+        buildFindOrderPaymentByIdSelector(orderPaymentId),
       );
 
-      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 +146,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,8 +156,8 @@ export const configureOrderPaymentsModule = ({
       await emit('ORDER_PAY', { orderPayment });
     },
 
-    updateContext: async (orderPaymentId, context) => {
-      const selector = buildFindByIdSelector(orderPaymentId);
+    updateContext: async (orderPaymentId: string, context: any): Promise<OrderPayment> => {
+      const selector = buildFindOrderPaymentByIdSelector(orderPaymentId);
       if (!context || Object.keys(context).length === 0) return OrderPayments.findOne(selector, {});
 
       const contextSetters = Object.fromEntries(
@@ -396,16 +186,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),
+        buildFindOrderPaymentByIdSelector(orderPaymentId),
         {
           $set: {
             calculation,
@@ -417,5 +203,11 @@ export const configureOrderPaymentsModule = ({
         },
       );
     },
+    deleteOrderPayments: async (orderId: string) => {
+      const { deletedCount } = await OrderPayments.deleteMany({ orderId });
+      return deletedCount;
+    },
   };
 };
+
+export type OrderPaymentsModule = ReturnType<typeof configureOrderPaymentsModule>;