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

package/src/module/configureOrdersModule-processing.ts

@@ -1,4 +1,3 @@
-import { Context } from '@unchainedshop/types/api';
 import { Collection } from '@unchainedshop/types/common';
 import { Order, OrderStatus, OrderProcessing, OrdersModule } from '@unchainedshop/types/orders';
 import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
@@ -8,6 +7,7 @@ import { emit, registerEvents } from '@unchainedshop/events';
 import { log } from '@unchainedshop/logger';
 import { generateDbFilterById } from '@unchainedshop/utils';
 import { ProductType } from '@unchainedshop/types/products';
+import { UnchainedCore } from '@unchainedshop/types/core';
 import { ordersSettings } from '../orders-settings';
 
 const ORDER_PROCESSING_EVENTS: string[] = ['ORDER_CHECKOUT', 'ORDER_CONFIRMED', 'ORDER_FULLFILLED'];
@@ -48,7 +48,7 @@ export const configureOrderModuleProcessing = ({
     return errors;
   };
 
-  const itemValidationErrors = async (order: Order, { modules }: Context) => {
+  const itemValidationErrors = async (order: Order, { modules }: UnchainedCore) => {
     // Check if items are valid
     const orderPositions = await findOrderPositions(order);
     if (orderPositions.length === 0) {
@@ -87,8 +87,8 @@ export const configureOrderModuleProcessing = ({
     return validationErrors.flatMap((f) => f);
   };
 
-  const isAutoConfirmationEnabled = async (order: Order, requestContext: Context) => {
-    const { modules } = requestContext;
+  const isAutoConfirmationEnabled = async (order: Order, unchainedAPI: UnchainedCore) => {
+    const { modules } = unchainedAPI;
 
     if (order.status === OrderStatus.FULLFILLED || order.status === OrderStatus.CONFIRMED) {
       return false;
@@ -97,20 +97,20 @@ export const configureOrderModuleProcessing = ({
     const orderPayment = await findOrderPayment(order);
     let isBlockingOrderConfirmation =
       orderPayment &&
-      (await modules.orders.payments.isBlockingOrderConfirmation(orderPayment, requestContext));
+      (await modules.orders.payments.isBlockingOrderConfirmation(orderPayment, unchainedAPI));
     if (isBlockingOrderConfirmation) return false;
 
     const orderDelivery = await findOrderDelivery(order);
     isBlockingOrderConfirmation =
       orderDelivery &&
-      (await modules.orders.deliveries.isBlockingOrderConfirmation(orderDelivery, requestContext));
+      (await modules.orders.deliveries.isBlockingOrderConfirmation(orderDelivery, unchainedAPI));
     if (isBlockingOrderConfirmation) return false;
 
     return true;
   };
 
-  const isAutoFullfillmentEnabled = async (order: Order, requestContext: Context) => {
-    const { modules } = requestContext;
+  const isAutoFullfillmentEnabled = async (order: Order, unchainedAPI: UnchainedCore) => {
+    const { modules } = unchainedAPI;
 
     const orderPayment = await findOrderPayment(order);
     let isBlockingOrderFullfillment =
@@ -134,7 +134,7 @@ export const configureOrderModuleProcessing = ({
   const findNextStatus = async (
     status: OrderStatus | null,
     order: Order,
-    requestContext: Context,
+    unchainedAPI: UnchainedCore,
   ): Promise<OrderStatus> => {
     if (status === null) {
       if ((await missingInputDataForCheckout(order)).length === 0) {
@@ -144,14 +144,14 @@ export const configureOrderModuleProcessing = ({
     }
 
     if (status === OrderStatus.PENDING) {
-      if (await isAutoConfirmationEnabled(order, requestContext)) {
+      if (await isAutoConfirmationEnabled(order, unchainedAPI)) {
         await emit('ORDER_CONFIRMED', { order });
         return OrderStatus.CONFIRMED;
       }
     }
 
     if (status === OrderStatus.CONFIRMED) {
-      const isFullfilled = await isAutoFullfillmentEnabled(order, requestContext);
+      const isFullfilled = await isAutoFullfillmentEnabled(order, unchainedAPI);
       if (isFullfilled) {
         await emit('ORDER_FULLFILLED', { order });
         return OrderStatus.FULLFILLED;
@@ -162,17 +162,17 @@ export const configureOrderModuleProcessing = ({
   };
 
   return {
-    checkout: async (orderId, { orderContext, paymentContext, deliveryContext }, requestContext) => {
-      const { modules, localeContext, userId } = requestContext;
+    checkout: async (orderId, { orderContext, paymentContext, deliveryContext }, unchainedAPI) => {
+      const { modules } = unchainedAPI;
 
-      await modules.orders.updateContext(orderId, orderContext, requestContext);
+      await modules.orders.updateContext(orderId, orderContext, unchainedAPI);
       let order = await modules.orders.findOrder({ orderId });
 
       if (order.status !== null) return order;
 
       const errors = [
         ...(await missingInputDataForCheckout(order)),
-        ...(await itemValidationErrors(order, requestContext)),
+        ...(await itemValidationErrors(order, unchainedAPI)),
       ].filter(Boolean);
 
       if (errors.length > 0) {
@@ -186,33 +186,31 @@ export const configureOrderModuleProcessing = ({
           paymentContext,
           deliveryContext,
         },
-        requestContext,
+        unchainedAPI,
       );
 
       // After checkout, store last checkout information on user
-      await modules.users.updateLastBillingAddress(order.userId, order.billingAddress, userId);
-      await modules.users.updateLastContact(order.userId, order.contact, userId);
+      await modules.users.updateLastBillingAddress(order.userId, order.billingAddress);
+      await modules.users.updateLastContact(order.userId, order.contact);
 
       // Then ensure new cart is created before we return from checkout
       const user = await modules.users.findUserById(order.userId);
-      const locale = modules.users.userLocale(user, {
-        localeContext,
-      });
+      const locale = modules.users.userLocale(user);
       await modules.orders.ensureCartForUser(
         {
           user,
           countryCode: locale.country,
         },
-        requestContext,
+        unchainedAPI,
       );
 
       return order;
     },
 
-    confirm: async (orderId, { orderContext, paymentContext, deliveryContext }, requestContext) => {
-      const { modules } = requestContext;
+    confirm: async (orderId, { orderContext, paymentContext, deliveryContext }, unchainedAPI) => {
+      const { modules } = unchainedAPI;
 
-      await modules.orders.updateContext(orderId, orderContext, requestContext);
+      await modules.orders.updateContext(orderId, orderContext, unchainedAPI);
       const order = await modules.orders.findOrder({ orderId });
 
       if (order.status !== OrderStatus.PENDING) return order;
@@ -224,14 +222,14 @@ export const configureOrderModuleProcessing = ({
           deliveryContext,
           nextStatus: OrderStatus.CONFIRMED,
         },
-        requestContext,
+        unchainedAPI,
       );
     },
 
-    reject: async (orderId, { orderContext, paymentContext, deliveryContext }, requestContext) => {
-      const { modules } = requestContext;
+    reject: async (orderId, { orderContext, paymentContext, deliveryContext }, unchainedAPI) => {
+      const { modules } = unchainedAPI;
 
-      await modules.orders.updateContext(orderId, orderContext, requestContext);
+      await modules.orders.updateContext(orderId, orderContext, unchainedAPI);
       const order = await modules.orders.findOrder({ orderId });
 
       if (order.status !== OrderStatus.PENDING) return order;
@@ -243,12 +241,12 @@ export const configureOrderModuleProcessing = ({
           deliveryContext,
           nextStatus: OrderStatus.REJECTED,
         },
-        requestContext,
+        unchainedAPI,
       );
     },
 
-    ensureCartForUser: async ({ user, countryCode }, requestContext) => {
-      const { modules, services } = requestContext;
+    ensureCartForUser: async ({ user, countryCode }, unchainedAPI) => {
+      const { modules, services } = unchainedAPI;
 
       if (!ordersSettings.ensureUserHasCart) return null;
 
@@ -260,7 +258,7 @@ export const configureOrderModuleProcessing = ({
           user,
           countryCode,
         },
-        requestContext as Context,
+        unchainedAPI,
       );
     },
 
@@ -283,14 +281,14 @@ export const configureOrderModuleProcessing = ({
       );
     },
 
-    processOrder: async (initialOrder, params, requestContext) => {
-      const { modules } = requestContext;
+    processOrder: async (initialOrder, params, unchainedAPI) => {
+      const { modules } = unchainedAPI;
       const { paymentContext, deliveryContext, nextStatus: forceNextStatus } = params;
 
       const orderId = initialOrder._id;
       let order = initialOrder;
       let nextStatus =
-        forceNextStatus || (await findNextStatus(initialOrder.status, order, requestContext));
+        forceNextStatus || (await findNextStatus(initialOrder.status, order, unchainedAPI));
 
       if (nextStatus === OrderStatus.PENDING) {
         // auto charge during transition to pending
@@ -300,10 +298,10 @@ export const configureOrderModuleProcessing = ({
 
         await modules.orders.payments.charge(
           orderPayment,
-          { transactionContext: paymentContext },
-          requestContext,
+          { userId: order.userId, transactionContext: paymentContext },
+          unchainedAPI,
         );
-        nextStatus = await findNextStatus(nextStatus, order, requestContext);
+        nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);
       }
 
       if (nextStatus === OrderStatus.REJECTED) {
@@ -313,10 +311,10 @@ export const configureOrderModuleProcessing = ({
         });
         await modules.orders.payments.cancel(
           orderPayment,
-          { transactionContext: paymentContext },
-          requestContext,
+          { userId: order.userId, transactionContext: paymentContext },
+          unchainedAPI,
         );
-        nextStatus = await findNextStatus(nextStatus, order, requestContext);
+        nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);
       }
 
       if (nextStatus === OrderStatus.CONFIRMED) {
@@ -326,8 +324,8 @@ export const configureOrderModuleProcessing = ({
         });
         await modules.orders.payments.confirm(
           orderPayment,
-          { transactionContext: paymentContext },
-          requestContext,
+          { userId: order.userId, transactionContext: paymentContext },
+          unchainedAPI,
         );
 
         const orderDelivery = await modules.orders.deliveries.findDelivery({
@@ -343,7 +341,7 @@ export const configureOrderModuleProcessing = ({
               status: OrderStatus.CONFIRMED,
               info: 'before delivery',
             },
-            requestContext,
+            unchainedAPI,
           );
 
           await modules.orders.deliveries.send(
@@ -352,7 +350,7 @@ export const configureOrderModuleProcessing = ({
               order,
               deliveryContext,
             },
-            requestContext,
+            unchainedAPI,
           );
 
           const orderPositions = await findOrderPositions(order);
@@ -377,7 +375,7 @@ export const configureOrderModuleProcessing = ({
               {
                 items: tokenizedItems,
               },
-              requestContext,
+              unchainedAPI,
             );
           }
 
@@ -395,7 +393,7 @@ export const configureOrderModuleProcessing = ({
                   deliveryContext,
                 },
               },
-              requestContext,
+              unchainedAPI,
             );
           }
 
@@ -411,7 +409,7 @@ export const configureOrderModuleProcessing = ({
                   orderId,
                   orderPositionId: orderPosition._id,
                 },
-                requestContext,
+                unchainedAPI,
               );
             }),
           );
@@ -422,66 +420,58 @@ export const configureOrderModuleProcessing = ({
           // ???
         }
 
-        nextStatus = await findNextStatus(nextStatus, order, requestContext);
+        nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);
       }
 
       order = await updateStatus(
         order._id,
         { status: nextStatus, info: 'order processed' },
-        requestContext,
+        unchainedAPI,
       );
 
       if (initialOrder.status !== order.status) {
         if (order.status === OrderStatus.REJECTED) {
-          await modules.orders.sendOrderRejectionToCustomer(order, params, requestContext);
+          await modules.orders.sendOrderRejectionToCustomer(order, params, unchainedAPI);
         } else {
-          await modules.orders.sendOrderConfirmationToCustomer(order, params, requestContext);
+          await modules.orders.sendOrderConfirmationToCustomer(order, params, unchainedAPI);
         }
       }
 
       return order;
     },
 
-    sendOrderConfirmationToCustomer: async (order, params, { modules, localeContext, userId }) => {
+    sendOrderConfirmationToCustomer: async (order, params, { modules }) => {
       const user = await modules.users.findUserById(order.userId);
-      const locale = modules.users.userLocale(user, {
-        localeContext,
-      });
-      await modules.worker.addWork(
-        {
-          type: 'MESSAGE',
-          retries: 0,
-          input: {
-            ...params,
-            locale,
-            template: 'ORDER_CONFIRMATION',
-            orderId: order._id,
-          },
+      const locale = modules.users.userLocale(user);
+
+      await modules.worker.addWork({
+        type: 'MESSAGE',
+        retries: 0,
+        input: {
+          ...params,
+          locale,
+          template: 'ORDER_CONFIRMATION',
+          orderId: order._id,
         },
-        userId,
-      );
+      });
 
       return order;
     },
 
-    sendOrderRejectionToCustomer: async (order, params, { modules, localeContext, userId }) => {
+    sendOrderRejectionToCustomer: async (order, params, { modules }) => {
       const user = await modules.users.findUserById(order.userId);
-      const locale = modules.users.userLocale(user, {
-        localeContext,
-      });
-      await modules.worker.addWork(
-        {
-          type: 'MESSAGE',
-          retries: 0,
-          input: {
-            ...params,
-            locale,
-            template: 'ORDER_REJECTION',
-            orderId: order._id,
-          },
+      const locale = modules.users.userLocale(user);
+
+      await modules.worker.addWork({
+        type: 'MESSAGE',
+        retries: 0,
+        input: {
+          ...params,
+          locale,
+          template: 'ORDER_REJECTION',
+          orderId: order._id,
         },
-        userId,
-      );
+      });
 
       return order;
     },

package/src/module/configureOrdersModule-queries.ts

@@ -3,7 +3,7 @@ import { Collection, FindOptions, Query } from '@unchainedshop/types/common';
 import { Order, OrderQueries, OrderQuery } from '@unchainedshop/types/orders';
 import { generateDbFilterById, buildSortOptions } from '@unchainedshop/utils';
 
-const buildFindSelector = ({ includeCarts, status, userId, queryString }: OrderQuery) => {
+export const buildFindSelector = ({ includeCarts, status, userId, queryString }: OrderQuery) => {
   const selector: Query = {};
 
   if (userId) {

package/src/module/configureOrdersModule-transformations.ts

@@ -8,8 +8,8 @@ export const configureOrderModuleTransformations = ({
   Orders: Collection<Order>;
 }): OrderTransformations => {
   return {
-    discounted: async (order, orderDiscount, requestContext) => {
-      const { modules } = requestContext;
+    discounted: async (order, orderDiscount, unchainedAPI) => {
+      const { modules } = unchainedAPI;
 
       // Delivery discounts
       const orderDelivery = await modules.orders.deliveries.findDelivery({
@@ -18,7 +18,7 @@ export const configureOrderModuleTransformations = ({
       const orderDeliveryDiscounts = modules.orders.deliveries.discounts(
         orderDelivery,
         { order, orderDiscount },
-        requestContext,
+        unchainedAPI,
       );
 
       // Payment discounts
@@ -28,7 +28,7 @@ export const configureOrderModuleTransformations = ({
       const orderPaymentDiscounts = modules.orders.payments.discounts(
         orderPayment,
         { order, orderDiscount },
-        requestContext,
+        unchainedAPI,
       );
 
       // Position discounts
@@ -36,7 +36,7 @@ export const configureOrderModuleTransformations = ({
         orderId: order._id,
       });
       const orderPositionDiscounts = orderPositions.flatMap((orderPosition) =>
-        modules.orders.positions.discounts(orderPosition, { order, orderDiscount }, requestContext),
+        modules.orders.positions.discounts(orderPosition, { order, orderDiscount }, unchainedAPI),
       );
 
       // order discounts
@@ -60,8 +60,8 @@ export const configureOrderModuleTransformations = ({
       return discounted;
     },
 
-    discountTotal: async (order, orderDiscount, requestContext) => {
-      const { modules } = requestContext;
+    discountTotal: async (order, orderDiscount, unchainedAPI) => {
+      const { modules } = unchainedAPI;
       const orderDiscountId = orderDiscount._id;
 
       // Delivery discounts
@@ -71,7 +71,7 @@ export const configureOrderModuleTransformations = ({
       const orderDeliveryDiscountSum =
         orderDelivery &&
         modules.orders.deliveries
-          .pricingSheet(orderDelivery, order.currency, requestContext)
+          .pricingSheet(orderDelivery, order.currency, unchainedAPI)
           .discountSum(orderDiscountId);
 
       // Payment discounts
@@ -81,7 +81,7 @@ export const configureOrderModuleTransformations = ({
       const orderPaymentDiscountSum =
         orderPayment &&
         modules.orders.payments
-          .pricingSheet(orderPayment, order.currency, requestContext)
+          .pricingSheet(orderPayment, order.currency, unchainedAPI)
           .discountSum(orderDiscountId);
 
       // Position discounts
@@ -90,7 +90,7 @@ export const configureOrderModuleTransformations = ({
       });
       const orderPositionDiscounts = orderPositions.map((orderPosition) =>
         modules.orders.positions
-          .pricingSheet(orderPosition, order.currency, requestContext)
+          .pricingSheet(orderPosition, order.currency, unchainedAPI)
           .discountSum(orderDiscountId),
       );
 

package/src/module/configureOrdersModule.ts

@@ -1,6 +1,5 @@
-import { Context } from '@unchainedshop/types/api';
 import { Update } from '@unchainedshop/types/common';
-import { ModuleInput } from '@unchainedshop/types/core';
+import { ModuleInput, UnchainedCore } from '@unchainedshop/types/core';
 import { Order, OrderStatus, OrdersModule, OrdersSettingsOptions } from '@unchainedshop/types/orders';
 import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
 import { OrderPayment } from '@unchainedshop/types/orders.payments';
@@ -60,11 +59,7 @@ export const configureOrdersModule = async ({
     return findNewOrderNumber(order, index + 1);
   };
 
-  const updateStatus: OrdersModule['updateStatus'] = async (
-    orderId,
-    { status, info },
-    requestContext,
-  ) => {
+  const updateStatus: OrdersModule['updateStatus'] = async (orderId, { status, info }) => {
     const selector = generateDbFilterById(orderId);
     const order = await Orders.findOne(selector, {});
 
@@ -74,7 +69,6 @@ export const configureOrdersModule = async ({
     const $set: Partial<Order> = {
       status,
       updated: new Date(),
-      updatedBy: requestContext.userId,
     };
 
     switch (status) {
@@ -122,8 +116,8 @@ export const configureOrdersModule = async ({
     return Orders.findOne(selector, {});
   };
 
-  const updateDiscounts = async (order: Order, requestContext: Context) => {
-    const { modules } = requestContext;
+  const updateDiscounts = async (order: Order, unchainedAPI: UnchainedCore) => {
+    const { modules } = unchainedAPI;
 
     // 1. go through existing order-discounts and check if discount still valid,
     // those who are not valid anymore should get removed
@@ -133,10 +127,10 @@ export const configureOrdersModule = async ({
 
     await Promise.all(
       discounts.map(async (discount) => {
-        const isValid = await modules.orders.discounts.isValid(discount, requestContext);
+        const isValid = await modules.orders.discounts.isValid(discount, unchainedAPI);
 
         if (!isValid) {
-          await modules.orders.discounts.delete(discount._id, requestContext);
+          await modules.orders.discounts.delete(discount._id, unchainedAPI);
         }
       }),
     );
@@ -148,34 +142,31 @@ export const configureOrdersModule = async ({
 
     const currentDiscountKeys = cleanedDiscounts.map(({ discountKey }) => discountKey);
 
-    const director = await OrderDiscountDirector.actions({ order, code: null }, requestContext);
+    const director = await OrderDiscountDirector.actions({ order, code: null }, unchainedAPI);
     const systemDiscounts = await director.findSystemDiscounts();
 
     await Promise.all(
       systemDiscounts
         .filter((key) => currentDiscountKeys.indexOf(key) === -1)
         .map((discountKey) =>
-          modules.orders.discounts.create(
-            {
-              orderId: order._id,
-              discountKey,
-              trigger: OrderDiscountTrigger.SYSTEM,
-            },
-            requestContext.userId,
-          ),
+          modules.orders.discounts.create({
+            orderId: order._id,
+            discountKey,
+            trigger: OrderDiscountTrigger.SYSTEM,
+          }),
         ),
     );
   };
 
-  const initProviders = async (order: Order, requestContext: Context) => {
-    const { modules } = requestContext;
+  const initProviders = async (order: Order, unchainedAPI: UnchainedCore) => {
+    const { modules } = unchainedAPI;
 
     let updatedOrder = order;
 
     // Init delivery provider
     const supportedDeliveryProviders = await modules.delivery.findSupported(
       { order: updatedOrder },
-      requestContext,
+      unchainedAPI,
     );
 
     const orderDelivery = await modules.orders.deliveries.findDelivery({
@@ -193,13 +184,13 @@ export const configureOrdersModule = async ({
       const defaultOrderDeliveryProvider = await modules.delivery.determineDefault(
         supportedDeliveryProviders,
         { order: updatedOrder },
-        requestContext,
+        unchainedAPI,
       );
       if (defaultOrderDeliveryProvider) {
         updatedOrder = await modules.orders.setDeliveryProvider(
           updatedOrder._id,
           defaultOrderDeliveryProvider._id,
-          requestContext,
+          unchainedAPI,
         );
       }
     }
@@ -207,7 +198,7 @@ export const configureOrdersModule = async ({
     // Init payment provider
     const supportedPaymentProviders = await modules.payment.paymentProviders.findSupported(
       { order: updatedOrder },
-      requestContext,
+      unchainedAPI,
     );
 
     const orderPayment = await modules.orders.payments.findOrderPayment({
@@ -234,22 +225,22 @@ export const configureOrdersModule = async ({
       const defaultOrderPaymentProvider = await modules.payment.paymentProviders.determineDefault(
         supportedPaymentProviders,
         { order: updatedOrder, paymentCredentials },
-        requestContext,
+        unchainedAPI,
       );
 
       if (defaultOrderPaymentProvider) {
         updatedOrder = await modules.orders.setPaymentProvider(
           updatedOrder._id,
           defaultOrderPaymentProvider._id,
-          requestContext,
+          unchainedAPI,
         );
       }
     }
     return updatedOrder;
   };
 
-  const updateCalculation: OrdersModule['updateCalculation'] = async (orderId, requestContext) => {
-    const { modules } = requestContext;
+  const updateCalculation: OrdersModule['updateCalculation'] = async (orderId, unchainedAPI) => {
+    const { modules } = unchainedAPI;
 
     const selector = generateDbFilterById(orderId);
     let order = (await Orders.findOne(selector, {})) as Order;
@@ -257,38 +248,35 @@ export const configureOrdersModule = async ({
     // Don't recalculate orders, only carts
     if (order.status !== null) return order;
 
-    await updateDiscounts(order, requestContext);
+    await updateDiscounts(order, unchainedAPI);
 
-    order = await initProviders(order, requestContext);
+    order = await initProviders(order, unchainedAPI);
 
     let orderPositions = (await findOrderPositions(order)) as OrderPosition[];
     orderPositions = await Promise.all(
       orderPositions.map(async (orderPosition) =>
-        modules.orders.positions.updateCalculation(orderPosition, requestContext),
+        modules.orders.positions.updateCalculation(orderPosition, unchainedAPI),
       ),
     );
 
     let orderDelivery = (await findOrderDelivery(order)) as OrderDelivery;
     if (orderDelivery) {
-      orderDelivery = await modules.orders.deliveries.updateCalculation(orderDelivery, requestContext);
+      orderDelivery = await modules.orders.deliveries.updateCalculation(orderDelivery, unchainedAPI);
     }
     let orderPayment = (await findOrderPayment(order)) as OrderPayment;
     if (orderPayment) {
-      orderPayment = await modules.orders.payments.updateCalculation(orderPayment, requestContext);
+      orderPayment = await modules.orders.payments.updateCalculation(orderPayment, unchainedAPI);
     }
 
     orderPositions = await Promise.all(
       orderPositions.map(async (orderPosition) =>
-        modules.orders.positions.updateScheduling(
-          { order, orderDelivery, orderPosition },
-          requestContext,
-        ),
+        modules.orders.positions.updateScheduling({ order, orderDelivery, orderPosition }, unchainedAPI),
       ),
     );
 
     const pricing = await OrderPricingDirector.actions(
       { order, orderPositions, orderDelivery, orderPayment },
-      requestContext,
+      unchainedAPI,
     );
 
     const calculation = await pricing.calculate();
@@ -297,7 +285,6 @@ export const configureOrdersModule = async ({
       $set: {
         calculation,
         updated: new Date(),
-        updatedBy: requestContext.userId,
       },
     });