@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/commercetools/services/ct-payment-method.service.ts

@@ -0,0 +1,223 @@
+import type {
+  PaymentMethod,
+  PaymentMethodPagedQueryResponse,
+} from '@commercetools/platform-sdk';
+import {
+  ErrorInternalConstraintViolated,
+  ErrorResourceNotFound,
+} from '@errorx';
+import type { Logger } from '@logger-types';
+import type { CommercetoolsAPI } from '@/commercetools/types/api.type.js';
+import type {
+  DeletePaymentMethodService,
+  DoesTokenBelongToCustomer,
+  FindPaymentMethod,
+  GetByTokenValuePaymentMethod,
+  GetPaymentMethodService,
+  PaymentMethodService,
+  PaymentMethodServiceOptions,
+  SavePaymentMethodDraft,
+  UpdatePaymentMethodService,
+} from '@/commercetools/types/payment-method.type.js';
+
+/**
+ * This is the default implementation of the PaymentMethodService interface.
+ */
+export class DefaultPaymentMethodService implements PaymentMethodService {
+  private ctAPI: CommercetoolsAPI;
+  private logger: Logger;
+
+  constructor(opts: PaymentMethodServiceOptions) {
+    this.ctAPI = opts.ctAPI;
+    this.logger = opts.logger;
+  }
+
+  async find(
+    opts: FindPaymentMethod,
+  ): Promise<PaymentMethodPagedQueryResponse> {
+    const whereFilters = [];
+
+    whereFilters.push(`customer(id="${opts.customerId}")`);
+    whereFilters.push(`paymentInterface="${opts.paymentInterface}"`);
+
+    if (opts.interfaceAccount) {
+      whereFilters.push(`interfaceAccount="${opts.interfaceAccount}"`);
+    }
+
+    const whereFilter = whereFilters.join(' and ');
+
+    return await this.ctAPI.paymentMethod.find({
+      queryString: whereFilter,
+    });
+  }
+
+  async get(opts: GetPaymentMethodService): Promise<PaymentMethod> {
+    const paymentMethods = await this.find({
+      customerId: opts.customerId,
+      paymentInterface: opts.paymentInterface,
+      interfaceAccount: opts.interfaceAccount,
+    });
+
+    const paymentMethodMatchesId = paymentMethods.results.find(
+      (pm) => opts.id === pm.id,
+    );
+
+    if (!paymentMethodMatchesId) {
+      throw new ErrorResourceNotFound('payment-method', opts.id);
+    }
+
+    return paymentMethodMatchesId;
+  }
+
+  async getByTokenValue(
+    opts: GetByTokenValuePaymentMethod,
+  ): Promise<PaymentMethod> {
+    const paymentMethods = await this.find({
+      customerId: opts.customerId,
+      paymentInterface: opts.paymentInterface,
+      interfaceAccount: opts.interfaceAccount,
+    });
+
+    const paymentMethodsMatchWithTokenValue = paymentMethods.results.filter(
+      (pm) => opts.tokenValue === pm.token?.value,
+    );
+
+    if (paymentMethodsMatchWithTokenValue.length > 1) {
+      throw new ErrorInternalConstraintViolated(
+        'Found more then one payment method with the same token value.',
+        {
+          privateFields: {
+            customerId: opts.customerId,
+            paymentMethodIds: paymentMethodsMatchWithTokenValue.map(
+              (pm) => pm.id,
+            ),
+            paymentInterface: opts.paymentInterface,
+            interfaceAccount: opts.interfaceAccount,
+          },
+        },
+      );
+    }
+
+    if (paymentMethodsMatchWithTokenValue.length === 0) {
+      throw new ErrorResourceNotFound('customer', opts.customerId, {
+        privateFields: {
+          customerId: opts.customerId,
+          paymentInterface: opts.paymentInterface,
+          interfaceAccount: opts.interfaceAccount,
+        },
+      });
+    }
+
+    return paymentMethodsMatchWithTokenValue[0];
+  }
+
+  async doesTokenBelongsToCustomer(
+    opts: DoesTokenBelongToCustomer,
+  ): Promise<boolean> {
+    try {
+      const paymentMethod = await this.getByTokenValue({
+        customerId: opts.customerId,
+        paymentInterface: opts.paymentInterface,
+        interfaceAccount: opts.interfaceAccount,
+        tokenValue: opts.tokenValue,
+      });
+
+      return paymentMethod !== undefined;
+    } catch (error) {
+      if (error instanceof ErrorResourceNotFound) {
+        return false;
+      }
+
+      throw error;
+    }
+  }
+
+  async update(opts: UpdatePaymentMethodService): Promise<PaymentMethod> {
+    await this.ensurePaymentMethodBelongsToGivenCustomer(
+      opts.resource.id,
+      opts.customerId,
+    );
+
+    return this.ctAPI.paymentMethod.update({
+      actions: opts.actions,
+      resource: opts.resource,
+    });
+  }
+
+  async save(opts: SavePaymentMethodDraft): Promise<PaymentMethod> {
+    const paymentMethodExistsWithSameTokenValue =
+      await this.doesTokenBelongsToCustomer({
+        customerId: opts.customerId,
+        paymentInterface: opts.paymentInterface,
+        interfaceAccount: opts.interfaceAccount,
+        tokenValue: opts.token,
+      });
+
+    if (paymentMethodExistsWithSameTokenValue) {
+      throw new ErrorInternalConstraintViolated(
+        'A payment method with the same "token.value" already exists.',
+        {
+          privateFields: {
+            customerId: opts.customerId,
+            paymentInterface: opts.paymentInterface,
+            interfaceAccount: opts.interfaceAccount,
+          },
+        },
+      );
+    }
+
+    return await this.ctAPI.paymentMethod.create({
+      customer: {
+        id: opts.customerId,
+        typeId: 'customer',
+      },
+      paymentInterface: opts.paymentInterface,
+      interfaceAccount: opts.interfaceAccount,
+      method: opts.method,
+      default: false,
+      paymentMethodStatus: 'Active',
+      token: {
+        value: opts.token,
+      },
+    });
+  }
+
+  async delete(opts: DeletePaymentMethodService): Promise<PaymentMethod> {
+    await this.ensurePaymentMethodBelongsToGivenCustomer(
+      opts.id,
+      opts.customerId,
+    );
+
+    return await this.ctAPI.paymentMethod.delete({
+      id: opts.id,
+      version: opts.version,
+    });
+  }
+
+  private async ensurePaymentMethodBelongsToGivenCustomer(
+    paymentMethodId: string,
+    customerId: string,
+  ) {
+    const predicate = `id="${paymentMethodId}" and customer(id="${customerId}")`;
+
+    const doesGivenPaymentMethodBelongToGivenCustomer =
+      await this.ctAPI.paymentMethod.checkIfExistsByPredicate({
+        queryString: predicate,
+      });
+
+    if (!doesGivenPaymentMethodBelongToGivenCustomer) {
+      throw new ErrorInternalConstraintViolated(
+        `The provided payment-method '${paymentMethodId}' does not have a customer '${customerId}' set`,
+        {
+          fields: {
+            paymentMethodId: paymentMethodId,
+            customerId: customerId,
+          },
+          privateFields: {
+            predicateQueryString: predicate,
+          },
+        },
+      );
+    }
+  }
+}