@hawcx/react-native-sdk 1.0.8 → 1.1.1

package/src/index.ts

@@ -6,6 +6,55 @@ import {
   NativeModule,
 } from 'react-native';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { normalizeV6FlowEvent } from './v6Normalization';
+import {
+  canHawcxV6Resend,
+  createIdentifierHawcxV6AuthState,
+  createInitialHawcxV6AuthState,
+  getHawcxV6ResendAvailability,
+  normalizeHawcxV6FlowType,
+  refreshHawcxV6AuthState,
+  reduceHawcxV6FlowEvent,
+} from './v6State';
+import type {
+  HawcxV6AuthState,
+  HawcxV6FlowEvent,
+  HawcxV6FlowType,
+  HawcxV6StartOptions,
+} from './v6Types';
+import { routeWebLoginScan, type HawcxV6QrApprovalResult } from './v6WebLogin';
+
+export type {
+  HawcxV6AwaitApprovalPrompt,
+  HawcxV6AuthState,
+  HawcxV6AuthStatus,
+  HawcxV6CompletedPayload,
+  HawcxV6EnterCodePrompt,
+  HawcxV6EnterTotpPrompt,
+  HawcxV6ErrorAction,
+  HawcxV6ErrorDetails,
+  HawcxV6ErrorPayload,
+  HawcxV6FieldError,
+  HawcxV6FlowEvent,
+  HawcxV6FlowType,
+  HawcxV6Method,
+  HawcxV6PromptPayload,
+  HawcxV6RedirectPrompt,
+  HawcxV6ResendAvailability,
+  HawcxV6RiskInfo,
+  HawcxV6RiskLocation,
+  HawcxV6SelectMethodPrompt,
+  HawcxV6SetupSmsPrompt,
+  HawcxV6SetupTotpPrompt,
+  HawcxV6StartOptions,
+  HawcxV6StepInfo,
+} from './v6Types';
+export type {
+  HawcxV6QrApprovalResult,
+  HawcxV6QrPayload,
+  HawcxV6QrPayloadType,
+  HawcxWebLoginScanRoute,
+} from './v6WebLogin';
 
 const LINKING_ERROR = [
   "The package '@hawcx/react-native-sdk' doesn't seem to be linked.",
@@ -16,6 +65,7 @@ const LINKING_ERROR = [
 const AUTH_EVENT = 'hawcx.auth.event';
 const SESSION_EVENT = 'hawcx.session.event';
 const PUSH_EVENT = 'hawcx.push.event';
+const V6_FLOW_EVENT = 'hawcx.v6.flow.event';
 
 export type HawcxInitializeConfig = {
   projectApiKey: string;
@@ -29,6 +79,8 @@ export type HawcxInitializeConfig = {
     publicKeyPem: string;
     tokenEndpoint: string;
   };
+  relyingParty?: string;
+  autoPollApprovals?: boolean;
   /**
    * @deprecated Use root-level `baseUrl` instead. Kept for backward compatibility during migration.
    */
@@ -86,15 +138,56 @@ export type PushEvent =
   | { type: 'push_login_request'; payload: PushLoginPayload }
   | { type: 'push_error'; payload: AuthErrorPayload };
 
+export type HawcxV6QrApprovalOptions = {
+  rememberDevice?: boolean;
+};
+
+export type HawcxV6AuthHookResult = {
+  state: HawcxV6AuthState;
+  start: (options: HawcxV6StartOptions) => Promise<void>;
+  selectMethod: (methodId: string) => Promise<void>;
+  submitCode: (code: string) => Promise<void>;
+  submitTotp: (code: string) => Promise<void>;
+  submitPhone: (phone: string) => Promise<void>;
+  resend: () => Promise<boolean>;
+  poll: () => Promise<void>;
+  cancel: () => Promise<void>;
+  changeIdentifier: () => Promise<void>;
+  reset: () => Promise<void>;
+  handleRedirectUrl: (url: string) => Promise<void>;
+  canResend: boolean;
+  resendAvailability: HawcxV6AuthState['resend'];
+  secondsUntilResend?: number;
+};
+
 type NativeBridge = {
   initialize(config: HawcxInitializeConfig): Promise<void>;
   authenticate(userId: string): Promise<void>;
   submitOtp(otp: string): Promise<void>;
+  v6Start(options: HawcxV6StartOptions): Promise<void>;
+  v6SelectMethod(methodId: string): Promise<void>;
+  v6SubmitCode(code: string): Promise<void>;
+  v6SubmitTotp(code: string): Promise<void>;
+  v6SubmitPhone(phone: string): Promise<void>;
+  v6Resend(): Promise<boolean>;
+  v6Poll(): Promise<void>;
+  v6Cancel(): Promise<void>;
+  v6Reset(): Promise<void>;
+  v6ApproveQr(
+    rawPayload: string,
+    identifier: string,
+    rememberDevice: boolean,
+  ): Promise<Record<string, unknown>>;
+  v6HandleRedirectUrl(url: string): Promise<void>;
   storeBackendOAuthTokens(
     userId: string,
     accessToken: string,
     refreshToken?: string | null,
   ): Promise<boolean>;
+  getLastLoggedInUser(): Promise<string>;
+  clearSessionTokens(userId: string): Promise<void>;
+  clearUserKeychainData(userId: string): Promise<void>;
+  clearLastLoggedInUser(): Promise<void>;
   getDeviceDetails(): Promise<void>;
   webLogin(pin: string): Promise<void>;
   webApprove(token: string): Promise<void>;
@@ -119,6 +212,7 @@ const HawcxReactNative = HawcxReactNativeModule;
 const authEventEmitter = new NativeEventEmitter(HawcxReactNativeModule);
 const sessionEventEmitter = new NativeEventEmitter(HawcxReactNativeModule);
 const pushEventEmitter = new NativeEventEmitter(HawcxReactNativeModule);
+const v6FlowEventEmitter = new NativeEventEmitter(HawcxReactNativeModule);
 
 const isIOS = () => Platform.OS === 'ios';
 const isAndroid = () => Platform.OS === 'android';
@@ -166,6 +260,119 @@ export function submitOtp(otp: string): Promise<void> {
   }
 }
 
+export function startV6Flow(options: HawcxV6StartOptions): Promise<void> {
+  try {
+    const identifier = ensureNonEmpty(options.identifier, 'identifier');
+    return HawcxReactNative.v6Start({
+      ...options,
+      identifier,
+      flowType: normalizeHawcxV6FlowType(options.flowType),
+      startToken: options.startToken?.trim() || undefined,
+      inviteCode: options.inviteCode?.trim() || undefined,
+      codeChallenge: options.codeChallenge?.trim() || undefined,
+    });
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function v6SelectMethod(methodId: string): Promise<void> {
+  try {
+    return HawcxReactNative.v6SelectMethod(ensureNonEmpty(methodId, 'methodId'));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function v6SubmitCode(code: string): Promise<void> {
+  try {
+    return HawcxReactNative.v6SubmitCode(ensureNonEmpty(code, 'code'));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function v6SubmitTotp(code: string): Promise<void> {
+  try {
+    return HawcxReactNative.v6SubmitTotp(ensureNonEmpty(code, 'code'));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function v6SubmitPhone(phone: string): Promise<void> {
+  try {
+    return HawcxReactNative.v6SubmitPhone(ensureNonEmpty(phone, 'phone'));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function v6Resend(): Promise<boolean> {
+  return HawcxReactNative.v6Resend();
+}
+
+export function v6Poll(): Promise<void> {
+  return HawcxReactNative.v6Poll();
+}
+
+export function v6Cancel(): Promise<void> {
+  return HawcxReactNative.v6Cancel();
+}
+
+export function v6Reset(): Promise<void> {
+  return HawcxReactNative.v6Reset();
+}
+
+const normalizeV6QrApprovalResult = (value: unknown): HawcxV6QrApprovalResult => {
+  const record =
+    typeof value === 'object' && value !== null && !Array.isArray(value)
+      ? (value as Record<string, unknown>)
+      : null;
+  const outcome = record?.outcome;
+  const payloadType = record?.payloadType;
+
+  if (outcome === 'approved' && (payloadType === 'qr_auth' || payloadType === 'qr_login')) {
+    return {
+      outcome,
+      payloadType,
+    };
+  }
+
+  if (outcome === 'bound' && (payloadType === 'qr_auth' || payloadType === 'qr_login')) {
+    return {
+      outcome,
+      payloadType,
+      userId: typeof record?.userId === 'string' ? record.userId : undefined,
+    };
+  }
+
+  throw new Error('Invalid V6 QR approval response from native bridge');
+};
+
+export async function approveV6Qr(
+  rawPayload: string,
+  identifier: string,
+  options: HawcxV6QrApprovalOptions = {},
+): Promise<HawcxV6QrApprovalResult> {
+  const trimmedPayload = ensureNonEmpty(rawPayload, 'rawPayload');
+  const trimmedIdentifier = ensureNonEmpty(identifier, 'identifier');
+  const result = await HawcxReactNative.v6ApproveQr(
+    trimmedPayload,
+    trimmedIdentifier,
+    options.rememberDevice ?? false,
+  );
+  return normalizeV6QrApprovalResult(result);
+}
+
+export function v6HandleRedirectUrl(url: string): Promise<void> {
+  try {
+    return HawcxReactNative.v6HandleRedirectUrl(ensureNonEmpty(url, 'url'));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
 export function storeBackendOAuthTokens(
   userId: string,
   accessToken: string,
@@ -272,10 +479,51 @@ export function addAuthListener(handler: (event: AuthEvent) => void): EmitterSub
   return authEventEmitter.addListener(AUTH_EVENT, handler);
 }
 
+export function addV6FlowListener(handler: (event: HawcxV6FlowEvent) => void): EmitterSubscription {
+  return v6FlowEventEmitter.addListener(V6_FLOW_EVENT, (rawEvent: unknown) => {
+    const normalized = normalizeV6FlowEvent(rawEvent);
+    if (normalized) {
+      handler(normalized);
+    }
+  });
+}
+
+export const addHawcxV6FlowListener = addV6FlowListener;
+export const startHawcxV6Flow = startV6Flow;
+export const handleHawcxV6RedirectUrl = v6HandleRedirectUrl;
+export { canHawcxV6Resend, getHawcxV6ResendAvailability };
+export { routeWebLoginScan };
+
+export async function getLastLoggedInUser(): Promise<string> {
+  const userId = await HawcxReactNative.getLastLoggedInUser();
+  return typeof userId === 'string' ? userId : '';
+}
+
+export function logoutSession(userId: string): Promise<void> {
+  try {
+    return HawcxReactNative.clearSessionTokens(ensureNonEmpty(userId, 'userId'));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function forgetTrustedDevice(userId: string): Promise<void> {
+  try {
+    return HawcxReactNative.clearUserKeychainData(ensureNonEmpty(userId, 'userId'));
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
+export function clearLastLoggedInUser(): Promise<void> {
+  return HawcxReactNative.clearLastLoggedInUser();
+}
+
 export function removeAllListeners(): void {
   authEventEmitter.removeAllListeners(AUTH_EVENT);
   sessionEventEmitter.removeAllListeners(SESSION_EVENT);
   pushEventEmitter.removeAllListeners(PUSH_EVENT);
+  v6FlowEventEmitter.removeAllListeners(V6_FLOW_EVENT);
 }
 
 export function addSessionListener(handler: (event: SessionEvent) => void): EmitterSubscription {
@@ -457,10 +705,120 @@ export class HawcxClient {
   storeBackendOAuthTokens(userId: string, tokens: BackendOAuthTokens): Promise<void> {
     return storeBackendOAuthTokens(userId, tokens.accessToken, tokens.refreshToken);
   }
+
+  getLastLoggedInUser(): Promise<string> {
+    return getLastLoggedInUser();
+  }
+
+  logoutSession(userId: string): Promise<void> {
+    return logoutSession(userId);
+  }
+
+  forgetTrustedDevice(userId: string): Promise<void> {
+    return forgetTrustedDevice(userId);
+  }
+
+  clearLastLoggedInUser(): Promise<void> {
+    return clearLastLoggedInUser();
+  }
 }
 
 export const hawcxClient = new HawcxClient();
 
+export type HawcxV6HookOptions = {
+  flowType?: HawcxV6FlowType;
+  now?: () => number;
+  resendTickMs?: number;
+};
+
+export class HawcxV6Client {
+  initialize(config: HawcxInitializeConfig): Promise<void> {
+    return initialize(config);
+  }
+
+  start(options: HawcxV6StartOptions): Promise<void> {
+    return startV6Flow(options);
+  }
+
+  selectMethod(methodId: string): Promise<void> {
+    return v6SelectMethod(methodId);
+  }
+
+  submitCode(code: string): Promise<void> {
+    return v6SubmitCode(code);
+  }
+
+  submitTotp(code: string): Promise<void> {
+    return v6SubmitTotp(code);
+  }
+
+  submitPhone(phone: string): Promise<void> {
+    return v6SubmitPhone(phone);
+  }
+
+  resend(): Promise<boolean> {
+    return v6Resend();
+  }
+
+  poll(): Promise<void> {
+    return v6Poll();
+  }
+
+  cancel(): Promise<void> {
+    return v6Cancel();
+  }
+
+  reset(): Promise<void> {
+    return v6Reset();
+  }
+
+  approveQr(
+    rawPayload: string,
+    identifier: string,
+    options?: HawcxV6QrApprovalOptions,
+  ): Promise<HawcxV6QrApprovalResult> {
+    return approveV6Qr(rawPayload, identifier, options);
+  }
+
+  changeIdentifier(): Promise<void> {
+    return v6Reset();
+  }
+
+  handleRedirectUrl(url: string): Promise<void> {
+    return v6HandleRedirectUrl(url);
+  }
+
+  addFlowListener(handler: (event: HawcxV6FlowEvent) => void): EmitterSubscription {
+    return addV6FlowListener(handler);
+  }
+
+  storeBackendOAuthTokens(userId: string, tokens: BackendOAuthTokens): Promise<void> {
+    return storeBackendOAuthTokens(userId, tokens.accessToken, tokens.refreshToken);
+  }
+
+  notifyUserAuthenticated(): Promise<void> {
+    return notifyUserAuthenticated();
+  }
+
+  getLastLoggedInUser(): Promise<string> {
+    return getLastLoggedInUser();
+  }
+
+  logoutSession(userId: string): Promise<void> {
+    return logoutSession(userId);
+  }
+
+  forgetTrustedDevice(userId: string): Promise<void> {
+    return forgetTrustedDevice(userId);
+  }
+
+  clearLastLoggedInUser(): Promise<void> {
+    return clearLastLoggedInUser();
+  }
+}
+
+export const hawcxV6Client = new HawcxV6Client();
+
 export type HawcxAuthHookState =
   | { status: 'idle' }
   | { status: 'pending' }
@@ -476,6 +834,123 @@ export type HawcxWebSessionState =
   | { status: 'success' }
   | { status: 'error'; error: AuthErrorPayload };
 
+export function useHawcxV6Auth(
+  client: HawcxV6Client = hawcxV6Client,
+  options: HawcxV6HookOptions = {},
+): HawcxV6AuthHookResult {
+  const now = options.now ?? Date.now;
+  const resendTickMs = Math.max(250, options.resendTickMs ?? 1000);
+  const [state, setState] = useState<HawcxV6AuthState>(() =>
+    createInitialHawcxV6AuthState(options.flowType),
+  );
+
+  useEffect(() => {
+    const subscription = client.addFlowListener((event) => {
+      setState((previous) => reduceHawcxV6FlowEvent(event, previous, now()));
+    });
+
+    return () => {
+      subscription.remove();
+    };
+  }, [client, now]);
+
+  useEffect(() => {
+    if (!state.resend.resendAt || state.resend.canResend) {
+      return;
+    }
+
+    const intervalId = setInterval(() => {
+      setState((previous) => refreshHawcxV6AuthState(previous, now()));
+    }, resendTickMs);
+
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [now, resendTickMs, state.resend.canResend, state.resend.resendAt]);
+
+  const start = useCallback(
+    (startOptions: HawcxV6StartOptions) => {
+      const identifier = ensureNonEmpty(startOptions.identifier, 'identifier');
+      const flowType = normalizeHawcxV6FlowType(startOptions.flowType ?? options.flowType);
+
+      setState((previous) =>
+        createIdentifierHawcxV6AuthState({
+          previous,
+          identifier,
+          flowType,
+        }),
+      );
+
+      return client.start({
+        ...startOptions,
+        identifier,
+        flowType,
+      });
+    },
+    [client, options.flowType],
+  );
+
+  const selectMethod = useCallback((methodId: string) => client.selectMethod(methodId), [client]);
+
+  const submitCode = useCallback((code: string) => client.submitCode(code), [client]);
+
+  const submitTotp = useCallback((code: string) => client.submitTotp(code), [client]);
+
+  const submitPhone = useCallback((phone: string) => client.submitPhone(phone), [client]);
+
+  const resend = useCallback(() => client.resend(), [client]);
+  const poll = useCallback(() => client.poll(), [client]);
+
+  const cancel = useCallback(async () => {
+    await client.cancel();
+    setState((previous) =>
+      createIdentifierHawcxV6AuthState({
+        previous,
+        identifier: previous.identifier,
+      }),
+    );
+  }, [client]);
+
+  const reset = useCallback(async () => {
+    await client.reset();
+    setState((previous) =>
+      createIdentifierHawcxV6AuthState({
+        previous,
+        identifier: previous.identifier,
+      }),
+    );
+  }, [client]);
+
+  const changeIdentifier = useCallback(async () => {
+    await client.changeIdentifier();
+    setState((previous) =>
+      createIdentifierHawcxV6AuthState({
+        previous,
+      }),
+    );
+  }, [client]);
+
+  const handleRedirectUrl = useCallback((url: string) => client.handleRedirectUrl(url), [client]);
+
+  return {
+    state,
+    start,
+    selectMethod,
+    submitCode,
+    submitTotp,
+    submitPhone,
+    resend,
+    poll,
+    cancel,
+    changeIdentifier,
+    reset,
+    handleRedirectUrl,
+    canResend: state.resend.canResend,
+    resendAvailability: state.resend,
+    secondsUntilResend: state.resend.secondsUntilResend,
+  };
+}
+
 export function useHawcxAuth(client: HawcxClient = hawcxClient) {
   const [state, setState] = useState<HawcxAuthHookState>({ status: 'idle' });
   const otpAttempts = useRef(0);
@@ -547,9 +1022,11 @@ export const __INTERNAL_EVENTS__ = {
   authEmitter: authEventEmitter,
   sessionEmitter: sessionEventEmitter,
   pushEmitter: pushEventEmitter,
+  v6FlowEmitter: v6FlowEventEmitter,
   authEventName: AUTH_EVENT,
   sessionEventName: SESSION_EVENT,
   pushEventName: PUSH_EVENT,
+  v6FlowEventName: V6_FLOW_EVENT,
 };
 
 export function useHawcxWebLogin(client: HawcxClient = hawcxClient) {