@deuna/react-native-sdk 1.0.0

package/src/interfaces/events/checkout.ts

@@ -0,0 +1,46 @@
+export enum CheckoutEventType {
+  custom = 'custom',
+  purchase = 'purchase',
+  purchaseError = 'purchaseError',
+  linkClose = 'linkClose',
+  linkFailed = 'linkFailed',
+  purchaseRejected = 'purchaseRejected',
+  paymentProcessing = 'paymentProcessing',
+  paymentMethodsAddCard = 'paymentMethodsAddCard',
+  paymentMethodsCardExpirationDateInitiated = 'paymentMethodsCardExpirationDateInitiated',
+  paymentMethodsCardNameEntered = 'paymentMethodsCardNameEntered',
+  apmSuccess = 'apmSuccess',
+  apmSuccessful = 'apmSuccessful',
+  changeAddress = 'changeAddress',
+  changeCart = 'changeCart',
+  paymentClick = 'paymentClick',
+  apmClickRedirect = 'apmClickRedirect',
+  paymentMethodsCardNumberInitiated = 'paymentMethodsCardNumberInitiated',
+  paymentMethodsCardNumberEntered = 'paymentMethodsCardNumberEntered',
+  paymentMethodsEntered = 'paymentMethodsEntered',
+  checkoutStarted = 'checkoutStarted',
+  linkStarted = 'linkStarted',
+  paymentMethodsStarted = 'paymentMethodsStarted',
+  paymentMethodsSelected = 'paymentMethodsSelected',
+  adBlock = 'adBlock',
+  paymentMethods3dsInitiated = 'paymentMethods3dsInitiated',
+  pointsToWinStarted = 'pointsToWinStarted',
+  paymentMethodsCardSecurityCodeInitiated = 'paymentMethodsCardSecurityCodeInitiated',
+  paymentMethodsCardSecurityCodeEntered = 'paymentMethodsCardSecurityCodeEntered',
+  paymentMethodsCardExpirationDateEntered = 'paymentMethodsCardExpirationDateEntered',
+  paymentMethodsCardNameInitiated = 'paymentMethodsCardNameInitiated',
+  paymentMethodsNotAvailable = 'paymentMethodsNotAvailable',
+  paymentMethodsShowMore = 'paymentMethodsShowMore',
+  paymentMethodsShowMyCards = 'paymentMethodsShowMyCards',
+  benefitsStarted = 'benefitsStarted',
+  donationsStarted = 'donationsStarted',
+  donationsUsed = 'donationsUsed',
+  onBinDetected = 'onBinDetected',
+  onInstallmentSelected = 'onInstallmentSelected',
+  onDownloadVoucher = 'onDownloadVoucher',
+}
+
+export interface CheckoutEvent {
+  type: CheckoutEventType;
+  data: Record<string, any>;
+}

package/src/interfaces/events/elements.ts

@@ -0,0 +1,29 @@
+export enum ElementsEventType {
+  vaultClosed = 'vaultClosed',
+  vaultProcessing = 'vaultProcessing',
+  vaultSaveClick = 'vaultSaveClick',
+  vaultStarted = 'vaultStarted',
+  vaultFailed = 'vaultFailed',
+  cardSuccessfullyCreated = 'cardSuccessfullyCreated',
+  changeAddress = 'changeAddress',
+  changeCart = 'changeCart',
+  vaultSaveError = 'vaultSaveError',
+  vaultSaveSuccess = 'vaultSaveSuccess',
+  vaultClickRedirect3DS = 'vaultClickRedirect3DS',
+  cardCreationError = 'cardCreationError',
+  paymentMethodsCardIdentityNumberInitiated = 'paymentMethodsCardIdentityNumberInitiated',
+  paymentMethodsCardIdentityNumberEntered = 'paymentMethodsCardIdentityNumberEntered',
+  paymentMethodsCardNameInitiated = 'paymentMethodsCardNameInitiated',
+  paymentMethodsCardNameEntered = 'paymentMethodsCardNameEntered',
+  paymentMethodsCardSecurityCodeInitiated = 'paymentMethodsCardSecurityCodeInitiated',
+  paymentMethodsCardSecurityCodeEntered = 'paymentMethodsCardSecurityCodeEntered',
+  paymentMethodsCardExpirationDateEntered = 'paymentMethodsCardExpirationDateEntered',
+  paymentMethodsCardExpirationDateInitiated = 'paymentMethodsCardExpirationDateInitiated',
+  paymentMethodsCardNumberEntered = 'paymentMethodsCardNumberEntered',
+  paymentMethodsCardNumberInitiated = 'paymentMethodsCardNumberInitiated',
+}
+
+export interface ElementsEvent {
+  type: ElementsEventType;
+  data: Record<string, any>;
+}

