@evervault/react-native 2.0.0

package/src/__mocks__/NativeEvervault.ts

@@ -0,0 +1,13 @@
+import type { Spec } from "../specs/NativeEvervault";
+
+export const encryptedValue =
+  "ev:W98t:uu98aas09udya863ty9372y7y23h97rg6gfs678987";
+
+export const NativeEvervault: Spec = {
+  initialize: vi.fn(),
+  encryptString: vi.fn(() => Promise.resolve(encryptedValue)),
+  encryptNumber: vi.fn(() => Promise.resolve(encryptedValue)),
+  encryptBoolean: vi.fn(() => Promise.resolve(encryptedValue)),
+  encryptObject: vi.fn(),
+  encryptArray: vi.fn(),
+};

package/src/__mocks__/react-native-webview.tsx

@@ -0,0 +1,6 @@
+import { View } from "react-native";
+import type { WebViewProps } from "react-native-webview";
+
+export function WebView(props: WebViewProps) {
+  return <View testID="webview" {...props} />;
+}

package/src/context.ts

@@ -0,0 +1,14 @@
+import { createContext } from "react";
+import type { Encrypted } from "./sdk";
+
+export type EncryptFn = <T>(data: T) => Promise<Encrypted<T>>;
+
+export interface EvervaultContextValue {
+  teamId: string;
+  appId: string;
+  encrypt: EncryptFn;
+}
+
+export const EvervaultContext = createContext<EvervaultContextValue | null>(
+  null
+);

package/src/index.ts

@@ -0,0 +1,21 @@
+import { sdk } from "./sdk";
+
+export const verifyInstallation = sdk.verify;
+
+export type { Encrypted } from "./sdk";
+
+export {
+  EvervaultProvider,
+  type EvervaultProviderProps,
+} from "./EvervaultProvider";
+
+export type { EncryptFn } from "./context";
+export { useEvervault } from "./useEvervault";
+
+export type {
+  EvervaultInput,
+  BaseEvervaultInputProps as EvervaultInputProps,
+} from "./Input";
+
+export * from "./Card";
+export * from "./ThreeDSecure";

package/src/sdk.test.ts

