@hawcx/react-native-sdk 1.0.1 → 1.0.2

package/src/__tests__/index.test.ts

@@ -2,6 +2,7 @@ import {
   initialize,
   authenticate,
   submitOtp,
+  storeBackendOAuthTokens,
   webLogin,
   webApprove,
   approvePushRequest,
@@ -11,7 +12,7 @@ import {
   HawcxAuthError,
   __INTERNAL_EVENTS__,
 } from '../index';
-import { Platform } from 'react-native';
+import { NativeModules, Platform } from 'react-native';
 
 const ORIGINAL_PLATFORM = Platform.OS;
 
@@ -114,6 +115,22 @@ describe('HawcxClient helpers', () => {
     });
   });
 
+  it('invokes authorization code callback', async () => {
+    const onAuthorizationCode = jest.fn();
+    client.authenticate('user@example.com', { onAuthorizationCode });
+    const payload = { code: 'abc', expiresIn: 30 };
+    emitAuth({ type: 'authorization_code', payload });
+    expect(onAuthorizationCode).toHaveBeenCalledWith(payload);
+  });
+
+  it('invokes additional verification callback', async () => {
+    const onAdditionalVerificationRequired = jest.fn();
+    client.authenticate('user@example.com', { onAdditionalVerificationRequired });
+    const payload = { sessionId: 'sid', detail: 'extra' };
+    emitAuth({ type: 'additional_verification_required', payload });
+    expect(onAdditionalVerificationRequired).toHaveBeenCalledWith(payload);
+  });
+
   it('invokes push event handlers', async () => {
     const handler = jest.fn();
     const subscription = client.addPushListener(handler);
@@ -161,3 +178,25 @@ describe('push token helpers', () => {
     );
   });
 });
+
+describe('storeBackendOAuthTokens helper', () => {
+  const bridge = NativeModules.HawcxReactNative.storeBackendOAuthTokens as jest.Mock;
+
+  beforeEach(() => {
+    bridge.mockResolvedValue(true);
+  });
+
+  it('calls native bridge with trimmed values', async () => {
+    await storeBackendOAuthTokens(' user@example.com ', ' token ', ' refresh ');
+    expect(bridge).toHaveBeenCalledWith('user@example.com', 'token', 'refresh');
+  });
+
+  it('passes null refresh token when omitted', async () => {
+    await storeBackendOAuthTokens('user@example.com', 'token');
+    expect(bridge).toHaveBeenCalledWith('user@example.com', 'token', null);
+  });
+
+  it('rejects when userId empty', async () => {
+    await expect(storeBackendOAuthTokens('   ', 'token')).rejects.toThrow('userId is required');
+  });
+});

package/src/index.ts

@@ -33,6 +33,21 @@ export type AuthSuccessPayload = {
   isLoginFlow: boolean;
 };
 
+export type AuthorizationCodePayload = {
+  code: string;
+  expiresIn?: number;
+};
+
+export type AdditionalVerificationPayload = {
+  sessionId: string;
+  detail?: string;
+};
+
+export type BackendOAuthTokens = {
+  accessToken: string;
+  refreshToken?: string;
+};
+
 export type AuthErrorPayload = {
   code: string;
   message: string;
@@ -41,6 +56,8 @@ export type AuthErrorPayload = {
 export type AuthEvent =
   | { type: 'otp_required' }
   | { type: 'auth_success'; payload: AuthSuccessPayload }
+  | { type: 'authorization_code'; payload: AuthorizationCodePayload }
+  | { type: 'additional_verification_required'; payload: AdditionalVerificationPayload }
   | { type: 'auth_error'; payload: AuthErrorPayload };
 
 export type SessionEvent =
@@ -63,6 +80,11 @@ type NativeBridge = {
   initialize(config: HawcxInitializeConfig): Promise<void>;
   authenticate(userId: string): Promise<void>;
   submitOtp(otp: string): Promise<void>;
+  storeBackendOAuthTokens(
+    userId: string,
+    accessToken: string,
+    refreshToken?: string | null,
+  ): Promise<boolean>;
   getDeviceDetails(): Promise<void>;
   webLogin(pin: string): Promise<void>;
   webApprove(token: string): Promise<void>;
@@ -127,6 +149,25 @@ export function submitOtp(otp: string): Promise<void> {
   }
 }
 
+export function storeBackendOAuthTokens(
+  userId: string,
+  accessToken: string,
+  refreshToken?: string,
+): Promise<void> {
+  try {
+    const trimmedUser = ensureNonEmpty(userId, 'userId');
+    const trimmedAccess = ensureNonEmpty(accessToken, 'accessToken');
+    const trimmedRefresh = refreshToken?.trim();
+    return HawcxReactNative.storeBackendOAuthTokens(
+      trimmedUser,
+      trimmedAccess,
+      trimmedRefresh && trimmedRefresh.length > 0 ? trimmedRefresh : null,
+    ).then(() => undefined);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+
 export function getDeviceDetails(): Promise<void> {
   return HawcxReactNative.getDeviceDetails();
 }
@@ -244,6 +285,8 @@ export class HawcxAuthError extends Error {
 
 export type HawcxAuthOptions = {
   onOtpRequired?: () => void;
+  onAuthorizationCode?: (payload: AuthorizationCodePayload) => void;
+  onAdditionalVerificationRequired?: (payload: AdditionalVerificationPayload) => void;
   onEvent?: (event: AuthEvent) => void;
 };
 
@@ -280,6 +323,12 @@ export class HawcxClient {
           case 'otp_required':
             options?.onOtpRequired?.();
             break;
+          case 'authorization_code':
+            options?.onAuthorizationCode?.(event.payload);
+            break;
+          case 'additional_verification_required':
+            options?.onAdditionalVerificationRequired?.(event.payload);
+            break;
           case 'auth_success':
             cleanup();
             resolve(event.payload);
@@ -387,6 +436,10 @@ export class HawcxClient {
   addPushListener(handler: (event: PushEvent) => void): EmitterSubscription {
     return addPushListener(handler);
   }
+
+  storeBackendOAuthTokens(userId: string, tokens: BackendOAuthTokens): Promise<void> {
+    return storeBackendOAuthTokens(userId, tokens.accessToken, tokens.refreshToken);
+  }
 }
 
 export const hawcxClient = new HawcxClient();
@@ -395,6 +448,8 @@ export type HawcxAuthHookState =
   | { status: 'idle' }
   | { status: 'pending' }
   | { status: 'otp'; attempts: number }
+  | { status: 'authorization_code'; payload: AuthorizationCodePayload }
+  | { status: 'additional_verification_required'; payload: AdditionalVerificationPayload }
   | { status: 'success'; result: AuthSuccessPayload }
   | { status: 'error'; error: AuthErrorPayload };
 
@@ -415,6 +470,17 @@ export function useHawcxAuth(client: HawcxClient = hawcxClient) {
           otpAttempts.current += 1;
           setState({ status: 'otp', attempts: otpAttempts.current });
           break;
+        case 'authorization_code':
+          otpAttempts.current = 0;
+          setState({ status: 'authorization_code', payload: event.payload });
+          break;
+        case 'additional_verification_required':
+          otpAttempts.current = 0;
+          setState({
+            status: 'additional_verification_required',
+            payload: event.payload,
+          });
+          break;
         case 'auth_success':
           otpAttempts.current = 0;
           setState({ status: 'success', result: event.payload });