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

package/src/module/configureOrderPositionsModule.ts

@@ -1,78 +1,7 @@
-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 { OrderPosition } from '../types.js';
 import { emit, registerEvents } from '@unchainedshop/events';
 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>;
-};
+import { PricingCalculation } from '@unchainedshop/utils';
 
 const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_UPDATE_CART_ITEM',
@@ -91,43 +20,24 @@ export const configureOrderPositionsModule = ({
   OrderPositions,
 }: {
   OrderPositions: mongodb.Collection<OrderPosition>;
-}): OrderPositionsModule => {
+}) => {
   registerEvents(ORDER_POSITION_EVENTS);
 
   return {
     // Queries
-    findOrderPosition: async ({ itemId }, options) => {
+    findOrderPosition: async (
+      { itemId }: { itemId: string },
+      options?: mongodb.FindOptions,
+    ): Promise<OrderPosition> => {
       return OrderPositions.findOne(buildFindByIdSelector(itemId), options);
     },
 
-    findOrderPositions: async ({ orderId }) => {
+    findOrderPositions: async ({ orderId }: { orderId: string }): Promise<OrderPosition[]> => {
       const positions = OrderPositions.find({ orderId, quantity: { $gt: 0 } });
       return positions.toArray();
     },
 
-    // Transformations
-    discounts: (orderPosition, { order, orderDiscount }, unchainedAPI) => {
-      const pricingSheet = unchainedAPI.modules.orders.positions.pricingSheet(
-        orderPosition,
-        order.currency,
-        unchainedAPI,
-      );
-
-      return pricingSheet.discountPrices(orderDiscount._id).map((discount) => ({
-        item: orderPosition,
-        ...discount,
-      }));
-    },
-
-    pricingSheet: (orderPosition, currency, { modules }) => {
-      return modules.products.pricingSheet({
-        calculation: orderPosition.calculation,
-        currency,
-        quantity: orderPosition.quantity,
-      });
-    },
-
-    delete: async (orderPositionId) => {
+    delete: async (orderPositionId: string): Promise<OrderPosition> => {
       const selector = buildFindByIdSelector(orderPositionId);
       const orderPosition = await OrderPositions.findOneAndDelete(selector, {});
       await emit('ORDER_REMOVE_CART_ITEM', {
@@ -136,52 +46,45 @@ export const configureOrderPositionsModule = ({
       return { ...orderPosition, calculation: [] };
     },
 
-    removePositions: async ({ orderId }) => {
+    removePositions: async ({ orderId }: { orderId: string }): Promise<number> => {
       const result = await OrderPositions.deleteMany({ orderId });
       await emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
       return result.deletedCount;
     },
 
-    updateProductItem: async (
-      { quantity, configuration },
-      { order, product, orderPosition },
-      unchainedAPI,
-    ) => {
-      const selector = buildFindByIdSelector(orderPosition._id, order._id);
+    updateProductItem: async ({
+      orderPositionId,
+      quantity,
+      configuration,
+    }: {
+      orderPositionId: string;
+      configuration?: Array<{ key: string; value: string }>;
+      quantity?: number;
+    }): Promise<OrderPosition> => {
       const modifier: any = {
         $set: {
           updated: new Date(),
         },
       };
 
-      if (quantity !== null && quantity !== orderPosition.quantity) {
+      if (quantity !== null) {
         modifier.$set.quantity = quantity;
       }
 
       if (configuration !== null) {
-        const resolvedProduct = await unchainedAPI.modules.products.resolveOrderableProduct(
-          product,
-          { configuration },
-          unchainedAPI,
-        );
-        modifier.$set.productId = resolvedProduct._id;
         modifier.$set.configuration = configuration;
       }
 
-      await ordersSettings.validateOrderPosition(
+      const updatedOrderPosition = await OrderPositions.findOneAndUpdate(
         {
-          order,
-          product,
-          configuration,
-          quantityDiff: quantity - orderPosition.quantity,
+          _id: orderPositionId,
+        },
+        modifier,
+        {
+          returnDocument: 'after',
         },
-        unchainedAPI,
       );
 
-      const updatedOrderPosition = await OrderPositions.findOneAndUpdate(selector, modifier, {
-        returnDocument: 'after',
-      });
-
       await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
       });
@@ -189,7 +92,7 @@ export const configureOrderPositionsModule = ({
       return updatedOrderPosition;
     },
 
-    removeProductByIdFromAllOpenPositions: async (productId) => {
+    removeProductByIdFromAllOpenPositions: async (productId: string): Promise<Array<string>> => {
       const positions = await OrderPositions.aggregate([
         {
           $match: {
@@ -225,56 +128,9 @@ export const configureOrderPositionsModule = ({
       return orderIdsToRecalculate;
     },
 
-    updateScheduling: async ({ order, orderDelivery, orderPosition }, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-      // scheduling (store in db for auditing)
-      const product = await modules.products.findProduct({
-        productId: orderPosition.productId,
-      });
-      const deliveryProvider =
-        orderDelivery &&
-        (await modules.delivery.findProvider({
-          deliveryProviderId: orderDelivery.deliveryProviderId,
-        }));
-      const { countryCode, userId } = order;
-
-      const scheduling = await Promise.all(
-        (
-          await modules.warehousing.findSupported(
-            {
-              product,
-              deliveryProvider,
-            },
-            unchainedAPI,
-          )
-        ).map(async (warehousingProvider) => {
-          const context = {
-            warehousingProvider,
-            deliveryProvider,
-            product,
-            item: orderPosition,
-            delivery: deliveryProvider,
-            order,
-            userId,
-            country: countryCode,
-            referenceDate: order.ordered,
-            quantity: orderPosition.quantity,
-          };
-          const dispatch = await unchainedAPI.modules.warehousing.estimatedDispatch(
-            warehousingProvider,
-            context,
-            unchainedAPI,
-          );
-
-          return {
-            warehousingProviderId: warehousingProvider._id,
-            ...dispatch,
-          };
-        }),
-      );
-
+    updateScheduling: async (orderPositionId, scheduling): Promise<OrderPosition> => {
       return OrderPositions.findOneAndUpdate(
-        generateDbFilterById(orderPosition._id),
+        generateDbFilterById(orderPositionId),
         {
           $set: { scheduling },
         },
@@ -284,13 +140,12 @@ export const configureOrderPositionsModule = ({
       );
     },
 
-    updateCalculation: async (orderPosition, unchainedAPI) => {
-      const calculation = await unchainedAPI.modules.products.calculate(
-        { item: orderPosition, configuration: orderPosition.configuration },
-        unchainedAPI,
-      );
+    updateCalculation: async <T extends PricingCalculation>(
+      orderPositionId: string,
+      calculation: Array<T>,
+    ): Promise<OrderPosition> => {
       return OrderPositions.findOneAndUpdate(
-        buildFindByIdSelector(orderPosition._id),
+        { _id: orderPositionId },
         {
           $set: { calculation },
         },
@@ -300,34 +155,22 @@ export const configureOrderPositionsModule = ({
       );
     },
 
-    addProductItem: async (orderPosition: OrderPosition, { order, product }, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-      const { configuration, orderId: positionOrderId, quantity, ...scope } = orderPosition;
-      const orderId = order._id || positionOrderId;
-
-      // Resolve product
-      const resolvedProduct = await modules.products.resolveOrderableProduct(
-        product,
-        { configuration },
-        unchainedAPI,
-      );
-
-      // Validate add to cart mutation
-      await ordersSettings.validateOrderPosition(
-        {
-          order,
-          product,
-          configuration,
-          quantityDiff: quantity,
-        },
-        unchainedAPI,
-      );
+    addProductItem: async (orderPosition: {
+      context?: any;
+      configuration?: Array<{ key: string; value: string }>;
+      orderId: string;
+      originalProductId: string;
+      productId: string;
+      quantity: number;
+      quotationId?: string;
+    }): Promise<OrderPosition> => {
+      const { configuration, orderId, originalProductId, productId, quantity, ...scope } = orderPosition;
 
       // Search for existing position
       const selector: mongodb.Filter<OrderPosition> = {
         orderId,
-        productId: resolvedProduct._id,
-        originalProductId: product._id,
+        productId,
+        originalProductId,
         configuration: configuration || { $in: [null, undefined] },
         ...scope,
       };
@@ -345,8 +188,8 @@ export const configureOrderPositionsModule = ({
             calculation: [],
             scheduling: [],
             orderId,
-            productId: resolvedProduct._id,
-            originalProductId: product._id,
+            productId,
+            originalProductId,
             configuration,
             ...scope,
           },
@@ -360,5 +203,11 @@ export const configureOrderPositionsModule = ({
 
       return upsertedOrderPosition;
     },
+    deleteOrderPositions: async (orderId: string) => {
+      const { deletedCount } = await OrderPositions.deleteMany({ orderId });
+      return deletedCount;
+    },
   };
 };
+
+export type OrderPositionsModule = ReturnType<typeof configureOrderPositionsModule>;

package/src/module/configureOrdersModule-mutations.ts

@@ -1,7 +1,4 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import { Order, OrderStatus } from '../types.js';
-import { OrderDelivery } from '@unchainedshop/core-orders';
-import { OrderPayment } from '@unchainedshop/core-orders';
+import { Order, OrderStatus, OrderPosition } from '../types.js';
 import { emit, registerEvents } from '@unchainedshop/events';
 import {
   Address,
@@ -10,7 +7,6 @@ import {
   generateDbObjectId,
   mongodb,
 } from '@unchainedshop/mongodb';
-import { OrderPosition } from '@unchainedshop/core-orders';
 
 export interface OrderMutations {
   create: (doc: {
@@ -28,20 +24,10 @@ export interface OrderMutations {
   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>;
+  updateContext: (orderId: string, context: any) => Promise<Order>;
+  updateCalculationSheet: (orderId: string, calculation) => Promise<Order>;
 }
 
 const ORDER_EVENTS: string[] = [
@@ -54,13 +40,9 @@ const ORDER_EVENTS: string[] = [
 
 export const configureOrderModuleMutations = ({
   Orders,
-  OrderDeliveries,
-  OrderPayments,
   OrderPositions,
 }: {
   Orders: mongodb.Collection<Order>;
-  OrderDeliveries: mongodb.Collection<OrderDelivery>;
-  OrderPayments: mongodb.Collection<OrderPayment>;
   OrderPositions: mongodb.Collection<OrderPosition>;
 }): OrderMutations => {
   registerEvents(ORDER_EVENTS);
@@ -112,109 +94,54 @@ export const configureOrderModuleMutations = ({
       );
     },
 
-    setDeliveryProvider: async (orderId, deliveryProviderId, { modules }) => {
-      const delivery = await OrderDeliveries.findOne({
-        orderId,
-        deliveryProviderId,
-      });
-      const deliveryId =
-        delivery?._id ||
-        (
-          await modules.orders.deliveries.create({
-            calculation: [],
-            deliveryProviderId,
-            log: [],
-            orderId,
-            status: null,
-          })
-        )._id;
-
+    updateBillingAddress: async (orderId, billingAddress) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
         {
           $set: {
-            deliveryId,
+            billingAddress,
             updated: new Date(),
           },
         },
         { returnDocument: 'after' },
       );
 
-      await emit('ORDER_SET_DELIVERY_PROVIDER', {
-        order,
-        deliveryProviderId,
-      });
-
-      return order;
-    },
-
-    setPaymentProvider: async (orderId, paymentProviderId, unchainedAPI) => {
-      const { modules } = unchainedAPI;
-      const payment = await OrderPayments.findOne({
-        orderId,
-        paymentProviderId,
-      });
-
-      const paymentId =
-        payment?._id ||
-        (
-          await modules.orders.payments.create({
-            calculation: [],
-            paymentProviderId,
-            log: [],
-            orderId,
-            status: null,
-          })
-        )._id;
-      const selector = generateDbFilterById(orderId);
-      const order = await Orders.findOneAndUpdate(
-        selector,
-        {
-          $set: { paymentId, updated: new Date() },
-        },
-        { returnDocument: 'after' },
-      );
-
-      await emit('ORDER_SET_PAYMENT_PROVIDER', {
-        order,
-        paymentProviderId,
-      });
-
+      await emit('ORDER_UPDATE', { order, field: 'billing' });
       return order;
     },
 
-    updateBillingAddress: async (orderId, billingAddress) => {
+    updateContact: async (orderId, contact) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
         {
           $set: {
-            billingAddress,
+            contact,
             updated: new Date(),
           },
         },
         { returnDocument: 'after' },
       );
 
-      await emit('ORDER_UPDATE', { order, field: 'billing' });
+      await emit('ORDER_UPDATE', { order, field: 'contact' });
       return order;
     },
 
-    updateContact: async (orderId, contact) => {
+    updateCalculationSheet: async (orderId, calculation) => {
       const selector = generateDbFilterById(orderId);
       const order = await Orders.findOneAndUpdate(
         selector,
         {
           $set: {
-            contact,
+            calculation,
             updated: new Date(),
           },
         },
         { returnDocument: 'after' },
       );
 
-      await emit('ORDER_UPDATE', { order, field: 'contact' });
+      await emit('ORDER_UPDATE', { order, field: 'calculation' });
       return order;
     },
 

package/src/module/configureOrdersModule-queries.ts

@@ -1,26 +1,7 @@
-import { SortDirection, SortOption } from '@unchainedshop/utils';
+import { SortDirection, SortOption, DateFilterInput } from '@unchainedshop/utils';
 import { Order, OrderQuery, OrderReport } from '../types.js';
 import { generateDbFilterById, buildSortOptions, mongodb } from '@unchainedshop/mongodb';
-
-export const buildFindSelector = ({ includeCarts, status, userId, queryString }: OrderQuery) => {
-  const selector: mongodb.Filter<Order> = {};
-
-  if (userId) {
-    selector.userId = userId;
-  }
-
-  if (Array.isArray(status) && status?.length) {
-    selector.status = { $in: status };
-  } else if (!includeCarts) {
-    selector.status = { $ne: null }; // TODO: Slow performance! IDXSCAN in common query!
-  }
-
-  if (queryString) {
-    (selector as any).$text = { $search: queryString };
-  }
-
-  return selector;
-};
+import buildFindSelector from './buildFindSelector.js';
 
 const normalizeOrderAggregateResult = (data = {}): OrderReport => {
   const statusToFieldMap = {
@@ -39,11 +20,41 @@ const normalizeOrderAggregateResult = (data = {}): OrderReport => {
 
 export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Collection<Order> }) => {
   return {
+    isCart: (order: Order) => {
+      return order.status === null;
+    },
+
+    cart: async ({
+      orderNumber,
+      countryContext,
+      userId,
+    }: {
+      countryContext?: string;
+      orderNumber?: string;
+      userId: string;
+    }): Promise<Order> => {
+      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);
+    },
+
     count: async (query: OrderQuery): Promise<number> => {
       const orderCount = await Orders.countDocuments(buildFindSelector(query));
       return orderCount;
     },
-
     findOrder: async (
       {
         orderId,
@@ -58,6 +69,19 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
       return Orders.findOne(selector, options);
     },
 
+    findCartsToInvalidate: async (maxAgeDays = 30) => {
+      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();
+
+      return orders;
+    },
+
     findOrders: async (
       {
         limit,
@@ -91,16 +115,16 @@ export const configureOrdersModuleQueries = ({ Orders }: { Orders: mongodb.Colle
       return Orders.find(selector, findOptions).toArray();
     },
 
-    getReport: async (params?: { from?: Date; to?: Date }): Promise<OrderReport> => {
-      const { from, to } = params || {};
+    getReport: async (params: { dateRange?: DateFilterInput }): Promise<OrderReport> => {
+      const { dateRange } = params || {};
       const selector: any = { $exists: true };
-      if (from || to) {
-        if (from) {
-          const fromDate = new Date(from);
+      if (dateRange?.end || dateRange?.start) {
+        if (dateRange?.start) {
+          const fromDate = new Date(dateRange?.start);
           selector.$gte = fromDate;
         }
-        if (to) {
-          const toDate = new Date(to);
+        if (dateRange?.end) {
+          const toDate = new Date(dateRange?.end);
           selector.$lte = toDate;
         }
       }