@evervault/react-native 2.4.0 → 2.5.1

package/src/ThreeDSecure/session.test.ts

@@ -1,4 +1,5 @@
 import { EV_API_DOMAIN } from "./config";
+import { ThreeDSecureEvent } from "./event";
 import {
   pollSession,
   startSession,
@@ -24,7 +25,7 @@ describe("stopPolling", () => {
 });
 
 describe("startSession", () => {
-  const callbacks = {
+  const options = {
     onSuccess: vi.fn(),
     onFailure: vi.fn(),
     onError: vi.fn(),
@@ -32,6 +33,10 @@ describe("startSession", () => {
   const intervalRef = { current: null };
   const setIsVisible = vi.fn();
 
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it("should start a successful session", async () => {
     const session: ThreeDSecureSession = {
       cancel: vi.fn(),
@@ -39,10 +44,10 @@ describe("startSession", () => {
       sessionId: "123",
     };
 
-    await startSession(session, callbacks, intervalRef, setIsVisible);
+    await startSession(session, options, intervalRef, setIsVisible);
 
     expect(session.get).toHaveBeenCalled();
-    expect(callbacks.onSuccess).toHaveBeenCalled();
+    expect(options.onSuccess).toHaveBeenCalled();
   });
 
   it("should start a failed session", async () => {
@@ -52,10 +57,10 @@ describe("startSession", () => {
       sessionId: "123",
     };
 
-    await startSession(session, callbacks, intervalRef, setIsVisible);
+    await startSession(session, options, intervalRef, setIsVisible);
 
     expect(session.get).toHaveBeenCalled();
-    expect(callbacks.onFailure).toHaveBeenCalledWith(
+    expect(options.onFailure).toHaveBeenCalledWith(
       new Error("3DS session failed")
     );
   });
@@ -67,12 +72,98 @@ describe("startSession", () => {
       sessionId: "123",
     };
 
-    await startSession(session, callbacks, intervalRef, setIsVisible);
+    await startSession(session, options, intervalRef, setIsVisible);
 
     expect(session.get).toHaveBeenCalled();
     expect(setIsVisible).toHaveBeenCalledWith(true);
   });
 
+  it("should fail the session when failOnChallenge is true and a challenge is required", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    await startSession(
+      session,
+      { ...options, failOnChallenge: true },
+      intervalRef,
+      setIsVisible
+    );
+
+    expect(session.get).toHaveBeenCalled();
+    expect(options.onFailure).toHaveBeenCalledWith(
+      new Error("3DS session failed")
+    );
+  });
+
+  it("should fail the session when failOnChallenge is a function that returns true and a challenge is required", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    await startSession(
+      session,
+      { ...options, failOnChallenge: () => Promise.resolve(true) },
+      intervalRef,
+      setIsVisible
+    );
+
+    expect(session.get).toHaveBeenCalled();
+    expect(options.onFailure).toHaveBeenCalledWith(
+      new Error("3DS session failed")
+    );
+  });
+
+  it("should call onRequestChallenge when a challenge is required", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    const onRequestChallenge = vi.fn();
+
+    await startSession(
+      session,
+      { ...options, onRequestChallenge },
+      intervalRef,
+      setIsVisible
+    );
+
+    expect(session.get).toHaveBeenCalled();
+    expect(onRequestChallenge).toHaveBeenCalled();
+    expect(options.onFailure).not.toHaveBeenCalled();
+  });
+
+  it("should fail the session when onRequestChallenge is called and default is prevented", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    const onRequestChallenge = vi.fn((event: ThreeDSecureEvent) => {
+      event.preventDefault();
+    });
+
+    await startSession(
+      session,
+      { ...options, onRequestChallenge },
+      intervalRef,
+      setIsVisible
+    );
+
+    expect(session.get).toHaveBeenCalled();
+    expect(onRequestChallenge).toHaveBeenCalled();
+    expect(options.onFailure).toHaveBeenCalledWith(
+      new Error("3DS session failed")
+    );
+  });
+
   it("should call onError if the session fails to start", async () => {
     const session: ThreeDSecureSession = {
       cancel: vi.fn(),
@@ -84,21 +175,21 @@ describe("startSession", () => {
       .spyOn(console, "error")
       .mockImplementation(() => {});
 
-    await startSession(session, callbacks, intervalRef, setIsVisible);
+    await startSession(session, options, intervalRef, setIsVisible);
 
     expect(session.get).toHaveBeenCalled();
     expect(consoleErrorSpy).toHaveBeenCalledWith(
       "Error checking session state",
       new Error("Failed to start session")
     );
-    expect(callbacks.onError).toHaveBeenCalledWith(
+    expect(options.onError).toHaveBeenCalledWith(
       new Error("Failed to check 3DS session state")
     );
   });
 });
 
 describe("pollSession", () => {
-  const callbacks = {
+  const options = {
     onSuccess: vi.fn(),
     onFailure: vi.fn(),
     onError: vi.fn(),
@@ -106,6 +197,10 @@ describe("pollSession", () => {
   const intervalRef = { current: null };
   const setIsVisible = vi.fn();
 
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it("should start an interval", () => {
     const session: ThreeDSecureSession = {
       cancel: vi.fn(),
@@ -114,7 +209,7 @@ describe("pollSession", () => {
     };
 
     const intervalSpy = vi.spyOn(global, "setInterval");
-    pollSession(session, callbacks, intervalRef, setIsVisible);
+    pollSession(session, options, intervalRef, setIsVisible);
 
     expect(intervalSpy).toHaveBeenCalledWith(expect.any(Function), 3000);
   });
@@ -127,11 +222,11 @@ describe("pollSession", () => {
     };
 
     const intervalSpy = vi.spyOn(global, "setInterval");
-    pollSession(session, callbacks, intervalRef, setIsVisible);
+    pollSession(session, options, intervalRef, setIsVisible);
     await intervalSpy.mock.calls[0][0]();
 
     expect(session.get).toHaveBeenCalled();
-    expect(callbacks.onSuccess).toHaveBeenCalled();
+    expect(options.onSuccess).toHaveBeenCalled();
   });
 
   it("should poll failed session", async () => {
@@ -142,11 +237,11 @@ describe("pollSession", () => {
     };
 
     const intervalSpy = vi.spyOn(global, "setInterval");
-    pollSession(session, callbacks, intervalRef, setIsVisible);
+    pollSession(session, options, intervalRef, setIsVisible);
     await intervalSpy.mock.calls[0][0]();
 
     expect(session.get).toHaveBeenCalled();
-    expect(callbacks.onFailure).toHaveBeenCalledWith(
+    expect(options.onFailure).toHaveBeenCalledWith(
       new Error("3DS session failed")
     );
   });
@@ -159,13 +254,113 @@ describe("pollSession", () => {
     };
 
     const intervalSpy = vi.spyOn(global, "setInterval");
-    pollSession(session, callbacks, intervalRef, setIsVisible);
+    pollSession(session, options, intervalRef, setIsVisible);
     await intervalSpy.mock.calls[0][0]();
 
     expect(session.get).toHaveBeenCalled();
     expect(setIsVisible).toHaveBeenCalledWith(true);
   });
 
+  it("should fail the session when failOnChallenge is true and a challenge is required", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    const intervalSpy = vi.spyOn(global, "setInterval");
+    const onRequestChallenge = vi.fn();
+    pollSession(
+      session,
+      { ...options, failOnChallenge: true, onRequestChallenge },
+      intervalRef,
+      setIsVisible
+    );
+    await intervalSpy.mock.calls[0][0]();
+
+    expect(session.get).toHaveBeenCalled();
+    expect(onRequestChallenge).not.toHaveBeenCalled();
+    expect(options.onFailure).toHaveBeenCalledWith(
+      new Error("3DS session failed")
+    );
+  });
+
+  it("should fail the session when failOnChallenge is a function that returns true and a challenge is required", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    const intervalSpy = vi.spyOn(global, "setInterval");
+    const onRequestChallenge = vi.fn();
+    pollSession(
+      session,
+      {
+        ...options,
+        onRequestChallenge,
+        failOnChallenge: () => Promise.resolve(true),
+      },
+      intervalRef,
+      setIsVisible
+    );
+    await intervalSpy.mock.calls[0][0]();
+
+    expect(session.get).toHaveBeenCalled();
+    expect(onRequestChallenge).not.toHaveBeenCalled();
+    expect(options.onFailure).toHaveBeenCalledWith(
+      new Error("3DS session failed")
+    );
+  });
+
+  it("should call onRequestChallenge when a challenge is required", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    const intervalSpy = vi.spyOn(global, "setInterval");
+    const onRequestChallenge = vi.fn();
+    pollSession(
+      session,
+      { ...options, onRequestChallenge },
+      intervalRef,
+      setIsVisible
+    );
+    await intervalSpy.mock.calls[0][0]();
+
+    expect(session.get).toHaveBeenCalled();
+    expect(onRequestChallenge).toHaveBeenCalled();
+    expect(options.onFailure).not.toHaveBeenCalled();
+  });
+
+  it("should fail the session when onRequestChallenge is called and default is prevented", async () => {
+    const session: ThreeDSecureSession = {
+      cancel: vi.fn(),
+      get: vi.fn(() => Promise.resolve({ status: "action-required" }) as any),
+      sessionId: "123",
+    };
+
+    const intervalSpy = vi.spyOn(global, "setInterval");
+    const onRequestChallenge = vi.fn((event: ThreeDSecureEvent) => {
+      event.preventDefault();
+    });
+    pollSession(
+      session,
+      { ...options, onRequestChallenge },
+      intervalRef,
+      setIsVisible
+    );
+    await intervalSpy.mock.calls[0][0]();
+
+    expect(session.get).toHaveBeenCalled();
+    expect(onRequestChallenge).toHaveBeenCalled();
+    expect(options.onFailure).toHaveBeenCalledWith(
+      new Error("3DS session failed")
+    );
+  });
+
   it("should call onError if the session fails to poll", async () => {
     const session: ThreeDSecureSession = {
       cancel: vi.fn(),
@@ -178,7 +373,7 @@ describe("pollSession", () => {
       .mockImplementation(() => {});
 
     const intervalSpy = vi.spyOn(global, "setInterval");
-    pollSession(session, callbacks, intervalRef, setIsVisible);
+    pollSession(session, options, intervalRef, setIsVisible);
     await intervalSpy.mock.calls[0][0]();
 
     expect(session.get).toHaveBeenCalled();
@@ -186,14 +381,14 @@ describe("pollSession", () => {
       "Error polling session",
       new Error("Failed to poll session")
     );
-    expect(callbacks.onError).toHaveBeenCalledWith(
+    expect(options.onError).toHaveBeenCalledWith(
       new Error("Error polling 3DS session")
     );
   });
 });
 
 describe("threeDSecureSession", () => {
-  const callbacks = {
+  const options = {
     onSuccess: vi.fn(),
     onFailure: vi.fn(),
     onError: vi.fn(),
@@ -205,7 +400,7 @@ describe("threeDSecureSession", () => {
     const session = threeDSecureSession({
       sessionId: "123",
       appId: "app_123",
-      callbacks,
+      options,
       intervalRef,
       setIsVisible,
     });
@@ -220,7 +415,7 @@ describe("threeDSecureSession", () => {
     const session = threeDSecureSession({
       sessionId: "123",
       appId: "app_123",
-      callbacks,
+      options,
       intervalRef,
       setIsVisible,
     });
@@ -250,7 +445,7 @@ describe("threeDSecureSession", () => {
     const session = threeDSecureSession({
       sessionId: "123",
       appId: "app_123",
-      callbacks,
+      options,
       intervalRef,
       setIsVisible,
     });
@@ -275,7 +470,7 @@ describe("threeDSecureSession", () => {
     const session = threeDSecureSession({
       sessionId: "123",
       appId: "app_123",
-      callbacks,
+      options,
       intervalRef,
       setIsVisible,
     });
@@ -297,7 +492,7 @@ describe("threeDSecureSession", () => {
       }
     );
 
-    expect(callbacks.onFailure).toHaveBeenCalledWith(
+    expect(options.onFailure).toHaveBeenCalledWith(
       new Error("3DS session cancelled by user")
     );
   });
@@ -306,7 +501,7 @@ describe("threeDSecureSession", () => {
     const session = threeDSecureSession({
       sessionId: "123",
       appId: "app_123",
-      callbacks,
+      options,
       intervalRef,
       setIsVisible,
     });

package/src/ThreeDSecure/session.ts

@@ -3,8 +3,10 @@ import {
   ThreeDSecureSessionsParams,
   ThreeDSecureSession,
   ThreeDSecureSessionResponse,
+  ThreeDSecureOptions,
 } from "./types";
 import { EV_API_DOMAIN } from "./config";
+import { ThreeDSecureEvent } from "./event";
 
 export function stopPolling(
   intervalRef: React.MutableRefObject<NodeJS.Timeout | null>,
@@ -20,58 +22,108 @@ export function stopPolling(
 
 export async function startSession(
   session: ThreeDSecureSession,
-  callbacks: ThreeDSecureCallbacks | undefined,
+  options: ThreeDSecureOptions | undefined,
   intervalRef: React.MutableRefObject<NodeJS.Timeout | null>,
   setIsVisible: (show: boolean) => void
 ) {
   try {
     const sessionState = await session.get();
 
+    function fail() {
+      stopPolling(intervalRef, setIsVisible);
+      options?.onFailure?.(new Error("3DS session failed"));
+    }
+
     switch (sessionState.status) {
-      case "success":
+      case "success": {
         stopPolling(intervalRef, setIsVisible);
-        callbacks?.onSuccess?.();
+        options?.onSuccess?.();
         break;
-      case "failure":
-        stopPolling(intervalRef, setIsVisible);
-        callbacks?.onFailure?.(new Error("3DS session failed"));
+      }
+
+      case "failure": {
+        fail();
         break;
-      case "action-required":
+      }
+
+      case "action-required": {
+        const failOnChallenge =
+          typeof options?.failOnChallenge === "function"
+            ? await options.failOnChallenge()
+            : options?.failOnChallenge ?? false;
+        if (failOnChallenge) {
+          fail();
+          break;
+        }
+
+        const event = new ThreeDSecureEvent("requestChallenge", session);
+        options?.onRequestChallenge?.(event);
+        if (event.defaultPrevented) {
+          fail();
+          break;
+        }
+
         setIsVisible(true);
-        pollSession(session, callbacks, intervalRef, setIsVisible);
-        break;
-      default:
-        break;
+        pollSession(session, options, intervalRef, setIsVisible);
+      }
     }
   } catch (error) {
     console.error("Error checking session state", error);
-    callbacks?.onError?.(new Error("Failed to check 3DS session state"));
+    options?.onError?.(new Error("Failed to check 3DS session state"));
   }
 }
 
 export function pollSession(
   session: ThreeDSecureSession,
-  callbacks: ThreeDSecureCallbacks | undefined,
+  options: ThreeDSecureOptions | undefined,
   intervalRef: React.MutableRefObject<NodeJS.Timeout | null>,
   setIsVisible: (show: boolean) => void,
   interval = 3000
 ) {
+  function fail() {
+    stopPolling(intervalRef, setIsVisible);
+    options?.onFailure?.(new Error("3DS session failed"));
+  }
+
   intervalRef.current = setInterval(async () => {
     try {
       const pollResponse: ThreeDSecureSessionResponse = await session.get();
-      if (pollResponse.status === "success") {
-        stopPolling(intervalRef, setIsVisible);
-        callbacks?.onSuccess?.();
-      } else if (pollResponse.status === "failure") {
-        stopPolling(intervalRef, setIsVisible);
-        callbacks?.onFailure?.(new Error("3DS session failed"));
-      } else {
-        setIsVisible(true);
+      switch (pollResponse.status) {
+        case "success": {
+          stopPolling(intervalRef, setIsVisible);
+          options?.onSuccess?.();
+          break;
+        }
+
+        case "failure": {
+          fail();
+          break;
+        }
+
+        case "action-required": {
+          const failOnChallenge =
+            typeof options?.failOnChallenge === "function"
+              ? await options.failOnChallenge()
+              : options?.failOnChallenge ?? false;
+          if (failOnChallenge) {
+            fail();
+            break;
+          }
+
+          const event = new ThreeDSecureEvent("requestChallenge", session);
+          options?.onRequestChallenge?.(event);
+          if (event.defaultPrevented) {
+            fail();
+            break;
+          }
+
+          setIsVisible(true);
+        }
       }
     } catch (error) {
       stopPolling(intervalRef, setIsVisible);
       console.error("Error polling session", error);
-      callbacks?.onError?.(new Error("Error polling 3DS session"));
+      options?.onError?.(new Error("Error polling 3DS session"));
     }
   }, interval);
 }
@@ -79,7 +131,7 @@ export function pollSession(
 export function threeDSecureSession({
   sessionId,
   appId,
-  callbacks,
+  options,
   intervalRef,
   setIsVisible,
 }: ThreeDSecureSessionsParams): ThreeDSecureSession {
@@ -116,7 +168,7 @@ export function threeDSecureSession({
         }
       );
 
-      callbacks?.onFailure?.(new Error("3DS session cancelled by user"));
+      options?.onFailure?.(new Error("3DS session cancelled by user"));
       stopPolling(intervalRef, setIsVisible);
     } catch (error) {
       console.error("Error cancelling 3DS session", error);

package/src/ThreeDSecure/types.ts

@@ -1,4 +1,4 @@
-import { PropsWithChildren } from "react";
+import { ThreeDSecureEvent } from "./event";
 
 export interface ThreeDSecureCallbacks {
   /**
@@ -6,6 +6,12 @@ export interface ThreeDSecureCallbacks {
    */
   onError?(error: Error): void;
 
+  /**
+   * The 'requestChallenge' event will be fired if the 3DS authentication process requires a challenge.
+   * If you'd like to fail the authentication, you should call `preventDefault` on the passed event.
+   */
+  onRequestChallenge?(event: ThreeDSecureEvent): void;
+
   /**
    * The 'failure' event will be fired if the 3DS authentication process fails. You should use this event to handle the failure and inform the user and prompt them to try again.
    * If the user cancels the 3DS authentication process this event will be fired.
@@ -20,6 +26,13 @@ export interface ThreeDSecureCallbacks {
   onSuccess?(): void;
 }
 
+export interface ThreeDSecureOptions extends ThreeDSecureCallbacks {
+  /**
+   * If set to `true` (or a function that returns `true`), the authentication will fail if a challenge is required.
+   */
+  failOnChallenge?: boolean | (() => Promise<boolean>);
+}
+
 export interface ThreeDSecureInitialState {
   session: ThreeDSecureSession | null;
   isVisible: boolean;
@@ -44,7 +57,7 @@ export interface ThreeDSecureSessionResponse {
 
 export interface ThreeDSecureSessionsParams {
   appId: string;
-  callbacks?: ThreeDSecureCallbacks;
+  options?: ThreeDSecureOptions;
   intervalRef: React.MutableRefObject<NodeJS.Timeout | null>;
   sessionId: string;
   setIsVisible: (show: boolean) => void;
@@ -61,7 +74,7 @@ export interface ThreeDSecureState extends ThreeDSecureInitialState {
    * The `start()` function is used to kick off the 3DS authentication process.
    *
    * @param sessionId The 3DS session ID. A 3DS session can be created using the [Evervault API](https://docs.evervault.com/api-reference#createThreeDSSession).
-   * @param callbacks The callbacks to be called when the 3DS authentication process is finished.
+   * @param options The options to be used for the 3DS authentication process.
    */
-  start(sessionId: string, callbacks?: ThreeDSecureCallbacks): void;
+  start(sessionId: string, options?: ThreeDSecureOptions): void;
 }