package/src/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './events/checkout';
+export * from './errors';
+export * from './types';

package/src/interfaces/types.ts

@@ -0,0 +1,13 @@
+export enum Mode {
+  MODAL = 'modal',
+  EMBEDDED = 'embedded',
+}
+
+export enum DownloadType {
+  URL = 'url',
+  BASE64 = 'base64',
+}
+
+export type OnDownloadFile = {
+  onDownloadFile?: (data: { type: DownloadType; data: string }) => void;
+};

package/src/types/base.ts

@@ -0,0 +1,126 @@
+import {
+  ElementsWidgetCallbacks,
+  NextActionWidgetCallbacks,
+  PaymentWidgetCallbacks,
+  VoucherWidgetCallbacks,
+} from './interfaces/callbacks';
+import { CustomStyles } from './interfaces/customStyle';
+import { ElementWidgetType } from './helpers/urlConfig';
+import {
+  InitWidgetBase,
+  PaymentMethodConfigurationFlow,
+} from './interfaces/initWidgetBase';
+import {
+  Merchant,
+  PaymentMethodTypes,
+  PaymentProcessorName,
+} from './interfaces/merchant';
+import { Order } from './interfaces/order';
+import { User } from './interfaces/user';
+
+export type Environment = 'production' | 'sandbox' | 'develop' | 'staging';
+
+export interface InitializeParams {
+  environment?: Environment;
+  publicApiKey: string;
+}
+export type SubmitStatus = 'success' | 'error';
+
+export type SubmitResult = {
+  status: SubmitStatus;
+  message?: string;
+  code?: string;
+};
+
+export interface State {
+  order: Order;
+  merchant: Merchant;
+  user: User;
+  paymentMethods: {
+    selectedPaymentMethod: {
+      method_type: PaymentMethodTypes;
+      processor_name?: PaymentProcessorName;
+      configuration?: {
+        express?: boolean;
+        flowType?: PaymentMethodConfigurationFlow;
+      };
+    };
+  };
+}
+
+export type Submit = () => Promise<SubmitResult>;
+export type SetCustomStyle = (customStyles: CustomStyles) => void;
+export type GetStateFn = () => Promise<State>;
+export type IsValid = () => Promise<boolean>;
+export type RefetchOrder = () => Promise<Order | null>;
+
+export type InitPaymentWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+  orderToken: string;
+  callbacks: PaymentWidgetCallbacks;
+  paymentMethods?: {
+    paymentMethod: string;
+    processors: string[];
+    configuration?: {
+      express?: boolean;
+      flowType?: PaymentMethodConfigurationFlow;
+    };
+  }[];
+  sessionId?: string;
+};
+
+export type InitElementsWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+  callbacks: ElementsWidgetCallbacks;
+  types?: ElementWidgetType[];
+};
+
+export type InitNextActionWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+  orderToken: string;
+  callbacks: NextActionWidgetCallbacks;
+};
+
+export type InitVoucherWidgetParams = Omit<InitWidgetBase, 'callbacks'> & {
+  orderToken: string;
+  callbacks: VoucherWidgetCallbacks;
+};
+
+export abstract class BaseDeuna {
+  abstract setCustomStyleFn?: SetCustomStyle;
+  abstract refetchOrderFn?: RefetchOrder;
+  abstract getStateFn?: GetStateFn;
+  abstract onSubmitFn?: Submit;
+  abstract isValidFn?: IsValid;
+  abstract closeFn?: () => void;
+
+  abstract getSessionId(): Promise<string>;
+  abstract submit(): Promise<SubmitResult>;
+  abstract close(): Promise<void>;
+
+  async setCustomStyles(customStyles: CustomStyles): Promise<void> {
+    await this.setCustomStyleFn?.(customStyles);
+  }
+
+  async refetchOrder(): Promise<Order | null> {
+    return this.refetchOrderFn?.() || null;
+  }
+
+  async getWidgetState() {
+    return this.getStateFn?.();
+  }
+
+  async isValid(): Promise<boolean> {
+    return this.isValidFn?.() || false;
+  }
+
+  async getSelectedPaymentMethod() {
+    const state = await this.getStateFn?.();
+    if (!state?.paymentMethods.selectedPaymentMethod) {
+      return null;
+    }
+    return state.paymentMethods.selectedPaymentMethod;
+  }
+
+  abstract initPaymentWidget(params: InitPaymentWidgetParams): Promise<void>;
+  abstract initElements(params: InitElementsWidgetParams): Promise<void>;
+  abstract initNextAction(params: InitNextActionWidgetParams): Promise<void>;
+  abstract initVoucherWidget(params: InitVoucherWidgetParams): Promise<void>;
+}

