@primer-io/react-native 2.16.7 → 2.17.0-rc.10

package/src/HeadlessUniversalCheckout/Managers/PaymentMethodManagers/RawDataManager.ts

@@ -0,0 +1,166 @@
+import type { RawData } from '@primer-io/react-native';
+import { NativeEventEmitter, NativeModules, EmitterSubscription } from 'react-native';
+import type { PrimerInitializationData } from 'src/models/PrimerInitializationData';
+import { PrimerError } from '../../../models/PrimerError';
+import type { PrimerInputElementType } from '../../../models/PrimerInputElementType';
+
+const { RNTPrimerHeadlessUniversalCheckoutRawDataManager } = NativeModules;
+const eventEmitter = new NativeEventEmitter(RNTPrimerHeadlessUniversalCheckoutRawDataManager);
+
+type EventType =
+    | 'onMetadataChange'
+    | 'onValidation';
+
+const eventTypes: EventType[] = [
+    'onMetadataChange',
+    'onValidation'
+];
+
+export interface RawDataManagerProps {
+    paymentMethodType: string;
+    onMetadataChange?: (metadata: any) => void;
+    onValidation?: (isValid: boolean, errors: PrimerError[] | undefined) => void;
+}
+
+class PrimerHeadlessUniversalCheckoutRawDataManager {
+
+    options?: RawDataManagerProps
+
+    ///////////////////////////////////////////
+    // Init
+    ///////////////////////////////////////////
+    constructor() { }
+
+    ///////////////////////////////////////////
+    // API
+    ///////////////////////////////////////////
+
+    async configure(options: RawDataManagerProps): Promise<{ initializationData: PrimerInitializationData } | void> {
+        return new Promise(async (resolve, reject) => {
+            try {
+                this.options = options;
+                await this.configureListeners();
+                const data = await RNTPrimerHeadlessUniversalCheckoutRawDataManager.configure(options.paymentMethodType);
+                if (data) {
+                    resolve(data);
+                } else {
+                    resolve();
+                }
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+
+    async configureListeners(): Promise<void> {
+        //@ts-ignore
+        return new Promise(async (resolve, reject) => {
+            if (this.options?.onMetadataChange) {
+                this.addListener("onMetadataChange", (data) => {
+                    if (this.options?.onMetadataChange) {
+                        this.options.onMetadataChange(data);
+                    }
+                });
+            }
+
+            if (this.options?.onValidation) {
+                this.addListener("onValidation", (data) => {
+                    if (this.options?.onValidation) {
+                        this.options.onValidation(data.isValid, data.errors);
+                    }
+                });
+            }
+
+            resolve();
+        });
+    }
+
+    async getRequiredInputElementTypes(): Promise<PrimerInputElementType[]> {
+        return new Promise(async (resolve, reject) => {
+            if (this.options?.paymentMethodType) {
+                try {
+                    const data = await RNTPrimerHeadlessUniversalCheckoutRawDataManager.listRequiredInputElementTypes();
+                    const inputElementTypes: PrimerInputElementType[] = data.inputElementTypes;
+                    resolve(inputElementTypes);
+                } catch (err) {
+                    reject(err);
+                }
+            } else {
+                const err = new PrimerError("manager-not-configured", "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
+                reject(err);
+            }
+        });
+    }
+
+    setRawData(rawData: RawData): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            if (this.options?.paymentMethodType) {
+                try {
+                    await RNTPrimerHeadlessUniversalCheckoutRawDataManager.setRawData(JSON.stringify(rawData));
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            } else {
+                const err = new PrimerError("manager-not-configured", "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
+                reject(err);
+            }
+        });
+    }
+
+    submit(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            if (this.options?.paymentMethodType) {
+                try {
+                    await RNTPrimerHeadlessUniversalCheckoutRawDataManager.submit();
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            } else {
+                const err = new PrimerError("manager-not-configured", "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
+                reject(err);
+            }
+        });
+    }
+
+    cleanUp(): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            if (this.options?.paymentMethodType) {
+                try {
+                    await RNTPrimerHeadlessUniversalCheckoutRawDataManager.cleanUp();
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            } else {
+                const err = new PrimerError("manager-not-configured", "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
+                reject(err);
+            }
+        });
+    }
+
+
+
+    ///////////////////////////////////////////
+    // HELPERS
+    ///////////////////////////////////////////
+
+    async addListener(eventType: EventType, listener: (...args: any[]) => any): Promise<EmitterSubscription> {
+        return eventEmitter.addListener(eventType, listener);
+    }
+
+    removeListener(eventType: EventType, listener: (...args: any[]) => any): void {
+        return eventEmitter.removeListener(eventType, listener);
+    }
+
+    removeAllListenersForEvent(eventType: EventType) {
+        eventEmitter.removeAllListeners(eventType);
+    }
+
+    removeAllListeners() {
+        eventTypes.forEach((eventType) => this.removeAllListenersForEvent(eventType));
+    }
+}
+
+export default PrimerHeadlessUniversalCheckoutRawDataManager;

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();