@explorins/pers-sdk-react-native 1.3.2 → 1.5.2

package/src/providers/react-native-auth-provider.ts

@@ -1,26 +1,12 @@
 import type { PersAuthProvider } from '@explorins/pers-sdk/core';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
-/**
- * Storage strategy for different types of data
- */
-export enum StorageStrategy {
-  /** Use AsyncStorage for general app data */
-  ASYNC_STORAGE = 'async_storage',
-  /** Use Keychain for sensitive tokens (when available) */
-  KEYCHAIN = 'keychain',
-  /** Use in-memory storage (fallback) */
-  MEMORY = 'memory'
-}
-
 /**
  * Configuration options for React Native Auth Provider
  */
 export interface ReactNativeAuthConfig {
-  /** Storage strategy for access tokens */
-  accessTokenStrategy?: StorageStrategy;
-  /** Storage strategy for refresh tokens */
-  refreshTokenStrategy?: StorageStrategy;
+  /** Use secure storage (Keychain) for tokens when available */
+  useSecureStorage?: boolean;
   /** Custom key prefix for storage */
   keyPrefix?: string;
   /** Enable debug logging */
@@ -28,26 +14,21 @@ export interface ReactNativeAuthConfig {
 }
 
 /**
- * Base React Native Authentication Provider
- * 
- * This serves as a blueprint for native implementations and can be extended
- * by consuming applications to integrate with their specific auth systems.
+ * React Native Authentication Provider
  * 
- * Features:
- * - Multiple storage strategies (AsyncStorage, Keychain, Memory)
- * - Configurable security levels per token type
- * - Cross-platform compatibility (iOS/Android/Web)
- * - Blueprint for native iOS/Android implementations
+ * Simple, unified implementation for React Native apps with:
+ * - AsyncStorage for basic token storage
+ * - Keychain integration for secure storage (when available)
+ * - Automatic fallback to AsyncStorage if Keychain is unavailable
+ * - Cross-platform compatibility (iOS/Android/Expo)
  */
-export abstract class BaseReactNativeAuthProvider implements PersAuthProvider {
-  abstract readonly authType: 'admin' | 'user';
-  abstract getProjectKey(): Promise<string | null>;
-  abstract onTokenExpired(): Promise<void>;
-
-  protected readonly config: Required<ReactNativeAuthConfig>;
-  protected readonly ACCESS_TOKEN_KEY: string;
-  protected readonly REFRESH_TOKEN_KEY: string;
-  protected readonly PROJECT_KEY_KEY: string;
+export class ReactNativeAuthProvider implements PersAuthProvider {
+  readonly authType: 'user' = 'user';
+  
+  private readonly config: Required<ReactNativeAuthConfig>;
+  private readonly ACCESS_TOKEN_KEY: string;
+  private readonly REFRESH_TOKEN_KEY: string;
+  private readonly projectKey: string;
   
   // In-memory fallback storage
   private memoryStorage: Map<string, string> = new Map();
@@ -56,15 +37,15 @@ export abstract class BaseReactNativeAuthProvider implements PersAuthProvider {
     projectKey: string,
     config: ReactNativeAuthConfig = {}
   ) {
-    // Validate projectKey
     if (!projectKey || typeof projectKey !== 'string') {
       throw new Error('ReactNativeAuthProvider: projectKey is required and must be a string');
     }
 
+    this.projectKey = projectKey;
+    
     // Set default configuration
     this.config = {
-      accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
-      refreshTokenStrategy: StorageStrategy.KEYCHAIN,
+      useSecureStorage: true, // Default to secure storage when available
       keyPrefix: `pers_${projectKey.slice(0, 8)}`,
       debug: false,
       ...config
@@ -73,168 +54,116 @@ export abstract class BaseReactNativeAuthProvider implements PersAuthProvider {
     // Create storage keys
     this.ACCESS_TOKEN_KEY = `${this.config.keyPrefix}_access_token`;
     this.REFRESH_TOKEN_KEY = `${this.config.keyPrefix}_refresh_token`;
-    this.PROJECT_KEY_KEY = `${this.config.keyPrefix}_project_key`;
 
     if (this.config.debug) {
-      console.log('🔧 ReactNativeAuthProvider initialized with config:', this.config);
+      console.log('ReactNativeAuthProvider initialized:', { 
+        projectKey: projectKey.slice(0, 8) + '...', 
+        useSecureStorage: this.config.useSecureStorage 
+      });
     }
   }
 
-  // Core token management methods
+  async getProjectKey(): Promise<string | null> {
+    return this.projectKey;
+  }
+
   async getToken(): Promise<string | null> {
-    return this.getStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy);
+    return this.getStoredValue(this.ACCESS_TOKEN_KEY);
   }
 
   async setAccessToken(token: string): Promise<void> {
-    await this.storeValue(this.ACCESS_TOKEN_KEY, token, this.config.accessTokenStrategy);
+    await this.storeValue(this.ACCESS_TOKEN_KEY, token);
     if (this.config.debug) {
-      console.log('✅ Access token stored securely');
+      console.log('Access token stored securely');
     }
   }
 
   async setRefreshToken(token: string): Promise<void> {
-    await this.storeValue(this.REFRESH_TOKEN_KEY, token, this.config.refreshTokenStrategy);
+    await this.storeValue(this.REFRESH_TOKEN_KEY, token);
     if (this.config.debug) {
-      console.log('✅ Refresh token stored securely');
+      console.log('Refresh token stored securely');
     }
   }
 
   async getRefreshToken(): Promise<string | null> {
-    return this.getStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy);
+    return this.getStoredValue(this.REFRESH_TOKEN_KEY);
   }
 
   async clearTokens(): Promise<void> {
     await Promise.all([
-      this.removeStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy),
-      this.removeStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy)
+      this.removeStoredValue(this.ACCESS_TOKEN_KEY),
+      this.removeStoredValue(this.REFRESH_TOKEN_KEY)
     ]);
     
     if (this.config.debug) {
-      console.log('✅ All tokens cleared from storage');
+      console.log('All tokens cleared from storage');
+    }
+  }
+
+  async onTokenExpired(): Promise<void> {
+    if (this.config.debug) {
+      console.warn('ReactNativeAuthProvider: Token expired - implement refresh logic in your app');
     }
+    // Clear expired tokens
+    await this.clearTokens();
   }
 
   // Token validation methods
   hasValidToken(): boolean {
-    // Synchronous check - for async check use hasValidTokenAsync()
     return true; // Actual validation happens in getToken()
   }
 
   hasRefreshToken(): boolean {
-    // Synchronous check - for async check use hasRefreshTokenAsync()
     return true; // Actual validation happens in getRefreshToken()
   }
 
-  // Async token validation methods
-  async hasValidTokenAsync(): Promise<boolean> {
-    const token = await this.getToken();
-    return !!token;
-  }
-
-  async hasRefreshTokenAsync(): Promise<boolean> {
-    const refreshToken = await this.getRefreshToken();
-    return !!refreshToken;
-  }
-
-  // Legacy methods for backward compatibility
-  setToken(token: string): void {
-    this.setAccessToken(token).catch(error => {
-      console.error('Legacy setToken failed:', error);
-    });
-  }
-
-  clearToken(): void {
-    this.clearTokens().catch(error => {
-      console.error('Legacy clearToken failed:', error);
-    });
-  }
-
-  // Protected storage implementation methods
-  protected async storeValue(key: string, value: string, strategy: StorageStrategy): Promise<void> {
+  // Storage implementation methods
+  private async storeValue(key: string, value: string): Promise<void> {
     try {
-      switch (strategy) {
-        case StorageStrategy.KEYCHAIN:
-          // Try Keychain first, fallback to AsyncStorage
-          if (await this.isKeychainAvailable()) {
-            await this.storeInKeychain(key, value);
-          } else {
-            await AsyncStorage.setItem(key, value);
-          }
-          break;
-          
-        case StorageStrategy.ASYNC_STORAGE:
-          await AsyncStorage.setItem(key, value);
-          break;
-          
-        case StorageStrategy.MEMORY:
-        default:
-          this.memoryStorage.set(key, value);
-          break;
+      if (this.config.useSecureStorage && await this.isKeychainAvailable()) {
+        await this.storeInKeychain(key, value);
+      } else {
+        await AsyncStorage.setItem(key, value);
       }
     } catch (error) {
-      console.error(`Failed to store value with strategy ${strategy}:`, error);
+      console.error(`Failed to store value for key ${key}:`, error);
       // Fallback to memory storage
       this.memoryStorage.set(key, value);
     }
   }
 
-  protected async getStoredValue(key: string, strategy: StorageStrategy): Promise<string | null> {
+  private async getStoredValue(key: string): Promise<string | null> {
     try {
-      switch (strategy) {
-        case StorageStrategy.KEYCHAIN:
-          // Try Keychain first, fallback to AsyncStorage
-          if (await this.isKeychainAvailable()) {
-            return await this.getFromKeychain(key);
-          } else {
-            return await AsyncStorage.getItem(key);
-          }
-          
-        case StorageStrategy.ASYNC_STORAGE:
-          return await AsyncStorage.getItem(key);
-          
-        case StorageStrategy.MEMORY:
-        default:
-          return this.memoryStorage.get(key) || null;
+      if (this.config.useSecureStorage && await this.isKeychainAvailable()) {
+        return await this.getFromKeychain(key);
+      } else {
+        return await AsyncStorage.getItem(key);
       }
     } catch (error) {
-      console.warn(`Failed to get value with strategy ${strategy}:`, error);
+      console.warn(`Failed to get value for key ${key}:`, error);
       // Fallback to memory storage
       return this.memoryStorage.get(key) || null;
     }
   }
 
-  protected async removeStoredValue(key: string, strategy: StorageStrategy): Promise<void> {
+  private async removeStoredValue(key: string): Promise<void> {
     try {
-      switch (strategy) {
-        case StorageStrategy.KEYCHAIN:
-          // Try Keychain first, fallback to AsyncStorage
-          if (await this.isKeychainAvailable()) {
-            await this.removeFromKeychain(key);
-          } else {
-            await AsyncStorage.removeItem(key);
-          }
-          break;
-          
-        case StorageStrategy.ASYNC_STORAGE:
-          await AsyncStorage.removeItem(key);
-          break;
-          
-        case StorageStrategy.MEMORY:
-        default:
-          this.memoryStorage.delete(key);
-          break;
+      if (this.config.useSecureStorage && await this.isKeychainAvailable()) {
+        await this.removeFromKeychain(key);
+      } else {
+        await AsyncStorage.removeItem(key);
       }
     } catch (error) {
-      console.error(`Failed to remove value with strategy ${strategy}:`, error);
-      // Ensure memory fallback is also cleared
-      this.memoryStorage.delete(key);
+      console.error(`Failed to remove value for key ${key}:`, error);
     }
+    
+    // Ensure memory fallback is also cleared
+    this.memoryStorage.delete(key);
   }
 
   // Keychain helper methods
   private async isKeychainAvailable(): Promise<boolean> {
     try {
-      // Check if react-native-keychain is available
       const Keychain = require('react-native-keychain');
       return !!Keychain && typeof Keychain.setInternetCredentials === 'function';
     } catch {
@@ -257,76 +186,4 @@ export abstract class BaseReactNativeAuthProvider implements PersAuthProvider {
     const Keychain = require('react-native-keychain');
     await Keychain.resetInternetCredentials(key);
   }
-}
-
-/**
- * React Native Authentication Provider
- * 
- * A ready-to-use implementation for basic use cases.
- * Uses AsyncStorage for access tokens and Keychain for refresh tokens (when available).
- */
-export class ReactNativeAuthProvider extends BaseReactNativeAuthProvider {
-  readonly authType: 'user' = 'user';
-
-  constructor(
-    private projectKey: string,
-    config: ReactNativeAuthConfig = {}
-  ) {
-    // Validate projectKey
-    if (!projectKey || typeof projectKey !== 'string') {
-      throw new Error('ReactNativeAuthProvider: projectKey is required and must be a string');
-    }
-
-    super(projectKey, {
-      accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
-      refreshTokenStrategy: StorageStrategy.KEYCHAIN,
-      debug: false,
-      ...config
-    });
-  }
-
-  async getProjectKey(): Promise<string | null> {
-    return this.projectKey;
-  }
-
-  async onTokenExpired(): Promise<void> {
-    if (this.config.debug) {
-      console.warn('ReactNativeAuthProvider: Token expired - no refresh logic implemented');
-    }
-  }
-}
-
-/**
- * Secure React Native Authentication Provider
- * 
- * Maximum security implementation using Keychain for all sensitive data.
- */
-export class SecureReactNativeAuthProvider extends BaseReactNativeAuthProvider {
-  readonly authType: 'user' = 'user';
-
-  constructor(
-    private projectKey: string,
-    config: Omit<ReactNativeAuthConfig, 'accessTokenStrategy' | 'refreshTokenStrategy'> = {}
-  ) {
-    // Validate projectKey
-    if (!projectKey || typeof projectKey !== 'string') {
-      throw new Error('SecureReactNativeAuthProvider: projectKey is required and must be a string');
-    }
-
-    super(projectKey, {
-      ...config,
-      accessTokenStrategy: StorageStrategy.KEYCHAIN,
-      refreshTokenStrategy: StorageStrategy.KEYCHAIN,
-    });
-  }
-
-  async getProjectKey(): Promise<string | null> {
-    return this.projectKey;
-  }
-
-  async onTokenExpired(): Promise<void> {
-    if (this.config.debug) {
-      console.warn('SecureReactNativeAuthProvider: Token expired - implement refresh logic');
-    }
-  }
 }