@unchainedshop/core-orders 2.14.2 → 3.0.0-alpha3

package/src/director/OrderPricingDirector.ts

@@ -1,12 +1,28 @@
+import { BasePricingDirector, PricingDiscount, IPricingDirector } from '@unchainedshop/utils';
+import { IOrderPricingSheet, OrderPricingCalculation, OrderPricingSheet } from './OrderPricingSheet.js';
+import { Order, OrderDelivery, OrderPayment, OrderPosition } from '../types.js';
 import {
   IOrderPricingAdapter,
-  IOrderPricingDirector,
   OrderPricingAdapterContext,
-  OrderPricingCalculation,
   OrderPricingContext,
-} from '@unchainedshop/types/orders.pricing.js';
-import { BasePricingDirector } from '@unchainedshop/utils';
-import { OrderPricingSheet } from './OrderPricingSheet.js';
+} from './OrderPricingAdapter.js';
+
+export type OrderPrice = { _id?: string; amount: number; currency: string };
+
+export type OrderPricingDiscount = PricingDiscount & {
+  delivery?: OrderDelivery;
+  item?: OrderPosition;
+  order?: Order;
+  payment?: OrderPayment;
+};
+
+export type IOrderPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
+  OrderPricingContext,
+  OrderPricingCalculation,
+  OrderPricingAdapterContext,
+  IOrderPricingSheet,
+  IOrderPricingAdapter<DiscountConfiguration>
+>;
 
 const baseDirector = BasePricingDirector<
   OrderPricingContext,

package/src/director/OrderPricingSheet.ts

