@rakomi/react-native 0.0.0 → 0.1.0

package/dist/native/index.cjs

@@ -0,0 +1,381 @@
+'use strict';
+
+// src/native/bare-rn-example.ts
+function createBareRnAdapter(options) {
+  const servicePrefix = options.keychainServicePrefix ?? "rakomi";
+  const crypto = {
+    getRandomBytes: async (length) => new Uint8Array(options.quickCrypto.randomBytes(length)),
+    digestSha256: async (input) => new Uint8Array(options.quickCrypto.createHash("sha256").update(input).digest())
+  };
+  const storage = {
+    getItem: async (key, opts) => {
+      const result = await options.keychain.getGenericPassword({
+        service: `${servicePrefix}.${key}`,
+        ...opts?.requireAuthentication ? { authenticationPrompt: { title: opts.authenticationPrompt ?? "Authenticate" } } : {}
+      });
+      return result ? result.password : null;
+    },
+    setItem: async (key, value, opts) => {
+      await options.keychain.setGenericPassword("rakomi", value, {
+        service: `${servicePrefix}.${key}`,
+        accessible: opts?.keychainAccessible ?? "AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY"
+      });
+    },
+    removeItem: async (key) => {
+      await options.keychain.resetGenericPassword({ service: `${servicePrefix}.${key}` });
+    }
+  };
+  const browser = {
+    openAuthSession: async (authUrl, redirectUri, opts) => {
+      const available = await options.inAppBrowser.isAvailable();
+      if (!available) return { type: "locked" };
+      const result = await options.inAppBrowser.openAuth(authUrl, redirectUri, {
+        ephemeralWebSession: opts?.preferEphemeralSession ?? true
+      });
+      if (result.type === "success" && result.url) return { type: "success", url: result.url };
+      if (result.type === "cancel") return { type: "cancel" };
+      return { type: "dismiss" };
+    }
+  };
+  const deepLink = {
+    getInitialUrl: () => options.linking.getInitialURL(),
+    addListener: (listener) => options.linking.addEventListener("url", (e) => listener(e.url))
+  };
+  const biometric = {
+    isAvailable: async () => {
+      const sensor = await options.biometrics.isSensorAvailable();
+      return sensor.available;
+    },
+    authenticate: async ({ promptMessage }) => {
+      const result = await options.biometrics.simplePrompt({ promptMessage });
+      if (result.success) return { success: true };
+      return { success: false, reason: "cancelled" };
+    }
+  };
+  const appLifecycle = {
+    addStateChangeListener: (listener) => options.appState.addEventListener("change", listener),
+    getCurrent: () => options.appState.currentState
+  };
+  const connectivity = {
+    isConnected: async () => {
+      const state = await options.netInfo.fetch();
+      return state.isConnected === true;
+    },
+    addListener: (listener) => {
+      const unsub = options.netInfo.addEventListener((state) => listener(state.isConnected === true));
+      return { remove: unsub };
+    }
+  };
+  return {
+    crypto,
+    storage,
+    browser,
+    deepLink,
+    biometric,
+    appLifecycle,
+    connectivity
+  };
+}
+
+// src/native/dpop-prover.ts
+function createNativeDpopProver(options) {
+  const mod = options.module;
+  return {
+    async createProof(input) {
+      const proof = await mod.createDpopProof(input.htm, input.htu, input.nonce ?? null);
+      if (typeof proof !== "string" || proof.length === 0) {
+        throw new Error("native DPoP signer returned an empty proof");
+      }
+      return proof;
+    },
+    async jktHint() {
+      return mod.dpopJktThumbprint();
+    }
+  };
+}
+
+// src/native/expo-adapter.ts
+function createDefaultExpoAdapter(options = {}) {
+  const crypto = createExpoCrypto();
+  const storage = createExpoSecureStore({ tokenCache: options.tokenCache });
+  const browser = createExpoBrowser();
+  const deepLink = createExpoDeepLink();
+  const biometric = createExpoBiometricGate();
+  const appLifecycle = createRnAppLifecycle();
+  const connectivity = createNetInfoConnectivity();
+  return {
+    crypto,
+    storage,
+    browser,
+    deepLink,
+    biometric,
+    appLifecycle,
+    connectivity
+  };
+}
+function createExpoCrypto() {
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-crypto').catch(() => null);
+      if (!mod) {
+        throw new Error(
+          "@rakomi/react-native: expo-crypto is required for the default adapter. Install it (Expo-managed) or pass a custom nativeAdapter (bare RN)."
+        );
+      }
+    }
+    return mod;
+  }
+  return {
+    getRandomBytes: async (n) => {
+      const m = await load();
+      const result = await m.getRandomBytesAsync(n);
+      return new Uint8Array(result);
+    },
+    digestSha256: async (input) => {
+      const m = await load();
+      let str = "";
+      for (let i = 0; i < input.length; i++) str += String.fromCharCode(input[i]);
+      const hex = await m.digestStringAsync(
+        m.CryptoDigestAlgorithm.SHA256,
+        str,
+        { encoding: m.CryptoEncoding.HEX }
+      );
+      const bytes = new Uint8Array(hex.length / 2);
+      for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+      }
+      return bytes;
+    }
+  };
+}
+function createExpoSecureStore(opts) {
+  if (opts.tokenCache) {
+    const tc = opts.tokenCache;
+    return {
+      getItem: (key) => tc.getToken(key),
+      setItem: async (key, value) => {
+        await tc.saveToken(key, value);
+      },
+      removeItem: (key) => tc.clearToken(key)
+    };
+  }
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-secure-store').catch(() => null);
+      if (!mod) {
+        throw new Error(
+          "@rakomi/react-native: expo-secure-store is required for the default adapter. Install it (Expo-managed) or pass `tokenCache` / a custom nativeAdapter."
+        );
+      }
+    }
+    return mod;
+  }
+  return {
+    getItem: async (key, options) => {
+      const m = await load();
+      return m.getItemAsync(key, {
+        requireAuthentication: options?.requireAuthentication,
+        authenticationPrompt: options?.authenticationPrompt
+      });
+    },
+    setItem: async (key, value, options) => {
+      const m = await load();
+      const accessibility = mapKeychainAccessible(
+        m,
+        options?.keychainAccessible ?? "AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY"
+      );
+      await m.setItemAsync(key, value, {
+        keychainAccessible: accessibility,
+        requireAuthentication: options?.requireAuthentication,
+        authenticationPrompt: options?.authenticationPrompt
+      });
+    },
+    removeItem: async (key) => {
+      const m = await load();
+      await m.deleteItemAsync(key);
+    }
+  };
+}
+function mapKeychainAccessible(m, level) {
+  switch (level) {
+    case "WHEN_UNLOCKED":
+      return m.WHEN_UNLOCKED;
+    case "AFTER_FIRST_UNLOCK":
+      return m.AFTER_FIRST_UNLOCK;
+    case "WHEN_UNLOCKED_THIS_DEVICE_ONLY":
+      return m.WHEN_UNLOCKED_THIS_DEVICE_ONLY;
+    case "AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY":
+      return m.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY;
+    case "WHEN_PASSCODE_SET_THIS_DEVICE_ONLY":
+      return m.WHEN_PASSCODE_SET_THIS_DEVICE_ONLY;
+  }
+}
+function createExpoBrowser() {
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-web-browser').catch(() => null);
+      if (!mod) {
+        throw new Error("@rakomi/react-native: expo-web-browser is required for OAuth flows.");
+      }
+    }
+    return mod;
+  }
+  return {
+    openAuthSession: async (authUrl, redirectUri, options) => {
+      const m = await load();
+      const result = await m.openAuthSessionAsync(authUrl, redirectUri, {
+        preferEphemeralSession: options?.preferEphemeralSession ?? true
+      });
+      if (result.type === "success" && result.url) {
+        return { type: "success", url: result.url };
+      }
+      if (result.type === "cancel") return { type: "cancel" };
+      if (result.type === "dismiss") return { type: "dismiss" };
+      if (result.type === "locked") return { type: "locked" };
+      return { type: "cancel" };
+    }
+  };
+}
+function createExpoDeepLink() {
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-linking').catch(() => null);
+      if (!mod) {
+        throw new Error("@rakomi/react-native: expo-linking is required for OAuth deep-link callback.");
+      }
+    }
+    return mod;
+  }
+  return {
+    getInitialUrl: async () => {
+      const m = await load();
+      return m.getInitialURL();
+    },
+    addListener: (listener) => {
+      let sub = null;
+      void load().then((m) => {
+        sub = m.addEventListener("url", (event) => listener(event.url));
+      });
+      return {
+        remove: () => {
+          sub?.remove();
+        }
+      };
+    }
+  };
+}
+function createExpoBiometricGate() {
+  let mod = null;
+  async function load() {
+    if (mod !== null) return mod;
+    try {
+      mod = await import('expo-local-authentication');
+    } catch {
+      mod = null;
+    }
+    return mod;
+  }
+  return {
+    isAvailable: async () => {
+      const m = await load();
+      if (!m) return false;
+      const has = await m.hasHardwareAsync();
+      if (!has) return false;
+      const enrolled = await m.isEnrolledAsync();
+      return enrolled;
+    },
+    authenticate: async ({ promptMessage, strict = false }) => {
+      const m = await load();
+      if (!m) return { success: false, reason: "unavailable" };
+      const result = await m.authenticateAsync({
+        promptMessage,
+        disableDeviceFallback: strict,
+        fallbackLabel: "Use passcode"
+      });
+      if (result.success) return { success: true };
+      switch (result.error) {
+        case "user_cancel":
+        case "system_cancel":
+        case "app_cancel":
+          return { success: false, reason: "cancelled" };
+        case "lockout":
+        case "lockout_permanent":
+          return { success: false, reason: "lockout" };
+        case "not_enrolled":
+          return { success: false, reason: "not_enrolled" };
+        case "not_available":
+        case "no_space":
+          return { success: false, reason: "unavailable" };
+        default:
+          return { success: false, reason: "unknown" };
+      }
+    }
+  };
+}
+function createRnAppLifecycle() {
+  let rn = null;
+  let pending = null;
+  async function ensure() {
+    if (rn) return rn;
+    if (!pending) {
+      pending = import('react-native').then((m) => {
+        rn = m.default ?? m;
+        return rn;
+      });
+    }
+    return pending;
+  }
+  void ensure().catch(() => void 0);
+  return {
+    addStateChangeListener: (listener) => {
+      let sub = null;
+      void ensure().then((r) => {
+        sub = r.AppState.addEventListener("change", (next) => {
+          listener(coerceAppState(next));
+        });
+      });
+      return { remove: () => sub?.remove() };
+    },
+    getCurrent: () => rn ? coerceAppState(rn.AppState.currentState) : "unknown"
+  };
+}
+function coerceAppState(value) {
+  if (value === "active" || value === "background" || value === "inactive") return value;
+  return "unknown";
+}
+function createNetInfoConnectivity() {
+  let mod = null;
+  async function load() {
+    if (mod !== null) return mod;
+    try {
+      mod = (await import('@react-native-community/netinfo')).default ?? null;
+    } catch {
+      mod = null;
+    }
+    return mod;
+  }
+  return {
+    isConnected: async () => {
+      const m = await load();
+      if (!m) return true;
+      const state = await m.fetch();
+      return state.isConnected ?? true;
+    },
+    addListener: (listener) => {
+      let unsubscribe = null;
+      void load().then((m) => {
+        if (!m) return;
+        unsubscribe = m.addEventListener((state) => listener(state.isConnected ?? true));
+      });
+      return { remove: () => unsubscribe?.() };
+    }
+  };
+}
+
+exports.createBareRnAdapter = createBareRnAdapter;
+exports.createDefaultExpoAdapter = createDefaultExpoAdapter;
+exports.createNativeDpopProver = createNativeDpopProver;

