@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/commercetools/services/ct-cart.service.ts

@@ -0,0 +1,316 @@
+import { getGiftCardPlannedAmountFromContext } from '@api';
+import type { ContextProvider, RequestContextData } from '@api-types';
+import type {
+  Address,
+  Cart,
+  Payment,
+  Shipping,
+  Transaction,
+} from '@commercetools/platform-sdk';
+import {
+  ErrorInvalidOperation,
+  ErrorReferencedResourceNotFound,
+} from '@errorx';
+import type { Logger } from '@logger-types';
+import { CommercetoolsAPIError } from '@/commercetools/errors/ct-api.error.js';
+import type {
+  AddPayment,
+  CommercetoolsAPI,
+} from '@/commercetools/types/api.type.js';
+import type {
+  CartService,
+  CartServiceOptions,
+  GetCart,
+  GetCartByPaymentIdRequest,
+  GetNormalizedShipping,
+  GetOneShippingAddress,
+  GetPaymentAmount,
+  NormalizedShipping,
+} from '@/commercetools/types/cart.type.js';
+import type { PaymentAmount } from '@/commercetools/types/payment.type.js';
+
+/**
+ * Default implementation of the CartService interface.
+ */
+export class DefaultCartService implements CartService {
+  private ctAPI: CommercetoolsAPI;
+  private logger: Logger;
+  private contextProvider: ContextProvider<RequestContextData>;
+
+  constructor(opts: CartServiceOptions) {
+    this.ctAPI = opts.ctAPI;
+    this.logger = opts.logger;
+    this.contextProvider = opts.contextProvider;
+  }
+
+  public async getCartByPaymentId(
+    opts: GetCartByPaymentIdRequest,
+  ): Promise<Cart> {
+    const queryPredicate = `paymentInfo(payments(id = "${opts.paymentId}"))`;
+
+    const result = await this.ctAPI.cart.find(queryPredicate);
+
+    if (result.count !== 1) {
+      throw new ErrorReferencedResourceNotFound(
+        'cart',
+        queryPredicate,
+        undefined,
+        {
+          privateFields: {
+            queryPredicate,
+            paymentId: opts.paymentId,
+          },
+          privateMessage: 'Could not find a cart with the given paymentId',
+        },
+      );
+    }
+
+    return result.results[0];
+  }
+
+  public async getCart(opts: GetCart): Promise<Cart> {
+    return await this.ctAPI.cart.getCartById(opts.id);
+  }
+
+  public async getPlannedPaymentAmount(
+    opts: GetPaymentAmount,
+  ): Promise<PaymentAmount> {
+    const giftCardPlannedAmount = getGiftCardPlannedAmountFromContext(
+      this.contextProvider.getContextData(),
+    );
+    const paidAmount = await this.calculateTotalPaidAmount(opts.cart);
+
+    let cartAmount: PaymentAmount;
+
+    if (opts.cart.taxedPrice) {
+      cartAmount = {
+        currencyCode: opts.cart.taxedPrice.totalGross.currencyCode,
+        centAmount: opts.cart.taxedPrice.totalGross.centAmount,
+        fractionDigits: opts.cart.taxedPrice.totalGross.fractionDigits,
+      };
+    } else {
+      cartAmount = {
+        currencyCode: opts.cart.totalPrice.currencyCode,
+        centAmount: opts.cart.totalPrice.centAmount,
+        fractionDigits: opts.cart.totalPrice.fractionDigits,
+      };
+    }
+
+    if (paidAmount >= cartAmount.centAmount) {
+      throw new ErrorInvalidOperation(
+        'The cart has already been paid in full',
+        {
+          fields: {
+            resource: opts.cart.id,
+            paidAmount,
+            cartAmount,
+          },
+        },
+      );
+    }
+
+    const currentAmountToPay =
+      giftCardPlannedAmount &&
+      giftCardPlannedAmount.currencyCode === cartAmount.currencyCode
+        ? cartAmount.centAmount - giftCardPlannedAmount.centAmount
+        : cartAmount.centAmount;
+
+    this.logger.info(
+      {
+        currentAmountToPay,
+      },
+      'current amount to pay after gift card amount deduction',
+    );
+
+    return {
+      currencyCode: cartAmount.currencyCode,
+      centAmount: currentAmountToPay - paidAmount,
+      fractionDigits: cartAmount.fractionDigits,
+    };
+  }
+
+  public async getPaymentAmount(
+    opts: GetPaymentAmount,
+  ): Promise<PaymentAmount> {
+    const paidAmount = await this.calculateTotalPaidAmount(opts.cart);
+
+    let cartAmount: PaymentAmount;
+
+    if (opts.cart.taxedPrice) {
+      cartAmount = {
+        currencyCode: opts.cart.taxedPrice.totalGross.currencyCode,
+        centAmount: opts.cart.taxedPrice.totalGross.centAmount,
+        fractionDigits: opts.cart.taxedPrice.totalGross.fractionDigits,
+      };
+    } else {
+      cartAmount = {
+        currencyCode: opts.cart.totalPrice.currencyCode,
+        centAmount: opts.cart.totalPrice.centAmount,
+        fractionDigits: opts.cart.totalPrice.fractionDigits,
+      };
+    }
+
+    if (paidAmount >= cartAmount.centAmount) {
+      throw new ErrorInvalidOperation(
+        'The cart has already been paid in full',
+        {
+          fields: {
+            resource: opts.cart.id,
+            paidAmount,
+            cartAmount,
+          },
+        },
+      );
+    }
+
+    const currentAmountToPay = cartAmount.centAmount - paidAmount;
+
+    this.logger.info(
+      {
+        currentAmountToPay,
+      },
+      'current amount to pay',
+    );
+
+    return {
+      currencyCode: cartAmount.currencyCode,
+      centAmount: currentAmountToPay,
+      fractionDigits: cartAmount.fractionDigits,
+    };
+  }
+
+  /**
+   * Get only one shipping address from the cart. If the cart has multiple shipping addresses, it returns the first one.
+   * @param cart
+   * @returns
+   */
+  public getOneShippingAddress(
+    opts: GetOneShippingAddress,
+  ): Address | undefined {
+    if (opts.cart.shippingMode === 'Single') {
+      return opts.cart.shippingAddress;
+    }
+    if (
+      opts.cart.shippingMode === 'Multiple' &&
+      opts.cart.shipping &&
+      opts.cart.shipping.length > 0
+    ) {
+      return opts.cart.shipping[0].shippingAddress;
+    }
+  }
+
+  /**
+   * Normalizes the shipping info from the cart. If the cart has a single shipping info, it returns an array with that shipping info.
+   * When the cart has multiple shipping infos, it returns an array with all the shipping infos.
+   * @param opts
+   * @returns
+   */
+  public getNormalizedShipping(
+    opts: GetNormalizedShipping,
+  ): NormalizedShipping[] {
+    if (opts.cart.shippingMode === 'Single' && opts.cart.shippingInfo) {
+      return opts.cart.shippingInfo && opts.cart.shippingAddress
+        ? [
+            {
+              shippingAddress: opts.cart.shippingAddress,
+              shippingInfo: opts.cart.shippingInfo,
+            },
+          ]
+        : [];
+    }
+
+    if (
+      opts.cart.shippingMode === 'Multiple' &&
+      opts.cart.shipping &&
+      opts.cart.shipping.length > 0
+    ) {
+      return opts.cart.shipping.map((shipping: Shipping) => ({
+        shippingAddress: shipping.shippingAddress,
+        shippingInfo: shipping.shippingInfo,
+      }));
+    }
+
+    return [];
+  }
+
+  public async addPayment(opts: AddPayment): Promise<Cart> {
+    const maxRetries = 6;
+    let cartVersion = opts.resource.version;
+    let err: unknown;
+    for (let retries = 0; retries < maxRetries; retries++) {
+      try {
+        return await this.ctAPI.cart.addPayment({
+          resource: { id: opts.resource.id, version: cartVersion },
+          paymentId: opts.paymentId,
+        });
+      } catch (e) {
+        err = e;
+        if (e instanceof CommercetoolsAPIError && e.httpErrorStatus === 409) {
+          const cart = await this.getCart({ id: opts.resource.id });
+          cartVersion = cart.version;
+          retries++;
+        } else {
+          throw e;
+        }
+      }
+    }
+    throw err;
+  }
+
+  public isRecurringCart(cart: Cart): boolean {
+    if (!cart.customerId) return false;
+
+    const cartOrigin = cart.origin === 'RecurringOrder';
+    const hasRecurringLineItems =
+      cart.lineItems?.some((item) => item.recurrenceInfo) ?? false;
+    const hasRecurringCustomLineItems =
+      cart.customLineItems?.some((item) => item.recurrenceInfo) ?? false;
+
+    return cartOrigin || hasRecurringLineItems || hasRecurringCustomLineItems;
+  }
+
+  private async calculateTotalPaidAmount(cart: Cart): Promise<number> {
+    if (!cart.paymentInfo || cart.paymentInfo.payments.length === 0) {
+      return 0;
+    }
+    const payments = await Promise.all(
+      cart.paymentInfo.payments.map((p) =>
+        this.ctAPI.payment.getPaymentById(p.id),
+      ),
+    );
+    return payments.reduce(
+      (total: number, payment: Payment) =>
+        total + this.calculatePaymentAmount(payment),
+      0,
+    );
+  }
+
+  private calculatePaymentAmount(payment: Payment): number {
+    //If an "approved" payment has been reverted, the amount should not be considered as paid
+    if (this.wasPaymentReverted(payment)) {
+      return 0;
+    }
+
+    if (this.isPaymentApproved(payment)) {
+      return payment.amountPlanned.centAmount;
+    }
+
+    return 0;
+  }
+
+  private wasPaymentReverted(payment: Payment): boolean {
+    return payment.transactions.some(
+      (tx: Transaction) =>
+        (tx.type === 'CancelAuthorization' || tx.type === 'Refund') &&
+        (tx.state === 'Success' || tx.state === 'Pending'),
+    );
+  }
+
+  private isPaymentApproved(payment: Payment): boolean {
+    return payment.transactions.some(
+      (transaction: Transaction) =>
+        (transaction.state === 'Success' || transaction.state === 'Pending') &&
+        (transaction.type === 'Authorization' || transaction.type === 'Charge'),
+    );
+  }
+}

