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

package/src/module/configureOrdersModule-processing.ts

@@ -1,508 +0,0 @@
-import { mongodb, generateDbFilterById } from '@unchainedshop/mongodb';
-import { ProductTypes } from '@unchainedshop/core-products';
-import { emit, registerEvents } from '@unchainedshop/events';
-
-import type { Locker } from '@kontsedal/locco';
-import { Order, OrderStatus } from '../types.js';
-import { OrderDelivery } from '@unchainedshop/core-orders';
-import { OrderPayment } from '@unchainedshop/core-orders';
-import { OrderPosition } from '@unchainedshop/core-orders';
-import { UnchainedCore } from '@unchainedshop/core';
-
-import { ordersSettings } from '../orders-settings.js';
-
-export type OrderContextParams<P> = (
-  order: Order,
-  params: P,
-  unchainedAPI: UnchainedCore,
-) => Promise<Order>;
-
-export type OrderTransactionContext = {
-  paymentContext?: any;
-  deliveryContext?: any;
-  comment?: string;
-  nextStatus?: OrderStatus;
-};
-
-export interface OrderProcessing {
-  checkout: (
-    orderId: string,
-    params: OrderTransactionContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<Order>;
-  confirm: OrderContextParams<OrderTransactionContext>;
-  reject: OrderContextParams<OrderTransactionContext>;
-  processOrder: OrderContextParams<OrderTransactionContext>;
-  updateStatus: (orderId: string, params: { status: OrderStatus; info?: string }) => Promise<Order>;
-}
-
-const ORDER_PROCESSING_EVENTS: string[] = [
-  'ORDER_CHECKOUT',
-  'ORDER_CONFIRMED',
-  'ORDER_REJECTED',
-  'ORDER_FULLFILLED',
-];
-
-export const configureOrderModuleProcessing = ({
-  Orders,
-  OrderPositions,
-  OrderDeliveries,
-  OrderPayments,
-  locker,
-}: {
-  Orders: mongodb.Collection<Order>;
-  OrderPositions: mongodb.Collection<OrderPosition>;
-  OrderDeliveries: mongodb.Collection<OrderDelivery>;
-  OrderPayments: mongodb.Collection<OrderPayment>;
-  locker: Locker;
-}): OrderProcessing => {
-  registerEvents(ORDER_PROCESSING_EVENTS);
-
-  const findNewOrderNumber = async (order: Order, index = 0) => {
-    const newHashID = ordersSettings.orderNumberHashFn(order, index);
-    if ((await Orders.countDocuments({ orderNumber: newHashID }, { limit: 1 })) === 0) {
-      return newHashID;
-    }
-    return findNewOrderNumber(order, index + 1);
-  };
-
-  const updateStatus: OrderProcessing['updateStatus'] = async (orderId, { status, info }) => {
-    const selector = generateDbFilterById(orderId);
-    const order = await Orders.findOne(selector, {});
-
-    if (order.status === status) return order;
-
-    const date = new Date();
-    const $set: Partial<Order> = {
-      status,
-      updated: new Date(),
-    };
-    switch (status) {
-      // explicitly use fallthrough here!
-      case OrderStatus.FULLFILLED:
-        $set.fullfilled = order.fullfilled || date;
-      case OrderStatus.REJECTED: // eslint-disable-line no-fallthrough
-      case OrderStatus.CONFIRMED: // eslint-disable-line no-fallthrough
-        if (status === OrderStatus.REJECTED) {
-          $set.rejected = order.rejected || date;
-        } else {
-          $set.confirmed = order.confirmed || date;
-        }
-      case OrderStatus.PENDING: // eslint-disable-line no-fallthrough
-        $set.ordered = order.ordered || date;
-        $set.orderNumber = order.orderNumber || (await findNewOrderNumber(order));
-        break;
-      default:
-        break;
-    }
-
-    const modifier: mongodb.UpdateFilter<Order> = {
-      $set,
-      $push: {
-        log: {
-          date,
-          status,
-          info,
-        },
-      },
-    };
-
-    const modificationResult = await Orders.findOneAndUpdate(
-      {
-        ...selector,
-        status: { $ne: status }, // Only update if status is different
-      },
-      modifier,
-      {
-        returnDocument: 'after',
-        includeResultMetadata: true,
-      },
-    );
-
-    if (modificationResult.ok) {
-      if (order.status === null) {
-        // The first time that an order transitions away from cart is a checkout event
-        await emit('ORDER_CHECKOUT', { order: modificationResult.value, oldStatus: order.status });
-      }
-      switch (status) {
-        case OrderStatus.FULLFILLED:
-          await emit('ORDER_FULLFILLED', { order: modificationResult.value, oldStatus: order.status });
-          break;
-        case OrderStatus.REJECTED:
-          await emit('ORDER_REJECTED', { order: modificationResult.value, oldStatus: order.status });
-          break;
-        case OrderStatus.CONFIRMED:
-          await emit('ORDER_CONFIRMED', { order: modificationResult.value, oldStatus: order.status });
-          break;
-        default:
-          break;
-      }
-    }
-
-    return modificationResult.value || Orders.findOne(selector, {});
-  };
-
-  const findOrderPositions = async (order: Order) =>
-    OrderPositions.find({
-      orderId: order._id,
-      quantity: { $gt: 0 },
-    }).toArray();
-
-  const findOrderDelivery = async (order: Order) =>
-    OrderDeliveries.findOne(generateDbFilterById(order.deliveryId), {});
-
-  const findOrderPayment = async (order: Order) =>
-    OrderPayments.findOne(generateDbFilterById(order.paymentId), {});
-
-  const missingInputDataForCheckout = async (order: Order) => {
-    const errors = [];
-    if (!order.contact) errors.push(new Error('Contact data not provided'));
-    if (!order.billingAddress) errors.push(new Error('Billing address not provided'));
-    if (!(await findOrderDelivery(order))) errors.push('No delivery provider selected');
-    if (!(await findOrderPayment(order))) errors.push('No payment provider selected');
-    return errors;
-  };
-
-  const itemValidationErrors = async (order: Order, unchainedAPI: UnchainedCore) => {
-    // Check if items are valid
-    const orderPositions = await findOrderPositions(order);
-    if (orderPositions.length === 0) {
-      const NoItemsError = new Error('No items to checkout');
-      NoItemsError.name = 'NoItemsError';
-      return [NoItemsError];
-    }
-    const validationErrors = await Promise.all(
-      orderPositions.map(async (orderPosition) => {
-        const errors = [];
-        const product = await unchainedAPI.modules.products.findProduct({
-          productId: orderPosition.productId,
-        });
-
-        try {
-          await ordersSettings.validateOrderPosition(
-            {
-              order,
-              product,
-              configuration: orderPosition.configuration,
-              quantityDiff: 0,
-            },
-            unchainedAPI,
-          );
-        } catch (e) {
-          errors.push(e);
-        }
-
-        const quotation =
-          orderPosition.quotationId &&
-          (await unchainedAPI.modules.quotations.findQuotation({
-            quotationId: orderPosition.quotationId,
-          }));
-        if (quotation && !unchainedAPI.modules.quotations.isProposalValid(quotation)) {
-          errors.push(new Error('Quotation expired or fullfiled, please request a new offer'));
-        }
-        return errors;
-      }),
-    );
-
-    return validationErrors.flatMap((f) => f);
-  };
-
-  const isAutoConfirmationEnabled = async (order: Order, unchainedAPI: UnchainedCore) => {
-    const { modules } = unchainedAPI;
-
-    if (order.status === OrderStatus.FULLFILLED || order.status === OrderStatus.CONFIRMED) {
-      return false;
-    }
-
-    const orderPayment = await findOrderPayment(order);
-    let isBlockingOrderConfirmation =
-      orderPayment &&
-      (await modules.orders.payments.isBlockingOrderConfirmation(orderPayment, unchainedAPI));
-    if (isBlockingOrderConfirmation) return false;
-
-    const orderDelivery = await findOrderDelivery(order);
-    isBlockingOrderConfirmation =
-      orderDelivery &&
-      (await modules.orders.deliveries.isBlockingOrderConfirmation(orderDelivery, unchainedAPI));
-    if (isBlockingOrderConfirmation) return false;
-
-    return true;
-  };
-
-  const isAutoFullfillmentEnabled = async (order: Order, unchainedAPI: UnchainedCore) => {
-    const { modules } = unchainedAPI;
-
-    const orderPayment = await findOrderPayment(order);
-    let isBlockingOrderFullfillment =
-      orderPayment && modules.orders.payments.isBlockingOrderFullfillment(orderPayment);
-
-    if (isBlockingOrderFullfillment) return false;
-
-    const orderDelivery = await findOrderDelivery(order);
-    isBlockingOrderFullfillment =
-      orderDelivery && modules.orders.deliveries.isBlockingOrderFullfillment(orderDelivery);
-
-    if (isBlockingOrderFullfillment) return false;
-
-    if (order.status === OrderStatus.FULLFILLED) {
-      return false;
-    }
-
-    return true;
-  };
-
-  const findNextStatus = async (
-    status: OrderStatus | null,
-    order: Order,
-    unchainedAPI: UnchainedCore,
-  ): Promise<OrderStatus | null> => {
-    if (status === null) {
-      return OrderStatus.PENDING;
-    }
-
-    if (status === OrderStatus.PENDING) {
-      if (await isAutoConfirmationEnabled(order, unchainedAPI)) {
-        return OrderStatus.CONFIRMED;
-      }
-    }
-
-    if (status === OrderStatus.CONFIRMED) {
-      if (await isAutoFullfillmentEnabled(order, unchainedAPI)) {
-        return OrderStatus.FULLFILLED;
-      }
-    }
-
-    return status;
-  };
-
-  return {
-    checkout: async (orderId, transactionContext, unchainedAPI) => {
-      const { modules, services } = unchainedAPI;
-
-      const order = await Orders.findOne(generateDbFilterById(orderId), {});
-      if (order.status !== null) return order;
-
-      const errors = [
-        ...(await missingInputDataForCheckout(order)),
-        ...(await itemValidationErrors(order, unchainedAPI)),
-      ].filter(Boolean);
-
-      if (errors.length > 0) {
-        throw new Error(errors[0]);
-      }
-
-      const lock = await locker.lock(`order:checkout:${order._id}`, 5000).acquire();
-      try {
-        const processedOrder = await modules.orders.processOrder(
-          order,
-          transactionContext,
-          unchainedAPI,
-        );
-
-        // After checkout, store last checkout information on user
-        await modules.users.updateLastBillingAddress(
-          processedOrder.userId,
-          processedOrder.billingAddress,
-        );
-        await modules.users.updateLastContact(processedOrder.userId, processedOrder.contact);
-
-        // Then eventually build next cart
-        const user = await modules.users.findUserById(processedOrder.userId);
-        const locale = modules.users.userLocale(user);
-        await services.orders.nextUserCart(
-          {
-            user,
-            countryCode: locale.region,
-          },
-          unchainedAPI,
-        );
-
-        return processedOrder;
-      } finally {
-        await lock.release();
-      }
-    },
-
-    confirm: async (order, transactionContext, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-
-      if (order.status !== OrderStatus.PENDING) return order;
-
-      const lock = await locker.lock(`order:confirm-reject:${order._id}`, 1500).acquire();
-      try {
-        return await modules.orders.processOrder(
-          order,
-          {
-            ...transactionContext,
-            nextStatus: OrderStatus.CONFIRMED,
-          },
-          unchainedAPI,
-        );
-      } finally {
-        await lock.release();
-      }
-    },
-
-    reject: async (order, transactionContext, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-
-      if (order.status !== OrderStatus.PENDING) return order;
-
-      const lock = await locker.lock(`order:confirm-reject:${order._id}`, 1500).acquire();
-      try {
-        return await modules.orders.processOrder(
-          order,
-          {
-            ...transactionContext,
-            nextStatus: OrderStatus.REJECTED,
-          },
-          unchainedAPI,
-        );
-      } finally {
-        await lock.release();
-      }
-    },
-
-    processOrder: async (initialOrder, orderTransactionContext, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-      const {
-        paymentContext,
-        deliveryContext,
-        nextStatus: forceNextStatus,
-        comment,
-      } = orderTransactionContext;
-
-      const orderId = initialOrder._id;
-      let order = initialOrder;
-      let nextStatus =
-        forceNextStatus || (await findNextStatus(initialOrder.status, order, unchainedAPI));
-
-      if (nextStatus === OrderStatus.PENDING) {
-        // auto charge during transition to pending
-        const orderPayment = await modules.orders.payments.findOrderPayment({
-          orderPaymentId: order.paymentId,
-        });
-
-        await modules.orders.payments.charge(
-          orderPayment,
-          { userId: order.userId, transactionContext: paymentContext },
-          unchainedAPI,
-        );
-
-        nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);
-      }
-
-      if (nextStatus === OrderStatus.REJECTED) {
-        // auto cancel during transition to rejected
-        const orderPayment = await modules.orders.payments.findOrderPayment({
-          orderPaymentId: order.paymentId,
-        });
-        await modules.orders.payments.cancel(
-          orderPayment,
-          { userId: order.userId, transactionContext: paymentContext },
-          unchainedAPI,
-        );
-      }
-
-      if (nextStatus === OrderStatus.CONFIRMED) {
-        // confirm pre-authorized payments
-        const orderPayment = await modules.orders.payments.findOrderPayment({
-          orderPaymentId: order.paymentId,
-        });
-        await modules.orders.payments.confirm(
-          orderPayment,
-          { userId: order.userId, transactionContext: paymentContext },
-          unchainedAPI,
-        );
-        if (order.status !== OrderStatus.CONFIRMED) {
-          // we have to stop here shortly to complete the confirmation
-          // before auto delivery is started, else we have no chance to create
-          // numbers that are needed for delivery
-          order = await updateStatus(orderId, {
-            status: OrderStatus.CONFIRMED,
-            info: comment,
-          });
-
-          const orderDelivery = await modules.orders.deliveries.findDelivery({
-            orderDeliveryId: order.deliveryId,
-          });
-          await modules.orders.deliveries.send(
-            orderDelivery,
-            {
-              order,
-              deliveryContext,
-            },
-            unchainedAPI,
-          );
-
-          const orderPositions = await findOrderPositions(order);
-          const mappedProductOrderPositions = await Promise.all(
-            orderPositions.map(async (orderPosition) => {
-              const product = await modules.products.findProduct({
-                productId: orderPosition.productId,
-              });
-              return {
-                orderPosition,
-                product,
-              };
-            }),
-          );
-          const tokenizedItems = mappedProductOrderPositions.filter(
-            (item) => item.product?.type === ProductTypes.TokenizedProduct,
-          );
-          if (tokenizedItems.length > 0) {
-            // Give virtual warehouse a chance to instantiate new virtual objects
-            await modules.warehousing.tokenizeItems(
-              order,
-              {
-                items: tokenizedItems,
-              },
-              unchainedAPI,
-            );
-          }
-
-          // Enrollments: Generate enrollments for plan products
-          const planItems = mappedProductOrderPositions.filter(
-            (item) => item.product?.type === ProductTypes.PlanProduct && !order.originEnrollmentId,
-          );
-          if (planItems.length > 0) {
-            await modules.enrollments.createFromCheckout(
-              order,
-              {
-                items: planItems,
-                context: {
-                  paymentContext,
-                  deliveryContext,
-                },
-              },
-              unchainedAPI,
-            );
-          }
-
-          // Quotations: If we came here, the checkout succeeded, so we can fullfill underlying quotations
-          const quotationItems = mappedProductOrderPositions.filter(
-            (item) => item.orderPosition.quotationId,
-          );
-          await Promise.all(
-            quotationItems.map(async ({ orderPosition }) => {
-              await modules.quotations.fullfillQuotation(
-                orderPosition.quotationId,
-                {
-                  orderId,
-                  orderPositionId: orderPosition._id,
-                },
-                unchainedAPI,
-              );
-            }),
-          );
-        }
-
-        nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);
-      }
-
-      return updateStatus(order._id, { status: nextStatus, info: comment });
-    },
-
-    updateStatus,
-  };
-};

