@tonder.io/rn-sdk 0.1.0-beta.DEV1355.1

package/src/infrastructure/index.ts

@@ -0,0 +1,2 @@
+export * from './ServiceManager';
+export * from './HttpClient';

package/src/services/BusinessService.ts

@@ -0,0 +1,33 @@
+import type { GetBusinessResponse } from '@types';
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { ErrorKeyEnum } from '@shared/enum';
+
+export class BusinessService {
+  private readonly BASE_PATH = '/api/v1/payments/business';
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  /**
+   * Fetches business information from the API
+   * @param signal Optional AbortSignal for request cancellation
+   * @returns Business information
+   * @throws {TonderError} If the request fails
+   */
+  async fetchBusiness(signal?: AbortSignal): Promise<GetBusinessResponse> {
+    try {
+      return await this.http.get<GetBusinessResponse>(
+        `${this.BASE_PATH}/${this.http.getApiKey()}`,
+        { signal } as RequestInit
+      );
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.FETCH_BUSINESS_ERROR,
+        details: error,
+      });
+    }
+  }
+}

package/src/services/CardService.ts

@@ -0,0 +1,118 @@
+import type {
+  ICustomerCardsResponse,
+  ISaveCardResponse,
+  ISaveCardSkyflowRequest,
+} from '@types';
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { MESSAGES_EN } from '@shared/constants';
+import { ErrorKeyEnum } from '@shared/enum';
+
+export class CardService {
+  private readonly BASE_PATH = '/api/v1/business';
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+  /**
+   * Fetches customer cards from the API
+   * @throws {TonderError} If the request fails
+   */
+  async fetchCustomerCards(
+    customerToken: string,
+    secureToken: string,
+    businessId: string | number
+  ): Promise<ICustomerCardsResponse> {
+    this.validateSecureToken(secureToken);
+    try {
+      return await this.http.get<ICustomerCardsResponse>(
+        `${this.BASE_PATH}/${businessId}/cards/`,
+        {
+          headers: this.buildAuthHeaders(secureToken, customerToken),
+        }
+      );
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.FETCH_CARDS_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  /**
+   * Saves a customer card
+   * @throws {TonderError} If the request fails
+   */
+  async saveCustomerCard(
+    customerToken: string,
+    secureToken: string,
+    businessId: string | number,
+    cardData: ISaveCardSkyflowRequest
+  ): Promise<ISaveCardResponse> {
+    this.validateSecureToken(secureToken);
+
+    try {
+      return await this.http.post<ISaveCardResponse>(
+        `${this.BASE_PATH}/${businessId}/cards/`,
+        cardData,
+        {
+          headers: this.buildAuthHeaders(secureToken, customerToken),
+        }
+      );
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.SAVE_CARD_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  /**
+   * Removes a customer card
+   * @throws {TonderError} If the request fails
+   */
+  async removeCustomerCard(
+    customerToken: string,
+    secureToken: string,
+    skyflowId: string,
+    businessId: string | number
+  ): Promise<string> {
+    this.validateSecureToken(secureToken);
+
+    try {
+      await this.http.delete(
+        `${this.BASE_PATH}/${businessId}/cards/${skyflowId}/`,
+        {
+          headers: this.buildAuthHeaders(secureToken, customerToken),
+        }
+      );
+
+      return MESSAGES_EN.REMOVE_CARD;
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.REMOVE_CARD_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  private validateSecureToken(token: string): void {
+    if (!token) {
+      throw new TonderError({ code: ErrorKeyEnum.SECURE_TOKEN_INVALID });
+    }
+  }
+
+  /**
+   * Builds authentication headers for card operations
+   */
+  private buildAuthHeaders(
+    secureToken: string,
+    customerToken: string
+  ): Record<string, string> {
+    return {
+      'Authorization': `Bearer ${secureToken}`,
+      'User-token': customerToken,
+    };
+  }
+}

package/src/services/CheckoutService.ts

@@ -0,0 +1,135 @@
+import type {
+  IStartCheckoutRequest,
+  IStartCheckoutIdRequest,
+  ICreateOrderResponse,
+  ICreatePaymentResponse,
+  ICheckoutResponse,
+  ICreatePaymentRequest,
+  ICreateOrderRequest,
+} from '@types';
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { ErrorKeyEnum } from '@shared/enum';
+
+export class CheckoutService {
+  private readonly BASE_PATHS = {
+    orders: '/api/v1/orders/',
+    payments: '/api/v1/business',
+    checkout: '/api/v1/checkout-router/',
+  } as const;
+
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+  /**
+   * Creates a new order
+   * @param orderItems Order data to create
+   * @throws {TonderError} If order creation fails
+   */
+  async createOrder(
+    orderItems: ICreateOrderRequest
+  ): Promise<ICreateOrderResponse> {
+    try {
+      this.validateOrderData(orderItems);
+
+      return await this.http.post<ICreateOrderResponse>(
+        this.BASE_PATHS.orders,
+        orderItems
+      );
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.CREATE_ORDER_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  /**
+   * Creates a new payment
+   * @param paymentItems Payment data to create
+   * @throws {TonderError} If payment creation fails
+   */
+  async createPayment(
+    paymentItems: ICreatePaymentRequest
+  ): Promise<ICreatePaymentResponse> {
+    try {
+      this.validatePaymentData(paymentItems);
+
+      return await this.http.post<ICreatePaymentResponse>(
+        `${this.BASE_PATHS.payments}/${paymentItems.business_pk}/payments/`,
+        paymentItems
+      );
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.CREATE_PAYMENT_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  /**
+   * Starts or continues a checkout process
+   * @param routerItems Checkout data or checkout ID
+   * @param deviceSessionId Optional device session ID for MercadoPago
+   * @throws {TonderError} If checkout process fails
+   */
+  async startCheckoutRouter(
+    routerItems: IStartCheckoutRequest | IStartCheckoutIdRequest,
+    deviceSessionId?: string
+  ): Promise<ICheckoutResponse> {
+    try {
+      const payload = {
+        ...routerItems,
+        ...(deviceSessionId ? { mp_device_session_id: deviceSessionId } : {}),
+      };
+
+      return await this.http.post<ICheckoutResponse>(
+        this.BASE_PATHS.checkout,
+        payload
+      );
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.START_CHECKOUT_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  /**
+   * Validates order data before creation
+   * @throws {TonderError} If order data is invalid
+   */
+  private validateOrderData(orderItems: ICreateOrderRequest): void {
+    if (!orderItems.business) {
+      throw new TonderError({ code: ErrorKeyEnum.BUSINESS_ID_REQUIRED });
+    }
+
+    if (!orderItems.amount || orderItems.amount <= 0) {
+      throw new TonderError({ code: ErrorKeyEnum.INVALID_AMOUNT });
+    }
+
+    if (!orderItems.items?.length) {
+      throw new TonderError({ code: ErrorKeyEnum.INVALID_ITEMS });
+    }
+  }
+
+  /**
+   * Validates payment data before creation
+   * @throws {TonderError} If payment data is invalid
+   */
+  private validatePaymentData(paymentItems: ICreatePaymentRequest): void {
+    if (!paymentItems.business_pk) {
+      throw new TonderError({ code: ErrorKeyEnum.BUSINESS_ID_REQUIRED });
+    }
+
+    if (!paymentItems.client_id) {
+      throw new TonderError({ code: ErrorKeyEnum.CLIENT_ID_REQUIRED });
+    }
+
+    if (!paymentItems.amount || paymentItems.amount <= 0) {
+      throw new TonderError({ code: ErrorKeyEnum.INVALID_AMOUNT });
+    }
+  }
+}

package/src/services/CustomerService.ts

@@ -0,0 +1,59 @@
+import type { ICustomer, ICustomerResponse } from '@types';
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { ErrorKeyEnum } from '@shared/enum';
+
+export class CustomerService {
+  private readonly BASE_PATH = '/api/v1/customer/';
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+  /**
+   * Registers a new customer or fetches existing one
+   * @param customer Customer data
+   * @param signal Optional AbortSignal for request cancellation
+   * @throws {TonderError} If registration/fetch fails or validation fails
+   */
+  async registerOrFetchCustomer(
+    customer: ICustomer,
+    signal?: AbortSignal
+  ): Promise<ICustomerResponse> {
+    try {
+      this.validateCustomerData(customer);
+
+      return await this.http.post<ICustomerResponse>(this.BASE_PATH, customer, {
+        signal,
+      } as RequestInit);
+    } catch (error) {
+      console.error('CUSTOMER_OPERATION_ERROR', error);
+      throw new TonderError({
+        code: ErrorKeyEnum.CUSTOMER_OPERATION_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  /**
+   * Validates customer data before processing
+   * @throws {TonderError} If customer data is invalid
+   */
+  private validateCustomerData(customer: ICustomer): void {
+    if (!customer.email) {
+      throw new TonderError({ code: ErrorKeyEnum.INVALID_EMAIL });
+    }
+
+    if (!this.isValidEmail(customer.email)) {
+      throw new TonderError({ code: ErrorKeyEnum.INVALID_EMAIL });
+    }
+  }
+
+  /**
+   * Validates email format
+   */
+  private isValidEmail(email: string): boolean {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+}

package/src/services/MercadoPagoService.ts

@@ -0,0 +1,19 @@
+export class MercadoPagoService {
+  injectMercadoPagoSecurity() {
+    // TODO: IMPLEMENT
+    // try {
+    //   const script = document.createElement('script');
+    //   script.src = 'https://www.mercadopago.com/v2/security.js';
+    //   script.setAttribute('view', '');
+    //   script.onload = () => {
+    //     console.log('Mercado Pago script loaded successfully.');
+    //   };
+    //   script.onerror = (error) => {
+    //     console.error('Error loading Mercado Pago script:', error);
+    //   };
+    //   document.head.appendChild(script);
+    // } catch (error) {
+    //   console.error('Error attempting to inject Mercado Pago script:', error);
+    // }
+  }
+}

package/src/services/OpenPayService.ts

@@ -0,0 +1,22 @@
+// @ts-nocheck
+
+export class OpenPayService {
+  async getDeviceSessionId(
+    merchantId: string,
+    publicKey: string,
+    isSandbox: boolean = true,
+    signal?: AbortSignal
+  ): Promise<string> {
+    // var openpay = new Openpay(' your merchant id ', ' your private key ', [ isProduction ]);
+    // if (typeof global.OpenPay === 'undefined') {
+    //   throw new Error('OpenPay scripts must be loaded first');
+    // }
+    //
+    // const openpay = global.OpenPay;
+    // openpay.setId(merchantId);
+    // openpay.setApiKey(publicKey);
+    // openpay.setSandboxMode(isSandbox);
+    // return await openpay.deviceData.setup({ signal });
+    return new Promise((r) => r(''));
+  }
+}

package/src/services/PaymentMethodService.ts

@@ -0,0 +1,38 @@
+import type { IPaymentMethodResponse } from '@types';
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { ErrorKeyEnum } from '@shared/enum';
+
+export class PaymentMethodService {
+  private readonly BASE_PATH = '/api/v1/payment_methods';
+  private readonly DEFAULT_PAGE_SIZE = '10000';
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+  /**
+   * Fetches available payment methods
+   * @param params Optional parameters for filtering payment methods
+   * @throws {TonderError} If the request fails
+   */
+  async fetchPaymentMethods(
+    params: Record<string, string> = {
+      status: 'active',
+      pagesize: this.DEFAULT_PAGE_SIZE,
+    }
+  ): Promise<IPaymentMethodResponse> {
+    try {
+      const queryString = new URLSearchParams(params).toString();
+
+      return await this.http.get<IPaymentMethodResponse>(
+        `${this.BASE_PATH}?${queryString}`
+      );
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.FETCH_PAYMENT_METHODS_ERROR,
+        details: error,
+      });
+    }
+  }
+}

package/src/services/SkyflowService.ts

@@ -0,0 +1,50 @@
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { ErrorKeyEnum } from '@shared/enum';
+import type { IConfig } from 'skyflow-react-native';
+import { Env, LogLevel } from 'skyflow-react-native';
+
+export class SkyflowService {
+  private readonly BASE_PATH = '/api/v1/vault-token';
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  /**
+   * Gets a Skyflow vault token
+   * @param signal Optional AbortSignal for request cancellation
+   * @throws {TonderError} If token fetch fails
+   */
+  async getVaultToken(signal?: AbortSignal): Promise<string> {
+    try {
+      const response = await this.http.get<{ token: string }>(this.BASE_PATH, {
+        signal,
+      } as RequestInit);
+
+      if (!response.token) {
+        throw new TonderError({ code: ErrorKeyEnum.INVALID_VAULT_TOKEN });
+      }
+
+      return response.token;
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.VAULT_TOKEN_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  async createSkyflowConfig(merchantData: any): Promise<IConfig> {
+    return {
+      vaultID: merchantData.vault_id,
+      vaultURL: merchantData.vault_url,
+      options: {
+        logLevel: LogLevel.ERROR,
+        env: Env.DEV,
+      },
+      getBearerToken: async () => await this.getVaultToken(),
+    };
+  }
+}

package/src/services/StorageService.ts

@@ -0,0 +1,56 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+interface StorageItem<T> {
+  data: T;
+  expires: number;
+}
+
+export class StorageService {
+  constructor() {}
+
+  async setItem<T>(
+    key: string,
+    data: T,
+    expirationMinutes: number = 20
+  ): Promise<void> {
+    try {
+      const item: StorageItem<T> = {
+        data,
+        expires: new Date().getTime() + expirationMinutes * 60 * 1000,
+      };
+      await AsyncStorage.setItem(key, JSON.stringify(item));
+    } catch (error) {
+      console.error('Storage set error:', error);
+      throw error;
+    }
+  }
+
+  async getItemWithExpires<T>(key: string): Promise<T | null> {
+    try {
+      const value = await AsyncStorage.getItem(key);
+      if (!value) return null;
+
+      const item: StorageItem<T> = JSON.parse(value);
+      const now = new Date().getTime();
+
+      if (now > item.expires) {
+        await this.removeItem(key);
+        return null;
+      }
+
+      return item.data;
+    } catch (error) {
+      console.error('Storage get error:', error);
+      throw error;
+    }
+  }
+
+  async removeItem(key: string): Promise<void> {
+    try {
+      await AsyncStorage.setItem(key, '');
+    } catch (error) {
+      console.error('Storage remove error:', error);
+      throw error;
+    }
+  }
+}

package/src/services/TokenService.ts

@@ -0,0 +1,45 @@
+import type { IGetSecureTokenResponse } from '@types';
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { ErrorKeyEnum } from '@shared/enum';
+
+export class TokenService {
+  private readonly BASE_PATH = '/api/secure-token/';
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+  /**
+   * Gets a secure token for authenticated operations
+   * @param secretApiKey Authorization token
+   * @param signal Optional AbortSignal for request cancellation
+   * @throws {TonderError} If secure token fetch fails
+   */
+  async getSecureToken(
+    secretApiKey: string,
+    signal?: AbortSignal
+  ): Promise<IGetSecureTokenResponse> {
+    try {
+      this.validateToken(secretApiKey);
+
+      return await this.http.post<IGetSecureTokenResponse>(this.BASE_PATH, {}, {
+        headers: {
+          Authorization: `Token ${secretApiKey}`,
+        },
+        signal,
+      } as RequestInit);
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.SECURE_TOKEN_ERROR,
+        details: error,
+      });
+    }
+  }
+
+  private validateToken(token: string): void {
+    if (!token) {
+      throw new TonderError({ code: ErrorKeyEnum.INVALID_SECRET_API_KEY });
+    }
+  }
+}

package/src/services/TransactionService.ts

@@ -0,0 +1,23 @@
+import type { ITransaction } from '@types';
+import TonderError from '@shared/utils/errors';
+import { HttpClient } from '@infrastructure/HttpClient';
+import { ErrorKeyEnum } from '@shared/enum';
+
+export class TransactionService {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  async verifyTransactionStatus(verifyUrl: string): Promise<ITransaction> {
+    try {
+      return await this.http.get<ITransaction>(`${verifyUrl}`);
+    } catch (error) {
+      throw new TonderError({
+        code: ErrorKeyEnum.FETCH_TRANSACTION_ERROR,
+        details: error,
+      });
+    }
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,12 @@
+export * from './CardService';
+export * from './TokenService';
+export * from './SkyflowService';
+export * from './OpenPayService';
+export * from './CardService';
+export * from './CheckoutService';
+export * from './CustomerService';
+export * from './PaymentMethodService';
+export * from './BusinessService';
+export * from './MercadoPagoService';
+export * from './TransactionService';
+export * from './StorageService';

package/src/shared/catalog/cardBrandCatalog.ts

@@ -0,0 +1,16 @@
+import { clearSpace } from '@shared/utils/stringUtils';
+
+const CARD_BRAND_CATALOG: {
+  [key: string]: string;
+} = {
+  visa: 'https://d35a75syrgujp0.cloudfront.net/cards/visa.png',
+  mastercard: 'https://d35a75syrgujp0.cloudfront.net/cards/mastercard.png',
+  americanexpress:
+    'https://d35a75syrgujp0.cloudfront.net/cards/american_express.png',
+  default: 'https://d35a75syrgujp0.cloudfront.net/cards/default_card.png',
+};
+
+export const getCardType = (scheme: string) => {
+  const scheme_clean = clearSpace(scheme).toLowerCase();
+  return CARD_BRAND_CATALOG[scheme_clean] || CARD_BRAND_CATALOG.default;
+};