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

package/src/module/configureOrderPositionsModule.ts

@@ -15,7 +15,7 @@ const ORDER_POSITION_EVENTS: string[] = [
   'ORDER_ADD_PRODUCT',
 ];
 
-const buildFindByIdSelector = (orderPositionId: string, orderId?: string) =>
+export const buildFindByIdSelector = (orderPositionId: string, orderId?: string) =>
   generateDbFilterById(orderPositionId, orderId ? { orderId } : undefined) as Filter<OrderPosition>;
 
 export const configureOrderPositionsModule = ({
@@ -44,11 +44,11 @@ export const configureOrderPositionsModule = ({
     },
 
     // Transformations
-    discounts: (orderPosition, { order, orderDiscount }, requestContext) => {
-      const pricingSheet = requestContext.modules.orders.positions.pricingSheet(
+    discounts: (orderPosition, { order, orderDiscount }, unchainedAPI) => {
+      const pricingSheet = unchainedAPI.modules.orders.positions.pricingSheet(
         orderPosition,
         order.currency,
-        requestContext,
+        unchainedAPI,
       );
 
       return pricingSheet.discountPrices(orderDiscount._id).map((discount) => ({
@@ -70,7 +70,7 @@ export const configureOrderPositionsModule = ({
     create: async (
       { configuration, context, quantity, quotationId },
       { order, product, originalProduct },
-      requestContext,
+      unchainedAPI,
     ) => {
       const orderId = order._id;
       const productId = product._id;
@@ -80,30 +80,27 @@ export const configureOrderPositionsModule = ({
         `Create ${quantity}x Position with Product ${productId} ${
           quotationId ? ` (${quotationId})` : ''
         }`,
-        { orderId, productId, originalProductId, userId: requestContext.userId },
+        { orderId, productId, originalProductId },
       );
 
-      const positionId = await mutations.create(
-        {
-          orderId,
-          productId,
-          originalProductId,
-          quotationId,
-          quantity,
-          configuration,
-          context,
-          calculation: [],
-          scheduling: [],
-        },
-        requestContext.userId,
-      );
+      const positionId = await mutations.create({
+        orderId,
+        productId,
+        originalProductId,
+        quotationId,
+        quantity,
+        configuration,
+        context,
+        calculation: [],
+        scheduling: [],
+      });
 
-      await updateCalculation(orderId, requestContext);
+      await updateCalculation(orderId, unchainedAPI);
 
       return OrderPositions.findOne(buildFindByIdSelector(positionId));
     },
 
-    delete: async (orderPositionId, requestContext) => {
+    delete: async (orderPositionId, unchainedAPI) => {
       const selector = buildFindByIdSelector(orderPositionId);
       const orderPosition = await OrderPositions.findOne(selector, {});
 
@@ -113,23 +110,23 @@ export const configureOrderPositionsModule = ({
 
       await OrderPositions.deleteOne(selector);
 
-      await updateCalculation(orderPosition.orderId, requestContext);
+      await updateCalculation(orderPosition.orderId, unchainedAPI);
 
-      emit('ORDER_REMOVE_CART_ITEM', {
+      await emit('ORDER_REMOVE_CART_ITEM', {
         orderPosition,
       });
 
       return { ...orderPosition, calculation: [] };
     },
 
-    removePositions: async ({ orderId }, requestContext) => {
+    removePositions: async ({ orderId }, unchainedAPI) => {
       log('Remove Positions', { orderId });
 
       const result = await OrderPositions.deleteMany({ orderId });
 
-      await updateCalculation(orderId, requestContext);
+      await updateCalculation(orderId, unchainedAPI);
 
-      emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
+      await emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
 
       return result.deletedCount;
     },
@@ -137,13 +134,12 @@ export const configureOrderPositionsModule = ({
     updateProductItem: async (
       { quantity, configuration },
       { order, product, orderPosition },
-      requestContext,
+      unchainedAPI,
     ) => {
       const selector = buildFindByIdSelector(orderPosition._id, order._id);
       const modifier: any = {
         $set: {
           updated: new Date(),
-          updatedBy: requestContext.userId,
         },
       };
 
@@ -152,10 +148,10 @@ export const configureOrderPositionsModule = ({
       }
 
       if (configuration !== null) {
-        const resolvedProduct = await requestContext.modules.products.resolveOrderableProduct(
+        const resolvedProduct = await unchainedAPI.modules.products.resolveOrderableProduct(
           product,
           { configuration },
-          requestContext,
+          unchainedAPI,
         );
         modifier.$set.productId = resolvedProduct._id;
         modifier.$set.configuration = configuration;
@@ -168,24 +164,41 @@ export const configureOrderPositionsModule = ({
           configuration,
           quantityDiff: quantity - orderPosition.quantity,
         },
-        requestContext,
+        unchainedAPI,
       );
 
       await OrderPositions.updateOne(selector, modifier);
 
-      await updateCalculation(order._id, requestContext);
+      await updateCalculation(order._id, unchainedAPI);
 
       const updatedOrderPosition = await OrderPositions.findOne(selector, {});
 
-      emit('ORDER_UPDATE_CART_ITEM', {
+      await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
       });
 
       return updatedOrderPosition;
     },
 
-    updateScheduling: async ({ order, orderDelivery, orderPosition }, requestContext) => {
-      const { modules } = requestContext;
+    removeProductByIdFromAllPositions: async ({ productId }, unchainedAPI) => {
+      log('Remove Position Product', { productId });
+      const positions = await OrderPositions.find(
+        { productId },
+        { projection: { orderId: 1 } },
+      ).toArray();
+
+      const result = await OrderPositions.deleteMany({ productId });
+
+      await Promise.all(
+        positions.map(async ({ orderId }) => {
+          await updateCalculation(orderId, unchainedAPI);
+        }),
+      );
+      return result.deletedCount;
+    },
+
+    updateScheduling: async ({ order, orderDelivery, orderPosition }, unchainedAPI) => {
+      const { modules } = unchainedAPI;
       // scheduling (store in db for auditing)
       const product = await modules.products.findProduct({
         productId: orderPosition.productId,
@@ -204,7 +217,7 @@ export const configureOrderPositionsModule = ({
               product,
               deliveryProvider,
             },
-            requestContext,
+            unchainedAPI,
           )
         ).map(async (warehousingProvider) => {
           const context = {
@@ -219,10 +232,10 @@ export const configureOrderPositionsModule = ({
             referenceDate: order.ordered,
             quantity: orderPosition.quantity,
           };
-          const dispatch = await requestContext.modules.warehousing.estimatedDispatch(
+          const dispatch = await unchainedAPI.modules.warehousing.estimatedDispatch(
             warehousingProvider,
             context,
-            requestContext,
+            unchainedAPI,
           );
 
           return {
@@ -239,14 +252,14 @@ export const configureOrderPositionsModule = ({
       return OrderPositions.findOne(generateDbFilterById(orderPosition._id), {});
     },
 
-    updateCalculation: async (orderPosition, requestContext) => {
+    updateCalculation: async (orderPosition, unchainedAPI) => {
       log(`OrderPosition ${orderPosition._id} -> Update Calculation`, {
         orderId: orderPosition.orderId,
       });
 
-      const calculation = await requestContext.modules.products.calculate(
+      const calculation = await unchainedAPI.modules.products.calculate(
         { item: orderPosition, configuration: orderPosition.configuration },
-        requestContext,
+        unchainedAPI,
       );
       const selector = buildFindByIdSelector(orderPosition._id);
 
@@ -257,8 +270,8 @@ export const configureOrderPositionsModule = ({
       return OrderPositions.findOne(selector, {});
     },
 
-    addProductItem: async (orderPosition: OrderPosition, { order, product }, requestContext) => {
-      const { modules } = requestContext;
+    addProductItem: async (orderPosition: OrderPosition, { order, product }, unchainedAPI) => {
+      const { modules } = unchainedAPI;
       const { configuration, orderId: positionOrderId, quantity, ...scope } = orderPosition;
       const orderId = order._id || positionOrderId;
 
@@ -266,7 +279,7 @@ export const configureOrderPositionsModule = ({
       const resolvedProduct = await modules.products.resolveOrderableProduct(
         product,
         { configuration },
-        requestContext,
+        unchainedAPI,
       );
 
       // Validate add to cart mutation
@@ -277,7 +290,7 @@ export const configureOrderPositionsModule = ({
           configuration,
           quantityDiff: quantity,
         },
-        requestContext,
+        unchainedAPI,
       );
 
       // Search for existing position
@@ -294,13 +307,11 @@ export const configureOrderPositionsModule = ({
         {
           $set: {
             updated: new Date(),
-            updatedBy: requestContext.userId,
           },
           $inc: { quantity },
           $setOnInsert: {
             _id: generateDbObjectId(),
             created: new Date(),
-            createdBy: requestContext.userId,
             calculation: [],
             scheduling: [],
             orderId,
@@ -313,11 +324,11 @@ export const configureOrderPositionsModule = ({
         { upsert: true },
       );
 
-      await updateCalculation(orderId, requestContext);
+      await updateCalculation(orderId, unchainedAPI);
 
       const upsertedOrderPosition = await OrderPositions.findOne(selector);
 
-      emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });
+      await emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });
 
       return upsertedOrderPosition;
     },

package/src/module/configureOrdersModule-mutations.ts

@@ -6,7 +6,6 @@ import { OrderPayment } from '@unchainedshop/types/orders.payments';
 import { emit, registerEvents } from '@unchainedshop/events';
 import { log, LogLevel } from '@unchainedshop/logger';
 import { generateDbFilterById, generateDbMutations } from '@unchainedshop/utils';
-import { Context } from '@unchainedshop/types/api';
 import { OrdersSchema } from '../db/OrdersSchema';
 
 const ORDER_EVENTS: string[] = [
@@ -40,39 +39,35 @@ export const configureOrderModuleMutations = ({
   }) as ModuleMutations<Order>;
 
   return {
-    create: async ({ orderNumber, currency, countryCode, billingAddress, contact }, userId) => {
-      const orderId = await mutations.create(
-        {
-          created: new Date(),
-          createdBy: userId,
-          status: null,
-          billingAddress,
-          contact,
-          userId,
-          currency,
-          countryCode,
-          calculation: [],
-          log: [],
-          orderNumber,
-        },
+    create: async ({ userId, orderNumber, currency, countryCode, billingAddress, contact }) => {
+      const orderId = await mutations.create({
+        created: new Date(),
+        status: null,
+        billingAddress,
+        contact,
         userId,
-      );
+        currency,
+        countryCode,
+        calculation: [],
+        log: [],
+        orderNumber,
+      });
 
       const order = await Orders.findOne(generateDbFilterById(orderId), {});
 
-      emit('ORDER_CREATE', { order });
+      await emit('ORDER_CREATE', { order });
       return order;
     },
 
-    delete: async (orderId, userId) => {
-      const deletedCount = await mutations.delete(orderId, userId);
-      emit('ORDER_REMOVE', { orderId });
+    delete: async (orderId) => {
+      const deletedCount = await mutations.delete(orderId);
+      await emit('ORDER_REMOVE', { orderId });
       return deletedCount;
     },
 
     initProviders,
 
-    invalidateProviders: async (requestContext, maxAgeDays = 30) => {
+    invalidateProviders: async (unchainedAPI, maxAgeDays = 30) => {
       log('Orders: Start invalidating cart providers', {
         level: LogLevel.Verbose,
       });
@@ -86,11 +81,11 @@ export const configureOrderModuleMutations = ({
         updated: { $gte: minValidDate },
       }).toArray();
 
-      await Promise.all(orders.map((order) => initProviders(order, requestContext as Context))); // TODO: Refactor Types
+      await Promise.all(orders.map((order) => initProviders(order, unchainedAPI)));
     },
 
-    setDeliveryProvider: async (orderId, deliveryProviderId, requestContext) => {
-      const { modules } = requestContext;
+    setDeliveryProvider: async (orderId, deliveryProviderId, unchainedAPI) => {
+      const { modules } = unchainedAPI;
       const delivery = await OrderDeliveries.findOne({
         orderId,
         deliveryProviderId,
@@ -98,16 +93,13 @@ export const configureOrderModuleMutations = ({
       const deliveryId =
         delivery?._id ||
         (
-          await modules.orders.deliveries.create(
-            {
-              calculation: [],
-              deliveryProviderId,
-              log: [],
-              orderId,
-              status: null,
-            },
-            requestContext.userId,
-          )
+          await modules.orders.deliveries.create({
+            calculation: [],
+            deliveryProviderId,
+            log: [],
+            orderId,
+            status: null,
+          })
         )._id;
 
       log(`Set Delivery Provider ${deliveryProviderId}`, { orderId });
@@ -117,13 +109,12 @@ export const configureOrderModuleMutations = ({
         $set: {
           deliveryId,
           updated: new Date(),
-          updatedBy: requestContext.userId,
         },
       });
 
-      const order = await updateCalculation(orderId, requestContext);
+      const order = await updateCalculation(orderId, unchainedAPI);
 
-      emit('ORDER_SET_DELIVERY_PROVIDER', {
+      await emit('ORDER_SET_DELIVERY_PROVIDER', {
         order,
         deliveryProviderId,
       });
@@ -131,8 +122,8 @@ export const configureOrderModuleMutations = ({
       return order;
     },
 
-    setPaymentProvider: async (orderId, paymentProviderId, requestContext) => {
-      const { modules, userId } = requestContext;
+    setPaymentProvider: async (orderId, paymentProviderId, unchainedAPI) => {
+      const { modules } = unchainedAPI;
       const payment = await OrderPayments.findOne({
         orderId,
         paymentProviderId,
@@ -141,27 +132,24 @@ export const configureOrderModuleMutations = ({
       const paymentId =
         payment?._id ||
         (
-          await modules.orders.payments.create(
-            {
-              calculation: [],
-              paymentProviderId,
-              log: [],
-              orderId,
-              status: null,
-            },
-            userId,
-          )
+          await modules.orders.payments.create({
+            calculation: [],
+            paymentProviderId,
+            log: [],
+            orderId,
+            status: null,
+          })
         )._id;
       log(`Set Payment Provider ${paymentProviderId}`, { orderId });
 
       const selector = generateDbFilterById(orderId);
       await Orders.updateOne(selector, {
-        $set: { paymentId, updated: new Date(), updatedBy: userId },
+        $set: { paymentId, updated: new Date() },
       });
 
-      const order = await updateCalculation(orderId, requestContext);
+      const order = await updateCalculation(orderId, unchainedAPI);
 
-      emit('ORDER_SET_PAYMENT_PROVIDER', {
+      await emit('ORDER_SET_PAYMENT_PROVIDER', {
         order,
         paymentProviderId,
       });
@@ -169,7 +157,7 @@ export const configureOrderModuleMutations = ({
       return order;
     },
 
-    updateBillingAddress: async (orderId, billingAddress, requestContext) => {
+    updateBillingAddress: async (orderId, billingAddress, unchainedAPI) => {
       log('Update Invoicing Address', { orderId });
 
       const selector = generateDbFilterById(orderId);
@@ -177,16 +165,15 @@ export const configureOrderModuleMutations = ({
         $set: {
           billingAddress,
           updated: new Date(),
-          updatedBy: requestContext.userId,
         },
       });
 
-      const order = await updateCalculation(orderId, requestContext);
-      emit('ORDER_UPDATE', { order, field: 'billing' });
+      const order = await updateCalculation(orderId, unchainedAPI);
+      await emit('ORDER_UPDATE', { order, field: 'billing' });
       return order;
     },
 
-    updateContact: async (orderId, contact, requestContext) => {
+    updateContact: async (orderId, contact, unchainedAPI) => {
       log('Update Contact', { orderId });
 
       const selector = generateDbFilterById(orderId);
@@ -194,16 +181,15 @@ export const configureOrderModuleMutations = ({
         $set: {
           contact,
           updated: new Date(),
-          updatedBy: requestContext.userId,
         },
       });
 
-      const order = await updateCalculation(orderId, requestContext);
-      emit('ORDER_UPDATE', { order, field: 'contact' });
+      const order = await updateCalculation(orderId, unchainedAPI);
+      await emit('ORDER_UPDATE', { order, field: 'contact' });
       return order;
     },
 
-    updateContext: async (orderId, context, requestContext) => {
+    updateContext: async (orderId, context, unchainedAPI) => {
       if (!context) return false;
 
       log('Update Arbitrary Context', { orderId, context });
@@ -215,13 +201,12 @@ export const configureOrderModuleMutations = ({
         $set: {
           context: { ...(order.context || {}), ...context },
           updated: new Date(),
-          updatedBy: requestContext.userId,
         },
       });
 
       if (result.modifiedCount) {
-        const calculatedOrder = await updateCalculation(orderId, requestContext);
-        emit('ORDER_UPDATE', { order: calculatedOrder, field: 'context' });
+        const calculatedOrder = await updateCalculation(orderId, unchainedAPI);
+        await emit('ORDER_UPDATE', { order: calculatedOrder, field: 'context' });
         return true;
       }
       return false;