@unchainedshop/core-orders 2.0.0-beta8 → 2.0.0-beta9

package/src/module/configureOrderDiscountsModule.ts

@@ -1,6 +1,5 @@
-import { Context } from '@unchainedshop/types/api';
 import { Collection, Filter } from '@unchainedshop/types/common';
-import { ModuleMutations } from '@unchainedshop/types/core';
+import { ModuleMutations, UnchainedCore } from '@unchainedshop/types/core';
 import { OrdersModule } from '@unchainedshop/types/orders';
 import { OrderDiscount, OrderDiscountsModule } from '@unchainedshop/types/orders.discounts';
 import { emit, registerEvents } from '@unchainedshop/events';
@@ -22,7 +21,7 @@ const OrderDiscountErrorCode = {
   CODE_NOT_VALID: 'CODE_NOT_VALID',
 };
 
-const buildFindByIdSelector = (orderDiscountId: string) =>
+export const buildFindByIdSelector = (orderDiscountId: string) =>
   generateDbFilterById(orderDiscountId) as Filter<OrderDiscount>;
 
 export const configureOrderDiscountsModule = ({
@@ -39,31 +38,31 @@ export const configureOrderDiscountsModule = ({
     hasCreateOnly: false,
   }) as ModuleMutations<OrderDiscount>;
 
-  const getAdapter = async (orderDiscount: OrderDiscount, requestContext: Context) => {
-    const order = await requestContext.modules.orders.findOrder({
+  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, ...requestContext },
+      context: { order, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
     });
     return adapter;
   };
 
-  const createDiscount: OrderDiscountsModule['create'] = async (doc, userId) => {
+  const createDiscount: OrderDiscountsModule['create'] = async (doc) => {
     const normalizedTrigger = doc.trigger || OrderDiscountTrigger.USER;
 
     log(`Create Order Discount: ${doc.discountKey} with trigger ${normalizedTrigger}`, {
       orderId: doc.orderId,
     });
 
-    const discountId = await mutations.create({ ...doc, trigger: normalizedTrigger }, userId);
+    const discountId = await mutations.create({ ...doc, trigger: normalizedTrigger });
     const discount = await OrderDiscounts.findOne(buildFindByIdSelector(discountId));
     return discount;
   };
 
-  const deleteDiscount: OrderDiscountsModule['delete'] = async (orderDiscountId, requestContext) => {
+  const deleteDiscount: OrderDiscountsModule['delete'] = async (orderDiscountId, unchainedAPI) => {
     const selector = buildFindByIdSelector(orderDiscountId);
     const discount = await OrderDiscounts.findOne(selector, {});
 
@@ -73,12 +72,12 @@ export const configureOrderDiscountsModule = ({
 
     if (discount.trigger === OrderDiscountTrigger.USER) {
       // Release
-      const adapter = await getAdapter(discount, requestContext);
+      const adapter = await getAdapter(discount, unchainedAPI);
       if (!adapter) return null;
       await adapter.release();
 
       await OrderDiscounts.deleteOne(selector);
-      await updateCalculation(discount.orderId, requestContext);
+      await updateCalculation(discount.orderId, unchainedAPI);
     } else {
       await OrderDiscounts.deleteOne(selector);
       await emit('ORDER_REMOVE_DISCOUNT', { discount });
@@ -86,14 +85,10 @@ export const configureOrderDiscountsModule = ({
     return discount;
   };
 
-  const updateDiscount: OrderDiscountsModule['update'] = async (orderDiscountId, doc, userId) => {
-    await mutations.update(
-      orderDiscountId,
-      {
-        $set: doc,
-      },
-      userId,
-    );
+  const updateDiscount: OrderDiscountsModule['update'] = async (orderDiscountId, doc) => {
+    await mutations.update(orderDiscountId, {
+      $set: doc,
+    });
 
     const selector = buildFindByIdSelector(orderDiscountId);
     const discount = await OrderDiscounts.findOne(selector, {});
@@ -101,24 +96,20 @@ export const configureOrderDiscountsModule = ({
     return discount;
   };
 
-  const reserveDiscount = async (orderDiscount: OrderDiscount, requestContext: Context) => {
-    const adapter = await getAdapter(orderDiscount, requestContext);
+  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 },
-      requestContext.userId,
-    );
+    return updateDiscount(orderDiscount._id, { orderId: orderDiscount.orderId, reservation });
   };
 
   const grabDiscount = async (
     { code, orderId }: { code: string; orderId: string },
-    requestContext: Context,
+    unchainedAPI: UnchainedCore,
   ) => {
     log(`OrderDiscounts -> Try to grab ${code}`, { orderId });
 
@@ -131,12 +122,12 @@ export const configureOrderDiscountsModule = ({
 
     const discountId = discount._id;
     try {
-      const updatedDiscount = await updateDiscount(discountId, { orderId }, requestContext.userId);
-      const reservedDiscount = await reserveDiscount(updatedDiscount, requestContext);
+      const updatedDiscount = await updateDiscount(discountId, { orderId });
+      const reservedDiscount = await reserveDiscount(updatedDiscount, unchainedAPI);
       return reservedDiscount;
     } catch (error) {
       // Rollback
-      await updateDiscount(discountId, { orderId: discount.orderId }, requestContext.userId);
+      await updateDiscount(discountId, { orderId: discount.orderId });
 
       throw error;
     }
@@ -153,13 +144,13 @@ export const configureOrderDiscountsModule = ({
     },
 
     // Transformations
-    interface: async (orderDiscount, requestContext) => {
-      const adapter = await getAdapter(orderDiscount, requestContext);
+    interface: async (orderDiscount, unchainedAPI) => {
+      const adapter = await getAdapter(orderDiscount, unchainedAPI);
       return adapter;
     },
 
-    isValid: async (orderDiscount, requestContext) => {
-      const adapter = await getAdapter(orderDiscount, requestContext);
+    isValid: async (orderDiscount, unchainedAPI) => {
+      const adapter = await getAdapter(orderDiscount, unchainedAPI);
       if (!adapter) return null;
 
       if (orderDiscount.trigger === OrderDiscountTrigger.SYSTEM) {
@@ -176,9 +167,9 @@ export const configureOrderDiscountsModule = ({
       orderDiscount,
       adapterKey,
       calculationSheet,
-      requestContext,
+      unchainedAPI,
     ) => {
-      const adapter = await getAdapter(orderDiscount, requestContext);
+      const adapter = await getAdapter(orderDiscount, unchainedAPI);
       if (!adapter) return null;
 
       return adapter.discountForPricingAdapterKey({
@@ -188,35 +179,32 @@ export const configureOrderDiscountsModule = ({
     },
 
     // Mutations
-    createManualOrderDiscount: async ({ order, code }, requestContext) => {
+    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 }, requestContext);
+      const fetchedDiscount = await grabDiscount({ code, orderId: order._id }, unchainedAPI);
       if (fetchedDiscount) return fetchedDiscount;
 
-      const director = await OrderDiscountDirector.actions({ order, code }, requestContext);
+      const director = await OrderDiscountDirector.actions({ order, code }, unchainedAPI);
       const discountKey = await director.resolveDiscountKeyFromStaticCode({
         code,
       });
 
       if (discountKey) {
-        const newDiscount = await createDiscount(
-          {
-            orderId: order._id,
-            code,
-            discountKey,
-          },
-          requestContext.userId,
-        );
+        const newDiscount = await createDiscount({
+          orderId: order._id,
+          code,
+          discountKey,
+        });
 
         try {
-          const reservedDiscount = await reserveDiscount(newDiscount, requestContext);
-          await updateCalculation(order._id, requestContext);
+          const reservedDiscount = await reserveDiscount(newDiscount, unchainedAPI);
+          await updateCalculation(order._id, unchainedAPI);
           await emit('ORDER_ADD_DISCOUNT', { discount: reserveDiscount });
           return reservedDiscount;
         } catch (error) {
-          await deleteDiscount(newDiscount._id, requestContext);
+          await deleteDiscount(newDiscount._id, unchainedAPI);
           throw error;
         }
       }
@@ -224,8 +212,8 @@ export const configureOrderDiscountsModule = ({
       throw new Error(OrderDiscountErrorCode.CODE_NOT_VALID);
     },
 
-    create: async (doc, userId) => {
-      const discount = await createDiscount(doc, userId);
+    create: async (doc) => {
+      const discount = await createDiscount(doc);
 
       if (discount.trigger === OrderDiscountTrigger.USER) {
         await emit('ORDER_CREATE_DISCOUNT', { discount });
@@ -236,8 +224,8 @@ export const configureOrderDiscountsModule = ({
 
     delete: deleteDiscount,
 
-    update: async (orderDiscountId, doc, userId) => {
-      await mutations.update(orderDiscountId, doc, userId);
+    update: async (orderDiscountId, doc) => {
+      await mutations.update(orderDiscountId, doc);
 
       const selector = buildFindByIdSelector(orderDiscountId);
       const discount = await OrderDiscounts.findOne(selector, {});

package/src/module/configureOrderPaymentsModule.ts

@@ -14,10 +14,10 @@ import { OrderPaymentsSchema } from '../db/OrderPaymentsSchema';
 
 const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
 
-const buildFindByIdSelector = (orderPaymentId: string) =>
+export const buildFindByIdSelector = (orderPaymentId: string) =>
   generateDbFilterById(orderPaymentId) as Filter<OrderPayment>;
 
-const buildFindByContextDataSelector = (context: any): Query => {
+export const buildFindByContextDataSelector = (context: any): Query => {
   const contextKeys = Object.keys(context);
 
   if (contextKeys.length === 0) return null;
@@ -55,27 +55,28 @@ export const configureOrderPaymentsModule = ({
       : (orderPayment.status as OrderPaymentStatus);
   };
 
-  const buildPaymentProviderActionsContext = (orderPayment: OrderPayment, transactionContext) => ({
+  const buildPaymentProviderActionsContext = (
+    orderPayment: OrderPayment,
+    { transactionContext, ...rest }: { transactionContext: any; userId: string },
+  ) => ({
+    ...rest,
+    orderPayment,
     paymentProviderId: orderPayment.paymentProviderId,
-    paymentContext: {
-      orderPayment,
-      transactionContext: {
-        ...(transactionContext || {}),
-        ...(orderPayment.context || {}),
-      },
+    transactionContext: {
+      ...(transactionContext || {}),
+      ...(orderPayment.context || {}),
     },
   });
 
   const updateStatus: OrderPaymentsModule['updateStatus'] = async (
     orderPaymentId,
     { status, transactionId, info },
-    userId,
   ) => {
     log(`OrderPayment ${orderPaymentId} -> New Status: ${status}`);
 
     const date = new Date();
     const modifier: Update<OrderPayment> = {
-      $set: { status, updated: new Date(), updatedBy: userId },
+      $set: { status, updated: new Date() },
       $push: {
         log: {
           date,
@@ -126,16 +127,16 @@ export const configureOrderPaymentsModule = ({
       }));
     },
 
-    isBlockingOrderConfirmation: async (orderPayment, requestContext) => {
+    isBlockingOrderConfirmation: async (orderPayment, unchainedAPI) => {
       if (orderPayment.status === OrderPaymentStatus.PAID) return false;
 
-      const provider = await requestContext.modules.payment.paymentProviders.findProvider({
+      const provider = await unchainedAPI.modules.payment.paymentProviders.findProvider({
         paymentProviderId: orderPayment.paymentProviderId,
       });
 
-      const isPayLaterAllowed = await requestContext.modules.payment.paymentProviders.isPayLaterAllowed(
+      const isPayLaterAllowed = await unchainedAPI.modules.payment.paymentProviders.isPayLaterAllowed(
         provider,
-        requestContext,
+        unchainedAPI,
       );
 
       return !isPayLaterAllowed;
@@ -156,92 +157,114 @@ export const configureOrderPaymentsModule = ({
 
     // Mutations
 
-    create: async (doc, userId) => {
-      const orderPaymentId = await mutations.create(
-        { ...doc, status: null, context: doc.context || {} },
-        userId,
-      );
+    create: async (doc) => {
+      const orderPaymentId = await mutations.create({
+        ...doc,
+        status: null,
+        context: doc.context || {},
+      });
 
       const orderPayment = await OrderPayments.findOne(buildFindByIdSelector(orderPaymentId));
 
       return orderPayment;
     },
 
-    confirm: async (orderPayment, { transactionContext }, requestContext) => {
-      const { services } = requestContext;
+    confirm: async (orderPayment, paymentContext, unchainedAPI) => {
+      const { modules } = unchainedAPI;
 
       if (normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
         return orderPayment;
       }
 
-      const arbitraryResponseData = await services.payment.confirm(
-        buildPaymentProviderActionsContext(orderPayment, transactionContext),
-        requestContext,
+      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),
-          },
-          requestContext.userId,
-        );
+        return updateStatus(orderPayment._id, {
+          status: OrderPaymentStatus.PAID,
+          info: JSON.stringify(arbitraryResponseData),
+        });
       }
 
       return orderPayment;
     },
 
-    cancel: async (orderPayment, { transactionContext }, requestContext) => {
-      const { services } = requestContext;
+    cancel: async (orderPayment, paymentContext, unchainedAPI) => {
+      const { modules } = unchainedAPI;
 
       if (normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
         return orderPayment;
       }
 
-      const arbitraryResponseData = await services.payment.cancel(
-        buildPaymentProviderActionsContext(orderPayment, transactionContext),
-        requestContext,
+      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),
-          },
-          requestContext.userId,
-        );
+        return updateStatus(orderPayment._id, {
+          status: OrderPaymentStatus.REFUNDED,
+          info: JSON.stringify(arbitraryResponseData),
+        });
       }
 
       return orderPayment;
     },
 
-    charge: async (orderPayment, { transactionContext }, requestContext) => {
-      const { services } = requestContext;
+    charge: async (orderPayment, context, unchainedAPI) => {
+      const { modules } = unchainedAPI;
 
       if (normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) {
         return orderPayment;
       }
 
-      const arbitraryResponseData = await services.payment.charge(
-        buildPaymentProviderActionsContext(orderPayment, transactionContext),
-        requestContext,
+      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),
-          },
-          requestContext.userId,
-        );
+        return updateStatus(orderPayment._id, {
+          transactionId,
+          status: OrderPaymentStatus.PAID,
+          info: JSON.stringify(info),
+        });
       }
 
       return orderPayment;
@@ -263,21 +286,17 @@ export const configureOrderPaymentsModule = ({
       return true;
     },
 
-    markAsPaid: async (orderPayment, meta, userId) => {
+    markAsPaid: async (orderPayment, meta) => {
       if (normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) return;
 
-      await updateStatus(
-        orderPayment._id,
-        {
-          status: OrderPaymentStatus.PAID,
-          info: meta ? JSON.stringify(meta) : 'mark paid manually',
-        },
-        userId,
-      );
+      await updateStatus(orderPayment._id, {
+        status: OrderPaymentStatus.PAID,
+        info: meta ? JSON.stringify(meta) : 'mark paid manually',
+      });
       await emit('ORDER_PAY', { orderPayment });
     },
 
-    updateContext: async (orderPaymentId, context, requestContext) => {
+    updateContext: async (orderPaymentId, context, unchainedAPI) => {
       if (!context) return false;
 
       const selector = buildFindByIdSelector(orderPaymentId);
@@ -292,12 +311,11 @@ export const configureOrderPaymentsModule = ({
         $set: {
           context: { ...(orderPayment.context || {}), ...context },
           updated: new Date(),
-          updatedBy: requestContext.userId,
         },
       });
 
       if (result.modifiedCount) {
-        await updateCalculation(orderId, requestContext);
+        await updateCalculation(orderId, unchainedAPI);
         await emit('ORDER_UPDATE_PAYMENT', {
           orderPayment: {
             ...orderPayment,
@@ -312,16 +330,16 @@ export const configureOrderPaymentsModule = ({
 
     updateStatus,
 
-    updateCalculation: async (orderPayment, requestContext) => {
+    updateCalculation: async (orderPayment, unchainedAPI) => {
       log(`OrderPayment ${orderPayment._id} -> Update Calculation`, {
         orderId: orderPayment.orderId,
       });
 
-      const calculation = await requestContext.modules.payment.paymentProviders.calculate(
+      const calculation = await unchainedAPI.modules.payment.paymentProviders.calculate(
         {
           item: orderPayment,
         },
-        requestContext,
+        unchainedAPI,
       );
 
       const selector = buildFindByIdSelector(orderPayment._id);
@@ -329,7 +347,6 @@ export const configureOrderPaymentsModule = ({
         $set: {
           calculation,
           updated: new Date(),
-          updatedBy: requestContext.userId,
         },
       });