@@ -0,0 +1,122 @@
+import { NativeEvervault } from "./__mocks__/NativeEvervault";
+import { sdk } from "./sdk";
+
+describe("sdk", () => {
+  describe("verify", () => {
+    it("should return true", () => {
+      expect(sdk.verify()).toBe(true);
+    });
+  });
+
+  describe("initialize", () => {
+    it("throws an error if teamId is not provided", () => {
+      expect(() => sdk.initialize("", "appId")).toThrow("Team ID is required.");
+    });
+
+    it("throws an error if appId is not provided", () => {
+      expect(() => sdk.initialize("teamId", "")).toThrow("App ID is required.");
+    });
+
+    it("initializes the sdk", () => {
+      sdk.initialize("teamId", "appId");
+      expect(NativeEvervault.initialize).toHaveBeenCalledWith(
+        "teamId",
+        "appId"
+      );
+    });
+  });
+
+  describe("encrypt", () => {
+    it("encrypts an undefined value", async () => {
+      const result = await sdk.encrypt("instanceId", undefined);
+      expect(result).toBe(undefined);
+      expect(NativeEvervault.encryptString).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptNumber).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptBoolean).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptObject).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptArray).not.toHaveBeenCalled();
+    });
+
+    it("encrypts a null value", async () => {
+      const result = await sdk.encrypt("instanceId", null);
+      expect(result).toBe(null);
+      expect(NativeEvervault.encryptString).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptNumber).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptBoolean).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptObject).not.toHaveBeenCalled();
+      expect(NativeEvervault.encryptArray).not.toHaveBeenCalled();
+    });
+
+    it("encrypts a string", async () => {
+      await sdk.encrypt("instanceId", "hello");
+      expect(NativeEvervault.encryptString).toHaveBeenCalledWith(
+        "instanceId",
+        "hello"
+      );
+      assertType<Promise<string>>(sdk.encrypt("instanceId", "hello"));
+    });
+
+    it("encrypts a number", async () => {
+      await sdk.encrypt("instanceId", 123);
+      expect(NativeEvervault.encryptNumber).toHaveBeenCalledWith(
+        "instanceId",
+        123
+      );
+      assertType<Promise<string>>(sdk.encrypt("instanceId", 123));
+    });
+
+    it("encrypts a boolean", async () => {
+      await sdk.encrypt("instanceId", true);
+      expect(NativeEvervault.encryptBoolean).toHaveBeenCalledWith(
+        "instanceId",
+        true
+      );
+      assertType<Promise<string>>(sdk.encrypt("instanceId", true));
+    });
+
+    it("encrypts an object", async () => {
+      await sdk.encrypt("instanceId", { a: 1, b: 2 });
+      expect(NativeEvervault.encryptObject).toHaveBeenCalledWith("instanceId", {
+        a: 1,
+        b: 2,
+      });
+      assertType<Promise<{ a: string; b: string }>>(
+        sdk.encrypt("instanceId", { a: 1, b: 2 })
+      );
+    });
+
+    it("encrypts a deep object", async () => {
+      await sdk.encrypt("instanceId", { a: 1, b: { c: 2, d: 3 } });
+      expect(NativeEvervault.encryptObject).toHaveBeenCalledWith("instanceId", {
+        a: 1,
+        b: { c: 2, d: 3 },
+      });
+      assertType<Promise<{ a: string; b: { c: string; d: string } }>>(
+        sdk.encrypt("instanceId", { a: 1, b: { c: 2, d: 3 } })
+      );
+    });
+
+    it("encrypts an array", async () => {
+      await sdk.encrypt("instanceId", [1, 2, 3]);
+      expect(NativeEvervault.encryptArray).toHaveBeenCalledWith(
+        "instanceId",
+        [1, 2, 3]
+      );
+      assertType<Promise<Array<string>>>(sdk.encrypt("instanceId", [1, 2, 3]));
+    });
+
+    it("throws an error if the data is not supported", async () => {
+      const fn = () => {};
+      await expect(() => sdk.encrypt("instanceId", fn)).rejects.toThrow(
+        "Unsupported data type."
+      );
+      assertType<() => Promise<never>>(() => sdk.encrypt("instanceId", fn));
+
+      const symbol = Symbol("test");
+      await expect(() => sdk.encrypt("instanceId", symbol)).rejects.toThrow(
+        "Unsupported data type."
+      );
+      assertType<() => Promise<never>>(() => sdk.encrypt("instanceId", symbol));
+    });
+  });
+});

package/src/sdk.ts

@@ -0,0 +1,71 @@
+import {
+  NativeEvervault,
+  Spec as NativeEvervaultSpec,
+} from "./specs/NativeEvervault";
+
+export type Encrypted<T> = T extends undefined
+  ? undefined
+  : T extends null
+  ? null
+  : T extends string | number | boolean
+  ? string
+  : T extends Function
+  ? never
+  : T extends object
+  ? {
+      [K in keyof T]: Encrypted<T[K]>;
+    }
+  : T extends Array<infer U>
+  ? Array<Encrypted<U>>
+  : never;
+
+function getModule(): NativeEvervaultSpec {
+  if (!NativeEvervault) {
+    throw new Error("NativeEvervault is not available.");
+  }
+
+  return NativeEvervault;
+}
+
+export const sdk = {
+  verify() {
+    getModule();
+    return true;
+  },
+
+  initialize(teamId: string, appId: string): string {
+    const evervault = getModule();
+
+    if (!teamId) {
+      throw new Error("Team ID is required.");
+    }
+
+    if (!appId) {
+      throw new Error("App ID is required.");
+    }
+
+    return evervault.initialize(teamId, appId);
+  },
+
+  async encrypt<T>(instanceId: string, data: T): Promise<Encrypted<T>> {
+    const evervault = getModule();
+
+    if (data === undefined) {
+      return undefined as any;
+    } else if (data === null) {
+      return null as any;
+    } else if (typeof data === "string") {
+      return (await evervault.encryptString(instanceId, data)) as any;
+    } else if (typeof data === "number") {
+      return (await evervault.encryptNumber(instanceId, data)) as any;
+    } else if (typeof data === "boolean") {
+      return (await evervault.encryptBoolean(instanceId, data)) as any;
+    } else if (Array.isArray(data)) {
+      return (await evervault.encryptArray(instanceId, data)) as any;
+    } else if (typeof data === "object") {
+      return (await evervault.encryptObject(instanceId, data)) as any;
+    }
+
+    throw new Error("Unsupported data type.");
+  },
+};

