@unchainedshop/core-orders 2.14.2 → 3.0.0-alpha3

package/src/module/configureOrderPositionsModule.ts

@@ -1,16 +1,78 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
-import { OrderPosition, OrderPositionsModule } from '@unchainedshop/types/orders.positions.js';
+import type { OrderDiscount } from '@unchainedshop/core-orders';
+import type { UnchainedCore } from '@unchainedshop/core';
+import { IProductPricingSheet, Product } from '@unchainedshop/core-products';
+
+import { Order, OrderPosition } from '../types.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-import {
-  generateDbFilterById,
-  generateDbMutations,
-  generateDbObjectId,
-  mongodb,
-} from '@unchainedshop/mongodb';
-import { OrderPositionsSchema } from '../db/OrderPositionsSchema.js';
+import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { ordersSettings } from '../orders-settings.js';
+import { OrderDelivery } from '@unchainedshop/core-orders';
+import { OrderPricingDiscount } from '../director/OrderPricingDirector.js';
+
+export type OrderPositionsModule = {
+  // Queries
+  findOrderPosition: (
+    params: { itemId: string },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderPosition>;
+  findOrderPositions: (params: { orderId: string }) => Promise<Array<OrderPosition>>;
+
+  // Transformations
+  discounts: (
+    orderPosition: OrderPosition,
+    params: { order: Order; orderDiscount: OrderDiscount },
+    unchainedAPI: UnchainedCore,
+  ) => Array<OrderPricingDiscount>;
+
+  pricingSheet: (
+    orderPosition: OrderPosition,
+    currency: string,
+    unchainedAPI: UnchainedCore,
+  ) => IProductPricingSheet;
+
+  delete: (orderPositionId: string) => Promise<OrderPosition>;
+
+  removePositions: ({ orderId }: { orderId: string }) => Promise<number>;
+  removeProductByIdFromAllOpenPositions: (productId: string) => Promise<Array<string>>;
+
+  updateProductItem: (
+    doc: {
+      context?: any;
+      configuration?: Array<{ key: string; value: string }>;
+      quantity?: number;
+    },
+    params: { order: Order; product: Product; orderPosition: OrderPosition },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+
+  updateScheduling: (
+    params: {
+      order: Order;
+      orderDelivery: OrderDelivery;
+      orderPosition: OrderPosition;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+
+  updateCalculation: (
+    orderPosition: OrderPosition,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+
+  addProductItem: (
+    doc: {
+      context?: any;
+      configuration?: Array<{ key: string; value: string }>;
+      orderId?: string;
+      originalProductId?: string;
+      productId?: string;
+      quantity: number;
+      quotationId?: string;
+    },
+    params: { order: Order; product: Product },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPosition>;
+};
 
 const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_UPDATE_CART_ITEM',
@@ -27,18 +89,11 @@ export const buildFindByIdSelector = (orderPositionId: string, orderId?: string)
 
 export const configureOrderPositionsModule = ({
   OrderPositions,
-  updateCalculation,
 }: {
   OrderPositions: mongodb.Collection<OrderPosition>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderPositionsModule => {
   registerEvents(ORDER_POSITION_EVENTS);
 
-  const mutations = generateDbMutations<OrderPosition>(OrderPositions, OrderPositionsSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<OrderPosition>;
-
   return {
     // Queries
     findOrderPosition: async ({ itemId }, options) => {
@@ -72,68 +127,18 @@ export const configureOrderPositionsModule = ({
       });
     },
 
-    // Mutations
-
-    create: async (
-      { configuration, context, quantity, quotationId },
-      { order, product, originalProduct },
-      unchainedAPI,
-    ) => {
-      const orderId = order._id;
-      const productId = product._id;
-      const originalProductId = originalProduct ? originalProduct._id : undefined;
-
-      log(
-        `Create ${quantity}x Position with Product ${productId} ${
-          quotationId ? ` (${quotationId})` : ''
-        }`,
-        { orderId, productId, originalProductId },
-      );
-
-      const positionId = await mutations.create({
-        orderId,
-        productId,
-        originalProductId,
-        quotationId,
-        quantity,
-        configuration,
-        context,
-        calculation: [],
-        scheduling: [],
-      });
-
-      await updateCalculation(orderId, unchainedAPI);
-
-      return OrderPositions.findOne(buildFindByIdSelector(positionId));
-    },
-
-    delete: async (orderPositionId, unchainedAPI) => {
+    delete: async (orderPositionId) => {
       const selector = buildFindByIdSelector(orderPositionId);
-
-      log(`Remove Position ${orderPositionId}`, {
-        orderPositionId,
-      });
-
       const orderPosition = await OrderPositions.findOneAndDelete(selector, {});
-
-      await updateCalculation(orderPosition.orderId, unchainedAPI);
-
       await emit('ORDER_REMOVE_CART_ITEM', {
         orderPosition,
       });
-
       return { ...orderPosition, calculation: [] };
     },
 
-    removePositions: async ({ orderId }, unchainedAPI) => {
-      log('Remove Positions', { orderId });
-
+    removePositions: async ({ orderId }) => {
       const result = await OrderPositions.deleteMany({ orderId });
-
-      await updateCalculation(orderId, unchainedAPI);
-
       await emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
-
       return result.deletedCount;
     },
 
@@ -173,11 +178,9 @@ export const configureOrderPositionsModule = ({
         unchainedAPI,
       );
 
-      await OrderPositions.updateOne(selector, modifier);
-
-      await updateCalculation(order._id, unchainedAPI);
-
-      const updatedOrderPosition = await OrderPositions.findOne(selector, {});
+      const updatedOrderPosition = await OrderPositions.findOneAndUpdate(selector, modifier, {
+        returnDocument: 'after',
+      });
 
       await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
@@ -186,9 +189,7 @@ export const configureOrderPositionsModule = ({
       return updatedOrderPosition;
     },
 
-    removeProductByIdFromAllOpenPositions: async (productId, unchainedAPI) => {
-      log('Remove Position Product', { productId });
-
+    removeProductByIdFromAllOpenPositions: async (productId) => {
       const positions = await OrderPositions.aggregate([
         {
           $match: {
@@ -211,15 +212,7 @@ export const configureOrderPositionsModule = ({
       ]).toArray();
 
       const positionIds = positions.map((o) => o._id);
-      const result = await OrderPositions.deleteMany({ _id: { $in: positionIds } });
-
-      const orderIdsToRecalculate = positions.map((o) => o.orderId);
-      await Promise.all(
-        [...new Set(orderIdsToRecalculate)].map(async (orderIdToRecalculate) => {
-          await updateCalculation(orderIdToRecalculate, unchainedAPI);
-        }),
-      );
-
+      await OrderPositions.deleteMany({ _id: { $in: positionIds } });
       await Promise.all(
         positions.map(async (orderPosition) => {
           await emit('ORDER_REMOVE_CART_ITEM', {
@@ -228,7 +221,8 @@ export const configureOrderPositionsModule = ({
         }),
       );
 
-      return result.deletedCount;
+      const orderIdsToRecalculate = positions.map((o) => o.orderId);
+      return orderIdsToRecalculate;
     },
 
     updateScheduling: async ({ order, orderDelivery, orderPosition }, unchainedAPI) => {
@@ -291,10 +285,6 @@ export const configureOrderPositionsModule = ({
     },
 
     updateCalculation: async (orderPosition, unchainedAPI) => {
-      log(`OrderPosition ${orderPosition._id} -> Update Calculation`, {
-        orderId: orderPosition.orderId,
-      });
-
       const calculation = await unchainedAPI.modules.products.calculate(
         { item: orderPosition, configuration: orderPosition.configuration },
         unchainedAPI,
@@ -364,8 +354,6 @@ export const configureOrderPositionsModule = ({
         { upsert: true },
       );
 
-      await updateCalculation(orderId, unchainedAPI);
-
       const upsertedOrderPosition = await OrderPositions.findOne(selector);
 
       await emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });

package/src/module/configureOrdersModule-mutations.ts

@@ -1,12 +1,48 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { Order, OrderStatus, OrderMutations, OrdersModule } from '@unchainedshop/types/orders.js';
-import { OrderDelivery } from '@unchainedshop/types/orders.deliveries.js';
-import { OrderPayment } from '@unchainedshop/types/orders.payments.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { Order, OrderStatus } from '../types.js';
+import { OrderDelivery } from '@unchainedshop/core-orders';
+import { OrderPayment } from '@unchainedshop/core-orders';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log, LogLevel } from '@unchainedshop/logger';
-import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
-import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
-import { OrdersSchema } from '../db/OrdersSchema.js';
+import {
+  Address,
+  Contact,
+  generateDbFilterById,
+  generateDbObjectId,
+  mongodb,
+} from '@unchainedshop/mongodb';
+import { OrderPosition } from '@unchainedshop/core-orders';
+
+export interface OrderMutations {
+  create: (doc: {
+    userId: string;
+    billingAddress?: Address;
+    contact?: Contact;
+    countryCode: string;
+    currency: string;
+    orderNumber?: string;
+    originEnrollmentId?: string;
+  }) => Promise<Order>;
+
+  delete: (orderId: string) => Promise<number>;
+
+  setCartOwner: (params: { orderId: string; userId: string }) => Promise<void>;
+  moveCartPositions: (params: { fromOrderId: string; toOrderId: string }) => Promise<void>;
+
+  setDeliveryProvider: (
+    orderId: string,
+    deliveryProviderId: string,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<Order>;
+  setPaymentProvider: (
+    orderId: string,
+    paymentProviderId: string,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<Order>;
+
+  updateBillingAddress: (orderId: string, billingAddress: Address) => Promise<Order>;
+  updateContact: (orderId: string, contact: Contact) => Promise<Order>;
+  updateContext: (orderId: string, context: any) => Promise<Order | null>;
+}
 
 const ORDER_EVENTS: string[] = [
   'ORDER_CREATE',
@@ -21,26 +57,18 @@ export const configureOrderModuleMutations = ({
   OrderDeliveries,
   OrderPayments,
   OrderPositions,
-  initProviders,
-  updateCalculation,
 }: {
   Orders: mongodb.Collection<Order>;
   OrderDeliveries: mongodb.Collection<OrderDelivery>;
   OrderPayments: mongodb.Collection<OrderPayment>;
   OrderPositions: mongodb.Collection<OrderPosition>;
-  initProviders: OrdersModule['initProviders'];
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderMutations => {
   registerEvents(ORDER_EVENTS);
 
-  const mutations = generateDbMutations<Order>(Orders, OrdersSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<Order>;
-
   return {
     create: async ({ userId, orderNumber, currency, countryCode, billingAddress, contact }) => {
-      const orderId = await mutations.create({
+      const { insertedId: orderId } = await Orders.insertOne({
+        _id: generateDbObjectId(),
         created: new Date(),
         status: null,
         billingAddress,
@@ -60,30 +88,11 @@ export const configureOrderModuleMutations = ({
     },
 
     delete: async (orderId) => {
-      const deletedCount = await mutations.delete(orderId);
+      const { deletedCount } = await Orders.deleteOne({ _id: orderId });
       await emit('ORDER_REMOVE', { orderId });
       return deletedCount;
     },
 
-    initProviders,
-
-    invalidateProviders: async (unchainedAPI, maxAgeDays = 30) => {
-      log('Orders: Start invalidating cart providers', {
-        level: LogLevel.Verbose,
-      });
-
-      const ONE_DAY_IN_MILLISECONDS = 86400000;
-
-      const minValidDate = new Date(new Date().getTime() - maxAgeDays * ONE_DAY_IN_MILLISECONDS);
-
-      const orders = await Orders.find({
-        status: { $eq: null },
-        updated: { $gte: minValidDate },
-      }).toArray();
-
-      await Promise.all(orders.map((order) => initProviders(order, unchainedAPI)));
-    },
-
     setCartOwner: async ({ orderId, userId }) => {
       await Orders.updateOne(generateDbFilterById(orderId), {
         $set: {
@@ -103,8 +112,7 @@ export const configureOrderModuleMutations = ({
       );
     },
 
-    setDeliveryProvider: async (orderId, deliveryProviderId, unchainedAPI) => {
-      const { modules } = unchainedAPI;
+    setDeliveryProvider: async (orderId, deliveryProviderId, { modules }) => {
       const delivery = await OrderDeliveries.findOne({
         orderId,
         deliveryProviderId,
@@ -121,17 +129,17 @@ export const configureOrderModuleMutations = ({
           })
         )._id;
 
-      log(`Set Delivery Provider ${deliveryProviderId}`, { orderId });
-
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          deliveryId,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            deliveryId,
+            updated: new Date(),
+          },
         },
-      });
-
-      const order = await updateCalculation(orderId, unchainedAPI);
+        { returnDocument: 'after' },
+      );
 
       await emit('ORDER_SET_DELIVERY_PROVIDER', {
         order,
@@ -159,14 +167,14 @@ export const configureOrderModuleMutations = ({
             status: null,
           })
         )._id;
-      log(`Set Payment Provider ${paymentProviderId}`, { orderId });
-
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: { paymentId, updated: new Date() },
-      });
-
-      const order = await updateCalculation(orderId, unchainedAPI);
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: { paymentId, updated: new Date() },
+        },
+        { returnDocument: 'after' },
+      );
 
       await emit('ORDER_SET_PAYMENT_PROVIDER', {
         order,
@@ -176,45 +184,46 @@ export const configureOrderModuleMutations = ({
       return order;
     },
 
-    updateBillingAddress: async (orderId, billingAddress, unchainedAPI) => {
-      log('Update Invoicing Address', { orderId });
-
+    updateBillingAddress: async (orderId, billingAddress) => {
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          billingAddress,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            billingAddress,
+            updated: new Date(),
+          },
         },
-      });
+        { returnDocument: 'after' },
+      );
 
-      const order = await updateCalculation(orderId, unchainedAPI);
       await emit('ORDER_UPDATE', { order, field: 'billing' });
       return order;
     },
 
-    updateContact: async (orderId, contact, unchainedAPI) => {
-      log('Update Contact', { orderId });
-
+    updateContact: async (orderId, contact) => {
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          contact,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            contact,
+            updated: new Date(),
+          },
         },
-      });
+        { returnDocument: 'after' },
+      );
 
-      const order = await updateCalculation(orderId, unchainedAPI);
       await emit('ORDER_UPDATE', { order, field: 'contact' });
       return order;
     },
 
-    updateContext: async (orderId, context, unchainedAPI) => {
+    updateContext: async (orderId, context) => {
       const selector = generateDbFilterById<Order>(orderId);
       selector.status = { $in: [null, OrderStatus.PENDING] };
 
       if (!context || Object.keys(context).length === 0) return Orders.findOne(selector, {});
 
-      log('Update Arbitrary Context', { orderId, context });
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
@@ -226,17 +235,14 @@ export const configureOrderModuleMutations = ({
             updated: new Date(),
           },
         },
-        { includeResultMetadata: true },
+        { includeResultMetadata: true, returnDocument: 'after' },
       );
 
       if (result.ok) {
-        const calculatedOrder = await updateCalculation(orderId, unchainedAPI);
-        await emit('ORDER_UPDATE', { order: calculatedOrder, field: 'context' });
-        return calculatedOrder;
+        await emit('ORDER_UPDATE', { order: result.value, field: 'context' });
+        return result.value;
       }
       return null;
     },
-
-    updateCalculation,
   };
 };

package/src/module/configureOrdersModule-processing.ts

@@ -1,15 +1,41 @@
 import { mongodb, generateDbFilterById } from '@unchainedshop/mongodb';
-import { Order, OrderStatus, OrderProcessing, OrdersModule } from '@unchainedshop/types/orders.js';
-import type { Locker } from '@kontsedal/locco';
-import { OrderDelivery } from '@unchainedshop/types/orders.deliveries.js';
-import { OrderPayment } from '@unchainedshop/types/orders.payments.js';
-import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
+import { ProductTypes } from '@unchainedshop/core-products';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-import { ProductType } from '@unchainedshop/types/products.js';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+
+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',
@@ -40,7 +66,7 @@ export const configureOrderModuleProcessing = ({
     return findNewOrderNumber(order, index + 1);
   };
 
-  const updateStatus: OrdersModule['updateStatus'] = async (orderId, { status, info }) => {
+  const updateStatus: OrderProcessing['updateStatus'] = async (orderId, { status, info }) => {
     const selector = generateDbFilterById(orderId);
     const order = await Orders.findOne(selector, {});
 
@@ -94,7 +120,6 @@ export const configureOrderModuleProcessing = ({
     );
 
     if (modificationResult.ok) {
-      log(`New Status: ${status}`, { orderId });
       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 });
@@ -149,11 +174,6 @@ export const configureOrderModuleProcessing = ({
     const validationErrors = await Promise.all(
       orderPositions.map(async (orderPosition) => {
         const errors = [];
-
-        log(`OrderPosition ${orderPosition._id} -> Validate ${orderPosition.quantity}`, {
-          orderId: orderPosition.orderId,
-        });
-
         const product = await unchainedAPI.modules.products.findProduct({
           productId: orderPosition.productId,
         });
@@ -292,7 +312,7 @@ export const configureOrderModuleProcessing = ({
         await services.orders.nextUserCart(
           {
             user,
-            countryCode: locale.country,
+            countryCode: locale.region,
           },
           unchainedAPI,
         );
@@ -428,7 +448,7 @@ export const configureOrderModuleProcessing = ({
             }),
           );
           const tokenizedItems = mappedProductOrderPositions.filter(
-            (item) => item.product?.type === ProductType.TokenizedProduct,
+            (item) => item.product?.type === ProductTypes.TokenizedProduct,
           );
           if (tokenizedItems.length > 0) {
             // Give virtual warehouse a chance to instantiate new virtual objects
@@ -443,7 +463,7 @@ export const configureOrderModuleProcessing = ({
 
           // Enrollments: Generate enrollments for plan products
           const planItems = mappedProductOrderPositions.filter(
-            (item) => item.product?.type === ProductType.PlanProduct && !order.originEnrollmentId,
+            (item) => item.product?.type === ProductTypes.PlanProduct && !order.originEnrollmentId,
           );
           if (planItems.length > 0) {
             await modules.enrollments.createFromCheckout(
@@ -475,11 +495,6 @@ export const configureOrderModuleProcessing = ({
               );
             }),
           );
-
-          // TODO: we will use this function to keep a "Ordered in Flight" amount, allowing us to
-          // do live stock stuff
-          // 2. Reserve quantity at Warehousing Provider until order is CANCELLED/FULLFILLED
-          // ???
         }
 
         nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);