@unchainedshop/core-orders 1.1.3

package/src/module/configureOrderDiscountsModule.ts

@@ -0,0 +1,245 @@
+import { Context } from '@unchainedshop/types/api';
+import { Collection, Filter, ModuleMutations } from '@unchainedshop/types/common';
+import { OrdersModule } from '@unchainedshop/types/orders';
+import { OrderDiscount, OrderDiscountsModule } from '@unchainedshop/types/orders.discounts';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { log } from '@unchainedshop/logger';
+import { generateDbFilterById, generateDbMutations } from '@unchainedshop/utils';
+import { OrderDiscountsSchema } from '../db/OrderDiscountsSchema';
+import { OrderDiscountTrigger } from '../db/OrderDiscountTrigger';
+import { OrderDiscountDirector } from '../director/OrderDiscountDirector';
+
+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',
+};
+
+const buildFindByIdSelector = (orderDiscountId: string) =>
+  generateDbFilterById(orderDiscountId) as Filter<OrderDiscount>;
+
+export const configureOrderDiscountsModule = ({
+  OrderDiscounts,
+  updateCalculation,
+}: {
+  OrderDiscounts: Collection<OrderDiscount>;
+  updateCalculation: OrdersModule['updateCalculation'];
+}): OrderDiscountsModule => {
+  registerEvents(ORDER_DISCOUNT_EVENTS);
+
+  const mutations = generateDbMutations<OrderDiscount>(OrderDiscounts, OrderDiscountsSchema, {
+    permanentlyDeleteByDefault: true,
+    hasCreateOnly: false,
+  }) as ModuleMutations<OrderDiscount>;
+
+  const getAdapter = async (orderDiscount: OrderDiscount, requestContext: Context) => {
+    const order = await requestContext.modules.orders.findOrder({
+      orderId: orderDiscount.orderId,
+    });
+    const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+    if (!Adapter) return null;
+    const adapter = Adapter.actions({
+      context: { order, orderDiscount, ...requestContext },
+    });
+    return adapter;
+  };
+
+  const createDiscount: OrderDiscountsModule['create'] = async (doc, userId) => {
+    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 discount = await OrderDiscounts.findOne(buildFindByIdSelector(discountId));
+    return discount;
+  };
+
+  const deleteDiscount: OrderDiscountsModule['delete'] = async (orderDiscountId, requestContext) => {
+    const selector = buildFindByIdSelector(orderDiscountId);
+    const discount = await OrderDiscounts.findOne(selector, {});
+
+    log(`OrderDiscounts -> Remove Discount ${orderDiscountId}`, {
+      orderId: discount.orderId,
+    });
+
+    if (discount.trigger === OrderDiscountTrigger.USER) {
+      // Release
+      const adapter = await getAdapter(discount, requestContext);
+      if (!adapter) return null;
+      await adapter.release();
+
+      await OrderDiscounts.deleteOne(selector);
+      await updateCalculation(discount.orderId, requestContext);
+    } else {
+      await OrderDiscounts.deleteOne(selector);
+      emit('ORDER_REMOVE_DISCOUNT', { discount });
+    }
+    return discount;
+  };
+
+  const updateDiscount: OrderDiscountsModule['update'] = async (orderDiscountId, doc, userId) => {
+    await mutations.update(orderDiscountId, doc, userId);
+
+    const selector = buildFindByIdSelector(orderDiscountId);
+    const discount = await OrderDiscounts.findOne(selector, {});
+    emit('ORDER_UPDATE_DISCOUNT', { discount });
+    return discount;
+  };
+
+  const reserveDiscount = async (orderDiscount: OrderDiscount, requestContext: Context) => {
+    const adapter = await getAdapter(orderDiscount, requestContext);
+    if (!adapter) return null;
+
+    const reservation = await adapter.reserve({
+      code: orderDiscount.code,
+    });
+
+    return updateDiscount(
+      orderDiscount._id,
+      { orderId: orderDiscount.orderId, reservation },
+      requestContext.userId,
+    );
+  };
+
+  const grabDiscount = async ({ code, orderId }: OrderDiscount, requestContext: Context) => {
+    log(`OrderDiscounts -> Try to grab ${code}`, { orderId });
+
+    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 }, requestContext.userId);
+      return reserveDiscount(updatedDiscount, requestContext);
+    } catch (error) {
+      // Rollback
+      await updateDiscount(discountId, { orderId: discount.orderId }, requestContext.userId);
+
+      throw error;
+    }
+  };
+
+  return {
+    // Queries
+    findOrderDiscount: async ({ discountId }, options) => {
+      return OrderDiscounts.findOne(buildFindByIdSelector(discountId), options);
+    },
+    findOrderDiscounts: async ({ orderId }) => {
+      const discounts = OrderDiscounts.find({ orderId });
+      return discounts.toArray();
+    },
+
+    // Transformations
+    interface: async (orderDiscount, requestContext) => {
+      const adapter = await getAdapter(orderDiscount, requestContext);
+      return adapter;
+    },
+
+    isValid: async (orderDiscount, requestContext) => {
+      const adapter = await getAdapter(orderDiscount, requestContext);
+      if (!adapter) return null;
+
+      if (orderDiscount.trigger === OrderDiscountTrigger.SYSTEM) {
+        return adapter.isValidForSystemTriggering();
+      }
+
+      return adapter.isValidForCodeTriggering({
+        code: orderDiscount.code,
+      });
+    },
+
+    // Adapter
+    configurationForPricingAdapterKey: async (
+      orderDiscount,
+      adapterKey,
+      calculationSheet,
+      requestContext,
+    ) => {
+      const adapter = await getAdapter(orderDiscount, requestContext);
+      if (!adapter) return null;
+
+      return adapter.discountForPricingAdapterKey({
+        pricingAdapterKey: adapterKey,
+        calculationSheet,
+      });
+    },
+
+    // Mutations
+    createManualOrderDiscount: async (doc, requestContext) => {
+      const { code, orderId } = doc;
+      // Try to grab single-usage-discount
+      if (!code) throw new Error(OrderDiscountErrorCode.CODE_NOT_VALID);
+
+      const fetchedDiscount = await grabDiscount(doc, requestContext);
+      if (fetchedDiscount) return fetchedDiscount;
+
+      const order = await requestContext.modules.orders.findOrder({ orderId });
+      const director = await OrderDiscountDirector.actions(
+        { order, orderDiscount: doc },
+        requestContext,
+      );
+      const discountKey = await director.resolveDiscountKeyFromStaticCode({
+        code,
+      });
+
+      if (discountKey) {
+        const newDiscount = await createDiscount(
+          {
+            ...doc,
+            discountKey,
+          },
+          requestContext.userId,
+        );
+
+        const reservedDiscount = await reserveDiscount(newDiscount, requestContext).catch(
+          async (error) => {
+            // Rollback
+            await deleteDiscount(newDiscount._id, requestContext);
+            throw error;
+          },
+        );
+
+        await updateCalculation(orderId, requestContext);
+
+        emit('ORDER_ADD_DISCOUNT', { discount: reserveDiscount });
+
+        return reservedDiscount;
+      }
+
+      throw new Error(OrderDiscountErrorCode.CODE_NOT_VALID);
+    },
+
+    create: async (doc, userId) => {
+      const discount = await createDiscount(doc, userId);
+
+      if (discount.trigger === OrderDiscountTrigger.USER) {
+        emit('ORDER_CREATE_DISCOUNT', { discount });
+      }
+
+      return discount;
+    },
+
+    delete: deleteDiscount,
+
+    update: async (orderDiscountId, doc, userId) => {
+      await mutations.update(orderDiscountId, doc, userId);
+
+      const selector = buildFindByIdSelector(orderDiscountId);
+      const discount = await OrderDiscounts.findOne(selector, {});
+      emit('ORDER_UPDATE_DISCOUNT', { discount });
+      return discount;
+    },
+  };
+};