package/src/module/configureOrdersModule-transformations.ts

@@ -1,171 +0,0 @@
-import { Order, OrderDiscount } from '../types.js';
-import { mongodb } from '@unchainedshop/mongodb';
-import { PaymentPricingRowCategory } from '@unchainedshop/core-payment';
-import {
-  IOrderPricingSheet,
-  OrderPricingRowCategory,
-  OrderPricingSheet,
-} from '../director/OrderPricingSheet.js';
-import { UnchainedCore } from '@unchainedshop/core';
-import { ProductPricingRowCategory } from '@unchainedshop/core-products';
-import { DeliveryPricingRowCategory } from '@unchainedshop/core-delivery';
-import { OrderPrice, OrderPricingDiscount } from '../director/OrderPricingDirector.js';
-
-export interface OrderTransformations {
-  discounted: (
-    order: Order,
-    orderDiscount: OrderDiscount,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<Array<OrderPricingDiscount>>;
-  discountTotal: (
-    order: Order,
-    orderDiscount: OrderDiscount,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<OrderPrice>;
-
-  isCart: (order: Order) => boolean;
-  cart: (order: { countryContext?: string; orderNumber?: string; userId: string }) => Promise<Order>;
-  pricingSheet: (order: Order) => IOrderPricingSheet;
-}
-
-export const configureOrderModuleTransformations = ({
-  Orders,
-}: {
-  Orders: mongodb.Collection<Order>;
-}): OrderTransformations => {
-  return {
-    discounted: async (order, orderDiscount, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-
-      // Delivery discounts
-      const orderDelivery = await modules.orders.deliveries.findDelivery({
-        orderDeliveryId: order.deliveryId,
-      });
-      const orderDeliveryDiscounts = modules.orders.deliveries.discounts(
-        orderDelivery,
-        { order, orderDiscount },
-        unchainedAPI,
-      );
-
-      // Payment discounts
-      const orderPayment = await modules.orders.payments.findOrderPayment({
-        orderPaymentId: order.paymentId,
-      });
-      const orderPaymentDiscounts = modules.orders.payments.discounts(
-        orderPayment,
-        { order, orderDiscount },
-        unchainedAPI,
-      );
-
-      // Position discounts
-      const orderPositions = await modules.orders.positions.findOrderPositions({
-        orderId: order._id,
-      });
-      const orderPositionDiscounts = orderPositions.flatMap((orderPosition) =>
-        modules.orders.positions.discounts(orderPosition, { order, orderDiscount }, unchainedAPI),
-      );
-
-      // order discounts
-      const pricingSheet = OrderPricingSheet({
-        calculation: order.calculation,
-        currency: order.currency,
-      });
-
-      const orderDiscounts = pricingSheet
-        .discountPrices(orderDiscount._id)
-        .map((discount) => ({ order, ...discount }));
-
-      // All discounts
-      const discounted = [
-        ...orderPaymentDiscounts,
-        ...orderDeliveryDiscounts,
-        ...orderPositionDiscounts,
-        ...orderDiscounts,
-      ].filter(Boolean);
-
-      return discounted;
-    },
-
-    discountTotal: async (order, orderDiscount, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-      const orderDiscountId = orderDiscount._id;
-
-      // Delivery discounts
-      const orderDelivery = await modules.orders.deliveries.findDelivery({
-        orderDeliveryId: order.deliveryId,
-      });
-      const orderDeliveryDiscountSum =
-        orderDelivery &&
-        modules.orders.deliveries
-          .pricingSheet(orderDelivery, order.currency, unchainedAPI)
-          .total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
-
-      // Payment discounts
-      const orderPayment = await modules.orders.payments.findOrderPayment({
-        orderPaymentId: order.paymentId,
-      });
-      const orderPaymentDiscountSum =
-        orderPayment &&
-        modules.orders.payments
-          .pricingSheet(orderPayment, order.currency, unchainedAPI)
-          .total({ category: PaymentPricingRowCategory.Discount, discountId: orderDiscountId });
-
-      // Position discounts
-      const orderPositions = await modules.orders.positions.findOrderPositions({
-        orderId: order._id,
-      });
-      const orderPositionDiscounts = orderPositions.map((orderPosition) =>
-        modules.orders.positions
-          .pricingSheet(orderPosition, order.currency, unchainedAPI)
-          .total({ category: ProductPricingRowCategory.Discount, discountId: orderDiscountId }),
-      );
-
-      // order discounts
-      const orderDiscountSum = OrderPricingSheet({
-        calculation: order.calculation,
-        currency: order.currency,
-      }).total({ category: OrderPricingRowCategory.Discounts, discountId: orderDiscountId });
-
-      const prices = [
-        orderDeliveryDiscountSum.amount,
-        orderPaymentDiscountSum.amount,
-        ...orderPositionDiscounts.map((positionDiscount) => positionDiscount.amount),
-        orderDiscountSum.amount,
-      ];
-      const amount = prices.reduce((oldValue, price) => oldValue + (price || 0), 0);
-      return {
-        amount,
-        currency: order.currency,
-      };
-    },
-
-    isCart: (order) => {
-      return order.status === null;
-    },
-    cart: async ({ orderNumber, countryContext, userId }) => {
-      const selector: mongodb.Filter<Order> = {
-        countryCode: countryContext,
-        status: { $eq: null },
-        userId,
-      };
-
-      if (orderNumber) {
-        selector.orderNumber = orderNumber;
-      }
-
-      const options: mongodb.FindOptions = {
-        sort: {
-          updated: -1,
-        },
-      };
-      return Orders.findOne(selector, options);
-    },
-
-    pricingSheet: (order) => {
-      return OrderPricingSheet({
-        calculation: order.calculation,
-        currency: order.currency,
-      });
-    },
-  };
-};