package/src/commercetools/services/ct-custom-type.service.ts

@@ -0,0 +1,62 @@
+import type {
+  Type,
+  TypeDraft,
+  TypePagedQueryResponse,
+} from '@commercetools/platform-sdk';
+import type { Logger } from '@logger-types';
+import type { CommercetoolsAPI } from '../types/api.type.js';
+import type {
+  CustomTypeService,
+  FindCustomType,
+  GetCustomType,
+} from '../types/custom-type.type.js';
+import type { PaymentServiceOptions } from '../types/payment.type.js';
+import {
+  CreateCardDetailsTypePayload,
+  CreatePaymentInterfaceInteractionTypePayload,
+  CreateSepaDetailsTypePayload,
+} from '../types/predefined-custom-types.type.js';
+
+/**
+ * This is the default implementation of the CustomTypeService interface.
+ */
+export class DefaultCustomTypeService implements CustomTypeService {
+  private ctAPI: CommercetoolsAPI;
+  private logger: Logger;
+
+  constructor(opts: PaymentServiceOptions) {
+    this.ctAPI = opts.ctAPI;
+    this.logger = opts.logger;
+  }
+
+  async getCustomType(opts: GetCustomType): Promise<Type> {
+    return await this.ctAPI.customType.getByKey(opts.key);
+  }
+
+  async findCustomType(opts: FindCustomType): Promise<TypePagedQueryResponse> {
+    return await this.ctAPI.customType.find(opts.predicate);
+  }
+
+  async createCustomType(draft: TypeDraft): Promise<Type> {
+    return await this.ctAPI.customType.create(draft);
+  }
+
+  async createPredefinedInterfaceInteractionType(): Promise<Type> {
+    return await this.createCustomType(
+      CreatePaymentInterfaceInteractionTypePayload,
+    );
+  }
+
+  async createPredefinedPaymentMethodsTypes(): Promise<Type[]> {
+    const createdTypes: Type[] = [];
+
+    createdTypes.push(
+      await this.createCustomType(CreateCardDetailsTypePayload),
+    );
+    createdTypes.push(
+      await this.createCustomType(CreateSepaDetailsTypePayload),
+    );
+
+    return createdTypes;
+  }
+}

