@evervault/react-native 2.3.0 → 2.5.0

package/src/Input.tsx

@@ -8,11 +8,13 @@ import {
   useCallback,
   useContext,
   useImperativeHandle,
+  useMemo,
   useRef,
+  useState,
 } from "react";
 import { TextInput, TextInputProps } from "react-native";
 import { mergeRefs } from "./utils";
-import { Controller, useFormContext } from "react-hook-form";
+import { Controller, useController, useFormContext } from "react-hook-form";
 import MaskInput, { Mask, MaskArray } from "react-native-mask-input";
 
 export interface EvervaultInputContextValue {
@@ -82,73 +84,97 @@ export type BaseEvervaultInputProps = Omit<
 >;
 
 export function mask(format: string): MaskArray {
-  return format.split("").map((char) => {
+  const maskArray: MaskArray = [];
+
+  let isObfuscated = false;
+  format.split("").forEach((char) => {
+    if (char === "[") {
+      isObfuscated = true;
+      return;
+    } else if (char === "]") {
+      isObfuscated = false;
+      return;
+    }
+
+    let value: string | RegExp | [RegExp] = char;
     if (char === "9") {
-      return /\d/;
+      value = isObfuscated ? [/\d/] : /\d/;
     }
-    return char;
+    maskArray.push(value);
   });
+
+  return maskArray;
 }
 
 export interface EvervaultInputProps<Values extends Record<string, unknown>>
   extends BaseEvervaultInputProps {
   name: keyof Values;
   mask?: Mask;
+  obfuscateValue?: boolean | string;
 }
 
 export const EvervaultInput = forwardRef<
   EvervaultInput,
   EvervaultInputProps<Record<string, unknown>>
->(function EvervaultInput({ name, mask, ...props }, ref) {
+>(function EvervaultInput({ name, mask, obfuscateValue, ...props }, ref) {
   const { validationMode } = useContext(EvervaultInputContext);
 
   const inputRef = useForwardedInputRef(ref);
 
   const methods = useFormContext();
 
+  const { field, fieldState } = useController({
+    control: methods.control,
+    name,
+    shouldUnregister: true,
+  });
+
+  const obfuscationCharacter = useMemo(() => {
+    if (typeof obfuscateValue === "string") {
+      return obfuscateValue;
+    } else {
+      return "•";
+    }
+  }, [obfuscateValue]);
+
   return (
-    <Controller
-      control={methods.control}
-      name={name}
-      shouldUnregister
-      render={({ field, fieldState }) => (
-        <MaskInput
-          // Overridable props
-          id={field.name}
-          {...props}
-          // Strict props
-          ref={mergeRefs(inputRef, field.ref)}
-          editable={!field.disabled && (props.editable ?? true)}
-          onBlur={(evt) => {
-            const shouldValidate =
-              validationMode === "onBlur" ||
-              validationMode === "onTouched" ||
-              validationMode === "all";
-            methods.setValue(field.name, field.value, {
-              shouldDirty: true,
-              shouldTouch: true,
-              shouldValidate,
-            });
-            props.onBlur?.(evt);
-          }}
-          mask={mask}
-          maskAutoComplete={!!mask}
-          value={field.value}
-          onChangeText={(masked, unmasked) => {
-            const shouldValidate =
-              (validationMode === "onTouched" && fieldState.isTouched) ||
-              ((validationMode === "onChange" || validationMode === "all") &&
-                (!!fieldState.error || fieldState.isTouched));
-            methods.setValue(field.name, unmasked, {
-              shouldDirty: true,
-              shouldValidate,
-            });
-          }}
-          // Remove unwanted props
-          defaultValue={undefined}
-          onChange={undefined}
-        />
-      )}
+    <MaskInput
+      // Overridable props
+      id={field.name}
+      {...props}
+      // Strict props
+      ref={mergeRefs(inputRef, field.ref)}
+      editable={!field.disabled && (props.editable ?? true)}
+      onBlur={(evt) => {
+        const shouldValidate =
+          validationMode === "onBlur" ||
+          validationMode === "onTouched" ||
+          validationMode === "all";
+        methods.setValue(field.name, field.value, {
+          shouldDirty: true,
+          shouldTouch: true,
+          shouldValidate,
+        });
+        props.onBlur?.(evt);
+      }}
+      mask={mask}
+      maskAutoComplete={!!mask}
+      obfuscationCharacter={obfuscationCharacter}
+      showObfuscatedValue={!!obfuscateValue}
+      value={field.value}
+      onChangeText={(masked, unmasked) => {
+        const shouldValidate =
+          (validationMode === "onTouched" && fieldState.isTouched) ||
+          ((validationMode === "onChange" || validationMode === "all") &&
+            (!!fieldState.error || fieldState.isTouched));
+        methods.setValue(field.name, unmasked, {
+          shouldDirty: true,
+          shouldValidate,
+        });
+      }}
+      // Remove unwanted props
+      defaultValue={undefined}
+      onChange={undefined}
     />
   );
 }) as <Values extends Record<string, unknown>>(

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