package/src/types/env.ts

@@ -0,0 +1,51 @@
+export enum Env {
+    Production = 'production',
+    Staging = 'staging',
+    Develop = 'develop',
+    Sandbox = 'sandbox',
+    local = 'local'
+  }
+  
+  export const env = {
+    [Env.Production]: 'https://apigw.getduna.com/',
+    [Env.Staging]: 'https://api.stg.deuna.io/',
+    [Env.Develop]: 'https://api.dev.deuna.io/',
+    [Env.Sandbox]: 'https://api.sandbox.deuna.io/'
+  };
+  
+  export const checkout = {
+    [Env.Production]: 'https://checkout-ux.deuna.com/',
+    [Env.Staging]: 'https://checkout.stg.deuna.io/',
+    [Env.Develop]: 'https://checkout.dev.deuna.io/',
+    [Env.Sandbox]: 'https://checkout.sandbox.deuna.io/'
+  };
+  
+  export const fingerprintjsEnv = {
+    [Env.Production]: 'PczoxhUz1RUyPv5Ih7nM',
+    [Env.Staging]: 'sB9jPdnpvLP3FkjjUPi3',
+    [Env.Develop]: 'sB9jPdnpvLP3FkjjUPi3',
+    [Env.Sandbox]: 'sB9jPdnpvLP3FkjjUPi3'
+  };
+  
+  export const storageSite = {
+    [Env.Production]: 'https://cdn.getduna.com/cdl/storageSite/index.html',
+    [Env.Staging]: 'https://cdn.stg.deuna.io/cdl/storageSite/index.html',
+    [Env.Develop]: 'https://cdn.dev.deuna.io/cdl/storageSite/index.html',
+    [Env.Sandbox]: 'https://cdn.stg.deuna.io/cdl/storageSite/index.html',
+    [Env.local]: 'http://localhost:3005/'
+  };
+  
+  export const siftCred = {
+    [Env.Production]: 'ab8ca5421b',
+    [Env.Staging]: 'b267dfc8a5',
+    [Env.Develop]: 'b267dfc8a5',
+    [Env.Sandbox]: 'b267dfc8a5'
+  };
+  
+  export const proxyUrls = {
+    URL: 'mimos.vendodeuna.com',
+    FPJS_BEHAVIOR_PATH: 'thomas',
+    FPJS_AGENT_DOWNLOAD_PATH: 'tommy',
+    FPJS_GET_RESULT_PATH: 'pabloinvita'
+  };
+  

package/src/types/helpers/buildElementsLink.ts

@@ -0,0 +1,87 @@
+import { Environment } from "../base";
+import { hasKey } from "../utils/hasKey";
+import { getIntegrationType, UrlConfig } from "./urlConfig";
+
+const urls: Record<Environment, string> = {
+  production: "https://elements.deuna.io",
+  sandbox: "https://elements.sandbox.deuna.io",
+  staging: "https://elements.stg.deuna.io",
+  develop: "https://elements.dev.deuna.io",
+};
+
+const pathsMapper = {
+  click_to_pay: "/click_to_pay",
+  vault: "/vault",
+};
+
+export const buildElementsLink = (config: UrlConfig): string => {
+  const { env, orderToken, userInfo, userToken, widgetExperience, types } =
+    config;
+
+  let baseUrl = urls.production;
+
+  if (env) {
+    baseUrl = urls[env];
+  }
+
+  if (config.domain) {
+    baseUrl = config.domain;
+  }
+
+  const url = new URL(baseUrl);
+
+  const publicApiKey = config.publicApiKey;
+  const firstName = userInfo?.firstName || "";
+  const lastName = userInfo?.lastName || "";
+  const email = userInfo?.email || "";
+
+  const searchParams = new URLSearchParams({
+    publicApiKey,
+    orderToken,
+    email,
+    firstName,
+    lastName,
+    ...(config.styleFile ? { cssFile: config.styleFile } : {}),
+    int: getIntegrationType(config.mode),
+    ...(userToken ? { userToken } : {}),
+    ...(widgetExperience?.userExperience?.showSavedCardsFlow
+      ? {
+          showSavedCardsFlow: String(
+            widgetExperience?.userExperience?.showSavedCardsFlow
+          ),
+        }
+      : {}),
+    ...(widgetExperience?.userExperience?.defaultCardFlow
+      ? {
+          showDefaultCardFlow: String(
+            widgetExperience?.userExperience?.defaultCardFlow
+          ),
+        }
+      : {}),
+    language: config.language,
+  });
+
+  const xpropsB64 = {
+    id: config.id,
+    behavior: config.behavior || {},
+  };
+
+  const getWidgetPath = () => {
+    if (types && types.length > 0) {
+      const firstPath = types[0]!.name;
+
+      if (hasKey(pathsMapper, firstPath)) {
+        return pathsMapper[firstPath];
+      }
+    }
+
+    return pathsMapper.vault;
+  };
+
+  searchParams.append("xpropsB64", btoa(JSON.stringify(xpropsB64)));
+
+  url.pathname = getWidgetPath();
+  url.search = searchParams.toString();
+
+  return url.toString();
+};