package/dist/native/index.d.cts

@@ -0,0 +1,113 @@
+import { N as NativeAuthAdapter } from '../expo-adapter-CtPCEgue.cjs';
+export { A as AppLifecycle, n as AppStateSubscription, a as AppStateValue, b as AttestationVerifier, B as BackgroundTask, c as BiometricGate, d as BiometricResult, e as BrowserAuthSessionOptions, f as BrowserAuthSessionResult, C as ConnectivityProvider, g as CreateDefaultExpoAdapterOptions, h as CreateNativeDpopProverOptions, i as DeepLinkProvider, o as DeepLinkSubscription, j as DpopProofInput, D as DpopProver, k as NativeDpopModuleSpec, p as NetInfoSubscription, P as ParClient, S as SystemBrowser, T as TokenCache, l as createDefaultExpoAdapter, m as createNativeDpopProver } from '../expo-adapter-CtPCEgue.cjs';
+import '@rakomi/sdk-core';
+
+/**
+ * Reference implementation: bare React Native `NativeAuthAdapter`.
+ *
+ * For consumers NOT on Expo. Wires the same contract the default Expo adapter
+ * implements (`createDefaultExpoAdapter`) but using bare-RN-friendly community
+ * packages:
+ *
+ * - `react-native-keychain` for secure storage
+ * - `react-native-inappbrowser-reborn` for system browser (Custom Tabs / SFSafariViewController)
+ * - `react-native-quick-crypto` for `getRandomBytes` + `digestSha256`
+ * - `react-native/Linking` for deep-link callback ingest
+ * - `react-native-biometrics` for biometric gate
+ * - `react-native/AppState` for app-lifecycle transitions
+ * - `@react-native-community/netinfo` for connectivity
+ *
+ * **Not a default export** bare-RN consumers MUST call `createBareRnAdapter`
+ * explicitly and pass the result via `<RakomiProvider nativeAdapter={...}>`. We
+ * keep this in `src/native/` as documentation/reference; the actual implementation
+ * stubs are intentional — `NotImplementedError` thrown lines indicate where the
+ * bare-RN package import goes. Replace the throws with the real package binding.
+ *
+ * Why stubbed: bare-RN packages have install-time native code that can't be
+ * imported at SDK build time. Consumer's bundler links them at app build.
+ */
+
+interface CreateBareRnAdapterOptions {
+    /** Required injection — `react-native-quick-crypto` named exports. */
+    quickCrypto: {
+        randomBytes(length: number): Uint8Array;
+        createHash(alg: 'sha256'): {
+            update(b: Uint8Array): {
+                digest(): Uint8Array;
+            };
+        };
+    };
+    /** Required injection — `react-native-keychain` namespace. */
+    keychain: {
+        setGenericPassword(username: string, password: string, options: {
+            service: string;
+            accessible?: string;
+        }): Promise<unknown>;
+        getGenericPassword(options: {
+            service: string;
+            authenticationPrompt?: {
+                title: string;
+            };
+        }): Promise<{
+            username: string;
+            password: string;
+        } | false>;
+        resetGenericPassword(options: {
+            service: string;
+        }): Promise<boolean>;
+    };
+    /** Required injection — `react-native-inappbrowser-reborn` namespace. */
+    inAppBrowser: {
+        isAvailable(): Promise<boolean>;
+        openAuth(url: string, redirectUri: string, options?: {
+            ephemeralWebSession?: boolean;
+        }): Promise<{
+            type: 'success' | 'cancel' | 'dismiss';
+            url?: string;
+        }>;
+    };
+    /** Required injection — `react-native-biometrics` instance. */
+    biometrics: {
+        isSensorAvailable(): Promise<{
+            available: boolean;
+            biometryType?: string;
+        }>;
+        simplePrompt(options: {
+            promptMessage: string;
+            cancelButtonText?: string;
+        }): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+    };
+    /** Required injection — `react-native/Linking` namespace. */
+    linking: {
+        getInitialURL(): Promise<string | null>;
+        addEventListener(event: 'url', handler: (e: {
+            url: string;
+        }) => void): {
+            remove(): void;
+        };
+    };
+    /** Required injection — `react-native/AppState` namespace. */
+    appState: {
+        currentState: 'active' | 'background' | 'inactive' | 'unknown';
+        addEventListener(event: 'change', handler: (state: 'active' | 'background' | 'inactive' | 'unknown') => void): {
+            remove(): void;
+        };
+    };
+    /** Required injection — `@react-native-community/netinfo` namespace. */
+    netInfo: {
+        fetch(): Promise<{
+            isConnected: boolean | null;
+        }>;
+        addEventListener(handler: (state: {
+            isConnected: boolean | null;
+        }) => void): () => void;
+    };
+    /** Tenant-scoped Keychain service prefix. Default `'rakomi'`. */
+    keychainServicePrefix?: string;
+}
+declare function createBareRnAdapter(options: CreateBareRnAdapterOptions): NativeAuthAdapter;
+
+export { type CreateBareRnAdapterOptions, NativeAuthAdapter, createBareRnAdapter };