package/src/commercetools/services/ct-order.service.test.ts

@@ -0,0 +1,136 @@
+import { randomUUID } from 'node:crypto';
+import { RequestContextProvider } from '@api';
+import type {
+  Order,
+  OrderPagedQueryResponse,
+} from '@commercetools/platform-sdk';
+import { CommercetoolsLogger } from '@logger';
+import { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+import { DefaultCommercetoolsAPI } from '@/commercetools/api/root-api.js';
+import { DefaultOrderService } from '@/commercetools/services/ct-order.service.js';
+import { authToken } from '@/mocks/auth.mock.js';
+
+const mockServer = setupServer();
+const projectKey = 'test';
+const contextProvider = new RequestContextProvider({
+  getContextFn: () => ({
+    correlationId: 'correlation-id',
+    requestId: 'request-id',
+  }),
+  updateContextFn: () => {},
+});
+const logger = new CommercetoolsLogger({ contextProvider, projectKey });
+
+const ctAPI = new DefaultCommercetoolsAPI({
+  apiUrl: 'http://api.test.com',
+  authUrl: 'http://auth.test.com',
+  clientId: 'clientId',
+  clientSecret: 'clientSecret',
+  projectKey,
+  contextProvider,
+  logger,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  httpClient: (input: string | URL | Request, init?: RequestInit) => {
+    return fetch(input, init);
+  },
+});
+
+const ctOrderService = new DefaultOrderService({ ctAPI, logger });
+
+describe('commercetools order service', () => {
+  beforeAll(() =>
+    mockServer.listen({
+      onUnhandledRequest: 'error',
+    }),
+  );
+  afterAll(() => mockServer.close());
+
+  describe('getOrderByPaymentId', () => {
+    test('should return a order', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const order: OrderPagedQueryResponse = {
+        count: 1,
+        limit: 100,
+        offset: 0,
+        results: [
+          {
+            id: 'order-id',
+            version: 1,
+            paymentInfo: {
+              payments: [
+                {
+                  id: paymentId,
+                  typeId: 'payment',
+                },
+              ],
+            },
+          } as Order,
+        ],
+      };
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockFindOrder(200, order),
+      );
+
+      // Actual
+      const actual = await ctOrderService.getOrderByPaymentId({ paymentId });
+
+      // Expected
+      const expected: Order = {
+        id: 'order-id',
+        version: 1,
+        paymentInfo: {
+          payments: [
+            {
+              id: paymentId,
+              typeId: 'payment',
+            },
+          ],
+        },
+      } as Order;
+
+      expect(actual).toEqual(expected);
+    });
+
+    test('should return ErrorResourceNotFound if no order by the given paymentId could be found', async () => {
+      //Given
+      const paymentId = randomUUID();
+      const order: OrderPagedQueryResponse = {
+        count: 0,
+        limit: 100,
+        offset: 0,
+        results: [],
+      };
+
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockFindOrder(200, order),
+      );
+
+      // Actual
+      const actual = ctOrderService.getOrderByPaymentId({ paymentId });
+
+      // Expected
+      await expect(actual).rejects.toThrow(
+        `The referenced object of type order paymentInfo(payments(id = "${paymentId}")) was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
+      );
+    });
+  });
+});
+
+const mockGetAuthToken = (respCode: number, data?: object) =>
+  http.post('http://auth.test.com/oauth/token', async () => {
+    return HttpResponse.json(data, {
+      status: respCode,
+    });
+  });
+
+const mockFindOrder = (respCode: number, data?: object) =>
+  http.get('http://api.test.com/test/orders', async () => {
+    return HttpResponse.json(data, {
+      status: respCode,
+    });
+  });

package/src/commercetools/services/ct-order.service.ts

@@ -0,0 +1,47 @@
+import type { Order } from '@commercetools/platform-sdk';
+import { ErrorReferencedResourceNotFound } from '@errorx';
+import type { Logger } from '@logger-types';
+import type { CommercetoolsAPI } from '@/commercetools/types/api.type.js';
+import type {
+  GetOrderByPaymentIdRequest,
+  OrderService,
+  OrderServiceOptions,
+} from '@/commercetools/types/order.type.js';
+
+/**
+ * This is the default implementation of the OrderService interface.
+ */
+export class DefaultOrderService implements OrderService {
+  private ctAPI: CommercetoolsAPI;
+  private logger: Logger;
+
+  constructor(opts: OrderServiceOptions) {
+    this.ctAPI = opts.ctAPI;
+    this.logger = opts.logger;
+  }
+
+  public async getOrderByPaymentId(
+    opts: GetOrderByPaymentIdRequest,
+  ): Promise<Order> {
+    const queryPredicate = `paymentInfo(payments(id = "${opts.paymentId}"))`;
+
+    const result = await this.ctAPI.order.find(queryPredicate);
+
+    if (result.count !== 1) {
+      throw new ErrorReferencedResourceNotFound(
+        'order',
+        queryPredicate,
+        undefined,
+        {
+          privateFields: {
+            queryPredicate,
+            paymentId: opts.paymentId,
+          },
+          privateMessage: 'Could not find a order with the given paymentId',
+        },
+      );
+    }
+
+    return result.results[0];
+  }
+}