package/src/types/helpers/buildNextActionLink.ts

@@ -0,0 +1,42 @@
+import { Environment } from "../base";
+import {
+  configToQueryParams,
+  getIntegrationType,
+  UrlConfig,
+} from "./urlConfig";
+
+const urls: Record<Environment, string> = {
+  production: "https://pay.deuna.io",
+  sandbox: "https://pay.sandbox.deuna.io",
+  staging: "https://pay.stg.deuna.com",
+  develop: "https://pay.dev.deuna.io",
+};
+
+export const buildNextActionLink = (config: UrlConfig): string => {
+  const { env, orderToken } = config;
+
+  let baseUrl = urls.production;
+
+  if (env) {
+    baseUrl = urls[env];
+  }
+
+  const searchParams = new URLSearchParams({
+    mode: "widget",
+    int: getIntegrationType(config.mode),
+    language: config.language,
+  });
+
+  configToQueryParams(config, searchParams);
+
+  if (config.domain) {
+    baseUrl = config.domain;
+  }
+
+  const url = new URL(baseUrl);
+
+  url.pathname = `/next-action-purchase/${orderToken}`;
+  url.search = searchParams.toString();
+
+  return url.toString();
+};

package/src/types/helpers/buildPaymentLink.ts

@@ -0,0 +1,63 @@
+/**
+ * Helper function to get base URL based on environment
+ * @param config
+ * @returns
+ */
+
+import { Environment } from "../base";
+import {
+  configToQueryParams,
+  getIntegrationType,
+  UrlConfig,
+} from "./urlConfig";
+
+const urls: Record<Environment, string> = {
+  production: "https://pay.deuna.io",
+  sandbox: "https://pay.sandbox.deuna.io",
+  staging: "https://pay.stg.deuna.com",
+  develop: "https://pay.dev.deuna.io",
+};
+
+export const buildPaymentLink = (config: UrlConfig): string => {
+  const { env, orderToken } = config;
+
+  let baseUrl = urls.production;
+
+  if (env) {
+    baseUrl = urls[env];
+  }
+
+  const searchParams = new URLSearchParams({
+    mode: "widget",
+    int: getIntegrationType(config.mode),
+    language: config.language,
+  });
+
+  // config.
+
+  const xpropsB64 = {
+    id: config.id,
+    paymentMethods: config.paymentMethods,
+    publicApiKey: config.publicApiKey,
+    behavior: config.behavior,
+    cdl: {
+      sessionId: config.sessionId,
+    },
+  };
+
+  configToQueryParams(config, searchParams);
+
+  if (config.domain) {
+    baseUrl = config.domain;
+  }
+
+  //encode to base64
+  searchParams.append("xpropsB64", btoa(JSON.stringify(xpropsB64)));
+
+  const url = new URL(baseUrl);
+
+  url.pathname = `/now/${orderToken}`;
+  url.search = searchParams.toString();
+
+  return url.toString();
+};

package/src/types/helpers/buildVoucherLink.ts

@@ -0,0 +1,53 @@
+/**
+ * Helper function to get base URL based on environment
+ * @param config
+ * @returns
+ */
+
+import { Environment } from "../base";
+import { getIntegrationType, UrlConfig } from "./urlConfig";
+
+const urls: Record<Environment, string> = {
+  production: "https://pay.deuna.io",
+  sandbox: "https://pay.sandbox.deuna.io",
+  staging: "https://pay.stg.deuna.com",
+  develop: "https://pay.dev.deuna.io",
+};
+
+export const buildVoucherLink = (config: UrlConfig): string => {
+  const { env, orderToken } = config;
+
+  let baseUrl = urls.production;
+
+  if (env) {
+    baseUrl = urls[env];
+  }
+
+  const searchParams = new URLSearchParams({
+    mode: "widget",
+    int: getIntegrationType(config.mode),
+    language: config.language,
+    orderToken,
+  });
+
+  const xpropsB64 = {
+    id: config.id,
+    cdl: {
+      sessionId: config.sessionId,
+    },
+  };
+
+  if (config.domain) {
+    baseUrl = config.domain;
+  }
+
+  //encode to base64
+  searchParams.append("xpropsB64", btoa(JSON.stringify(xpropsB64)));
+
+  const url = new URL(baseUrl);
+
+  url.pathname = `/voucher`;
+  url.search = searchParams.toString();
+
+  return url.toString();
+};