package/src/specs/NativeEvervault.ts

@@ -0,0 +1,67 @@
+import { TurboModule, TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  /**
+   * Initialize the Evervault SDK.
+   *
+   * @param teamId - The team ID.
+   * @param appId - The app ID.
+   *
+   * @returns A unique identifier for the SDK instance.
+   */
+  initialize(teamId: string, appId: string): string;
+
+  /**
+   * Encrypt a string.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The string to encrypt.
+   *
+   * @returns The encrypted string.
+   */
+  encryptString(instanceId: string, data: string): Promise<string>;
+
+  /**
+   * Encrypt a number.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The number to encrypt.
+   *
+   * @returns The encrypted number.
+   */
+  encryptNumber(instanceId: string, data: number): Promise<string>;
+
+  /**
+   * Encrypt a boolean.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The boolean to encrypt.
+   *
+   * @returns The encrypted boolean.
+   */
+  encryptBoolean(instanceId: string, data: boolean): Promise<string>;
+
+  /**
+   * Encrypt an object.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The object to encrypt.
+   *
+   * @returns The encrypted object.
+   */
+  encryptObject(instanceId: string, data: Object): Promise<Object>;
+
+  /**
+   * Encrypt an array.
+   *
+   * @param instanceId - The unique identifier for the SDK instance.
+   * @param data - The array to encrypt.
+   *
+   * @returns The encrypted array.
+   */
+  encryptArray(instanceId: string, data: Array<any>): Promise<Array<any>>;
+}
+
+export const NativeEvervault = TurboModuleRegistry.get<Spec>(
+  "NativeEvervault"
+) as Spec | null;

package/src/useEvervault.test.tsx

@@ -0,0 +1,31 @@
+import { renderHook } from "@testing-library/react-native";
+import { useEvervault } from "./useEvervault";
+import { EvervaultProvider } from "./EvervaultProvider";
+import { PropsWithChildren } from "react";
+import { ErrorBoundary } from "./utils";
+
+it("throws an error if used outside of EvervaultProvider", () => {
+  const onError = vi.fn();
+  const wrapper = ({ children }: PropsWithChildren) => (
+    <ErrorBoundary onError={onError}>{children}</ErrorBoundary>
+  );
+
+  renderHook(() => useEvervault(), { wrapper });
+  expect(onError).toHaveBeenCalledWith(
+    new Error("`useEvervault` must be used within an `EvervaultProvider`.")
+  );
+});
+
+it("returns the config when used within EvervaultProvider", () => {
+  const wrapper = ({ children }: PropsWithChildren) => (
+    <EvervaultProvider teamId="team_123" appId="app_123">
+      {children}
+    </EvervaultProvider>
+  );
+
+  const { result } = renderHook(() => useEvervault(), { wrapper });
+
+  expect(result.current.appId).toBe("app_123");
+  expect(result.current.teamId).toBe("team_123");
+  expect(result.current.encrypt).toStrictEqual(expect.any(Function));
+});

package/src/useEvervault.ts

@@ -0,0 +1,14 @@
+import { useContext } from "react";
+import { EvervaultContext } from "./context";
+
+export function useEvervault() {
+  const context = useContext(EvervaultContext);
+
+  if (!context) {
+    throw new Error(
+      "`useEvervault` must be used within an `EvervaultProvider`."
+    );
+  }
+
+  return context;
+}

package/src/utils.ts

@@ -0,0 +1,41 @@
+import {
+  Component,
+  LegacyRef,
+  MutableRefObject,
+  PropsWithChildren,
+  RefCallback,
+} from "react";
+
+// Taken from https://github.com/gregberge/react-merge-refs
+export function mergeRefs<T = any>(
+  ...refs: Array<MutableRefObject<T> | LegacyRef<T> | undefined | null>
+): RefCallback<T> {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        (ref as MutableRefObject<T | null>).current = value;
+      }
+    });
+  };
+}
+
+export class ErrorBoundary extends Component<
+  PropsWithChildren<{ onError?(error: Error): void }>
+> {
+  state = { hasError: false };
+
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+
+  componentDidCatch(error: Error) {
+    this.props.onError?.(error);
+  }
+
+  render() {
+    if (this.state.hasError) return null;
+    return this.props.children;
+  }
+}