@unchainedshop/plugins 3.0.0-alpha7 → 3.0.0-rc2

package/src/payment/datatrans-v2/index.ts

@@ -1,9 +1,6 @@
-import { IPaymentAdapter } from '@unchainedshop/core-payment';
-import { PaymentAdapter, PaymentError, PaymentDirector } from '@unchainedshop/core-payment';
 import { createLogger } from '@unchainedshop/logger';
-import { PaymentPricingRowCategory } from '@unchainedshop/core-payment';
 import createDatatransAPI from './api/index.js';
-import type {
+import {
   AuthorizeAuthenticatedResponseSuccess,
   AuthorizeResponseSuccess,
   InitResponseSuccess,
@@ -13,6 +10,15 @@ import type {
 } from './api/types.js';
 import parseRegistrationData from './parseRegistrationData.js';
 import roundedAmountFromOrder from './roundedAmountFromOrder.js';
+import {
+  IPaymentAdapter,
+  PaymentAdapter,
+  PaymentDirector,
+  PaymentError,
+  PaymentPricingRowCategory,
+  PaymentPricingSheet,
+  OrderPricingSheet,
+} from '@unchainedshop/core';
 
 export * from './middleware.js';
 
@@ -57,11 +63,9 @@ const Datatrans: IPaymentAdapter = {
     return type === 'GENERIC';
   },
 
-  actions: (params) => {
-    const { modules } = params.context;
-
+  actions: (config, context) => {
     const getMerchantId = (): string | undefined => {
-      return params.config.find((item) => item.key === 'merchantId')?.value || DATATRANS_MERCHANT_ID;
+      return config.find((item) => item.key === 'merchantId')?.value || DATATRANS_MERCHANT_ID;
     };
 
     const api = () => {
@@ -70,7 +74,7 @@ const Datatrans: IPaymentAdapter = {
     };
 
     const shouldSettleInUnchained = () => {
-      return params.config.reduce((current, item) => {
+      return config.reduce((current, item) => {
         if (item.key === 'settleInUnchained') return Boolean(item.value);
         return current;
       }, true);
@@ -83,18 +87,21 @@ const Datatrans: IPaymentAdapter = {
         commission: number;
       }[]
     > => {
-      const { order, orderPayment } = params.paymentContext;
+      const { order, orderPayment } = context;
+
+      const pricingForOrderPayment = PaymentPricingSheet({
+        calculation: orderPayment.calculation,
+        currency: order.currency,
+      });
+      const pricing = OrderPricingSheet({
+        calculation: order.calculation,
+        currency: order.currency,
+      });
 
-      const pricingForOrderPayment = modules.orders.payments.pricingSheet(
-        orderPayment,
-        order.currency,
-        params.context,
-      );
-      const pricing = modules.orders.pricingSheet(order);
       const { amount: total } = pricing.total({ useNetPrice: false });
 
       return Promise.all(
-        params.config
+        config
           .filter((item) => item.key === 'marketplaceSplit')
           .map((item) => {
             const [subMerchantId, staticDiscountId, sharePercentage] = item.value
@@ -119,11 +126,11 @@ const Datatrans: IPaymentAdapter = {
     };
 
     const authorize = async ({ paymentCredentials, ...arbitraryFields }): Promise<string> => {
-      const { order, orderPayment } = params.paymentContext;
+      const { order, orderPayment } = context;
       const refno = Buffer.from(orderPayment._id, 'hex').toString('base64');
-      const userId = order?.userId || params.paymentContext?.userId;
+      const userId = order?.userId || context?.userId;
       const refno2 = userId;
-      const { currency, amount } = roundedAmountFromOrder(order, params.context);
+      const { currency, amount } = roundedAmountFromOrder(order);
       const splits = await getMarketplaceSplits();
       const result = await api().authorize({
         ...arbitraryFields,
@@ -152,8 +159,8 @@ const Datatrans: IPaymentAdapter = {
       refno2,
       ...arbitraryFields
     }): Promise<string> => {
-      const { order } = params.paymentContext;
-      const { currency, amount } = roundedAmountFromOrder(order, params.context);
+      const { order } = context;
+      const { currency, amount } = roundedAmountFromOrder(order);
       const result = await api().authorizeAuthenticated({
         ...arbitraryFields,
         transactionId,
@@ -168,13 +175,13 @@ const Datatrans: IPaymentAdapter = {
     };
 
     const isTransactionAmountValid = (transaction: StatusResponseSuccess): boolean => {
-      const { order } = params.paymentContext;
-      const { currency, amount } = roundedAmountFromOrder(order, params.context);
+      const { order } = context;
+      const { currency, amount } = roundedAmountFromOrder(order);
       if (
         transaction.currency !== currency ||
         (transaction.detail.authorize as any)?.amount !== amount
       ) {
-        logger.verbose(
+        logger.info(
           `currency: ${transaction.currency} === ${currency} => ${
             transaction.currency === currency
           }, amount: ${(transaction.detail.authorize as any)?.amount} === ${amount} => ${
@@ -202,8 +209,8 @@ const Datatrans: IPaymentAdapter = {
     };
 
     const settle = async ({ transactionId, refno, refno2, extensions }): Promise<boolean> => {
-      const { order } = params.paymentContext;
-      const { currency, amount } = roundedAmountFromOrder(order, params.context);
+      const { order } = context;
+      const { currency, amount } = roundedAmountFromOrder(order);
       const splits = await getMarketplaceSplits();
       const result = await api().settle({
         transactionId,
@@ -232,7 +239,7 @@ const Datatrans: IPaymentAdapter = {
     };
 
     const adapterActions = {
-      ...PaymentAdapter.actions(params),
+      ...PaymentAdapter.actions(config, context),
 
       configurationError() {
         if (!getMerchantId() || !DATATRANS_SECRET || !DATATRANS_SIGN_KEY) {
@@ -252,15 +259,13 @@ const Datatrans: IPaymentAdapter = {
 
       async sign(transactionContext: any = {}) {
         const { useSecureFields = false, ...arbitraryFields } = transactionContext || {};
-        const { orderPayment, paymentProviderId, order } = params.paymentContext;
+        const { orderPayment, paymentProviderId, order } = context;
         const refno = Buffer.from(orderPayment ? orderPayment._id : paymentProviderId, 'hex').toString(
           'base64',
         );
-        const userId = order?.userId || params.paymentContext?.userId;
+        const userId = order?.userId || context?.userId;
         const refno2 = userId;
-        const price: { amount?: number; currency?: string } = order
-          ? roundedAmountFromOrder(order, params.context)
-          : {};
+        const price: { amount?: number; currency?: string } = order ? roundedAmountFromOrder(order) : {};
 
         if (useSecureFields) {
           const result = await api().secureFields({
@@ -314,7 +319,7 @@ const Datatrans: IPaymentAdapter = {
 
       async confirm() {
         if (!shouldSettleInUnchained()) return false;
-        const { orderPayment, transactionContext } = params.paymentContext;
+        const { orderPayment, transactionContext } = context;
         const { transactionId } = orderPayment;
 
         const { extensions } = transactionContext || {};
@@ -344,7 +349,7 @@ const Datatrans: IPaymentAdapter = {
 
       async cancel() {
         if (!shouldSettleInUnchained()) return false;
-        const { orderPayment } = params.paymentContext;
+        const { orderPayment } = context;
         const { transactionId } = orderPayment;
         if (!transactionId) {
           return false;
@@ -437,7 +442,7 @@ const Datatrans: IPaymentAdapter = {
           // at the dumbest possible moment
           try {
             checkIfTransactionAmountValid(transactionId, settledTransaction);
-            credentials = parseRegistrationData(settledTransaction);
+            credentials = await parseRegistrationData(settledTransaction);
             const result = await api().status({
               transactionId,
             });

package/src/payment/datatrans-v2/middleware.ts

@@ -1,8 +1,7 @@
 import { createLogger } from '@unchainedshop/logger';
 import { Context } from '@unchainedshop/api';
 import generateSignature, { Security } from './generateSignature.js';
-
-import type { StatusResponseSuccess } from './api/types.js';
+import { StatusResponseSuccess } from './api/types.js';
 
 const {
   DATATRANS_SIGN_KEY,
@@ -14,14 +13,14 @@ const logger = createLogger('unchained:core-payment:datatrans:webhook');
 
 export const datatransHandler = async (req, res) => {
   const resolvedContext = req.unchainedContext as Context;
-  const { modules } = resolvedContext;
+  const { modules, services } = resolvedContext;
   const signature = req.headers['datatrans-signature'];
   if (req.method === 'POST' && signature) {
     const [rawTimestamp, rawHash] = signature.split(',');
     const [, hash] = rawHash.split('=');
     const [, timestamp] = rawTimestamp.split('=');
 
-    const comparableSignature = generateSignature({
+    const comparableSignature = await generateSignature({
       security: DATATRANS_SECURITY as any,
       signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
     })(timestamp, req.body);
@@ -35,7 +34,7 @@ export const datatransHandler = async (req, res) => {
 
     const transaction: StatusResponseSuccess = JSON.parse(req.body) as StatusResponseSuccess;
 
-    logger.verbose(`received request`, {
+    logger.info(`received request`, {
       type: transaction.type,
     });
 
@@ -46,10 +45,9 @@ export const datatransHandler = async (req, res) => {
       try {
         if (transaction.type === 'card_check') {
           const paymentProviderId = referenceId;
-          const paymentCredentials = await modules.payment.registerCredentials(
+          const paymentCredentials = await services.orders.registerPaymentCredentials(
             paymentProviderId,
             { userId, transactionContext: { transactionId: transaction.transactionId } },
-            resolvedContext,
           );
           logger.info(`registered payment credentials for ${userId}`, {
             userId,
@@ -65,11 +63,9 @@ export const datatransHandler = async (req, res) => {
           });
           if (!orderPayment) throw new Error(`Order Payment with id ${orderPaymentId} not found`);
 
-          const order = await modules.orders.checkout(
-            orderPayment.orderId,
-            { paymentContext: { userId, transactionId: transaction.transactionId } },
-            resolvedContext,
-          );
+          const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+            paymentContext: { userId, transactionId: transaction.transactionId },
+          });
           res.writeHead(200);
           logger.info(`confirmed checkout for order ${order.orderNumber}`, {
             orderId: order._id,

package/src/payment/datatrans-v2/parseRegistrationData.ts

@@ -1,12 +1,12 @@
 import splitProperties from './splitProperties.js';
-import type { StatusResponseSuccess } from './api/types.js';
+import { StatusResponseSuccess } from './api/types.js';
+import { sha256 } from '@unchainedshop/utils';
 
-export default function parseRegistrationData(transaction: StatusResponseSuccess) {
+export default async function parseRegistrationData(transaction: StatusResponseSuccess) {
   const parsed = Object.entries(transaction).reduce((acc, [objectKey, payload]) => {
-    const { token, info, _id } = splitProperties({ objectKey, payload });
+    const { token, info } = splitProperties({ objectKey, payload });
     if (token) {
       return {
-        _id,
         token,
         info,
         objectKey,
@@ -14,14 +14,16 @@ export default function parseRegistrationData(transaction: StatusResponseSuccess
     }
     return acc;
   }, {}) as {
-    _id?: string;
     token?: Record<string, unknown>;
     info?: Record<string, unknown>;
     objectKey?: string;
   };
   if (parsed.objectKey) {
+    const _id = await sha256(parsed.token);
+
     return {
       ...parsed,
+      _id,
       paymentMethod: transaction.paymentMethod,
       currency: transaction.currency,
       language: transaction.language,

package/src/payment/datatrans-v2/roundedAmountFromOrder.ts

@@ -1,11 +1,11 @@
-import { UnchainedCore } from '@unchainedshop/core';
+import { OrderPricingSheet } from '@unchainedshop/core';
 import { Order } from '@unchainedshop/core-orders';
 
-const roundedAmountFromOrder = (
-  order: Order,
-  context: UnchainedCore,
-): { currency: string; amount: number } => {
-  const pricing = context.modules.orders.pricingSheet(order);
+const roundedAmountFromOrder = (order: Order): { currency: string; amount: number } => {
+  const pricing = OrderPricingSheet({
+    calculation: order.calculation,
+    currency: order.currency,
+  });
   const { currency, amount } = pricing.total({ useNetPrice: false });
   return {
     currency,

package/src/payment/datatrans-v2/splitProperties.ts

@@ -1,10 +1,8 @@
 // This method splits the return data of alias registration to the important properties needed for validation and the additional data
-import crypto from 'crypto';
 
 export default function splitProperties({ objectKey, payload }: { objectKey?: string; payload: any }): {
   token?: string;
   info: any;
-  _id?: string;
 } {
   if (!payload || !objectKey) return { info: {} };
 
@@ -21,12 +19,9 @@ export default function splitProperties({ objectKey, payload }: { objectKey?: st
       expiryYear,
       '3D': is3DActive ? payload['3D'] : undefined,
     });
-    const _id = crypto.createHash('sha256').update(token).digest('hex');
-
     return {
       token,
       info,
-      _id,
     };
   }
 

package/src/payment/invoice-prepaid.ts

@@ -1,5 +1,5 @@
-import { IPaymentAdapter } from '@unchainedshop/core-payment';
-import { PaymentDirector, PaymentAdapter, PaymentProviderType } from '@unchainedshop/core-payment';
+import { IPaymentAdapter, PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
 
 const InvoicePrepaid: IPaymentAdapter = {
   ...PaymentAdapter,
@@ -14,9 +14,9 @@ const InvoicePrepaid: IPaymentAdapter = {
     return type === PaymentProviderType.INVOICE;
   },
 
-  actions: (params) => {
+  actions: (config, context) => {
     return {
-      ...PaymentAdapter.actions(params),
+      ...PaymentAdapter.actions(config, context),
 
       configurationError: () => {
         return null;

package/src/payment/invoice.ts

@@ -1,5 +1,5 @@
-import { IPaymentAdapter } from '@unchainedshop/core-payment';
-import { PaymentDirector, PaymentAdapter, PaymentProviderType } from '@unchainedshop/core-payment';
+import { IPaymentAdapter, PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
 
 const Invoice: IPaymentAdapter = {
   ...PaymentAdapter,
@@ -14,9 +14,9 @@ const Invoice: IPaymentAdapter = {
     return type === PaymentProviderType.INVOICE;
   },
 
-  actions: (params) => {
+  actions: (config, context) => {
     return {
-      ...PaymentAdapter.actions(params),
+      ...PaymentAdapter.actions(config, context),
 
       configurationError: () => {
         return null;

package/src/payment/paypal-checkout.ts

@@ -1,9 +1,16 @@
-import { IPaymentAdapter } from '@unchainedshop/core-payment';
-import { PaymentDirector, PaymentAdapter, PaymentError } from '@unchainedshop/core-payment';
+import {
+  OrderPricingSheet,
+  IPaymentAdapter,
+  PaymentAdapter,
+  PaymentDirector,
+  PaymentError,
+} from '@unchainedshop/core';
 import { createLogger } from '@unchainedshop/logger';
 
 let checkoutNodeJssdk;
 try {
+  // eslint-disable-next-line
+  // @ts-ignore
   checkoutNodeJssdk = await import('@paypal/checkout-server-sdk');
 } catch {
   /* */
@@ -41,9 +48,9 @@ const PaypalCheckout: IPaymentAdapter = {
     return type === 'GENERIC';
   },
 
-  actions: (params) => {
+  actions: (config, context) => {
     const adapter = {
-      ...PaymentAdapter.actions(params),
+      ...PaymentAdapter.actions(config, context),
 
       configurationError: () => {
         const publicCredentialsValid = PAYPAL_CLIENT_ID && PAYPAL_SECRET;
@@ -68,8 +75,7 @@ const PaypalCheckout: IPaymentAdapter = {
       },
 
       charge: async ({ orderID }) => {
-        const { modules } = params.context;
-        const { order } = params.paymentContext;
+        const { order } = context;
 
         if (!orderID) {
           logger.warn('Paypal Native Plugin: PRICE MATCH');
@@ -81,7 +87,10 @@ const PaypalCheckout: IPaymentAdapter = {
           const client = new checkoutNodeJssdk.core.PayPalHttpClient(environment());
           const paypalOrder = await client.execute(request);
 
-          const pricing = modules.orders.pricingSheet(order);
+          const pricing = OrderPricingSheet({
+            calculation: order.calculation,
+            currency: order.currency,
+          });
           const ourTotal = (pricing.total({ useNetPrice: false }).amount / 100).toFixed(2);
           const paypalTotal = paypalOrder.result.purchase_units[0].amount.value;
 

package/src/payment/payrexx/api/makeFetcher.ts

@@ -1,4 +1,3 @@
-/// <reference lib="dom" />
 import fs from 'fs';
 import util from 'util';
 import { resolve } from 'path';
@@ -48,7 +47,7 @@ export default (
       new TextEncoder().encode(secret),
       { name: 'HMAC', hash: 'SHA-256' },
       false,
-      ['sign', 'verify'],
+      ['sign'],
     );
     const signature = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(query));
     return btoa(String.fromCharCode(...new Uint8Array(signature)));
@@ -61,7 +60,7 @@ export default (
   };
 
   return async (path: string, method: 'GET' | 'DELETE' | 'POST', data?: any): Promise<Response> => {
-    logger.verbose(`${method} ${path}`);
+    logger.info(`${method} ${path}`);
     if (method === 'POST') {
       const queryParams = { ...data };
       const signature = await buildSignature(new URLSearchParams(queryParams).toString());

package/src/payment/payrexx/index.ts

@@ -1,8 +1,13 @@
-import { IPaymentAdapter } from '@unchainedshop/core-payment';
-import { PaymentAdapter, PaymentDirector, PaymentError } from '@unchainedshop/core-payment';
 import { createLogger } from '@unchainedshop/logger';
 import { mapOrderDataToGatewayObject, mapUserToGatewayObject } from './payrexx.js';
 import createPayrexxAPI, { GatewayObjectStatus } from './api/index.js';
+import {
+  OrderPricingSheet,
+  IPaymentAdapter,
+  PaymentAdapter,
+  PaymentDirector,
+  PaymentError,
+} from '@unchainedshop/core';
 
 export * from './middleware.js';
 
@@ -19,17 +24,17 @@ const Payrexx: IPaymentAdapter = {
     return type === 'GENERIC';
   },
 
-  actions: (params) => {
-    const { modules } = params.context;
+  actions: (config, context) => {
+    const { modules } = context;
 
     const getInstance = () => {
-      return params.config.find((c) => c.key === 'instance')?.value;
+      return config.find((c) => c.key === 'instance')?.value;
     };
 
     const api = createPayrexxAPI(getInstance(), process.env.PAYREXX_SECRET);
 
     const adapterActions = {
-      ...PaymentAdapter.actions(params),
+      ...PaymentAdapter.actions(config, context),
 
       configurationError() {
         if (!process.env.PAYREXX_SECRET) {
@@ -51,10 +56,13 @@ const Payrexx: IPaymentAdapter = {
       },
 
       sign: async (transactionContext = {}) => {
-        const { orderPayment, userId, order } = params.paymentContext;
+        const { orderPayment, userId, order } = context;
         if (orderPayment) {
           // Order Checkout signing (One-time payment)
-          const pricing = await modules.orders.pricingSheet(order);
+          const pricing = OrderPricingSheet({
+            calculation: order.calculation,
+            currency: order.currency,
+          });
           const gatewayObject = mapOrderDataToGatewayObject(
             { order, orderPayment, pricing },
             transactionContext,
@@ -94,13 +102,13 @@ const Payrexx: IPaymentAdapter = {
         //   transactionId,
         // })) as StatusResponseSuccess;
         // if (result.transactionId) {
-        //   return parseRegistrationData(result);
+        //   return await parseRegistrationData(result);
         // }
         return null;
       },
 
       async confirm() {
-        const { orderPayment } = params.paymentContext;
+        const { orderPayment } = context;
         const { transactionId } = orderPayment;
 
         if (!transactionId) {
@@ -133,7 +141,7 @@ const Payrexx: IPaymentAdapter = {
       },
 
       async cancel() {
-        const { orderPayment } = params.paymentContext;
+        const { orderPayment } = context;
         const { transactionId } = orderPayment;
         if (!transactionId) {
           return false;
@@ -164,7 +172,7 @@ const Payrexx: IPaymentAdapter = {
           throw new Error('You have to provide gatewayId or paymentCredentials');
         }
 
-        const { order } = params.paymentContext;
+        const { order } = context;
         const orderPayment = await modules.orders.payments.findOrderPayment({
           orderPaymentId: order.paymentId,
         });
@@ -175,7 +183,10 @@ const Payrexx: IPaymentAdapter = {
           throw new Error('Could not load gateway from the Payrexx API');
         }
 
-        const pricing = await modules.orders.pricingSheet(order);
+        const pricing = OrderPricingSheet({
+          calculation: order.calculation,
+          currency: order.currency,
+        });
         const { currency, amount } = pricing.total({ useNetPrice: false });
 
         if (
@@ -195,7 +206,7 @@ const Payrexx: IPaymentAdapter = {
             }
 
             // confirm will do the transition, to do a checkout those stati above are fine
-            logger.verbose(`Mark as charged, status is ${gatewayObject.status}`, {
+            logger.info(`Mark as charged, status is ${gatewayObject.status}`, {
               orderPaymentId: gatewayObject.referenceId,
             });
             return {
@@ -214,7 +225,7 @@ const Payrexx: IPaymentAdapter = {
           }
         }
 
-        logger.verbose('Charge not possible', {
+        logger.info('Charge not possible', {
           orderPaymentId: gatewayObject.referenceId,
           status: gatewayObject.status,
         });

package/src/payment/payrexx/middleware.ts

@@ -5,12 +5,12 @@ const logger = createLogger('unchained:core-payment:payrexx:webhook');
 
 export const payrexxHandler = async (request, response) => {
   const resolvedContext = request.unchainedContext as Context;
-  const { modules } = resolvedContext;
+  const { modules, services } = resolvedContext;
 
   const { transaction } = request.body;
 
   if (!transaction) {
-    logger.verbose(`unhandled event type`, {
+    logger.info(`unhandled event type`, {
       type: Object.keys(request.body).join(','),
     });
     response.writeHead(200);
@@ -25,7 +25,7 @@ export const payrexxHandler = async (request, response) => {
   if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
     // Ignore confirmed transactions, because those hooks are generated through calling the confirm()
     // method in the payment adapter and could lead to double bookings.
-    logger.verbose(`unhandled transaction state: ${transaction.status}`);
+    logger.info(`unhandled transaction state: ${transaction.status}`);
     response.writeHead(200);
     response.end(
       JSON.stringify({
@@ -36,7 +36,7 @@ export const payrexxHandler = async (request, response) => {
     return;
   }
 
-  logger.verbose(`Processing event`, {
+  logger.info(`Processing event`, {
     transactionId: transaction.id,
   });
   try {
@@ -44,12 +44,11 @@ export const payrexxHandler = async (request, response) => {
       // Pre-Authorization Flow, referenceId is a userId
       const { referenceId: paymentProviderId, invoice } = transaction;
       const userId = '';
-      logger.verbose(`register credentials for: ${userId}`);
-      await modules.payment.registerCredentials(
-        paymentProviderId,
-        { userId, transactionContext: { gatewayId: invoice.paymentRequestId } },
-        resolvedContext,
-      );
+      logger.info(`register credentials for: ${userId}`);
+      await services.orders.registerPaymentCredentials(paymentProviderId, {
+        userId,
+        transactionContext: { gatewayId: invoice.paymentRequestId },
+      });
       logger.info(`registration successful`, {
         paymentProviderId,
         userId,
@@ -64,7 +63,7 @@ export const payrexxHandler = async (request, response) => {
       );
     } else {
       const { referenceId: orderPaymentId, invoice } = transaction;
-      logger.verbose(`checkout with orderPaymentId: ${orderPaymentId}`);
+      logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
       await modules.orders.payments.logEvent(orderPaymentId, {
         transactionId: transaction.id,
       });
@@ -75,15 +74,11 @@ export const payrexxHandler = async (request, response) => {
         throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
       }
 
-      const order = await modules.orders.checkout(
-        orderPayment.orderId,
-        {
-          paymentContext: {
-            gatewayId: invoice.paymentRequestId,
-          },
+      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+        paymentContext: {
+          gatewayId: invoice.paymentRequestId,
         },
-        resolvedContext,
-      );
+      });
       logger.info(`checkout successful`, {
         orderPaymentId,
         orderId: order._id,