@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/commercetools/api/payment-method-api.ts

@@ -0,0 +1,118 @@
+import type {
+  PaymentMethod,
+  PaymentMethodDraft,
+  PaymentMethodPagedQueryResponse,
+} from '@commercetools/platform-sdk';
+import { CommercetoolsBaseAPI } from '@/commercetools/api/base-api.js';
+import { CommercetoolsAPIError } from '@/commercetools/errors/ct-api.error.js';
+import type {
+  APIOpts,
+  CheckIfExistsByPredicate,
+  DeletePaymentMethod,
+  FindPaymentMethods,
+  GetPaymentMethod,
+  PaymentMethodAPI,
+  UpdatePaymentMethod,
+} from '@/commercetools/types/api.type.js';
+
+export class CommercetoolsPaymentMethodAPI
+  extends CommercetoolsBaseAPI
+  implements PaymentMethodAPI
+{
+  constructor(opts: APIOpts) {
+    super(opts);
+    Object.setPrototypeOf(this, CommercetoolsPaymentMethodAPI.prototype);
+  }
+
+  get(opts: GetPaymentMethod): Promise<PaymentMethod> {
+    return this.executeCall(
+      this.client.paymentMethods().withId({ ID: opts.id }).get().execute(),
+    );
+  }
+
+  async checkIfExistsByPredicate(
+    opts: CheckIfExistsByPredicate,
+  ): Promise<boolean> {
+    try {
+      const result = await this.executeCall(
+        this.client
+          .paymentMethods()
+          .get({
+            queryArgs: {
+              where: opts.queryString,
+            },
+          })
+          .execute(),
+      );
+
+      if (result.total === 0) {
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      // The HEAD call returns a 404 if the paymentMethod does not exist
+      if (
+        error instanceof CommercetoolsAPIError &&
+        error.httpErrorStatus === 404
+      ) {
+        return false;
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  find(opts: FindPaymentMethods): Promise<PaymentMethodPagedQueryResponse> {
+    return this.executeCall(
+      this.client
+        .paymentMethods()
+        .get({
+          queryArgs: {
+            where: opts.queryString,
+          },
+        })
+        .execute(),
+    );
+  }
+
+  create(draft: PaymentMethodDraft): Promise<PaymentMethod> {
+    return this.executeCall(
+      this.client
+        .paymentMethods()
+        .post({
+          body: draft,
+        })
+        .execute(),
+    );
+  }
+
+  update(opts: UpdatePaymentMethod): Promise<PaymentMethod> {
+    return this.executeCall(
+      this.client
+        .paymentMethods()
+        .withId({ ID: opts.resource.id })
+        .post({
+          body: {
+            version: opts.resource.version,
+            actions: opts.actions,
+          },
+        })
+        .execute(),
+    );
+  }
+
+  delete(opts: DeletePaymentMethod): Promise<PaymentMethod> {
+    return this.executeCall(
+      this.client
+        .paymentMethods()
+        .withId({ ID: opts.id })
+        .delete({
+          queryArgs: {
+            version: opts.version,
+          },
+        })
+        .execute(),
+    );
+  }
+}

package/src/commercetools/api/root-api.ts

@@ -0,0 +1,109 @@
+import { randomUUID } from 'node:crypto';
+import { createApiBuilderFromCtpClient } from '@commercetools/platform-sdk';
+import {
+  type AuthMiddlewareOptions,
+  ClientBuilder,
+  type CorrelationIdMiddlewareOptions,
+  type HttpMiddlewareOptions,
+} from '@commercetools/ts-client';
+import type { Logger } from '@logger-types';
+import type {
+  ContextProvider,
+  RequestContextData,
+} from '@/api/context/types/request-context.type.js';
+import { CommercetoolsCartAPI } from '@/commercetools/api/cart-api.js';
+import { CommercetoolsOrderAPI } from '@/commercetools/api/order-api.js';
+import { CommercetoolsPaymentAPI } from '@/commercetools/api/payment-api.js';
+import { CommercetoolsPaymentMethodAPI } from '@/commercetools/api/payment-method-api.js';
+import type {
+  CartAPI,
+  CommercetoolsAPI,
+  CommercetoolsClient,
+  CustomTypeAPI,
+  OrderAPI,
+  PaymentAPI,
+  PaymentMethodAPI,
+} from '@/commercetools/types/api.type.js';
+import { CommercetoolsCustomTypeAPI } from './custom-type-api.js';
+
+export class DefaultCommercetoolsAPI implements CommercetoolsAPI {
+  public client: CommercetoolsClient;
+  public cart: CartAPI;
+  public payment: PaymentAPI;
+  public order: OrderAPI;
+  public paymentMethod: PaymentMethodAPI;
+  public customType: CustomTypeAPI;
+  private logger: Logger;
+
+  constructor(opts: {
+    clientId: string;
+    clientSecret: string;
+    authUrl: string;
+    apiUrl: string;
+    projectKey: string;
+    contextProvider: ContextProvider<RequestContextData>;
+    logger: Logger;
+    // biome-ignore lint/complexity/noBannedTypes: Accept any function
+    httpClient?: Function;
+  }) {
+    this.client = createClient(opts);
+    this.cart = new CommercetoolsCartAPI({ client: this.client });
+    this.payment = new CommercetoolsPaymentAPI({ client: this.client });
+    this.order = new CommercetoolsOrderAPI({ client: this.client });
+    this.paymentMethod = new CommercetoolsPaymentMethodAPI({
+      client: this.client,
+    });
+    this.customType = new CommercetoolsCustomTypeAPI({ client: this.client });
+    this.logger = opts.logger;
+  }
+}
+
+const createClient = (opts: {
+  clientId: string;
+  clientSecret: string;
+  authUrl: string;
+  apiUrl: string;
+  projectKey: string;
+  contextProvider: ContextProvider<RequestContextData>;
+  // biome-ignore lint/complexity/noBannedTypes: Accept any function
+  httpClient?: Function;
+}): CommercetoolsClient => {
+  const authMiddlewareOptions: AuthMiddlewareOptions = {
+    host: opts.authUrl,
+    projectKey: opts.projectKey,
+    credentials: {
+      clientId: opts.clientId,
+      clientSecret: opts.clientSecret,
+    },
+    ...(opts.httpClient ? { httpClient: opts.httpClient } : {}),
+  };
+
+  const httpMiddlewareOptions: HttpMiddlewareOptions = {
+    host: opts.apiUrl,
+    //Enables SDK retries when CoCo returns a 503 error. It retries up to 10 times with an 200ms backoff.
+    enableRetry: true,
+    ...(opts.httpClient ? { httpClient: opts.httpClient } : {}),
+    maskSensitiveHeaderData: true,
+  };
+
+  const correlationIdMiddlewareOptions: CorrelationIdMiddlewareOptions = {
+    generate: () => {
+      const contextData = opts.contextProvider.getContextData();
+      const correlationID =
+        contextData.correlationId && contextData.correlationId.length > 0
+          ? contextData.correlationId
+          : randomUUID();
+      return correlationID;
+    },
+  };
+
+  const ctpClient = new ClientBuilder()
+    .withClientCredentialsFlow(authMiddlewareOptions)
+    .withCorrelationIdMiddleware(correlationIdMiddlewareOptions)
+    .withHttpMiddleware(httpMiddlewareOptions)
+    .build();
+
+  return createApiBuilderFromCtpClient(ctpClient).withProjectKey({
+    projectKey: opts.projectKey,
+  });
+};

package/src/commercetools/errors/ct-api.error.ts

@@ -0,0 +1,27 @@
+import { Errorx } from '@errorx';
+
+export type CocoErrorType = {
+  body?: {
+    message?: string;
+    errors?: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      [key: string]: unknown;
+    }[];
+  };
+  statusCode: number;
+  message?: string;
+};
+
+export class CommercetoolsAPIError extends Errorx {
+  constructor(err: CocoErrorType) {
+    super({
+      code: (err.body?.errors?.[0]?.code as string) ?? 'CommercetoolsAPIError',
+      message: err?.body?.message ?? err?.message ?? '',
+      httpErrorStatus: err.statusCode,
+      //TODO: make sure this type is handled better. Remove the `as unknown as Error`
+      cause: err as unknown as Error,
+      fields: err.body?.errors,
+    });
+    this.name = 'CommercetoolsAPIError';
+  }
+}

package/src/commercetools/helpers/currency.converter.test.ts

@@ -0,0 +1,121 @@
+import {
+  type ConvertWithMappingOptions,
+  convert,
+  convertWithMapping,
+} from '@/commercetools/helpers/currency.converter.js';
+import CurrencyConverterTestData from '@/commercetools/helpers/currency.converter.test_data.json' with {
+  type: 'json',
+};
+
+describe('currency.converter.ts', () => {
+  describe('convert', () => {
+    test('should pass all types of conversions', () => {
+      const failedTests: Record<string, unknown>[] = [];
+
+      for (const testInput of CurrencyConverterTestData) {
+        const got = convert(testInput.inputvalue, testInput.fractionDigits);
+
+        const areEqual = got === testInput.expectedValue;
+        if (!areEqual) {
+          failedTests.push({ ...testInput, got });
+        }
+      }
+
+      expect(failedTests).toStrictEqual([]);
+    });
+
+    test('should throw an error if the given fractionDigit is not a integer', () => {
+      const input = 10.99;
+
+      expect(() => convert(100, input)).toThrow(
+        `The given fraction digit of "${input}" is not a integer. Fraction digit must be an integer value.`,
+      );
+    });
+
+    test('should throw an error if the given amount is not a safe integer', () => {
+      const input = Number.MAX_SAFE_INTEGER + 1;
+
+      expect(() => convert(input, 0)).toThrow(
+        `The given value of ${input} is not a safe integer number`,
+      );
+    });
+  });
+
+  describe('convertWithMapping', () => {
+    test('it should use return the original value if no mapping matches and no fractionDigits are given', () => {
+      const input: ConvertWithMappingOptions = {
+        amount: 100,
+        currencyCode: 'EUR',
+        mapping: new Map<string, number>(),
+      };
+
+      const result = convertWithMapping(input);
+
+      expect(result).toEqual(100);
+    });
+
+    test('it should use apply the overruling fractionDigit from the map when the currencyCode matches with the one in the mapping', () => {
+      const input: ConvertWithMappingOptions = {
+        amount: 100,
+        currencyCode: 'EUR',
+        mapping: new Map<string, number>([['EUR', 4]]),
+      };
+
+      const result = convertWithMapping(input);
+
+      expect(result).toEqual(1000000);
+    });
+
+    test('it should use apply the overruling fractionDigit from the map even if the fractionDigit is provided', () => {
+      const input: ConvertWithMappingOptions = {
+        amount: 100,
+        currencyCode: 'EUR',
+        mapping: new Map<string, number>([['EUR', 4]]),
+        fractionDigit: 2,
+      };
+
+      const result = convertWithMapping(input);
+
+      expect(result).toEqual(1000000);
+    });
+
+    test('it should apply the given fractionDigit if no mapping could be found', () => {
+      const input: ConvertWithMappingOptions = {
+        amount: 100,
+        currencyCode: 'USD',
+        mapping: new Map<string, number>([['EUR', 4]]),
+        fractionDigit: 2,
+      };
+
+      const result = convertWithMapping(input);
+
+      expect(result).toEqual(10000);
+    });
+
+    test('it should throw an error if the given fractionDigit is not a integer', () => {
+      const input: ConvertWithMappingOptions = {
+        amount: 100,
+        currencyCode: 'USD',
+        mapping: new Map<string, number>([['EUR', 4]]),
+        fractionDigit: 2.288,
+      };
+
+      expect(() => convertWithMapping(input)).toThrow(
+        `The given fraction digit of "${input.fractionDigit}" is not a integer. Fraction digit must be an integer value.`,
+      );
+    });
+
+    test('it should throw an error if the fractionDigit from the mapping is not a integer', () => {
+      const input: ConvertWithMappingOptions = {
+        amount: 100,
+        currencyCode: 'EUR',
+        mapping: new Map<string, number>([['EUR', 4.123]]),
+        fractionDigit: 2,
+      };
+
+      expect(() => convertWithMapping(input)).toThrow(
+        `The given fraction digit of "4.123" is not a integer. Fraction digit must be an integer value.`,
+      );
+    });
+  });
+});