@primer-io/react-native 2.16.0 → 2.17.0-rc.1

package/src/HeadlessUniversalCheckout/PrimerHeadlessUniversalCheckout.ts

@@ -0,0 +1,333 @@
+import RNPrimerHeadlessUniversalCheckout from './RNPrimerHeadlessUniversalCheckout';
+import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
+import type { PrimerCheckoutAdditionalInfo } from '../models/PrimerCheckoutAdditionalInfo';
+import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
+import type { PrimerSettings } from '../models/PrimerSettings';
+import type { PrimerClientSession } from '../models/PrimerClientSession';
+import { PrimerError } from '../models/PrimerError';
+import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData';
+import type { PrimerImplementedRNCallbacks } from 'src/models/PrimerImplementedRNCallbacks';
+import type { IPrimerHeadlessUniversalCheckoutPaymentMethod } from '../models/PrimerHeadlessUniversalCheckoutPaymentMethod';
+import type { PrimerHeadlessUniversalCheckoutResumeHandler, PrimerPaymentCreationHandler } from 'src/models/PrimerHandlers';
+
+///////////////////////////////////////////
+// DECISION HANDLERS
+///////////////////////////////////////////
+
+// Tokenization Handler
+
+const tokenizationHandler: PrimerHeadlessUniversalCheckoutResumeHandler = {
+  continueWithNewClientToken: async (newClientToken: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleTokenizationNewClientToken(newClientToken);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+  
+  complete: () => {
+    RNPrimerHeadlessUniversalCheckout.handleCompleteFlow();
+  }
+}
+
+// Resume Handler
+
+const resumeHandler: PrimerHeadlessUniversalCheckoutResumeHandler = {
+  continueWithNewClientToken: async (newClientToken: string) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.handleResumeWithNewClientToken(newClientToken);
+    } catch (err) {
+      console.error(err);
+    }
+  },
+
+  complete: () => {
+    RNPrimerHeadlessUniversalCheckout.handleCompleteFlow();
+  }
+}
+
+// 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);
+    }
+  }
+}
+
+export let primerSettings: PrimerSettings | undefined = undefined;
+
+async function configureListeners(): Promise<void> {
+  return new Promise(async (resolve, reject) => {
+    try {
+      RNPrimerHeadlessUniversalCheckout.removeAllListeners();
+
+      let implementedRNCallbacks: PrimerImplementedRNCallbacks = {
+        onAvailablePaymentMethodsLoad: (primerSettings?.headlessUniversalCheckoutCallbacks?.onAvailablePaymentMethodsLoad !== undefined) || false,
+        onTokenizationStart: (primerSettings?.headlessUniversalCheckoutCallbacks?.onTokenizationStart !== undefined) || false,
+        onTokenizationSuccess: (primerSettings?.headlessUniversalCheckoutCallbacks?.onTokenizationSuccess !== undefined) || false,
+    
+        onCheckoutResume: (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutResume !== undefined) || false,
+        onCheckoutPending: (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutPending !== undefined) || false,
+        onCheckoutAdditionalInfo: (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutAdditionalInfo !== undefined) || false,
+    
+        onError: (primerSettings?.headlessUniversalCheckoutCallbacks?.onError !== undefined) || false,
+        onCheckoutComplete: (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutComplete !== undefined) || false,
+        onBeforeClientSessionUpdate: (primerSettings?.headlessUniversalCheckoutCallbacks?.onBeforeClientSessionUpdate !== undefined) || false,
+    
+        onClientSessionUpdate: (primerSettings?.headlessUniversalCheckoutCallbacks?.onClientSessionUpdate !== undefined) || false,
+        onBeforePaymentCreate: (primerSettings?.headlessUniversalCheckoutCallbacks?.onBeforePaymentCreate !== undefined) || false,
+        onPreparationStart: (primerSettings?.headlessUniversalCheckoutCallbacks?.onPreparationStart !== undefined) || false,
+    
+        onPaymentMethodShow: (primerSettings?.headlessUniversalCheckoutCallbacks?.onPaymentMethodShow !== undefined) || false,
+        onDismiss: false
+      };
+
+      await RNPrimerHeadlessUniversalCheckout.setImplementedRNCallbacks(implementedRNCallbacks);
+
+      if (implementedRNCallbacks.onAvailablePaymentMethodsLoad) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onAvailablePaymentMethodsLoad',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onAvailablePaymentMethodsLoad) {
+              const availablePaymentMethods: IPrimerHeadlessUniversalCheckoutPaymentMethod[] = data.availablePaymentMethods || [];
+              primerSettings.headlessUniversalCheckoutCallbacks.onAvailablePaymentMethodsLoad(availablePaymentMethods);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onPreparationStart) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onPreparationStart',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onPreparationStart) {
+              primerSettings.headlessUniversalCheckoutCallbacks.onPreparationStart(data.paymentMethodType);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onBeforeClientSessionUpdate) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onBeforeClientSessionUpdate',
+          () => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onBeforeClientSessionUpdate) {
+              primerSettings.headlessUniversalCheckoutCallbacks.onBeforeClientSessionUpdate();
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onClientSessionUpdate) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onClientSessionUpdate',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onClientSessionUpdate) {
+              const clientSession: PrimerClientSession = data.clientSession;
+              primerSettings.headlessUniversalCheckoutCallbacks.onClientSessionUpdate(clientSession);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onBeforePaymentCreate) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onBeforePaymentCreate',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onBeforePaymentCreate) {
+              const checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData = data;
+              primerSettings.headlessUniversalCheckoutCallbacks.onBeforePaymentCreate(checkoutPaymentMethodData, paymentCreationHandler);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onTokenizationStart) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onTokenizationStart',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onTokenizationStart) {
+              primerSettings.headlessUniversalCheckoutCallbacks.onTokenizationStart(data.paymentMethodType);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onPaymentMethodShow) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onPaymentMethodShow',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onPaymentMethodShow) {
+              primerSettings.headlessUniversalCheckoutCallbacks.onPaymentMethodShow(data.paymentMethodType);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onTokenizationSuccess) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onTokenizationSuccess',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onTokenizationSuccess) {
+              const paymentMethodTokenData: PrimerPaymentMethodTokenData = data.paymentMethodTokenData;
+              primerSettings.headlessUniversalCheckoutCallbacks.onTokenizationSuccess(paymentMethodTokenData, tokenizationHandler);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onCheckoutResume) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onCheckoutResume',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutResume) {
+              primerSettings.headlessUniversalCheckoutCallbacks.onCheckoutResume(data.resumeToken, resumeHandler);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+      
+      if (implementedRNCallbacks.onCheckoutPending) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onCheckoutPending',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutPending) {
+              const checkoutAdditionalInfo: PrimerCheckoutAdditionalInfo = data;
+              primerSettings.headlessUniversalCheckoutCallbacks.onCheckoutPending(checkoutAdditionalInfo);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onCheckoutAdditionalInfo) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onCheckoutAdditionalInfo',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutAdditionalInfo) {
+              const checkoutAdditionalInfo: PrimerCheckoutAdditionalInfo = data;
+              primerSettings.headlessUniversalCheckoutCallbacks.onCheckoutAdditionalInfo(checkoutAdditionalInfo);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+      
+      if (implementedRNCallbacks.onCheckoutComplete) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onCheckoutComplete',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onCheckoutComplete) {
+              const checkoutData: PrimerCheckoutData = data;
+              primerSettings.headlessUniversalCheckoutCallbacks.onCheckoutComplete(checkoutData);
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      if (implementedRNCallbacks.onError) {
+        RNPrimerHeadlessUniversalCheckout.addListener(
+          'onError',
+          (data) => {
+            if (primerSettings?.headlessUniversalCheckoutCallbacks?.onError) {
+              if (data && data.error && data.error.errorId && primerSettings) {
+                const errorId: string = data.error.errorId;
+                const description: string | undefined = data.error.description;
+                const recoverySuggestion: string | undefined = data.error.recoverySuggestion;
+                const diagnosticsId: string | undefined = data.error.diagnosticsId;
+                const primerError = new PrimerError(errorId, description || 'Unknown error', recoverySuggestion, diagnosticsId);
+
+                const checkoutData: PrimerCheckoutData = data.checkoutData;
+                primerSettings.headlessUniversalCheckoutCallbacks.onError(primerError, checkoutData);
+              }
+            } else {
+              // Ignore!
+            }
+          }
+        );
+      }
+
+      resolve();
+
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+class PrimerHeadlessUniversalCheckoutClass {
+
+  ///////////////////////////////////////////
+  // Init
+  ///////////////////////////////////////////
+  constructor() {
+
+  }
+
+  ///////////////////////////////////////////
+  // API
+  ///////////////////////////////////////////
+  startWithClientToken(
+    clientToken: string,
+    settings: PrimerSettings
+  ): Promise<IPrimerHeadlessUniversalCheckoutPaymentMethod[]> {
+    primerSettings = settings;
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        await configureListeners();
+        const res = await RNPrimerHeadlessUniversalCheckout.startWithClientToken(clientToken, settings);
+
+        if (res["availablePaymentMethods"]) {
+          const availablePaymentMethods: IPrimerHeadlessUniversalCheckoutPaymentMethod[] = res["availablePaymentMethods"];
+          resolve(availablePaymentMethods);
+        } else {
+          const err = new PrimerError("primer-rn-sdk", "Failed to find availablePaymentMethods", "Create another client session", undefined);
+          reject(err);
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  cleanUp(): Promise<void> {
+    return RNPrimerHeadlessUniversalCheckout.cleanUp();
+  }
+}
+
+export const PrimerHeadlessUniversalCheckout = new PrimerHeadlessUniversalCheckoutClass();

package/src/{headless_checkout → HeadlessUniversalCheckout}/RNPrimerHeadlessUniversalCheckout.ts

@@ -1,38 +1,47 @@
 import { NativeEventEmitter, NativeModules } from 'react-native';
+import type { PrimerSettings } from '../models/PrimerSettings';
 
 const { PrimerHeadlessUniversalCheckout } = NativeModules;
 
 const eventEmitter = new NativeEventEmitter(PrimerHeadlessUniversalCheckout);
 
 type EventType =
-  | 'onHUCTokenizeStart'
-  | 'onHUCPrepareStart'
-  | 'onHUCAvailablePaymentMethodsLoaded'
-  | 'onHUCPaymentMethodShow'
-  | 'onTokenizeSuccess'
-  | 'onResumeSuccess'
-  | 'onResumePending'
-  | 'onCheckoutReceivedAdditionalInfo'
-  | 'onBeforePaymentCreate'
+  | 'onAvailablePaymentMethodsLoad'
+  | 'onTokenizationStart'
+  | 'onTokenizationSuccess'
+
+  | 'onCheckoutResume'
+  | 'onCheckoutPending'
+  | 'onCheckoutAdditionalInfo'
+
+  | 'onError'
+  | 'onCheckoutComplete'
   | 'onBeforeClientSessionUpdate'
+
   | 'onClientSessionUpdate'
-  | 'onCheckoutComplete'
-  | 'onError';
+  | 'onBeforePaymentCreate'
+  | 'onPreparationStart'
+
+  | 'onPaymentMethodShow';
 
 const eventTypes: EventType[] = [
-  'onHUCTokenizeStart',
-  'onHUCPrepareStart',
-  'onHUCAvailablePaymentMethodsLoaded',
-  'onHUCPaymentMethodShow',
-  'onTokenizeSuccess',
-  'onResumeSuccess',
-  'onResumePending',
-  'onCheckoutReceivedAdditionalInfo',
-  'onBeforePaymentCreate',
+  'onAvailablePaymentMethodsLoad',
+  'onTokenizationStart',
+  'onTokenizationSuccess',
+
+  'onCheckoutResume',
+  'onCheckoutPending',
+  'onCheckoutAdditionalInfo',
+
+  'onError',
+  'onCheckoutComplete',
   'onBeforeClientSessionUpdate',
+
   'onClientSessionUpdate',
-  'onCheckoutComplete',
-  'onError'
+  'onBeforePaymentCreate',
+  'onPreparationStart',
+
+  'onPaymentMethodShow'
 ];
 
 const RNPrimerHeadlessUniversalCheckout = {
@@ -58,75 +67,9 @@ const RNPrimerHeadlessUniversalCheckout = {
   ///////////////////////////////////////////
   // 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.getAssetForCardNetwork(
-          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);
-      }
-    });
+  startWithClientToken(clientToken: string, settings: PrimerSettings): Promise<any> {
+    return PrimerHeadlessUniversalCheckout.startWithClientToken(clientToken, JSON.stringify(settings));
   },
 
   ///////////////////////////////////////////