package/src/module/configureOrderPaymentsModule.ts

@@ -0,0 +1,331 @@
+import { Collection, Filter, ModuleMutations, Query, Update } from '@unchainedshop/types/common';
+import { OrdersModule } from '@unchainedshop/types/orders';
+import {
+  OrderPayment,
+  OrderPaymentsModule,
+  OrderPaymentStatus,
+} from '@unchainedshop/types/orders.payments';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { log } from '@unchainedshop/logger';
+import { generateDbFilterById, generateDbMutations } from '@unchainedshop/utils';
+import { OrderPaymentsSchema } from '../db/OrderPaymentsSchema';
+
+const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
+
+const buildFindByIdSelector = (orderPaymentId: string) =>
+  generateDbFilterById(orderPaymentId) as Filter<OrderPayment>;
+
+const buildFindByContextDataSelector = (context: any): Query => {
+  const contextKeys = Object.keys(context);
+
+  if (contextKeys.length === 0) return null;
+
+  const selector: Query = contextKeys.reduce(
+    (currentSelector, key) =>
+      context[key] !== undefined
+        ? {
+          ...currentSelector,
+          [`context.${key}`]: context[key],
+        }
+        : currentSelector,
+    {},
+  );
+  return selector;
+};
+
+export const configureOrderPaymentsModule = ({
+  OrderPayments,
+  updateCalculation,
+}: {
+  OrderPayments: Collection<OrderPayment>;
+  updateCalculation: OrdersModule['updateCalculation'];
+}): OrderPaymentsModule => {
+  registerEvents(ORDER_PAYMENT_EVENTS);
+
+  const mutations = generateDbMutations<OrderPayment>(OrderPayments, OrderPaymentsSchema, {
+    permanentlyDeleteByDefault: true,
+    hasCreateOnly: false,
+  }) as ModuleMutations<OrderPayment>;
+
+  const normalizedStatus: OrderPaymentsModule['normalizedStatus'] = (orderPayment) => {
+    return orderPayment.status === null
+      ? OrderPaymentStatus.OPEN
+      : (orderPayment.status as OrderPaymentStatus);
+  };
+
+  const buildPaymentProviderActionsContext = (orderPayment: OrderPayment, transactionContext) => ({
+    paymentProviderId: orderPayment.paymentProviderId,
+    paymentContext: {
+      orderPayment,
+      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 },
+      $push: {
+        log: {
+          date,
+          status,
+          info,
+        },
+      },
+    };
+    if (transactionId) {
+      modifier.$set.transactionId = transactionId;
+    }
+    if (status === OrderPaymentStatus.PAID) {
+      modifier.$set.paid = date;
+    }
+
+    const selector = buildFindByIdSelector(orderPaymentId);
+    await OrderPayments.updateOne(selector, modifier);
+    return OrderPayments.findOne(selector, {});
+  };
+
+  return {
+    // Queries
+    findOrderPayment: async ({ orderPaymentId }, options) => {
+      return OrderPayments.findOne(buildFindByIdSelector(orderPaymentId), options);
+    },
+    findOrderPaymentByContextData: async ({ context }, options) => {
+      const selector = buildFindByContextDataSelector(context);
+
+      return OrderPayments.findOne(selector, options);
+    },
+    countOrderPaymentsByContextData: async ({ context }, options) => {
+      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, requestContext) => {
+      if (orderPayment.status === OrderPaymentStatus.PAID) return false;
+
+      const provider = await requestContext.modules.payment.paymentProviders.findProvider({
+        paymentProviderId: orderPayment.paymentProviderId,
+      });
+
+      const isPayLaterAllowed = await requestContext.modules.payment.paymentProviders.isPayLaterAllowed(
+        provider,
+        requestContext,
+      );
+
+      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, userId) => {
+      const orderPaymentId = await mutations.create(
+        { ...doc, status: null, context: doc.context || {} },
+        userId,
+      );
+
+      const orderPayment = await OrderPayments.findOne(buildFindByIdSelector(orderPaymentId));
+
+      return orderPayment;
+    },
+
+    confirm: async (orderPayment, { transactionContext }, requestContext) => {
+      const { services } = requestContext;
+
+      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
+        return orderPayment;
+      }
+
+      const arbitraryResponseData = await services.payment.confirm(
+        buildPaymentProviderActionsContext(orderPayment, transactionContext),
+        requestContext,
+      );
+
+      if (arbitraryResponseData) {
+        return updateStatus(
+          orderPayment._id,
+          {
+            status: OrderPaymentStatus.PAID,
+            info: JSON.stringify(arbitraryResponseData),
+          },
+          requestContext.userId,
+        );
+      }
+
+      return orderPayment;
+    },
+
+    cancel: async (orderPayment, { transactionContext }, requestContext) => {
+      const { services } = requestContext;
+
+      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
+        return orderPayment;
+      }
+
+      const arbitraryResponseData = await services.payment.cancel(
+        buildPaymentProviderActionsContext(orderPayment, transactionContext),
+        requestContext,
+      );
+
+      if (arbitraryResponseData) {
+        return updateStatus(
+          orderPayment._id,
+          {
+            status: OrderPaymentStatus.REFUNDED,
+            info: JSON.stringify(arbitraryResponseData),
+          },
+          requestContext.userId,
+        );
+      }
+
+      return orderPayment;
+    },
+
+    charge: async (orderPayment, { transactionContext }, requestContext) => {
+      const { services } = requestContext;
+
+      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) {
+        return orderPayment;
+      }
+
+      const arbitraryResponseData = await services.payment.charge(
+        buildPaymentProviderActionsContext(orderPayment, transactionContext),
+        requestContext,
+      );
+
+      if (arbitraryResponseData) {
+        const { transactionId, ...info } = arbitraryResponseData;
+        return updateStatus(
+          orderPayment._id,
+          {
+            transactionId,
+            status: OrderPaymentStatus.PAID,
+            info: JSON.stringify(info),
+          },
+          requestContext.userId,
+        );
+      }
+
+      return orderPayment;
+    },
+
+    logEvent: async (orderPaymentId, event) => {
+      const date = new Date();
+      const modifier = {
+        $push: {
+          log: {
+            date,
+            status: undefined,
+            info: JSON.stringify(event),
+          },
+        },
+      };
+      await OrderPayments.updateOne(generateDbFilterById(orderPaymentId), modifier);
+
+      return true;
+    },
+
+    markAsPaid: async (orderPayment, meta, userId) => {
+      if (normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) return;
+
+      await updateStatus(
+        orderPayment._id,
+        {
+          status: OrderPaymentStatus.PAID,
+          info: meta ? JSON.stringify(meta) : 'mark paid manually',
+        },
+        userId,
+      );
+      emit('ORDER_PAY', { orderPayment });
+    },
+
+    updateContext: async (orderPaymentId, context, requestContext) => {
+      const selector = buildFindByIdSelector(orderPaymentId);
+      const orderPayment = await OrderPayments.findOne(selector, {});
+      const { orderId } = orderPayment;
+
+      log(`OrderPayment ${orderPaymentId} -> Update Context`, {
+        orderId,
+        context,
+      });
+      const result = await OrderPayments.updateOne(selector, {
+        $set: {
+          context: { ...(orderPayment.context || {}), ...context },
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      if (result.modifiedCount) {
+        await updateCalculation(orderId, requestContext);
+        emit('ORDER_UPDATE_PAYMENT', {
+          orderPayment: {
+            ...orderPayment,
+            context: { ...(orderPayment.context || {}), ...context },
+          },
+        });
+        return true;
+      }
+
+      return false;
+    },
+
+    updateStatus,
+
+    updateCalculation: async (orderPayment, requestContext) => {
+      log(`OrderPayment ${orderPayment._id} -> Update Calculation`, {
+        orderId: orderPayment.orderId,
+      });
+
+      const calculation = await requestContext.modules.payment.paymentProviders.calculate(
+        {
+          item: orderPayment,
+        },
+        requestContext,
+      );
+
+      const selector = buildFindByIdSelector(orderPayment._id);
+      await OrderPayments.updateOne(selector, {
+        $set: {
+          calculation,
+          updated: new Date(),
+          updatedBy: requestContext.userId,
+        },
+      });
+
+      return OrderPayments.findOne(selector);
+    },
+  };
+};