package/src/types/helpers/index.ts

@@ -0,0 +1,11 @@
+import { buildElementsLink } from "./buildElementsLink";
+import { buildNextActionLink } from "./buildNextActionLink";
+import { buildPaymentLink } from "./buildPaymentLink";
+import { buildVoucherLink } from "./buildVoucherLink";
+
+export const linkBuilders = {
+  elements: buildElementsLink,
+  payment: buildPaymentLink,
+  nextAction: buildNextActionLink,
+  voucher: buildVoucherLink,
+};

package/src/types/helpers/urlConfig.ts

@@ -0,0 +1,80 @@
+import { Environment } from "../base";
+import { BehaviorWidget, InitWidgetBase } from "../interfaces/initWidgetBase";
+
+type ParamsKey = keyof UrlConfig;
+
+export const configToQueryParams = (
+  config: UrlConfig,
+  searchParams: URLSearchParams
+) => {
+  const params: ParamsKey[] = ["styleFile", "userToken", "language"];
+
+  params.forEach((param) => {
+    if (param in config && config[param]) {
+      searchParams.append(param, config[param] as string);
+    }
+  });
+};
+
+export const getIntegrationType = (mode?: string) => {
+  const modeMap: { [key: string]: string } = {
+    widget: "modal",
+    modal: "modal",
+    target: "embedded",
+  };
+
+  return modeMap[mode || ""] || "redirect";
+};
+
+interface PaymentMethods {
+  paymentMethod: string;
+  processors: string[];
+}
+
+export interface UrlConfig {
+  // Instance identificator (zoid tag)
+  id?: string;
+
+  // Environment where the widget will run (optional)
+  env?: Environment;
+
+  // Order token to identify the transaction (mandatory)
+  orderToken: string;
+
+  // Only when this field is true when setCustomCss is called the upperTag will be showed
+  showPromotionsBanner?: boolean;
+
+  paymentMethods?: PaymentMethods[];
+
+  publicApiKey: string;
+
+  styleFile?: string;
+
+  userToken: string;
+
+  language: string;
+
+  devUrl?: string;
+
+  domain?: string;
+
+  mode?: string;
+
+  target?: string;
+
+  userInfo?: InitWidgetBase["userInfo"];
+
+  widgetExperience?: InitWidgetBase["widgetExperience"];
+
+  behavior?: BehaviorWidget;
+
+  sessionId: string;
+
+  types?: ElementWidgetType[];
+}
+
+export interface ElementWidgetType {
+  name: ElementWidgetTypeName;
+}
+
+type ElementWidgetTypeName = "vault" | "click_to_pay";

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./interfaces";
+export * from "./env";
+export * from "./base";
+export * from "./utils";

package/src/types/interfaces/callbacks.ts

@@ -0,0 +1,43 @@
+export type ClosedAction = "userAction" | "systemAction";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Json = Record<string, any>;
+
+export interface OnError {
+  type: string;
+  metadata: {
+    code: string;
+    message: string;
+  };
+}
+
+interface OnCardBinDetected {
+  cardBin: string;
+  cardBrand: string;
+}
+
+interface OnInstallmentSelectedPayload {
+  cardBin: string;
+  installmentPlanOptionId: string;
+}
+
+interface BaseCallbacks {
+  onSuccess?: (data: Json) => void;
+  onError?: (data: OnError) => void;
+  onClosed?: (action: ClosedAction) => void;
+  onEventDispatch?: (event: string, payload: Json) => void;
+}
+
+export interface PaymentWidgetCallbacks extends BaseCallbacks {
+  onCardBinDetected?: (data: OnCardBinDetected) => void;
+  onInstallmentSelected?: (data: OnInstallmentSelectedPayload) => void;
+  onPaymentProcessing?: () => void;
+}
+
+export interface ElementsWidgetCallbacks extends BaseCallbacks {
+  onCardBinDetected?: (data: OnCardBinDetected) => void;
+  onInstallmentSelected?: (data: OnInstallmentSelectedPayload) => void;
+}
+
+export interface NextActionWidgetCallbacks extends BaseCallbacks {}
+
+export interface VoucherWidgetCallbacks extends BaseCallbacks {}