@tonder.io/ionic-lite-sdk 0.0.35-beta.2 → 0.0.35-beta.20

package/src/classes/liteCheckout.ts

@@ -1,47 +1,39 @@
-import {fetchBusiness} from "../data/businessApi";
+import { fetchBusiness } from "../data/businessApi";
 
 declare const MP_DEVICE_SESSION_ID: string | undefined;
-
-import {APM, Business, IInlineCheckoutBaseOptions, TonderAPM} from "../types/commons";
-import {
-  CreateOrderRequest,
-  CreatePaymentRequest,
-  RegisterCustomerCardRequest,
-  StartCheckoutRequest,
-  StartCheckoutFullRequest,
-  StartCheckoutIdRequest,
-  TokensRequest
-} from "../types/requests";
-import {
-  CustomerRegisterResponse,
-  CreateOrderResponse,
-  CreatePaymentResponse,
-  StartCheckoutResponse,
-  IErrorResponse,
-  RegisterCustomerCardResponse,
-  GetBusinessResponse
-} from "../types/responses";
 import { ErrorResponse } from "./errorResponse";
 import {
   buildErrorResponse,
   buildErrorResponseFromCatch,
   getBrowserInfo,
   getBusinessId,
-  formatPublicErrorResponse, getCardType
+  formatPublicErrorResponse,
+  getCardType,
 } from "../helpers/utils";
 import { getCustomerAPMs } from "../data/api";
-import {BaseInlineCheckout} from "./BaseInlineCheckout";
-import {fetchCustomerCards, removeCustomerCard, saveCustomerCard} from "../data/cardApi";
-import {MESSAGES} from "../shared/constants/messages";
-import {ICustomerCardsResponse, ISaveCardRequest, ISaveCardResponse} from "../types/card";
-import {getSkyflowTokens} from "../helpers/skyflow";
-import {fetchCustomerAPMs} from "../data/paymentMethodApi";
+import { BaseInlineCheckout } from "./BaseInlineCheckout";
+import { MESSAGES } from "../shared/constants/messages";
+import { getSkyflowTokens } from "../helpers/skyflow";
+import { startCheckoutRouter } from "../data/checkoutApi";
+import { getOpenpayDeviceSessionID } from "../data/openPayApi";
+import { getPaymentMethodDetails } from "../shared/catalog/paymentMethodsCatalog";
+import {APM, IInlineCheckoutBaseOptions, TonderAPM} from "../types/commons";
+import {ICustomerCardsResponse, ISaveCardRequest, ISaveCardResponse, ISaveCardSkyflowRequest} from "../types/card";
 import {IPaymentMethod} from "../types/paymentMethod";
+import {
+  CreateOrderResponse,
+  CreatePaymentResponse,
+  CustomerRegisterResponse,
+  GetBusinessResponse, IErrorResponse, RegisterCustomerCardResponse, StartCheckoutResponse
+} from "../types/responses";
+import {
+  CreateOrderRequest,
+  CreatePaymentRequest, RegisterCustomerCardRequest, StartCheckoutFullRequest,
+  StartCheckoutIdRequest,
+  StartCheckoutRequest,
+  TokensRequest
+} from "../types/requests";
 import {ICardFields} from "../types/checkout";
