@evervault/react-native 2.4.0 → 2.5.0

package/build/index.esm.js

@@ -7583,6 +7583,23 @@ const defaultStyles = StyleSheet.create({
     },
 });
 
+class ThreeDSecureEvent {
+    type;
+    session;
+    _defaultPrevented;
+    constructor(type, session, _defaultPrevented = false) {
+        this.type = type;
+        this.session = session;
+        this._defaultPrevented = _defaultPrevented;
+    }
+    preventDefault() {
+        this._defaultPrevented = true;
+    }
+    get defaultPrevented() {
+        return this._defaultPrevented;
+    }
+}
+
 function stopPolling(intervalRef, setIsVisible) {
     setIsVisible(false);
     if (intervalRef.current) {
@@ -7590,55 +7607,91 @@ function stopPolling(intervalRef, setIsVisible) {
         intervalRef.current = null;
     }
 }
-async function startSession(session, callbacks, intervalRef, setIsVisible) {
+async function startSession(session, options, intervalRef, setIsVisible) {
     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"));
     }
 }
-function pollSession(session, callbacks, intervalRef, setIsVisible, interval = 3000) {
+function pollSession(session, options, intervalRef, setIsVisible, interval = 3000) {
+    function fail() {
+        stopPolling(intervalRef, setIsVisible);
+        options?.onFailure?.(new Error("3DS session failed"));
+    }
     intervalRef.current = setInterval(async () => {
         try {
             const pollResponse = 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);
 }
-function threeDSecureSession({ sessionId, appId, callbacks, intervalRef, setIsVisible, }) {
+function threeDSecureSession({ sessionId, appId, options, intervalRef, setIsVisible, }) {
     async function get() {
         try {
             const response = await fetch(`https://${EV_API_DOMAIN}/frontend/3ds/browser-sessions/${sessionId}`, {
@@ -7664,7 +7717,7 @@ function threeDSecureSession({ sessionId, appId, callbacks, intervalRef, setIsVi
                 },
                 body: JSON.stringify({ outcome: "cancelled" }),
             });
-            callbacks?.onFailure?.(new Error("3DS session cancelled by user"));
+            options?.onFailure?.(new Error("3DS session cancelled by user"));
             stopPolling(intervalRef, setIsVisible);
         }
         catch (error) {
@@ -7679,22 +7732,27 @@ function threeDSecureSession({ sessionId, appId, callbacks, intervalRef, setIsVi
     };
 }
 
-function useThreeDSecure() {
+function useThreeDSecure(options) {
     const { appId } = useEvervault();
     const intervalRef = useRef(null);
     const [session, setSession] = useState(null);
     const [isVisible, setIsVisible] = useState(false);
-    const start = useCallback((sessionId, callbacks) => {
+    const failOnChallenge = options?.failOnChallenge ?? false;
+    const start = useCallback((sessionId, options) => {
+        const startOptions = {
+            ...options,
+            failOnChallenge: options?.failOnChallenge ?? failOnChallenge,
+        };
         const session = threeDSecureSession({
             sessionId,
             appId,
-            callbacks,
+            options: startOptions,
             intervalRef,
             setIsVisible,
         });
         setSession(session);
-        startSession(session, callbacks, intervalRef, setIsVisible);
-    }, [appId]);
+        startSession(session, startOptions, intervalRef, setIsVisible);
+    }, [appId, failOnChallenge]);
     const cancel = useCallback(async () => {
         if (session) {
             await session.cancel();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evervault/react-native",
   "description": "Evervault SDK for React Native",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "source": "./src/index.ts",
   "main": "./build/index.cjs.js",
   "module": "./build/index.esm.js",

package/src/ThreeDSecure/event.ts

@@ -0,0 +1,19 @@
+import { ThreeDSecureSession } from "./types";
+
+export type ThreeDSecureEventType = "requestChallenge";
+
+export class ThreeDSecureEvent {
+  constructor(
+    public readonly type: ThreeDSecureEventType,
+    public readonly session: ThreeDSecureSession,
+    private _defaultPrevented: boolean = false
+  ) {}
+
+  public preventDefault() {
+    this._defaultPrevented = true;
+  }
+
+  public get defaultPrevented() {
+    return this._defaultPrevented;
+  }
+}

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,
     });