@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc10

package/src/resolvers/mutations/orders/addMultipleCartProducts.ts

@@ -1,11 +1,12 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import {
   ProductNotFoundError,
   OrderQuantityTooLowError,
   OrderWrongStatusError,
+  OrderNotFoundError,
 } from '../../../errors.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
+import { ordersSettings } from '@unchainedshop/core-orders';
 
 export default async function addMultipleCartProducts(
   root: never,
@@ -19,7 +20,7 @@ export default async function addMultipleCartProducts(
   },
   context: Context,
 ) {
-  const { modules, userId, user } = context;
+  const { modules, services, userId, user } = context;
   const { orderId, items } = params;
 
   log(`mutation addMultipleCartProducts ${JSON.stringify(items)}`, {
@@ -30,39 +31,60 @@ export default async function addMultipleCartProducts(
   /* verify existence of products */
   const itemsWithProducts = await Promise.all(
     items.map(async ({ productId, ...item }) => {
-      const product = await modules.products.findProduct({ productId });
-      if (!product) throw new ProductNotFoundError({ productId });
+      const originalProduct = await modules.products.findProduct({ productId });
+      if (!originalProduct) throw new ProductNotFoundError({ productId });
 
       return {
         ...item,
-        product,
+        originalProduct,
       };
     }),
   );
 
-  const order = await getOrderCart({ orderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 
   // Reduce is used to wait for each product to be added before processing the next (sequential processing)
-  await itemsWithProducts.reduce(async (positionsPromise, { product, quantity, configuration }) => {
-    const positions = await positionsPromise;
-    if (quantity < 1)
-      throw new OrderQuantityTooLowError({
-        quantity,
-        productId: product._id,
+  await itemsWithProducts.reduce(
+    async (positionsPromise, { originalProduct, quantity, configuration }) => {
+      const positions = await positionsPromise;
+      if (quantity < 1)
+        throw new OrderQuantityTooLowError({
+          quantity,
+          productId: originalProduct._id,
+        });
+
+      const product = await modules.products.resolveOrderableProduct(originalProduct, {
+        configuration,
       });
 
-    const position = await modules.orders.positions.addProductItem(
-      {
+      await ordersSettings.validateOrderPosition(
+        {
+          order,
+          product,
+          configuration,
+          quantityDiff: quantity,
+        },
+        context,
+      );
+
+      const position = await modules.orders.positions.addProductItem({
         quantity,
         configuration,
-      },
-      { order, product },
-      context,
-    );
-    positions.push(position);
-    return positions;
-  }, Promise.resolve([]));
+        originalProductId: originalProduct._id,
+        productId: product._id,
+        orderId: order._id,
+      });
+      positions.push(position);
+      return positions;
+    },
+    Promise.resolve([]),
+  );
 
-  return modules.orders.updateCalculation(order._id, context);
+  return services.orders.updateCalculation(order._id);
 }

package/src/resolvers/mutations/orders/checkoutCart.ts

@@ -1,7 +1,8 @@
-import { Context } from '../../../types.js';
-import { log, LogLevel } from '@unchainedshop/logger';
-import { OrderCheckoutError } from '../../../errors.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
+import { Context } from '../../../context.js';
+import { OrderCheckoutError, OrderNotFoundError } from '../../../errors.js';
+import { createLogger, log } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api');
 
 export default async function checkoutCart(
   root: never,
@@ -12,19 +13,24 @@ export default async function checkoutCart(
   },
   context: Context,
 ) {
-  const { modules, user, userId } = context;
+  const { services, user, userId } = context;
   const { orderId: forceOrderId, ...transactionContext } = params;
 
   log('mutation checkoutCart', { orderId: forceOrderId, userId });
 
   // Do not check for order status here! The checkout method will act accordingly
-  let order = await getOrderCart({ orderId: forceOrderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId: forceOrderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId: forceOrderId });
 
   try {
-    order = await modules.orders.checkout(order._id, transactionContext, context);
-    return order;
+    const checkedOutOrder = await services.orders.checkoutOrder(order._id, transactionContext);
+    return checkedOutOrder;
   } catch (error) {
-    log(error.message, { userId, orderId: order._id, level: LogLevel.Error });
+    logger.error(error.message, { userId, orderId: order._id });
     throw new OrderCheckoutError({
       userId,
       orderId: order._id,

package/src/resolvers/mutations/orders/confirmOrder.ts

@@ -1,4 +1,4 @@
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { OrderStatus } from '@unchainedshop/core-orders';
 import { log } from '@unchainedshop/logger';
 import { InvalidIdError, OrderNotFoundError, OrderWrongStatusError } from '../../../errors.js';
@@ -13,7 +13,7 @@ export default async function confirmOrder(
   },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { services, modules, userId } = context;
   const { orderId, ...transactionContext } = params;
 
   log('mutation confirmOrder', { orderId, userId });
@@ -27,5 +27,5 @@ export default async function confirmOrder(
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  return modules.orders.confirm(order, transactionContext, context);
+  return services.orders.confirmOrder(order, transactionContext);
 }

package/src/resolvers/mutations/orders/createCart.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { OrderNumberAlreadyExistsError } from '../../../errors.js';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function createCart(
   root: never,
@@ -13,8 +13,10 @@ export default async function createCart(
   const order = await modules.orders.findOrder({ orderNumber });
   if (order) throw new OrderNumberAlreadyExistsError({ orderNumber });
 
-  return services.orders.nextUserCart(
-    { user, orderNumber, countryCode: context.countryContext, forceCartCreation: true },
-    context,
-  );
+  return services.orders.nextUserCart({
+    user,
+    orderNumber,
+    countryCode: context.countryContext,
+    forceCartCreation: true,
+  });
 }

package/src/resolvers/mutations/orders/deliverOrder.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { OrderDeliveryStatus } from '@unchainedshop/core-orders';
 import {
   OrderNotFoundError,
@@ -13,7 +13,7 @@ export default async function deliverOrder(
   { orderId }: { orderId: string },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
   log('mutation deliverOrder', { orderId, userId });
 
   if (!orderId) throw new InvalidIdError({ orderId });
@@ -39,5 +39,5 @@ export default async function deliverOrder(
   }
 
   await modules.orders.deliveries.markAsDelivered(orderDelivery);
-  return modules.orders.processOrder(order, {}, context);
+  return services.orders.processOrder(order, {});
 }

package/src/resolvers/mutations/orders/emptyCart.ts

@@ -1,22 +1,27 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
-import { OrderWrongStatusError } from '../../../errors.js';
+import { Context } from '../../../context.js';
+import { OrderNotFoundError, OrderWrongStatusError } from '../../../errors.js';
 
 export default async function emptyCart(
   root: never,
   { orderId }: { orderId?: string },
   context: Context,
 ) {
-  const { modules, userId, user } = context;
+  const { modules, services, userId, user } = context;
 
   log('mutation emptyCart', { userId, orderId });
 
-  const order = await getOrderCart({ orderId, user }, context);
+  const order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 
   if (!order) return null;
 
   await modules.orders.positions.removePositions({ orderId: order._id });
-  return modules.orders.updateCalculation(order._id, context);
+
+  return services.orders.updateCalculation(order._id);
 }

package/src/resolvers/mutations/orders/payOrder.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { OrderPaymentStatus } from '@unchainedshop/core-orders';
 import {
   OrderNotFoundError,
@@ -9,7 +9,7 @@ import {
 } from '../../../errors.js';
 
 export default async function payOrder(root: never, { orderId }: { orderId: string }, context: Context) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
 
   log('mutation payOrder', { orderId, userId });
 
@@ -33,5 +33,5 @@ export default async function payOrder(root: never, { orderId }: { orderId: stri
   }
 
   await modules.orders.payments.markAsPaid(payment, null);
-  return modules.orders.processOrder(order, {}, context);
+  return services.orders.processOrder(order, {});
 }

package/src/resolvers/mutations/orders/rejectOrder.ts

@@ -1,4 +1,4 @@
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { OrderStatus } from '@unchainedshop/core-orders';
 import { log } from '@unchainedshop/logger';
 import { InvalidIdError, OrderNotFoundError, OrderWrongStatusError } from '../../../errors.js';
@@ -13,7 +13,7 @@ export default async function rejectOrder(
   },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
   const { orderId, ...transactionContext } = params;
 
   log('mutation rejectOrder', { orderId, userId });
@@ -26,5 +26,5 @@ export default async function rejectOrder(
   if (order.status !== OrderStatus.PENDING) {
     throw new OrderWrongStatusError({ status: order.status });
   }
-  return modules.orders.reject(order, transactionContext, context);
+  return services.orders.rejectOrder(order, transactionContext);
 }

package/src/resolvers/mutations/orders/removeCartDiscount.ts

@@ -1,14 +1,16 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 import { OrderDiscountNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors.js';
+import { OrderDiscountTrigger } from '@unchainedshop/core-orders';
+import { OrderDiscountDirector } from '@unchainedshop/core';
 
 export default async function removeCartDiscount(
   root: never,
   { discountId }: { discountId: string },
-  context: Context,
+  requestContext: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = requestContext;
 
   log(`mutation removeCartDiscount ${discountId}`, { userId });
 
@@ -26,7 +28,18 @@ export default async function removeCartDiscount(
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  const deletedDiscount = await modules.orders.discounts.delete(discountId, context);
-  await modules.orders.updateCalculation(order._id, context);
+  if (orderDiscount.trigger === OrderDiscountTrigger.USER) {
+    // Release
+    const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+    if (Adapter) {
+      const adapter = await Adapter.actions({
+        context: { order, orderDiscount, code: orderDiscount.code, ...requestContext },
+      });
+      await adapter.release();
+    }
+  }
+
+  const deletedDiscount = await modules.orders.discounts.delete(discountId);
+  await services.orders.updateCalculation(order._id);
   return deletedDiscount;
 }

package/src/resolvers/mutations/orders/removeCartItem.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { OrderItemNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors.js';
 
 export default async function removeCartItem(
@@ -7,7 +7,7 @@ export default async function removeCartItem(
   { itemId }: { itemId: string },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
 
   log(`mutation removeCartItem ${itemId}`, { userId });
 
@@ -25,6 +25,6 @@ export default async function removeCartItem(
   }
 
   const removedOrderPosition = await modules.orders.positions.delete(itemId);
-  await modules.orders.updateCalculation(order._id, context);
+  await services.orders.updateCalculation(order._id);
   return removedOrderPosition;
 }

package/src/resolvers/mutations/orders/removeOrder.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { OrderNotFoundError, OrderWrongStatusError, InvalidIdError } from '../../../errors.js';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function removeOrder(
   root: never,

package/src/resolvers/mutations/orders/setOrderDeliveryProvider.ts

@@ -1,13 +1,13 @@
 import { log } from '@unchainedshop/logger';
 import { OrderNotFoundError, InvalidIdError } from '../../../errors.js';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function setOrderDeliveryProvider(
   root: never,
   params: { orderId: string; deliveryProviderId: string },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
   const { orderId, deliveryProviderId } = params;
 
   log(`mutation setOrderDeliveryProvider ${deliveryProviderId}`, {
@@ -20,6 +20,6 @@ export default async function setOrderDeliveryProvider(
 
   if (!(await modules.orders.orderExists({ orderId }))) throw new OrderNotFoundError({ orderId });
 
-  await modules.orders.setDeliveryProvider(orderId, deliveryProviderId, context);
-  return modules.orders.updateCalculation(orderId, context);
+  await modules.orders.setDeliveryProvider(orderId, deliveryProviderId);
+  return services.orders.updateCalculation(orderId);
 }

package/src/resolvers/mutations/orders/setOrderPaymentProvider.ts

@@ -1,13 +1,13 @@
 import { log } from '@unchainedshop/logger';
 import { OrderNotFoundError, InvalidIdError } from '../../../errors.js';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export default async function setOrderPaymentProvider(
   root: never,
   params: { orderId: string; paymentProviderId: string },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
   const { orderId, paymentProviderId } = params;
 
   log(`mutation setOrderPaymentProvider ${paymentProviderId}`, {
@@ -21,6 +21,6 @@ export default async function setOrderPaymentProvider(
   const order = await modules.orders.findOrder({ orderId });
   if (!order) throw new OrderNotFoundError({ orderId });
 
-  await modules.orders.setPaymentProvider(orderId, paymentProviderId, context);
-  return modules.orders.updateCalculation(orderId, context);
+  await modules.orders.setPaymentProvider(orderId, paymentProviderId);
+  return services.orders.updateCalculation(orderId);
 }

package/src/resolvers/mutations/orders/signPaymentProviderForCheckout.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { PaymentProviderType } from '@unchainedshop/core-payment';
 import { OrderPaymentStatus } from '@unchainedshop/core-orders';
 import {
@@ -9,6 +9,7 @@ import {
   OrderWrongPaymentStatusError,
   UserNoCartError,
 } from '../../../errors.js';
+import { PaymentDirector } from '@unchainedshop/core';
 
 export default async function signPaymentProviderForCheckout(
   root: never,
@@ -31,7 +32,7 @@ export default async function signPaymentProviderForCheckout(
     if (!orderPayment) throw new OrderPaymentNotFoundError({ orderPaymentId });
   } else {
     const order = await modules.orders.cart({
-      countryContext: context.countryContext || context.user.lastLogin?.countryCode,
+      countryCode: context.countryContext,
       userId,
     });
     if (!order) throw new UserNoCartError({ userId });
@@ -60,8 +61,8 @@ export default async function signPaymentProviderForCheckout(
   }
 
   try {
-    const sign = await modules.payment.paymentProviders.sign(
-      provider._id,
+    const actions = await PaymentDirector.actions(
+      provider,
       {
         userId,
         orderPayment,
@@ -69,6 +70,8 @@ export default async function signPaymentProviderForCheckout(
       },
       context,
     );
+    const sign = await actions.sign();
+
     return sign;
   } catch (error) {
     throw new OrderPaymentConfigurationError(error);

package/src/resolvers/mutations/orders/updateCart.ts

@@ -1,8 +1,7 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
-import { getOrderCart } from '../utils/getOrderCart.js';
-import { OrderWrongStatusError } from '../../../errors.js';
-import type { Address, Contact } from '@unchainedshop/mongodb';
+import { Context } from '../../../context.js';
+import { OrderNotFoundError, OrderWrongStatusError } from '../../../errors.js';
+import { Address, Contact } from '@unchainedshop/mongodb';
 
 interface UpdateCartParams {
   orderId?: string;
@@ -16,11 +15,16 @@ interface UpdateCartParams {
 export default async function updateCart(root: never, params: UpdateCartParams, context: Context) {
   const { orderId, billingAddress, contact, paymentProviderId, deliveryProviderId, meta } = params;
 
-  const { modules, userId, user } = context;
+  const { modules, services, userId, user } = context;
 
   log('mutation updateCart', { userId });
 
-  let order = await getOrderCart({ orderId, user }, context);
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user,
+    countryCode: context.countryContext,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
   if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
 
   if (meta) {
@@ -36,13 +40,13 @@ export default async function updateCart(root: never, params: UpdateCartParams,
   }
 
   if (paymentProviderId) {
-    order = await modules.orders.setPaymentProvider(order._id, paymentProviderId, context);
+    order = await modules.orders.setPaymentProvider(order._id, paymentProviderId);
   }
 
   if (deliveryProviderId) {
-    order = await modules.orders.setDeliveryProvider(order._id, deliveryProviderId, context);
+    order = await modules.orders.setDeliveryProvider(order._id, deliveryProviderId);
   }
 
   // Recalculate, then return
-  return modules.orders.updateCalculation(order._id, context);
+  return services.orders.updateCalculation(order._id);
 }

package/src/resolvers/mutations/orders/updateCartItem.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import {
   OrderQuantityTooLowError,
   OrderItemNotFoundError,
@@ -7,6 +7,7 @@ import {
   ProductNotFoundError,
   InvalidIdError,
 } from '../../../errors.js';
+import { ordersSettings } from '@unchainedshop/core-orders';
 
 export default async function updateCartItem(
   root: never,
@@ -17,7 +18,7 @@ export default async function updateCartItem(
   },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
   const { itemId, configuration = null, quantity = null } = params;
 
   log(`mutation updateCartItem ${itemId} ${quantity} ${JSON.stringify(configuration)}`, { userId });
@@ -32,23 +33,28 @@ export default async function updateCartItem(
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  const productId = item.originalProductId || item.productId;
   const product = await modules.products.findProduct({
-    productId,
+    productId: item.productId,
   });
-  if (!product) throw new ProductNotFoundError({ productId });
+  if (!product) throw new ProductNotFoundError({ productId: item.productId });
 
   if (quantity !== null && quantity < 1) throw new OrderQuantityTooLowError({ quantity });
 
-  const updatedOrderPosition = await modules.orders.positions.updateProductItem(
-    { quantity, configuration },
+  await ordersSettings.validateOrderPosition(
     {
       order,
       product,
-      orderPosition: item,
+      configuration,
+      quantityDiff: quantity - item.quantity,
     },
     context,
   );
-  await modules.orders.updateCalculation(order._id, context);
+
+  const updatedOrderPosition = await modules.orders.positions.updateProductItem({
+    orderPositionId: item._id,
+    quantity,
+    configuration,
+  });
+  await services.orders.updateCalculation(order._id);
   return modules.orders.positions.findOrderPosition({ itemId: updatedOrderPosition._id });
 }

package/src/resolvers/mutations/orders/updateOrderDeliveryPickUp.ts

@@ -1,4 +1,4 @@
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 import { log } from '@unchainedshop/logger';
 import { InvalidIdError, OrderDeliveryNotFoundError, OrderDeliveryTypeError } from '../../../errors.js';
@@ -8,7 +8,7 @@ export default async function updateOrderDeliveryPickUp(
   params: { orderDeliveryId: string; orderPickUpLocationId: string; meta: any },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
   const { orderDeliveryId, orderPickUpLocationId, meta } = params;
   log(`mutation updateOrderDeliveryPickUp ${orderDeliveryId} with location ${orderPickUpLocationId}`, {
     userId,
@@ -37,7 +37,7 @@ export default async function updateOrderDeliveryPickUp(
     orderPickUpLocationId,
     meta,
   });
-  await modules.orders.updateCalculation(orderDelivery.orderId, context);
+  await services.orders.updateCalculation(orderDelivery.orderId);
   return modules.orders.deliveries.findDelivery({
     orderDeliveryId,
   });

package/src/resolvers/mutations/orders/updateOrderDeliveryShipping.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 import { OrderDeliveryNotFoundError, InvalidIdError, OrderDeliveryTypeError } from '../../../errors.js';
 
@@ -8,7 +8,7 @@ export default async function updateOrderDeliveryShipping(
   params: { orderDeliveryId: string; address: any; meta: any },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
   const { orderDeliveryId, address, meta } = params;
 
   log(`mutation updateOrderDeliveryShipping ${orderDeliveryId}`, { userId });
@@ -36,7 +36,7 @@ export default async function updateOrderDeliveryShipping(
     address,
     meta,
   });
-  await modules.orders.updateCalculation(orderDelivery.orderId, context);
+  await services.orders.updateCalculation(orderDelivery.orderId);
   return modules.orders.deliveries.findDelivery({
     orderDeliveryId,
   });

package/src/resolvers/mutations/orders/updateOrderPaymentCard.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { PaymentProviderType } from '@unchainedshop/core-payment';
 import { OrderPaymentNotFoundError, InvalidIdError, OrderPaymentTypeError } from '../../../errors.js';
 
@@ -8,7 +8,7 @@ export default async function updateOrderPaymentCard(
   { orderPaymentId, meta }: { orderPaymentId: string; meta?: any },
   context: Context,
 ) {
-  const { modules, userId } = context;
+  const { modules, services, userId } = context;
 
   log(`mutation updateOrderPaymentCard ${orderPaymentId} ${JSON.stringify(meta)}`, { userId });
 
@@ -32,6 +32,6 @@ export default async function updateOrderPaymentCard(
     });
 
   await modules.orders.payments.updateContext(orderPayment._id, { meta });
-  await modules.orders.updateCalculation(orderPayment.orderId, context);
+  await services.orders.updateCalculation(orderPayment.orderId);
   return modules.orders.payments.findOrderPayment({ orderPaymentId });
 }