package/dist/native/index.d.ts

@@ -0,0 +1,113 @@
+import { N as NativeAuthAdapter } from '../expo-adapter-CtPCEgue.js';
+export { A as AppLifecycle, n as AppStateSubscription, a as AppStateValue, b as AttestationVerifier, B as BackgroundTask, c as BiometricGate, d as BiometricResult, e as BrowserAuthSessionOptions, f as BrowserAuthSessionResult, C as ConnectivityProvider, g as CreateDefaultExpoAdapterOptions, h as CreateNativeDpopProverOptions, i as DeepLinkProvider, o as DeepLinkSubscription, j as DpopProofInput, D as DpopProver, k as NativeDpopModuleSpec, p as NetInfoSubscription, P as ParClient, S as SystemBrowser, T as TokenCache, l as createDefaultExpoAdapter, m as createNativeDpopProver } from '../expo-adapter-CtPCEgue.js';
+import '@rakomi/sdk-core';
+
+/**
+ * Reference implementation: bare React Native `NativeAuthAdapter`.
+ *
+ * For consumers NOT on Expo. Wires the same contract the default Expo adapter
+ * implements (`createDefaultExpoAdapter`) but using bare-RN-friendly community
+ * packages:
+ *
+ * - `react-native-keychain` for secure storage
+ * - `react-native-inappbrowser-reborn` for system browser (Custom Tabs / SFSafariViewController)
+ * - `react-native-quick-crypto` for `getRandomBytes` + `digestSha256`
+ * - `react-native/Linking` for deep-link callback ingest
+ * - `react-native-biometrics` for biometric gate
+ * - `react-native/AppState` for app-lifecycle transitions
+ * - `@react-native-community/netinfo` for connectivity
+ *
+ * **Not a default export** bare-RN consumers MUST call `createBareRnAdapter`
+ * explicitly and pass the result via `<RakomiProvider nativeAdapter={...}>`. We
+ * keep this in `src/native/` as documentation/reference; the actual implementation
+ * stubs are intentional — `NotImplementedError` thrown lines indicate where the
+ * bare-RN package import goes. Replace the throws with the real package binding.
+ *
+ * Why stubbed: bare-RN packages have install-time native code that can't be
+ * imported at SDK build time. Consumer's bundler links them at app build.
+ */
+
+interface CreateBareRnAdapterOptions {
+    /** Required injection — `react-native-quick-crypto` named exports. */
+    quickCrypto: {
+        randomBytes(length: number): Uint8Array;
+        createHash(alg: 'sha256'): {
+            update(b: Uint8Array): {
+                digest(): Uint8Array;
+            };
+        };
+    };
+    /** Required injection — `react-native-keychain` namespace. */
+    keychain: {
+        setGenericPassword(username: string, password: string, options: {
+            service: string;
+            accessible?: string;
+        }): Promise<unknown>;
+        getGenericPassword(options: {
+            service: string;
+            authenticationPrompt?: {
+                title: string;
+            };
+        }): Promise<{
+            username: string;
+            password: string;
+        } | false>;
+        resetGenericPassword(options: {
+            service: string;
+        }): Promise<boolean>;
+    };
+    /** Required injection — `react-native-inappbrowser-reborn` namespace. */
+    inAppBrowser: {
+        isAvailable(): Promise<boolean>;
+        openAuth(url: string, redirectUri: string, options?: {
+            ephemeralWebSession?: boolean;
+        }): Promise<{
+            type: 'success' | 'cancel' | 'dismiss';
+            url?: string;
+        }>;
+    };
+    /** Required injection — `react-native-biometrics` instance. */
+    biometrics: {
+        isSensorAvailable(): Promise<{
+            available: boolean;
+            biometryType?: string;
+        }>;
+        simplePrompt(options: {
+            promptMessage: string;
+            cancelButtonText?: string;
+        }): Promise<{
+            success: boolean;
+            error?: string;
+        }>;
+    };
+    /** Required injection — `react-native/Linking` namespace. */
+    linking: {
+        getInitialURL(): Promise<string | null>;
+        addEventListener(event: 'url', handler: (e: {
+            url: string;
+        }) => void): {
+            remove(): void;
+        };
+    };
+    /** Required injection — `react-native/AppState` namespace. */
+    appState: {
+        currentState: 'active' | 'background' | 'inactive' | 'unknown';
+        addEventListener(event: 'change', handler: (state: 'active' | 'background' | 'inactive' | 'unknown') => void): {
+            remove(): void;
+        };
+    };
+    /** Required injection — `@react-native-community/netinfo` namespace. */
+    netInfo: {
+        fetch(): Promise<{
+            isConnected: boolean | null;
+        }>;
+        addEventListener(handler: (state: {
+            isConnected: boolean | null;
+        }) => void): () => void;
+    };
+    /** Tenant-scoped Keychain service prefix. Default `'rakomi'`. */
+    keychainServicePrefix?: string;
+}
+declare function createBareRnAdapter(options: CreateBareRnAdapterOptions): NativeAuthAdapter;
+
+export { type CreateBareRnAdapterOptions, NativeAuthAdapter, createBareRnAdapter };