@primer-io/react-native 0.16.2 → 2.1.0

package/src/headless_checkout/PrimerHeadlessUniversalCheckout.ts

@@ -1,80 +1,270 @@
-import type { PaymentInstrumentToken } from 'src/models/payment-instrument-token';
-import type { PrimerError } from 'src/models/primer-error';
-import type { PrimerSettings } from 'src/models/primer-settings';
-import NativePrimerHeadlessUniversalCheckout from './NativePrimerHeadlessUniversalCheckout';
-import type {
-  PrimerHeadlessUniversalCheckoutStartResponse,
-  PrimerHeadlessUniversalCheckoutCallbacks,
-} from './types';
+import RNPrimerHeadlessUniversalCheckout from './RNPrimerHeadlessUniversalCheckout';
+import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
+import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
+import type { PrimerTokenizationHandler, PrimerResumeHandler, PrimerPaymentCreationHandler } from '../models/PrimerInterfaces';
+import type { PrimerHeadlessUniversalCheckoutStartResponse } from './types';
+import type { PrimerSettings } from '../models/PrimerSettings';
+import type { PrimerClientSession } from '../models/PrimerClientSession';
+import { PrimerError } from '../models/PrimerError';
+import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData';
 
-let callbacks: PrimerHeadlessUniversalCheckoutCallbacks | undefined;
+///////////////////////////////////////////
+// DECISION HANDLERS
+///////////////////////////////////////////
 
