PICT-219: Cancel Payment via Payments API

processor/src/errors/mollie.error.ts

@@ -2,11 +2,11 @@ import { CTError, CTEnumErrors, CTErrorExtensionExtraInfo } from '../types/comme
 
 // This is based on MollieApiError interface from Mollie's SDK
 /* eslint-disable  @typescript-eslint/no-explicit-any */
-const getExtraInfo = ({ status, statusCode, links, title, field }: any): CTErrorExtensionExtraInfo => {
-  const orginalStatus = status || statusCode;
+export const getExtraInfo = ({ status, statusCode, links, title, field }: any): CTErrorExtensionExtraInfo => {
+  const originalStatus = status || statusCode;
   const extraInfo = Object.assign(
     {},
-    orginalStatus && { originalStatusCode: orginalStatus },
+    originalStatus && { originalStatusCode: originalStatus },
     links && { links },
     title && { title },
     field && { field },

processor/src/mollie/refund.mollie.ts

@@ -16,13 +16,13 @@ export const createPaymentRefund = async (params: CreateParameters): Promise<Ref
     let errorMessage;
 
     if (error instanceof MollieApiError) {
-      errorMessage = `SCTM - createMolliePaymentRefund - Calling Mollie API - error: ${error.message}`;
+      errorMessage = `SCTM - createPaymentRefund - Calling Mollie API - error: ${error.message}`;
     } else {
-      errorMessage = `SCTM - createMolliePaymentRefund - Calling Mollie API - Failed to create refund with unknown errors`;
+      errorMessage = `SCTM - createPaymentRefund - Calling Mollie API - Failed to create refund with unknown errors`;
     }
 
     logger.error(errorMessage, {
-      paymentId: params.paymentId,
+      molliePaymentId: params.paymentId,
       error,
     });
 
@@ -45,13 +45,14 @@ export const getPaymentRefund = async (refundId: string, params: GetParameters)
     let errorMessage;
 
     if (error instanceof MollieApiError) {
-      errorMessage = `getPaymentRefund - error: ${error.message}`;
+      errorMessage = `SCTM - getPaymentRefund - Calling Mollie API - error: ${error.message}`;
     } else {
-      errorMessage = `getPaymentRefund - Failed to cancel the refund with unknown errors`;
+      errorMessage = `SCTM - getPaymentRefund - Calling Mollie API - Failed to cancel the refund with unknown errors`;
     }
 
-    logger.error({
-      message: errorMessage,
+    logger.error(errorMessage, {
+      molliePaymentId: params.paymentId,
+      mollieRefundId: refundId,
       error,
     });
 
@@ -74,9 +75,9 @@ export const cancelPaymentRefund = async (refundId: string, params: CancelParame
     let errorMessage;
 
     if (error instanceof MollieApiError) {
-      errorMessage = `cancelPaymentRefund - error: ${error.message}`;
+      errorMessage = `SCTM - cancelPaymentRefund - Calling Mollie API - error: ${error.message}`;
     } else {
-      errorMessage = `cancelPaymentRefund - Failed to cancel the refund with unknown errors`;
+      errorMessage = `SCTM - cancelPaymentRefund - Calling Mollie API - Failed to cancel the refund with unknown errors`;
     }
 
     logger.error(errorMessage, {

processor/src/service/payment.service.ts

@@ -1,5 +1,5 @@
 import { ControllerResponseType, DeterminePaymentActionType } from '../types/controller.types';
-import { CancelRefundStatusText, ConnectorActions, CustomFields, PAY_LATER_ENUMS } from '../utils/constant.utils';
+import { CancelStatusText, ConnectorActions, CustomFields, PAY_LATER_ENUMS } from '../utils/constant.utils';
 import { List, Method, Payment as MPayment, PaymentMethod } from '@mollie/api-client';
 import { logger } from '../utils/logger.utils';
 import {
@@ -308,23 +308,30 @@ export const handlePaymentCancelRefund = async (ctPayment: Payment): Promise<Con
  * Retrieves the payment cancel actions based on the provided pending refund transaction.
  * Would be used for cancel a payment or cancel a refund
  *
- * @param {Transaction} pendingRefundTransaction - The pending refund transaction.
+ * @param {Transaction} transaction - The pending refund transaction.
  * @return {Action[]} An array of actions including updating the transaction state and setting the transaction custom field value.
  * @throws {CustomError} If the JSON string from the custom field cannot be parsed.
  */
 export const getPaymentCancelActions = (transaction: Transaction, action: DeterminePaymentActionType) => {
   const transactionCustomFieldName = CustomFields.paymentCancelReason;
 
+  let errorPrefix;
+  if (action === ConnectorActions.CancelPayment) {
+    errorPrefix = 'SCTM - handleCancelPayment';
+  } else if (action === ConnectorActions.CancelRefund) {
+    errorPrefix = 'SCTM - handleCancelRefund';
+  }
+
   const transactionCustomFieldValue = parseStringToJsonObject(
-    pendingRefundTransaction.custom?.fields[transactionCustomFieldName],
+    transaction.custom?.fields[transactionCustomFieldName],
     transactionCustomFieldName,
-    'SCTM - handleCancelRefund',
-    pendingRefundTransaction.id,
+    errorPrefix,
+    transaction.id,
   );
 
   const newTransactionCustomFieldValue = {
     reasonText: transactionCustomFieldValue.reasonText,
-    statusText: CancelRefundStatusText,
+    statusText: CancelStatusText,
   };
 
   return [
@@ -352,6 +359,11 @@ export const handleCancelPayment = async (ctPayment: Payment): Promise<Controlle
       molliePaymentId: molliePayment.id,
       commerceToolsPaymentId: ctPayment.id,
     });
+
+    throw new CustomError(
+      400,
+      `SCTM - handleCancelPayment - Payment is not cancelable, Mollie Payment ID: ${molliePayment.id}`,
+    );
   }
 
   await cancelPayment(molliePayment.id);

processor/src/utils/constant.utils.ts

@@ -34,4 +34,4 @@ export const ErrorMessages = {
 
 export const PAY_LATER_ENUMS = [PaymentMethod.klarnapaylater, PaymentMethod.klarnasliceit];
 
-export const CancelRefundStatusText = 'Cancelled from shop side';
+export const CancelStatusText = 'Cancelled from shop side';

processor/src/utils/paymentAction.utils.ts

@@ -48,7 +48,7 @@ const getTransactionGroups = (transactions: Transaction[]) => {
   return groups;
 };
 
-const determineAction = (groups: ReturnType<typeof getTransactionGroups>, key?: string): DeterminePaymentActionType => {
+const determineAction = (groups: ReturnType<typeof getTransactionGroups>): DeterminePaymentActionType => {
   if (groups.initialCharge.length > 1) {
     throw new CustomError(400, 'Only one transaction can be in "Initial" state at any time');
   }
@@ -60,14 +60,7 @@ const determineAction = (groups: ReturnType<typeof getTransactionGroups>, key?:
     );
   }
 
-  if (groups.pendingCharge.length && !key) {
-    throw new CustomError(
-      400,
-      'Cannot create a Transaction in state "Pending". This state is reserved to indicate the transaction has been accepted by the payment service provider',
-    );
-  }
-
-  if ((key || groups.initialCharge.length === 1) && !groups.successCharge.length && !groups.pendingCharge.length) {
+  if (groups.initialCharge.length === 1 && !groups.successCharge.length && !groups.pendingCharge.length) {
     return ConnectorActions.CreatePayment;
   }
 
@@ -106,8 +99,8 @@ export const determinePaymentAction = (ctPayment?: Payment): DeterminePaymentAct
     return ConnectorActions.GetPaymentMethods;
   }
 
-  const { key, transactions } = ctPayment;
+  const { transactions } = ctPayment;
   const groups = getTransactionGroups(transactions);
 
-  return determineAction(groups, key);
+  return determineAction(groups);
 };

processor/src/validators/payment.validators.ts

@@ -177,6 +177,31 @@ export const checkValidRefundTransactionForCancel = (ctPayment: CTPayment): bool
   return true;
 };
 
+/**
+ * Checks if the given Commercetools Payment object has a valid success charge transaction.
+ *
+ * @param {CTPayment} ctPayment - The Commercetools Payment object to check.
+ * @return {true | CustomError} Returns true if the refund transaction is valid, otherwise exception.
+ */
+export const checkValidPendingAuthorizationTransaction = (ctPayment: CTPayment): boolean => {
+  const pendingAuthorizationTransaction = ctPayment.transactions.find(
+    (transaction) =>
+      transaction.type === CTTransactionType.Authorization && transaction.state === CTTransactionState.Pending,
+  );
+
+  if (!pendingAuthorizationTransaction?.interactionId) {
+    logger.error(
+      `SCTM - handleCancelPayment - Cannot get the Mollie payment ID from CommerceTools transaction, CommerceTools Transaction ID: ${pendingAuthorizationTransaction?.id}.`,
+    );
+    throw new CustomError(
+      400,
+      `SCTM - handleCancelPayment - Cannot get the Mollie payment ID from CommerceTools transaction, CommerceTools Transaction ID: ${pendingAuthorizationTransaction?.id}.`,
+    );
+  }
+
+  return true;
+};
+
 /**
  * Checks whether the payment method specific parameters are present in the payment object
  * Currently, only perform the check with two payment methods: applepay and creditcard
@@ -259,6 +284,9 @@ export const validateCommerceToolsPaymentPayload = (
     case ConnectorActions.CreatePayment:
       checkPaymentMethodInput(connectorAction, ctPayment);
       break;
+    case ConnectorActions.CancelPayment:
+      checkValidPendingAuthorizationTransaction(ctPayment);
+      break;
     case ConnectorActions.CreateRefund:
       checkValidSuccessChargeTransaction(ctPayment);
       checkValidRefundTransactionForCreate(ctPayment);

processor/tests/controllers/payment.controller.spec.ts

@@ -9,11 +9,7 @@ import {
   handlePaymentCancelRefund,
   handleCreateRefund,
 } from '../../src/service/payment.service';
-import {
-  CancelRefundStatusText,
-  ConnectorActions,
-  CustomFields as CustomFieldName,
-} from '../../src/utils/constant.utils';
+import { CancelStatusText, ConnectorActions, CustomFields as CustomFieldName } from '../../src/utils/constant.utils';
 import { validateCommerceToolsPaymentPayload } from '../../src/validators/payment.validators';
 
 jest.mock('../../src/service/payment.service', () => ({
@@ -289,7 +285,7 @@ describe('Test payment.controller.ts', () => {
 
     const transactionCustomFieldValue = JSON.stringify({
       responseText: 'Manually cancelled',
-      statusText: CancelRefundStatusText,
+      statusText: CancelStatusText,
     });
 
     const handlePaymentCancelRefundResponse = {

processor/tests/errors/mollie.error.spec.ts

@@ -0,0 +1,78 @@
+import { CTEnumErrors } from './../../src/types/commercetools.types';
+import { jest, expect, describe, it } from '@jest/globals';
+import { formatErrorResponse, getExtraInfo } from '../../src/errors/mollie.error';
+
+describe('Test getExtraInfo', () => {
+  it('should return correct information', () => {
+    const input = {
+      status: 'Error',
+      statusCode: 400,
+      links: 'dummy link',
+      title: 'dummy title',
+      field: 'dummy field',
+      test: 'test',
+    };
+
+    const result = getExtraInfo(input);
+
+    expect(result).toEqual({
+      originalStatusCode: input.status,
+      field: input.field,
+      links: input.links,
+      title: input.title,
+    });
+  });
+});
+
+describe('Test formatErrorResponse', () => {
+  jest.spyOn(require('../../src/errors/mollie.error'), 'getExtraInfo');
+
+  it('should return syntax error', () => {
+    const error = {
+      statusCode: 400,
+      message: 'Something wrong happened',
+    };
+
+    const result = formatErrorResponse(error);
+
+    expect(getExtraInfo).toBeCalledTimes(1);
+    expect(getExtraInfo).toBeCalledWith(error);
+
+    expect(result).toEqual({
+      status: 400,
+      errors: [
+        {
+          code: CTEnumErrors.SyntaxError,
+          message: error.message,
+          extensionExtraInfo: {
+            originalStatusCode: error.statusCode,
+          },
+        },
+      ],
+    });
+  });
+
+  it('should return general error', () => {
+    const error = {
+      statusCode: 500,
+    };
+
+    const result = formatErrorResponse(error);
+
+    expect(getExtraInfo).toBeCalledTimes(1);
+    expect(getExtraInfo).toBeCalledWith(error);
+
+    expect(result).toEqual({
+      status: 400,
+      errors: [
+        {
+          code: CTEnumErrors.General,
+          message: 'Please see logs for more details',
+          extensionExtraInfo: {
+            originalStatusCode: error.statusCode,
+          },
+        },
+      ],
+    });
+  });
+});

processor/tests/mollie/payment.mollie.spec.ts

@@ -1,28 +1,29 @@
 import { jest, expect, describe, it, afterEach } from '@jest/globals';
-import { cancelPayment, createMolliePayment, getPaymentById, listPaymentMethods } from '../../src/mollie/payment.mollie';
+import {
+  cancelPayment,
+  createMolliePayment,
+  getPaymentById,
+  listPaymentMethods,
+} from '../../src/mollie/payment.mollie';
 import { MollieApiError, PaymentCreateParams } from '@mollie/api-client';
 import { logger } from '../../src/utils/logger.utils';
 import CustomError from '../../src/errors/custom.error';
 
 const mockPaymentsCreate = jest.fn();
 const mockPaymentsGet = jest.fn();
 const mockPaymentsList = jest.fn();
-const mockPaymentRefundGet = jest.fn();
-const mockPaymentRefundCancel = jest.fn();
+const mockPaymentCancel = jest.fn();
 
 jest.mock('../../src/client/mollie.client', () => ({
   initMollieClient: jest.fn(() => ({
     payments: {
       create: mockPaymentsCreate,
       get: mockPaymentsGet,
+      cancel: mockPaymentCancel,
     },
     methods: {
       list: mockPaymentsList,
     },
-    paymentRefunds: {
-      get: mockPaymentRefundGet,
-      cancel: mockPaymentRefundCancel,
-    },
   })),
 }));
 
@@ -198,18 +199,18 @@ describe('cancelPayment', () => {
     jest.clearAllMocks(); // Clear all mocks after each test
   });
 
-  it('should call cancel refund with the correct parameters', async () => {
+  it('should call cancel payment with the correct parameters', async () => {
     await cancelPayment('tr_WDqYK6vllg');
 
-    expect(mockPaymentRefundCancel).toHaveBeenCalledTimes(1);
-    expect(mockPaymentRefundCancel).toHaveBeenCalledWith('tr_WDqYK6vllg');
+    expect(mockPaymentCancel).toHaveBeenCalledTimes(1);
+    expect(mockPaymentCancel).toHaveBeenCalledWith('tr_WDqYK6vllg');
   });
 
   it('should be able to return a proper error message when error which is an instance of MollieApiError occurred', async () => {
     const errorMessage = 'Something wrong happened';
-    const mollieApiError = new MollieApiError(errorMessage);
+    const mollieApiError = new MollieApiError(errorMessage, { field: 'paymentId' });
 
-    (mockPaymentRefundCancel as jest.Mock).mockImplementation(() => {
+    (mockPaymentCancel as jest.Mock).mockImplementation(() => {
       throw mollieApiError;
     });
 
@@ -218,7 +219,7 @@ describe('cancelPayment', () => {
     } catch (error: unknown) {
       expect(error).toBeInstanceOf(CustomError);
       expect(logger.error).toBeCalledTimes(1);
-      expect(logger.error).toBeCalledWith(`SCTM - cancelPayment - error: ${errorMessage}`,{
+      expect(logger.error).toBeCalledWith(`SCTM - cancelPayment - error: ${errorMessage}, field: paymentId`, {
         error: mollieApiError,
       });
     }
@@ -227,7 +228,7 @@ describe('cancelPayment', () => {
   it('should be able to return a proper error message when error which is not an instance of MollieApiError occurred', async () => {
     const unexpectedError = new CustomError(400, 'dummy message');
 
-    (mockPaymentRefundCancel as jest.Mock).mockImplementation(() => {
+    (mockPaymentCancel as jest.Mock).mockImplementation(() => {
       throw unexpectedError;
     });
 
@@ -236,8 +237,7 @@ describe('cancelPayment', () => {
     } catch (error: unknown) {
       expect(error).toBeInstanceOf(CustomError);
       expect(logger.error).toBeCalledTimes(1);
-      expect(logger.error).toBeCalledWith({
-        message: `SCTM - cancelPayment - Failed to cancel payments with unknown errors`,
+      expect(logger.error).toBeCalledWith('SCTM - cancelPayment - Failed to cancel payments with unknown errors', {
         error: unexpectedError,
       });
     }