@@ -1,10 +1,29 @@
-import { BasePricingSheet } from '@unchainedshop/utils';
 import {
-  OrderPricingCalculation,
-  OrderPricingRowCategory,
-  IOrderPricingSheet,
-} from '@unchainedshop/types/orders.pricing.js';
-import { IBasePricingSheet, PricingSheetParams } from '@unchainedshop/types/pricing.js';
+  BasePricingSheet,
+  IPricingSheet,
+  IBasePricingSheet,
+  PricingCalculation,
+  PricingSheetParams,
+} from '@unchainedshop/utils';
+
+export interface OrderPricingCalculation extends PricingCalculation {
+  discountId?: string;
+}
+
+export enum OrderPricingRowCategory {
+  Items = 'ITEMS',
+  Discounts = 'DISCOUNTS',
+  Taxes = 'TAXES',
+  Delivery = 'DELIVERY',
+  Payment = 'PAYMENT',
+}
+
+export interface IOrderPricingSheet extends IPricingSheet<OrderPricingCalculation> {
+  addDelivery: (params: { amount: number; taxAmount: number; meta?: any }) => void;
+  addDiscount: (params: { amount: number; taxAmount: number; discountId: string; meta?: any }) => void;
+  addItems: (params: { amount: number; taxAmount: number; meta?: any }) => void;
+  addPayment: (params: { amount: number; taxAmount: number; meta?: any }) => void;
+}
 
 export const OrderPricingSheet = (
   params: PricingSheetParams<OrderPricingCalculation>,

package/src/module/buildFindSelector.test.ts

@@ -1,3 +1,4 @@
+import { OrderStatus } from "../types.js"
 import {buildFindByIdSelector as buildFindByIdSelectorForDelivery} from "./configureOrderDeliveriesModule.js"
 import {buildFindByIdSelector as buildFindByIdSelectorForDiscount } from "./configureOrderDiscountsModule.js"
 import {buildFindByIdSelector as buildFindByIdSelectorForPayment, buildFindByContextDataSelector } from "./configureOrderPaymentsModule.js"
@@ -13,9 +14,13 @@ describe('OrderPosition', () => {
     });
 
     it('Return filter object when passed no argument includeCarts, queryString, status, userId and (status should take precedence over includeCarts', async () => {   
-      expect(buildFindSelectorForOrder({includeCarts: false, queryString: "hello world", status: 'CONFIRMED', userId: "admin-id"})).toEqual({
+      expect(buildFindSelectorForOrder({includeCarts: false, queryString: "hello world", status: [OrderStatus.CONFIRMED], userId: "admin-id"})).toEqual({
         userId: 'admin-id',
-        status: 'CONFIRMED',
+        "status": {
+          "$in": [
+           "CONFIRMED",
+         ],
+       },
         '$text': { '$search': 'hello world' }
       }
   )

package/src/module/configureOrderDeliveriesModule.ts

@@ -1,15 +1,65 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { mongodb, generateDbFilterById, generateDbMutations } from '@unchainedshop/mongodb';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
-import {
-  OrderDeliveriesModule,
-  OrderDelivery,
-  OrderDeliveryStatus,
-} from '@unchainedshop/types/orders.deliveries.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { mongodb, generateDbFilterById, generateDbObjectId } from '@unchainedshop/mongodb';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-import { OrderDeliveriesSchema } from '../db/OrderDeliveriesSchema.js';
+import { Order, OrderDelivery, OrderDeliveryStatus, OrderDiscount } from '../types.js';
+import { DeliveryLocation, IDeliveryPricingSheet } from '@unchainedshop/core-delivery';
 import { DeliveryDirector } from '@unchainedshop/core-delivery';
+import { OrderPricingDiscount } from '../director/OrderPricingDirector.js';
+
+export type OrderDeliveriesModule = {
+  // Queries
+  findDelivery: (
+    params: { orderDeliveryId: string },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderDelivery>;
+
+  // Transformations
+  discounts: (
+    orderDelivery: OrderDelivery,
+    params: { order: Order; orderDiscount: OrderDiscount },
+    unchainedAPI: UnchainedCore,
+  ) => Array<OrderPricingDiscount>;
+  isBlockingOrderConfirmation: (
+    orderDelivery: OrderDelivery,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<boolean>;
+  isBlockingOrderFullfillment: (orderDelivery: OrderDelivery) => boolean;
+  normalizedStatus: (orderDelivery: OrderDelivery) => string;
+  pricingSheet: (
+    orderDelivery: OrderDelivery,
+    currency: string,
+    unchainedAPI: UnchainedCore,
+  ) => IDeliveryPricingSheet;
+
+  // Mutations
+  create: (doc: OrderDelivery) => Promise<OrderDelivery>;
+  delete: (orderDeliveryId: string) => Promise<number>;
+
+  markAsDelivered: (orderDelivery: OrderDelivery) => Promise<void>;
+
+  activePickUpLocation: (
+    orderDelivery: OrderDelivery,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<DeliveryLocation | null>;
+
+  send: (
+    orderDelivery: OrderDelivery,
+    params: { order: Order; deliveryContext?: any },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderDelivery>;
+
+  updateContext: (orderDeliveryId: string, context: any) => Promise<OrderDelivery | null>;
+
+  updateStatus: (
+    orderDeliveryId: string,
+    params: { status: OrderDeliveryStatus; info?: string },
+  ) => Promise<OrderDelivery>;
+
+  updateCalculation: (
+    orderDelivery: OrderDelivery,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderDelivery>;
+};
 
 const ORDER_DELIVERY_EVENTS: string[] = ['ORDER_DELIVER', 'ORDER_UPDATE_DELIVERY'];
 
@@ -18,18 +68,11 @@ export const buildFindByIdSelector = (orderDeliveryId: string) =>
 
 export const configureOrderDeliveriesModule = ({
   OrderDeliveries,
-  updateCalculation,
 }: {
   OrderDeliveries: mongodb.Collection<OrderDelivery>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderDeliveriesModule => {
   registerEvents(ORDER_DELIVERY_EVENTS);
 
-  const mutations = generateDbMutations<OrderDelivery>(OrderDeliveries, OrderDeliveriesSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<OrderDelivery>;
-
   const normalizedStatus: OrderDeliveriesModule['normalizedStatus'] = (orderDelivery) => {
     return orderDelivery.status === null
       ? OrderDeliveryStatus.OPEN
@@ -40,8 +83,6 @@ export const configureOrderDeliveriesModule = ({
     orderDeliveryId,
     { status, info },
   ) => {
-    log(`OrderDelivery ${orderDeliveryId} -> New Status: ${status}`);
-
     const date = new Date();
     const modifier: mongodb.UpdateFilter<OrderDelivery> = {
       $set: { status, updated: new Date() },
@@ -131,7 +172,9 @@ export const configureOrderDeliveriesModule = ({
     // Mutations
 
     create: async (doc) => {
-      const orderDeliveryId = await mutations.create({
+      const { insertedId: orderDeliveryId } = await OrderDeliveries.insertOne({
+        _id: generateDbObjectId(),
+        created: new Date(),
         ...doc,
         context: doc.context || {},
         status: null,
@@ -142,7 +185,7 @@ export const configureOrderDeliveriesModule = ({
     },
 
     delete: async (orderDeliveryId) => {
-      const deletedCount = await mutations.delete(orderDeliveryId);
+      const { deletedCount } = await OrderDeliveries.deleteOne({ _id: orderDeliveryId });
       return deletedCount;
     },
 
@@ -190,11 +233,9 @@ export const configureOrderDeliveriesModule = ({
       return orderDelivery;
     },
 
-    updateContext: async (orderDeliveryId, context, unchainedAPI) => {
+    updateContext: async (orderDeliveryId, context) => {
       const selector = buildFindByIdSelector(orderDeliveryId);
       if (!context || Object.keys(context).length === 0) return OrderDeliveries.findOne(selector, {});
-
-      log(`OrderDelivery ${orderDeliveryId} -> Update Context`, { context });
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
@@ -211,7 +252,6 @@ export const configureOrderDeliveriesModule = ({
       );
 
       if (result.ok) {
-        await updateCalculation(result.value.orderId, unchainedAPI);
         await emit('ORDER_UPDATE_DELIVERY', {
           orderDelivery: result.value,
         });
@@ -224,10 +264,6 @@ export const configureOrderDeliveriesModule = ({
     updateStatus,
 
     updateCalculation: async (orderDelivery, unchainedAPI) => {
-      log(`OrderDelivery ${orderDelivery._id} -> Update Calculation`, {
-        orderId: orderDelivery.orderId,
-      });
-
       const calculation = await unchainedAPI.modules.delivery.calculate(
         {
           item: orderDelivery,

package/src/module/configureOrderDiscountsModule.ts

@@ -1,12 +1,50 @@
-import { ModuleMutations, UnchainedCore } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
-import { OrderDiscount, OrderDiscountsModule } from '@unchainedshop/types/orders.discounts.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
-import { OrderDiscountsSchema } from '../db/OrderDiscountsSchema.js';
+import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { OrderDiscountTrigger } from '../db/OrderDiscountTrigger.js';
 import { OrderDiscountDirector } from '../director/OrderDiscountDirector.js';
+import { Order, OrderDiscount } from '../types.js';
+import {
+  IPricingSheet,
+  PricingCalculation,
+  DiscountAdapterActions,
+  DiscountContext,
+} from '@unchainedshop/utils';
+
+export type OrderDiscountsModule = {
+  // Queries
+  findOrderDiscount: (
+    params: { discountId: string },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderDiscount>;
+  findOrderDiscounts: (params: { orderId: string }) => Promise<Array<OrderDiscount>>;
+
+  // Transformations
+  interface: (
+    orderDiscount: OrderDiscount,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<DiscountAdapterActions<any>>;
+
+  isValid: (orderDiscount: OrderDiscount, unchainedAPI: UnchainedCore) => Promise<boolean>;
+
+  // Adapter
+  configurationForPricingAdapterKey: (
+    orderDiscount: OrderDiscount,
+    adapterKey: string,
+    calculationSheet: IPricingSheet<PricingCalculation>,
+    pricingContext: DiscountContext & UnchainedCore,
+  ) => Promise<any>;
+
+  // Mutations
+  createManualOrderDiscount: (
+    params: { code: string; order: Order },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderDiscount>;
+
+  create: (doc: OrderDiscount) => Promise<OrderDiscount>;
+  update: (orderDiscountId: string, doc: OrderDiscount) => Promise<OrderDiscount>;
+  delete: (orderDiscountId: string, unchainedAPI: UnchainedCore) => Promise<OrderDiscount>;
+};
 
 const ORDER_DISCOUNT_EVENTS: string[] = [
   'ORDER_CREATE_DISCOUNT',
@@ -25,18 +63,11 @@ export const buildFindByIdSelector = (orderDiscountId: string) =>
 
 export const configureOrderDiscountsModule = ({
   OrderDiscounts,
-  updateCalculation,
 }: {
   OrderDiscounts: mongodb.Collection<OrderDiscount>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderDiscountsModule => {
   registerEvents(ORDER_DISCOUNT_EVENTS);
 
-  const mutations = generateDbMutations<OrderDiscount>(OrderDiscounts, OrderDiscountsSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<OrderDiscount>;
-
   const getAdapter = async (orderDiscount: OrderDiscount, unchainedAPI: UnchainedCore) => {
     const order = await unchainedAPI.modules.orders.findOrder({
       orderId: orderDiscount.orderId,
@@ -51,12 +82,12 @@ export const configureOrderDiscountsModule = ({
 
   const createDiscount: OrderDiscountsModule['create'] = async (doc) => {
     const normalizedTrigger = doc.trigger || OrderDiscountTrigger.USER;
-
-    log(`Create Order Discount: ${doc.discountKey} with trigger ${normalizedTrigger}`, {
-      orderId: doc.orderId,
+    const { insertedId: discountId } = await OrderDiscounts.insertOne({
+      _id: generateDbObjectId(),
+      created: new Date(),
+      ...doc,
+      trigger: normalizedTrigger,
     });
-
-    const discountId = await mutations.create({ ...doc, trigger: normalizedTrigger });
     const discount = await OrderDiscounts.findOne(buildFindByIdSelector(discountId));
     return discount;
   };
@@ -64,33 +95,28 @@ export const configureOrderDiscountsModule = ({
   const deleteDiscount: OrderDiscountsModule['delete'] = async (orderDiscountId, unchainedAPI) => {
     const selector = buildFindByIdSelector(orderDiscountId);
     const discount = await OrderDiscounts.findOne(selector, {});
-
-    log(`OrderDiscounts -> Remove Discount ${orderDiscountId}`, {
-      orderId: discount.orderId,
-    });
-
     if (discount.trigger === OrderDiscountTrigger.USER) {
       // Release
       const adapter = await getAdapter(discount, unchainedAPI);
       if (!adapter) return null;
       await adapter.release();
-
-      await OrderDiscounts.deleteOne(selector);
-      await updateCalculation(discount.orderId, unchainedAPI);
-    } else {
-      await OrderDiscounts.deleteOne(selector);
     }
+    await OrderDiscounts.deleteOne(selector);
     await emit('ORDER_REMOVE_DISCOUNT', { discount });
     return discount;
   };
 
   const updateDiscount: OrderDiscountsModule['update'] = async (orderDiscountId, doc) => {
-    await mutations.update(orderDiscountId, {
-      $set: doc,
-    });
-
-    const selector = buildFindByIdSelector(orderDiscountId);
-    const discount = await OrderDiscounts.findOne(selector, {});
+    const discount = await OrderDiscounts.findOneAndUpdate(
+      generateDbFilterById(orderDiscountId),
+      {
+        $set: {
+          updated: new Date(),
+          ...doc,
+        },
+      },
+      { returnDocument: 'after' },
+    );
     await emit('ORDER_UPDATE_DISCOUNT', { discount });
     return discount;
   };
@@ -110,15 +136,10 @@ export const configureOrderDiscountsModule = ({
     { code, orderId }: { code: string; orderId: string },
     unchainedAPI: UnchainedCore,
   ) => {
-    log(`OrderDiscounts -> Try to grab ${code}`, { orderId });
-
     const existingDiscount = await OrderDiscounts.findOne({ code, orderId });
-
     if (existingDiscount) throw new Error(OrderDiscountErrorCode.CODE_ALREADY_PRESENT);
-
     const discount = await OrderDiscounts.findOne({ code, orderId: null });
     if (!discount) return null;
-
     const discountId = discount._id;
     try {
       const updatedDiscount = await updateDiscount(discountId, { orderId });
@@ -199,7 +220,6 @@ export const configureOrderDiscountsModule = ({
 
         try {
           const reservedDiscount = await reserveDiscount(newDiscount, unchainedAPI);
-          await updateCalculation(order._id, unchainedAPI);
           await emit('ORDER_ADD_DISCOUNT', { discount: reserveDiscount });
           return reservedDiscount;
         } catch (error) {
@@ -224,10 +244,17 @@ export const configureOrderDiscountsModule = ({
     delete: deleteDiscount,
 
     update: async (orderDiscountId, doc) => {
-      await mutations.update(orderDiscountId, doc);
+      const discount = await OrderDiscounts.findOneAndUpdate(
+        generateDbFilterById(orderDiscountId),
+        {
+          $set: {
+            updated: new Date(),
+            ...doc,
+          },
+        },
+        { returnDocument: 'after' },
+      );
 
-      const selector = buildFindByIdSelector(orderDiscountId);
-      const discount = await OrderDiscounts.findOne(selector, {});
       await emit('ORDER_UPDATE_DISCOUNT', { discount });
       return discount;
     },

package/src/module/configureOrderPaymentsModule.ts

@@ -1,14 +1,94 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
-import {
-  OrderPayment,
-  OrderPaymentsModule,
-  OrderPaymentStatus,
-} from '@unchainedshop/types/orders.payments.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
-import { OrderPaymentsSchema } from '../db/OrderPaymentsSchema.js';
+import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
+import { Order, OrderDiscount, OrderPayment, OrderPaymentStatus } from '../types.js';
+import { IPaymentPricingSheet } from '@unchainedshop/core-payment';
+import { OrderPricingDiscount } from '../director/OrderPricingDirector.js';
+
+export type OrderPaymentsModule = {
+  // Queries
+  findOrderPayment: (
+    params: {
+      orderPaymentId: string;
+    },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderPayment>;
+
+  findOrderPaymentByContextData: (
+    params: {
+      context: any;
+    },
+    options?: mongodb.FindOptions,
+  ) => Promise<OrderPayment>;
+
+  countOrderPaymentsByContextData: (
+    params: {
+      context: any;
+    },
+    options?: mongodb.FindOptions,
+  ) => Promise<number>;
+
+  // Transformations
+  discounts: (
+    orderPayment: OrderPayment,
+    params: { order: Order; orderDiscount: OrderDiscount },
+    unchainedAPI: UnchainedCore,
+  ) => Array<OrderPricingDiscount>;
+  isBlockingOrderConfirmation: (
+    orderPayment: OrderPayment,
+    unchainedAPI: UnchainedCore,
+  ) => Promise<boolean>;
+  isBlockingOrderFullfillment: (orderPayment: OrderPayment) => boolean;
+  normalizedStatus: (orderPayment: OrderPayment) => string;
+  pricingSheet: (
+    orderPayment: OrderPayment,
+    currency: string,
+    unchainedAPI: UnchainedCore,
+  ) => IPaymentPricingSheet;
+
+  // Mutations
+  create: (doc: OrderPayment) => Promise<OrderPayment>;
+
+  cancel: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPayment>;
+
+  confirm: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPayment>;
+
+  charge: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI: UnchainedCore,
+  ) => Promise<OrderPayment>;
+
+  logEvent: (orderPaymentId: string, event: any) => Promise<boolean>;
+
+  markAsPaid: (payment: OrderPayment, meta: any) => Promise<void>;
+
+  updateContext: (orderPaymentId: string, context: any) => Promise<OrderPayment | null>;
+
+  updateStatus: (
+    orderPaymentId: string,
+    params: { transactionId?: string; status: OrderPaymentStatus; info?: string },
+  ) => Promise<OrderPayment>;
+
+  updateCalculation: (orderPayment: OrderPayment, unchainedAPI: UnchainedCore) => Promise<OrderPayment>;
+};
 
 const ORDER_PAYMENT_EVENTS: string[] = ['ORDER_UPDATE_PAYMENT', 'ORDER_SIGN_PAYMENT', 'ORDER_PAY'];
 
@@ -35,18 +115,11 @@ export const buildFindByContextDataSelector = (context: any): mongodb.Filter<Ord
 
 export const configureOrderPaymentsModule = ({
   OrderPayments,
-  updateCalculation,
 }: {
   OrderPayments: mongodb.Collection<OrderPayment>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderPaymentsModule => {
   registerEvents(ORDER_PAYMENT_EVENTS);
 
-  const mutations = generateDbMutations<OrderPayment>(OrderPayments, OrderPaymentsSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<OrderPayment>;
-
   const normalizedStatus: OrderPaymentsModule['normalizedStatus'] = (orderPayment) => {
     return orderPayment.status === null
       ? OrderPaymentStatus.OPEN
@@ -70,8 +143,6 @@ export const configureOrderPaymentsModule = ({
     orderPaymentId,
     { status, transactionId, info },
   ) => {
-    log(`OrderPayment ${orderPaymentId} -> New Status: ${status}`);
-
     const date = new Date();
     const modifier: mongodb.UpdateFilter<OrderPayment> = {
       $set: { status, updated: new Date() },
@@ -155,7 +226,9 @@ export const configureOrderPaymentsModule = ({
     // Mutations
 
     create: async (doc) => {
-      const orderPaymentId = await mutations.create({
+      const { insertedId: orderPaymentId } = await OrderPayments.insertOne({
+        _id: generateDbObjectId(),
+        created: new Date(),
         ...doc,
         status: null,
         context: doc.context || {},
@@ -293,13 +366,10 @@ export const configureOrderPaymentsModule = ({
       await emit('ORDER_PAY', { orderPayment });
     },
 
-    updateContext: async (orderPaymentId, context, unchainedAPI) => {
+    updateContext: async (orderPaymentId, context) => {
       const selector = buildFindByIdSelector(orderPaymentId);
       if (!context || Object.keys(context).length === 0) return OrderPayments.findOne(selector, {});
 
-      log(`OrderPayment ${orderPaymentId} -> Update Context`, {
-        context,
-      });
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
@@ -315,7 +385,6 @@ export const configureOrderPaymentsModule = ({
       );
 
       if (result.ok) {
-        await updateCalculation(result.value.orderId, unchainedAPI);
         await emit('ORDER_UPDATE_PAYMENT', {
           orderPayment: result.value,
         });
@@ -328,10 +397,6 @@ export const configureOrderPaymentsModule = ({
     updateStatus,
 
     updateCalculation: async (orderPayment, unchainedAPI) => {
-      log(`OrderPayment ${orderPayment._id} -> Update Calculation`, {
-        orderId: orderPayment.orderId,
-      });
-
       const calculation = await unchainedAPI.modules.payment.paymentProviders.calculate(
         {
           item: orderPayment,