-import {ILiteInlineCheckout} from "../types/liteInlineCheckout";
-import {startCheckoutRouter} from "../data/checkoutApi";
-import {getOpenpayDeviceSessionID} from "../data/openPayApi";
-import {getPaymentMethodDetails} from "../shared/catalog/paymentMethodsCatalog";
 
 declare global {
   interface Window {
@@ -49,33 +41,26 @@ declare global {
   }
 }
 
-export interface LiteCheckoutConstructor  extends IInlineCheckoutBaseOptions {}
+export interface LiteCheckoutConstructor extends IInlineCheckoutBaseOptions {}
 
-export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheckout  {
-  activeAPMs: APM[] = []
-  #customerData?: Record<string, any>;
+export class LiteCheckout extends BaseInlineCheckout {
+  activeAPMs: APM[] = [];
 
-  constructor({
-      apiKey,
-      mode,
-      returnUrl,
-      callBack,
-  }: LiteCheckoutConstructor) {
-    super({mode, apiKey, returnUrl, callBack});
+  constructor({ apiKey, mode, returnUrl, callBack }: LiteCheckoutConstructor) {
+    super({ mode, apiKey, returnUrl, callBack });
   }
 
-  async injectCheckout() {
+  public async injectCheckout() {
     await this._initializeCheckout();
   }
 
-  async getCustomerCards(): Promise<ICustomerCardsResponse> {
+  public async getCustomerCards(): Promise<ICustomerCardsResponse> {
     try {
-      await this._fetchMerchantData()
+      await this._fetchMerchantData();
       const { auth_token } = await this._getCustomer();
-      const response = await fetchCustomerCards(
-          this.baseUrl,
-          auth_token,
-          this.merchantData!.business.pk,
+      const response = await this._getCustomerCards(
+        auth_token,
+        this.merchantData!.business.pk,
       );
 
       return {
@@ -87,21 +72,23 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
       };
     } catch (error) {
       throw formatPublicErrorResponse(
-          {
-            message: MESSAGES.getCardsError,
-          },
-          error,
+        {
+          message: MESSAGES.getCardsError,
+        },
+        error,
       );
     }
   }
 
-  async saveCustomerCard(card: ISaveCardRequest): Promise<ISaveCardResponse> {
+  public async saveCustomerCard(
+    card: ISaveCardRequest,
+  ): Promise<ISaveCardResponse> {
     try {
-      await this._fetchMerchantData()
+      await this._fetchMerchantData();
       const { auth_token } = await this._getCustomer();
       const { vault_id, vault_url, business } = this.merchantData!;
 
-      const skyflowTokens = await getSkyflowTokens({
+      const skyflowTokens: ISaveCardSkyflowRequest = await getSkyflowTokens({
         vault_id: vault_id,
         vault_url: vault_url,
         data: card,
@@ -109,108 +96,138 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
         apiKey: this.apiKeyTonder,
       });
 
-      return await saveCustomerCard(
-          this.baseUrl,
-          auth_token,
-          business?.pk,
-          skyflowTokens,
+      return await this._saveCustomerCard(
+        auth_token,
+        business?.pk,
+        skyflowTokens,
       );
     } catch (error) {
       throw formatPublicErrorResponse(
-          {
-            message: MESSAGES.saveCardError,
-          },
-          error,
+        {
+          message: MESSAGES.saveCardError,
+        },
+        error,
       );
     }
   }
 
-
-  async removeCustomerCard(skyflowId: string): Promise<string> {
+  public async removeCustomerCard(skyflowId: string): Promise<string> {
     try {
-      await this._fetchMerchantData()
+      await this._fetchMerchantData();
       const { auth_token } = await this._getCustomer();
       const { business } = this.merchantData!;
 
-      return await removeCustomerCard(
-          this.baseUrl,
-          auth_token,
-          skyflowId,
-          business?.pk,
+      return await this._removeCustomerCard(
+        auth_token,
+        business?.pk,
+        skyflowId,
       );
     } catch (error) {
       throw formatPublicErrorResponse(
-          {
-            message: MESSAGES.removeCardError,
-          },
-          error,
+        {
+          message: MESSAGES.removeCardError,
+        },
+        error,
       );
     }
   }
 
-  async getCustomerPaymentMethods(): Promise<IPaymentMethod[]> {
+  public async getCustomerPaymentMethods(): Promise<IPaymentMethod[]> {
     try {
-      const response = await fetchCustomerAPMs(this.baseUrl, this.apiKeyTonder);
+      const response = await this._fetchCustomerPaymentMethods();
 
       const apms_results =
-          response && "results" in response && response["results"].length > 0
-              ? response["results"]
-              : [];
+        response && "results" in response && response["results"].length > 0
+          ? response["results"]
+          : [];
 
       return apms_results
-          .filter((apmItem) => apmItem.category.toLowerCase() !== "cards")
-          .map((apmItem) => {
-            const apm = {
-              id: apmItem.pk,
-              payment_method: apmItem.payment_method,
-              priority: apmItem.priority,
-              category: apmItem.category,
-              ...getPaymentMethodDetails(apmItem.payment_method),
-            };
-            return apm;
-          })
-          .sort((a, b) => a.priority - b.priority);
+        .filter((apmItem) => apmItem.category.toLowerCase() !== "cards")
+        .map((apmItem) => {
+          const apm = {
+            id: apmItem.pk,
+            payment_method: apmItem.payment_method,
+            priority: apmItem.priority,
+            category: apmItem.category,
+            ...getPaymentMethodDetails(apmItem.payment_method),
+          };
+          return apm;
+        })
+        .sort((a, b) => a.priority - b.priority);
     } catch (error) {
       throw formatPublicErrorResponse(
-          {
-            message: MESSAGES.getPaymentMethodsError,
-          },
-          error,
+        {
+          message: MESSAGES.getPaymentMethodsError,
+        },
+        error,
       );
     }
   }
 
-  async getBusiness(): Promise<GetBusinessResponse> {
+  public async getBusiness(): Promise<GetBusinessResponse> {
     try {
-      return await fetchBusiness(this.baseUrl, this.apiKeyTonder, this.abortController.signal)
+      return await fetchBusiness(
+        this.baseUrl,
+        this.apiKeyTonder,
+        this.abortController.signal,
+      );
     } catch (e) {
-      throw formatPublicErrorResponse({
-        message: MESSAGES.getBusinessError
-      },e);
+      throw formatPublicErrorResponse(
+        {
+          message: MESSAGES.getBusinessError,
+        },
+        e,
+      );
     }
   }
 
+  // TODO: DEPRECATED
+  async getOpenpayDeviceSessionID(
+    merchant_id: string,
+    public_key: string,
+    is_sandbox: boolean,
+  ): Promise<string | ErrorResponse> {
+    try {
+      return await getOpenpayDeviceSessionID(
+        merchant_id,
+        public_key,
+        is_sandbox,
+      );
+    } catch (e) {
+      throw buildErrorResponseFromCatch(e);
+    }
+  }
 
   // TODO: DEPRECATED
-  async getSkyflowTokens({vault_id, vault_url, data}: TokensRequest): Promise<any | ErrorResponse> {
+  async getSkyflowTokens({
+    vault_id,
+    vault_url,
+    data,
+  }: TokensRequest): Promise<any | ErrorResponse> {
     return await getSkyflowTokens({
       vault_id: vault_id,
       vault_url: vault_url,
       data,
       baseUrl: this.baseUrl,
       apiKey: this.apiKeyTonder,
-    })
+    });
   }
 
   _setCartTotal(total: string) {
     this.cartTotal = total;
   }
 
-  async _checkout({ card, payment_method, isSandbox }: {card?: ICardFields | string; payment_method?: string; isSandbox?: boolean;}) {
-    await this._fetchMerchantData()
-    const customer = await this._getCustomer(
-        this.abortController.signal,
-    );
+  async _checkout({
+    card,
+    payment_method,
+    isSandbox,
+  }: {
+    card?: ICardFields | string;
+    payment_method?: string;
+    isSandbox?: boolean;
+  }) {
+    await this._fetchMerchantData();
+    const customer = await this._getCustomer(this.abortController.signal);
     const { vault_id, vault_url } = this.merchantData!;
     let skyflowTokens;
     if (!payment_method || payment_method !== "" || payment_method === null) {
@@ -222,7 +239,7 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
         skyflowTokens = await getSkyflowTokens({
           vault_id: vault_id,
           vault_url: vault_url,
-          data: {...card, card_number: card!.card_number.replace(/\s+/g, '')},
+          data: { ...card, card_number: card!.card_number.replace(/\s+/g, "") },
           baseUrl: this.baseUrl,
           apiKey: this.apiKeyTonder,
         });
@@ -233,18 +250,19 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
       card: skyflowTokens,
       payment_method,
       customer,
-      isSandbox
+      isSandbox,
     });
   }
 
-
   // TODO: DEPRECATED
   /**
    * @deprecated This method is deprecated and will be removed in a future release.
    * It is no longer necessary to use this method as customer registration is now automatically handled
    * during the payment process or when using card management methods.
    */
-  async customerRegister(email: string): Promise<CustomerRegisterResponse | ErrorResponse> {
+  async customerRegister(
+    email: string,
+  ): Promise<CustomerRegisterResponse | ErrorResponse> {
     try {
       const url = `${this.baseUrl}/api/v1/customer/`;
       const data = { email: email };
@@ -258,21 +276,23 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
         body: JSON.stringify(data),
       });
 
-      if (response.ok) return await response.json() as CustomerRegisterResponse;
+      if (response.ok)
+        return (await response.json()) as CustomerRegisterResponse;
       throw await buildErrorResponse(response);
     } catch (e) {
       throw buildErrorResponseFromCatch(e);
     }
   }
 
-
   // TODO: DEPRECATED
   /**
    * @deprecated This method is deprecated and will be removed in a future release.
    * It is no longer necessary to use this method as order creation is now automatically
    * handled when making a payment through the `payment` function.
    */
-  async createOrder(orderItems: CreateOrderRequest): Promise<CreateOrderResponse | ErrorResponse> {
+  async createOrder(
+    orderItems: CreateOrderRequest,
+  ): Promise<CreateOrderResponse | ErrorResponse> {
     try {
       const url = `${this.baseUrl}/api/v1/orders/`;
       const data = orderItems;
@@ -284,7 +304,7 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
         },
         body: JSON.stringify(data),
       });
-      if (response.ok) return await response.json() as CreateOrderResponse;
+      if (response.ok) return (await response.json()) as CreateOrderResponse;
       throw await buildErrorResponse(response);
     } catch (e) {
       throw buildErrorResponseFromCatch(e);
@@ -297,7 +317,9 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
    * It is no longer necessary to use this method as payment creation is now automatically
    * handled when making a payment through the `payment` function.
    */
-  async createPayment(paymentItems: CreatePaymentRequest): Promise<CreatePaymentResponse | ErrorResponse> {
+  async createPayment(
+    paymentItems: CreatePaymentRequest,
+  ): Promise<CreatePaymentResponse | ErrorResponse> {
     try {
       const url = `${this.baseUrl}/api/v1/business/${paymentItems.business_pk}/payments/`;
       const data = paymentItems;
@@ -309,7 +331,7 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
         },
         body: JSON.stringify(data),
       });
-      if (response.ok) return await response.json() as CreatePaymentResponse;
+      if (response.ok) return (await response.json()) as CreatePaymentResponse;
       throw await buildErrorResponse(response);
     } catch (e) {
       throw buildErrorResponseFromCatch(e);
@@ -321,17 +343,22 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
    * @deprecated This method is deprecated and will be removed in a future release.
    * Use the {@link payment} method
    */
-  async startCheckoutRouter(routerData: StartCheckoutRequest | StartCheckoutIdRequest): Promise<StartCheckoutResponse | ErrorResponse | undefined> {
-    const checkoutResult = await startCheckoutRouter(this.baseUrl, this.apiKeyTonder, routerData);
-    const payload = await this.init3DSRedirect(checkoutResult)
-    if(payload)
-      return checkoutResult;
+  async startCheckoutRouter(
+    routerData: StartCheckoutRequest | StartCheckoutIdRequest,
+  ): Promise<StartCheckoutResponse | ErrorResponse | undefined> {
+    const checkoutResult = await startCheckoutRouter(
+      this.baseUrl,
+      this.apiKeyTonder,
+      routerData,
+    );
+    const payload = await this.init3DSRedirect(checkoutResult);
+    if (payload) return checkoutResult;
   }
 
   // TODO: DEPRECATED
-  async init3DSRedirect(checkoutResult: ErrorResponse | StartCheckoutResponse){
-    this.process3ds.setPayload(checkoutResult)
-    return await this._handle3dsRedirect(checkoutResult)
+  async init3DSRedirect(checkoutResult: ErrorResponse | StartCheckoutResponse) {
+    this.process3ds.setPayload(checkoutResult);
+    return await this._handle3dsRedirect(checkoutResult);
   }
 
   // TODO: DEPRECATED
@@ -339,28 +366,33 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
    * @deprecated This method is deprecated and will be removed in a future release.
    * Use the {@link payment} method
    */
-  async startCheckoutRouterFull(routerFullData: StartCheckoutFullRequest): Promise<StartCheckoutResponse | ErrorResponse | undefined> {
-    
+  async startCheckoutRouterFull(
+    routerFullData: StartCheckoutFullRequest,
+  ): Promise<StartCheckoutResponse | ErrorResponse | undefined> {
     try {
-
-      const { 
-        order, 
-        total, 
-        customer, 
-        skyflowTokens, 
-        return_url, 
-        isSandbox, 
-        metadata, 
+      const {
+        order,
+        total,
+        customer,
+        skyflowTokens,
+        return_url,
+        isSandbox,
+        metadata,
         currency,
-        payment_method
+        payment_method,
       } = routerFullData;
 
       const merchantResult = await this._fetchMerchantData();
 
-      const customerResult : CustomerRegisterResponse | ErrorResponse = await this.customerRegister(customer.email);
-
-      if(customerResult && "auth_token" in customerResult && merchantResult && "reference" in merchantResult) {
+      const customerResult: CustomerRegisterResponse | ErrorResponse =
+        await this.customerRegister(customer.email);
 
+      if (
+        customerResult &&
+        "auth_token" in customerResult &&
+        merchantResult &&
+        "reference" in merchantResult
+      ) {
         const orderData: CreateOrderRequest = {
           business: this.apiKeyTonder,
           client: customerResult.auth_token,
@@ -378,29 +410,30 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
 
         const dateString = now.toISOString();
 
-        if("id" in orderResult && "id" in customerResult && "business" in merchantResult) {
-
+        if (
+          "id" in orderResult &&
+          "id" in customerResult &&
+          "business" in merchantResult
+        ) {
           const paymentItems: CreatePaymentRequest = {
             business_pk: merchantResult.business.pk,
             amount: total,
             date: dateString,
             order_id: orderResult.id,
-            client_id: customerResult.id
+            client_id: customerResult.id,
           };
 
-          const paymentResult = await this.createPayment(
-            paymentItems
-          );
+          const paymentResult = await this.createPayment(paymentItems);
 
           let deviceSessionIdTonder: any;
 
-          const { openpay_keys, business } = merchantResult
+          const { openpay_keys, business } = merchantResult;
 
           if (openpay_keys.merchant_id && openpay_keys.public_key) {
             deviceSessionIdTonder = await getOpenpayDeviceSessionID(
               openpay_keys.merchant_id,
               openpay_keys.public_key,
-              isSandbox
+              isSandbox,
             );
           }
 
@@ -417,51 +450,50 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
             amount: total,
             title_ship: "shipping",
             description: "transaction",
-            device_session_id: deviceSessionIdTonder ? deviceSessionIdTonder : null,
+            device_session_id: deviceSessionIdTonder
+              ? deviceSessionIdTonder
+              : null,
             token_id: "",
-            order_id: ("id" in orderResult) && orderResult.id,
+            order_id: "id" in orderResult && orderResult.id,
             business_id: business.pk,
-            payment_id: ("pk" in paymentResult) && paymentResult.pk,
-            source: 'sdk',
+            payment_id: "pk" in paymentResult && paymentResult.pk,
+            source: "sdk",
             metadata: metadata,
             browser_info: getBrowserInfo(),
             currency: currency,
-            ...( !!payment_method
-              ? {payment_method}
-              : {card: skyflowTokens}
-            ),
-            ...(typeof MP_DEVICE_SESSION_ID !== "undefined" ? {mp_device_session_id: MP_DEVICE_SESSION_ID}:{})
+            ...(!!payment_method
+              ? { payment_method }
+              : { card: skyflowTokens }),
+            ...(typeof MP_DEVICE_SESSION_ID !== "undefined"
+              ? { mp_device_session_id: MP_DEVICE_SESSION_ID }
+              : {}),
           };
 
-          const checkoutResult = await startCheckoutRouter(this.baseUrl, this.apiKeyTonder, routerItems);
-          const payload = await this.init3DSRedirect(checkoutResult)
-          if(payload)
-            return checkoutResult;
+          const checkoutResult = await startCheckoutRouter(
+            this.baseUrl,
+            this.apiKeyTonder,
+            routerItems,
+          );
+          const payload = await this.init3DSRedirect(checkoutResult);
+          if (payload) return checkoutResult;
         } else {
-
           throw new ErrorResponse({
             code: "500",
             body: orderResult as any,
             name: "Keys error",
-            message: "Order response errors"
-          } as IErrorResponse)
-        
+            message: "Order response errors",
+          } as IErrorResponse);
         }
-      
       } else {
-
         throw new ErrorResponse({
           code: "500",
           body: merchantResult as any,
           name: "Keys error",
-          message: "Merchant or customer reposne errors"
-        } as IErrorResponse)
-      
+          message: "Merchant or customer reposne errors",
+        } as IErrorResponse);
       }
     } catch (e) {
-      
       throw buildErrorResponseFromCatch(e);
-    
     }
   }
 
@@ -470,20 +502,27 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
    * @deprecated This method is deprecated and will be removed in a future release.
    * Use the {@link saveCustomerCard} method
    */
-  async registerCustomerCard(customerToken: string, data: RegisterCustomerCardRequest): Promise<RegisterCustomerCardResponse | ErrorResponse> {
+  async registerCustomerCard(
+    customerToken: string,
+    data: RegisterCustomerCardRequest,
+  ): Promise<RegisterCustomerCardResponse | ErrorResponse> {
     try {
-      await this._fetchMerchantData()
-
-      const response = await fetch(`${this.baseUrl}/api/v1/business/${getBusinessId(this.merchantData)}/cards/`, {
-        method: 'POST',
-        headers: {
-          'Authorization': `Token ${customerToken}`,
-          'Content-Type': 'application/json'
+      await this._fetchMerchantData();
+
+      const response = await fetch(
+        `${this.baseUrl}/api/v1/business/${getBusinessId(this.merchantData)}/cards/`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Token ${customerToken}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ ...data }),
         },
-        body: JSON.stringify({...data})
-      });
+      );
 
-      if (response.ok) return await response.json() as RegisterCustomerCardResponse;
+      if (response.ok)
+        return (await response.json()) as RegisterCustomerCardResponse;
       throw await buildErrorResponse(response);
     } catch (error) {
       throw buildErrorResponseFromCatch(error);
@@ -495,17 +534,23 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
    * @deprecated This method is deprecated and will be removed in a future release.
    * Use the {@link removeCustomerCard} method
    */
-  async deleteCustomerCard(customerToken: string, skyflowId: string = ""): Promise<Boolean | ErrorResponse> {
+  async deleteCustomerCard(
+    customerToken: string,
+    skyflowId: string = "",
+  ): Promise<Boolean | ErrorResponse> {
     try {
-      await this._fetchMerchantData()
-      const response = await fetch(`${this.baseUrl}/api/v1/business/${getBusinessId(this.merchantData)}/cards/${skyflowId}`, {
-        method: 'DELETE',
-        headers: {
-          'Authorization': `Token ${customerToken}`,
-          'Content-Type': 'application/json'
+      await this._fetchMerchantData();
+      const response = await fetch(
+        `${this.baseUrl}/api/v1/business/${getBusinessId(this.merchantData)}/cards/${skyflowId}`,
+        {
+          method: "DELETE",
+          headers: {
+            Authorization: `Token ${customerToken}`,
+            "Content-Type": "application/json",
+          },
+          signal: this.abortController.signal,
         },
-        signal: this.abortController.signal,
-      });
+      );
 
       if (response.ok) return true;
       throw await buildErrorResponse(response);
@@ -521,27 +566,36 @@ export class LiteCheckout extends BaseInlineCheckout implements ILiteInlineCheck
    */
   async getActiveAPMs(): Promise<APM[]> {
     try {
-      const apms_response = await getCustomerAPMs(this.baseUrl, this.apiKeyTonder);
-      const apms_results = apms_response && apms_response['results'] && apms_response['results'].length > 0 ? apms_response['results'] : []
+      const apms_response = await getCustomerAPMs(
+        this.baseUrl,
+        this.apiKeyTonder,
+      );
+      const apms_results =
+        apms_response &&
+        apms_response["results"] &&
+        apms_response["results"].length > 0
+          ? apms_response["results"]
+          : [];
       this.activeAPMs = apms_results
-          .filter((apmItem: TonderAPM) =>
-              apmItem.category.toLowerCase() !== 'cards')
-          .map((apmItem: TonderAPM) => {
-            const apm: APM = {
-              id: apmItem.pk,
-              payment_method: apmItem.payment_method,
-              priority: apmItem.priority,
-              category: apmItem.category,
-              ...getPaymentMethodDetails(apmItem.payment_method,)
-            }
-            return apm;
-          }).sort((a: APM, b: APM) => a.priority - b.priority);
-
-      return this.activeAPMs
+        .filter(
+          (apmItem: TonderAPM) => apmItem.category.toLowerCase() !== "cards",
+        )
+        .map((apmItem: TonderAPM) => {
+          const apm: APM = {
+            id: apmItem.pk,
+            payment_method: apmItem.payment_method,
+            priority: apmItem.priority,
+            category: apmItem.category,
+            ...getPaymentMethodDetails(apmItem.payment_method),
+          };
+          return apm;
+        })
+        .sort((a: APM, b: APM) => a.priority - b.priority);
+
+      return this.activeAPMs;
     } catch (e) {
       console.error("Error getting APMS", e);
       return [];
     }
   }
-
 }