-class PrimerHeadlessUniversalCheckoutClass {
+// Tokenization Handler
 
-  ///////////////////////////////////////////
-  // Init
-  ///////////////////////////////////////////
-  constructor() {
+const tokenizationHandler: PrimerTokenizationHandler = {
+  handleFailure: async (errorMessage: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleTokenizationFailure(errorMessage);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  handleSuccess: async () => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleTokenizationSuccess();
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  continueWithNewClientToken: async (newClientToken: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+
+// Resume Handler
+
+const resumeHandler: PrimerResumeHandler = {
+  handleFailure: async (errorMessage: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleResumeFailure(errorMessage);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  handleSuccess: async () => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleResumeSuccess();
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  continueWithNewClientToken: async (newClientToken: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}
+
+// Payment Creation Handler
 
+const paymentCreationHandler: PrimerPaymentCreationHandler = {
+  abortPaymentCreation: async (errorMessage: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationAbort(errorMessage);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  continuePaymentCreation: async () => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handlePaymentCreationContinue();
+    } catch (err) {
+      console.error(err);
+    }
   }
+}
+
+let primerSettings: PrimerSettings | undefined = undefined;
+
+async function configureListeners(): Promise<void> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.removeAllListeners();
 
-  private configureListeners() {
-    NativePrimerHeadlessUniversalCheckout.removeAllListeners();
+      let implementedRNCallbacks: any = {
+        onCheckoutComplete: (primerSettings?.onCheckoutComplete !== undefined),
+        onBeforePaymentCreate: (primerSettings?.onBeforePaymentCreate !== undefined),
+        onBeforeClientSessionUpdate: (primerSettings?.onBeforeClientSessionUpdate !== undefined),
+        onClientSessionUpdate: (primerSettings?.onClientSessionUpdate !== undefined),
+        onTokenizeSuccess: (primerSettings?.onTokenizeSuccess !== undefined),
+        onResumeSuccess: (primerSettings?.onResumeSuccess !== undefined),
+        onDismiss: false,
+        onError: (primerSettings?.onError !== undefined),
+        onHUCAvailablePaymentMethodsLoaded: (primerSettings?.onAvailablePaymentMethodsLoad !== undefined),
+        onHUCPrepareStart: (primerSettings?.onPrepareStart !== undefined),
+        onHUCTokenizeStart: (primerSettings?.onTokenizeStart !== undefined),
+        onHUCPaymentMethodShow: (primerSettings?.onPaymentMethodShow !== undefined),
+      };
 
-    NativePrimerHeadlessUniversalCheckout.addListener(
-      'preparationStarted',
-      () => {
-        console.log('preparationStarted');
-        callbacks?.onPreparationStarted?.();
+      await RNPrimerHeadlessUniversalCheckout.setImplementedRNCallbacks(implementedRNCallbacks);
+
+      if (implementedRNCallbacks.onCheckoutComplete) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onCheckoutComplete',
+          (data) => {
+            console.log('onCheckoutComplete');
+            if (primerSettings && primerSettings.onCheckoutComplete) {
+              const checkoutData: PrimerCheckoutData = data;
+              primerSettings.onCheckoutComplete(checkoutData);
+            } else {
+              // Ignore!
+            }
+          }
+        );
       }
-    );
 
-    NativePrimerHeadlessUniversalCheckout.addListener(
-      'paymentMethodPresented',
-      () => {
-        console.log('paymentMethodPresented');
-        callbacks?.onPaymentMethodPresented?.();
+      if (implementedRNCallbacks.onHUCPrepareStart) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCPrepareStart',
+          (data) => {
+            console.log('onHUCPrepareStart');
+            if (primerSettings && primerSettings.onPrepareStart) {
+              primerSettings.onPrepareStart(data.paymentMethodType || 'not implemented');
+            } else {
+              // Ignore!
+            }
+          }
+        );
       }
-    );
 
-    NativePrimerHeadlessUniversalCheckout.addListener(
-      'tokenizationStarted',
-      () => {
-        console.log('tokenizationStarted');
-        callbacks?.onTokenizeStart?.();
+      if (implementedRNCallbacks.onHUCTokenizeStart) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCTokenizeStart',
+          (data) => {
+            console.log('onHUCTokenizeStart');
+            if (primerSettings && primerSettings.onTokenizeStart) {
+              primerSettings.onTokenizeStart(data.paymentMethodType || 'not implemented');
+            } else {
+              // Ignore!
+            }
+          }
+        );
       }
-    );
 
-    NativePrimerHeadlessUniversalCheckout.addListener(
-      'tokenizationSucceeded',
-      (data) => {
-        console.log('tokenizationSucceeded', data);
-
-        if (data.paymentMethodToken) {
-          const paymentMethodTokenObj: PaymentInstrumentToken = JSON.parse(
-            data.paymentMethodToken
-          );
-          callbacks?.onTokenizeSuccess?.(paymentMethodTokenObj);
-        } else {
-          const err: PrimerError = {
-            name: 'ParseJsonFailed',
-            description: 'Failed to parse payment method token',
-          };
-          //@ts-ignore
-          callbacks?.onFailure?.(err);
-        }
+      if (implementedRNCallbacks.onHUCPaymentMethodShow) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCPaymentMethodShow',
+          (data) => {
+            console.log('onHUCPaymentMethodShow');
+            if (primerSettings && primerSettings.onPaymentMethodShow) {
+              primerSettings.onPaymentMethodShow(data.paymentMethodType || 'not implemented');
+            } else {
+              // Ignore!
+            }
+          }
+        );
       }
-    );
 
-    NativePrimerHeadlessUniversalCheckout.addListener('resume', (data) => {
-      console.log('resume', data);
-      callbacks?.onResumeSuccess?.(data.resumeToken);
-    });
+      if (implementedRNCallbacks.onHUCAvailablePaymentMethodsLoaded) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onHUCAvailablePaymentMethodsLoaded',
+          (data) => {
+            console.log('onHUCAvailablePaymentMethodsLoaded');
+            if (primerSettings && primerSettings.onAvailablePaymentMethodsLoad) {
+              if (data && data.paymentMethodTypes) {
+                const paymentMethodTypes: string[] = data.paymentMethodTypes;
+                const availablePaymentMethodTypes = paymentMethodTypes.filter(pmt => pmt !== 'PAYMENT_CARD');
+                primerSettings.onAvailablePaymentMethodsLoad(availablePaymentMethodTypes || ['not implemented']);
+              } else {
+                primerSettings.onAvailablePaymentMethodsLoad(['not implemented']);
+              }
+              
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onBeforePaymentCreate) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onBeforePaymentCreate', data => {
+          if (primerSettings && primerSettings.onBeforePaymentCreate) {
+            const checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData = data;
+            primerSettings.onBeforePaymentCreate(checkoutPaymentMethodData, paymentCreationHandler);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onBeforeClientSessionUpdate) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onBeforeClientSessionUpdate', _ => {
+          if (primerSettings && primerSettings.onBeforeClientSessionUpdate) {
+            primerSettings.onBeforeClientSessionUpdate();
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onClientSessionUpdate) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onClientSessionUpdate', data => {
+          if (primerSettings && primerSettings.onClientSessionUpdate) {
+            const clientSession: PrimerClientSession = data;
+            primerSettings.onClientSessionUpdate(clientSession);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onTokenizeSuccess) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onTokenizeSuccess', data => {
+          if (primerSettings && primerSettings.onTokenizeSuccess) {
+            const paymentMethodTokenData: PrimerPaymentMethodTokenData = data;
+            primerSettings.onTokenizeSuccess(paymentMethodTokenData, tokenizationHandler);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onResumeSuccess) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onResumeSuccess', data => {
+          if (primerSettings && primerSettings.onResumeSuccess && data.resumeToken) {
+            primerSettings.onResumeSuccess(data.resumeToken, resumeHandler);
+          }
+        });
+      }
+
+      if (implementedRNCallbacks.onError) {
+        RNPrimerHeadlessUniversalCheckout.addListener('onError', data => {
+          if (data && data.error && data.error.errorId && primerSettings && primerSettings.onError) {
+            const errorId: string = data.error.errorId;
+            const description: string | undefined = data.error.description;
+            const recoverySuggestion: string | undefined = data.error.recoverySuggestion;
+            const primerError = new PrimerError(errorId, description || 'Unknown error', recoverySuggestion);
+
+            if (data.checkoutData) {
+              primerSettings.onError(primerError, data.checkoutData, undefined);
+            } else {
+              primerSettings.onError(primerError, null, undefined);
+            }
+          }
+        });
+      }
+
+      resolve();
+
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+class PrimerHeadlessUniversalCheckoutClass {
+
+  ///////////////////////////////////////////
+  // Init
+  ///////////////////////////////////////////
+  constructor() {
 
-    NativePrimerHeadlessUniversalCheckout.addListener('error', (data) => {
-      console.log('error', data);
-      callbacks?.onFailure?.(data.error);
-    });
   }
 
   ///////////////////////////////////////////
@@ -82,43 +272,38 @@ class PrimerHeadlessUniversalCheckoutClass {
   ///////////////////////////////////////////
   startWithClientToken(
     clientToken: string,
-    settings: PrimerSettings & PrimerHeadlessUniversalCheckoutCallbacks
-  ): Promise<PrimerHeadlessUniversalCheckoutStartResponse> {
-    // Copy callback
-    callbacks = {
-      onPreparationStarted: settings.onPreparationStarted,
-      onPaymentMethodPresented: settings.onPaymentMethodPresented,
-      onTokenizeStart: settings.onTokenizeStart,
-      onTokenizeSuccess: settings.onTokenizeSuccess,
-      onResumeSuccess: settings.onResumeSuccess,
-      onFailure: settings.onFailure,
-    };
-
-    return NativePrimerHeadlessUniversalCheckout.startWithClientToken(
-      clientToken,
-      settings
-    );
-  }
-
-  showPaymentMethod(paymentMethod: string) {
-    this.configureListeners();
+    settings: PrimerSettings
+  ): Promise<string[]> {
+    primerSettings = settings;
 
-    return NativePrimerHeadlessUniversalCheckout.showPaymentMethod(
-      paymentMethod
-    );
+    return new Promise(async (resolve, reject) => {
+      try {
+        await configureListeners();
+        const hucResponse: PrimerHeadlessUniversalCheckoutStartResponse = await RNPrimerHeadlessUniversalCheckout.startWithClientToken(clientToken, settings);
+        const availablePaymentMethodTypes: string[] = hucResponse.paymentMethodTypes.filter(pmt => pmt !== 'PAYMENT_CARD');
+        resolve(availablePaymentMethodTypes);
+      } catch (err) {
+        reject(err);
+      }
+    });
   }
 
-  resumeWithClientToken(resumeToken: string) {
-    return NativePrimerHeadlessUniversalCheckout.resumeWithClientToken(
-      resumeToken
-    );
+  async showPaymentMethod(paymentMethodType: string): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await RNPrimerHeadlessUniversalCheckout.showPaymentMethod(paymentMethodType);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
   }
 
-  getAssetForPaymentMethod(
+  getAssetForPaymentMethodType(
     paymentMethodType: string,
     assetType: 'logo' | 'icon'
   ): Promise<string> {
-    return NativePrimerHeadlessUniversalCheckout.getAssetForPaymentMethod(
+    return RNPrimerHeadlessUniversalCheckout.getAssetForPaymentMethodType(
       paymentMethodType,
       assetType
     );
@@ -128,13 +313,15 @@ class PrimerHeadlessUniversalCheckoutClass {
     cardNetwork: string,
     assetType: 'logo' | 'icon'
   ): Promise<string> {
-    return NativePrimerHeadlessUniversalCheckout.getAssetForCardNetwork(
+    return RNPrimerHeadlessUniversalCheckout.getAssetForCardNetwork(
       cardNetwork,
       assetType
     );
   }
-}
 
-const PrimerHeadlessUniversalCheckout = new PrimerHeadlessUniversalCheckoutClass();
+  disposePrimerHeadlessUniversalCheckout(): Promise<void> {
+    return RNPrimerHeadlessUniversalCheckout.disposePrimerHeadlessUniversalCheckout();
+  }
+}
 
-export default PrimerHeadlessUniversalCheckout;
+export const PrimerHeadlessUniversalCheckout = new PrimerHeadlessUniversalCheckoutClass();

package/src/headless_checkout/RNPrimerHeadlessUniversalCheckout.ts

@@ -0,0 +1,252 @@
+import { NativeEventEmitter, NativeModules } from 'react-native';
+
+const { PrimerHeadlessUniversalCheckout } = NativeModules;
+
+const eventEmitter = new NativeEventEmitter(PrimerHeadlessUniversalCheckout);
+
+type EventType =
+  | 'onHUCTokenizeStart'
+  | 'onHUCPrepareStart'
+  | 'onHUCAvailablePaymentMethodsLoaded'
+  | 'onHUCPaymentMethodShow'
+  | 'onTokenizeSuccess'
+  | 'onResumeSuccess'
+  | 'onBeforePaymentCreate'
+  | 'onBeforeClientSessionUpdate'
+  | 'onClientSessionUpdate'
+  | 'onCheckoutComplete'
+  | 'onError';
+
+const eventTypes: EventType[] = [
+  'onHUCTokenizeStart',
+  'onHUCPrepareStart',
+  'onHUCAvailablePaymentMethodsLoaded',
+  'onHUCPaymentMethodShow',
+  'onTokenizeSuccess',
+  'onResumeSuccess',
+  'onBeforePaymentCreate',
+  'onBeforeClientSessionUpdate',
+  'onClientSessionUpdate',
+  'onCheckoutComplete',
+  'onError'
+];
+
+const RNPrimerHeadlessUniversalCheckout = {
+  ///////////////////////////////////////////
+  // Event Emitter
+  ///////////////////////////////////////////
+  addListener: (eventType: EventType, listener: (...args: any[]) => any) => {
+    eventEmitter.addListener(eventType, listener);
+  },
+
+  removeListener: (eventType: EventType, listener: (...args: any[]) => any) => {
+    eventEmitter.removeListener(eventType, listener);
+  },
+
+  removeAllListenersForEvent(eventType: EventType) {
+    eventEmitter.removeAllListeners(eventType);
+  },
+
+  removeAllListeners() {
+    eventTypes.forEach((eventType) => RNPrimerHeadlessUniversalCheckout.removeAllListenersForEvent(eventType));
+  },
+
+  ///////////////////////////////////////////
+  // Native API
+  ///////////////////////////////////////////
+  getAssetForPaymentMethodType: (
+    paymentMethodType: string,
+    assetType: 'logo' | 'icon'
+  ): Promise<string> => {
+    return new Promise((resolve, reject) => {
+      try {
+        PrimerHeadlessUniversalCheckout.getAssetForPaymentMethodType(
+          paymentMethodType,
+          assetType,
+          (err: Error) => {
+            reject(err);
+          },
+          (url: string) => {
+            resolve(url);
+          }
+        );
+      } catch (e) {
+        reject(e);
+      }
+    });
+  },
+
+  getAssetForCardNetwork: (
+    cardNetwork: string,
+    assetType: 'logo' | 'icon'
+  ): Promise<string> => {
+    return new Promise((resolve, reject) => {
+      try {
+        PrimerHeadlessUniversalCheckout.getAssetForPaymentMethodType(
+          cardNetwork,
+          assetType,
+          (err: Error) => {
+            reject(err);
+          },
+          (url: string) => {
+            resolve(url);
+          }
+        );
+      } catch (e) {
+        reject(e);
+      }
+    });
+  },
+
+  startWithClientToken(clientToken: string, settings: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      PrimerHeadlessUniversalCheckout.startWithClientToken(
+        clientToken,
+        JSON.stringify(settings),
+        (err: Error) => {
+          console.error(err);
+          reject(err);
+        },
+        (paymentMethodTypes: string[]) => {
+          resolve({ paymentMethodTypes });
+        }
+      );
+    });
+  },
+
+  showPaymentMethod: (paymentMethodType: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.showPaymentMethod(paymentMethodType);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  ///////////////////////////////////////////
+  // DECISION HANDLERS
+  ///////////////////////////////////////////
+
+  // Tokenization Handlers
+
+  handleTokenizationNewClientToken: (newClientToken: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handleTokenizationSuccess: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleTokenizationSuccess();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handleTokenizationFailure: (errorMessage: string | null): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleTokenizationFailure(errorMessage || "");
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  // Resume Handlers
+
+  handleResumeWithNewClientToken: (newClientToken: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handleResumeSuccess: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleResumeSuccess();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handleResumeFailure: (errorMessage: string | null): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handleTokenizationFailure(errorMessage || "");
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  // Payment Creation Handlers
+
+  handlePaymentCreationAbort: (errorMessage: string | null): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handlePaymentCreationAbort(errorMessage || "");
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handlePaymentCreationContinue: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.handlePaymentCreationContinue();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  // HELPERS
+
+  setImplementedRNCallbacks: (implementedRNCallbacks: any): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.setImplementedRNCallbacks(JSON.stringify(implementedRNCallbacks));
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  
+  disposePrimerHeadlessUniversalCheckout: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await PrimerHeadlessUniversalCheckout.disposePrimerHeadlessUniversalCheckout();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+};
+
+export default RNPrimerHeadlessUniversalCheckout;