@@ -146,28 +89,6 @@ const RNPrimerHeadlessUniversalCheckout = {
     });
   },
 
-  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> => {
@@ -181,21 +102,10 @@ const RNPrimerHeadlessUniversalCheckout = {
     });
   },
 
-  handleResumeSuccess: (): Promise<void> => {
+  handleCompleteFlow: (): 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 || "");
+        await PrimerHeadlessUniversalCheckout.handleCompleteFlow();
         resolve();
       } catch (err) {
         reject(err);
@@ -240,11 +150,10 @@ const RNPrimerHeadlessUniversalCheckout = {
     });
   },
 
-
-  disposePrimerHeadlessUniversalCheckout: (): Promise<void> => {
+  cleanUp: (): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await PrimerHeadlessUniversalCheckout.disposePrimerHeadlessUniversalCheckout();
+        await PrimerHeadlessUniversalCheckout.cleanUp();
         resolve();
       } catch (err) {
         reject(err);

package/src/HeadlessUniversalCheckout/types.ts

@@ -0,0 +1,32 @@
+// import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
+// import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
+// import type { 
+//   PrimerTokenizationHandler, 
+//   PrimerResumeHandler, 
+//   PrimerPaymentCreationHandler, 
+//   PrimerErrorHandler
+// } from '../models/PrimerInterfaces';
+// import type { PrimerClientSession } from '../models/PrimerClientSession';
+// import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData'; 
+// import type { PrimerError } from '../models/PrimerError';
+
+// export interface PrimerHeadlessUniversalCheckoutStartResponse {
+//   paymentMethodTypes: string[];
+// }
+
+// export interface PrimerHeadlessUniversalCheckoutCallbacks {
+//   // Common
+//   onBeforeClientSessionUpdate?: () => void;
+//   onClientSessionUpdate?: (clientSession: PrimerClientSession) => void;
+//   onBeforePaymentCreate?: (checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData, handler: PrimerPaymentCreationHandler) => void;
+//   onCheckoutComplete?: (checkoutData: PrimerCheckoutData) => void;
+//   onTokenizeSuccess?: (paymentMethodTokenData: PrimerPaymentMethodTokenData, handler: PrimerTokenizationHandler) => void;
+//   onResumeSuccess?: (resumeToken: string, handler: PrimerResumeHandler) => void;
+//   onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler | undefined) => void;
+
+//   // Only on HUC
+//   onPrepareStart?: (paymentMethodType: string) => void;
+//   onTokenizeStart?: (paymentMethodType: string) => void;
+//   onPaymentMethodShow?: (paymentMethodType: string) => void;
+//   onAvailablePaymentMethodTypesLoad?: (paymentMethodTypes: string[]) => void;
+// }