@explorins/pers-sdk-react-native 1.5.18 → 1.5.20

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

@@ -1,189 +1,72 @@
-import type { PersAuthProvider } from '@explorins/pers-sdk/core';
-import AsyncStorage from '@react-native-async-storage/async-storage';
+/**
+ * React Native Unified Auth Provider
+ * 
+ * Creates a platform-specific auth provider that automatically selects the appropriate storage:
+ * - Web: Uses LocalStorageTokenStorage from core SDK
+ * - Mobile: Uses AsyncStorage-based storage
+ */
+
+import { Platform } from 'react-native';
+import { DefaultAuthProvider, AuthApi, AuthType, LocalStorageTokenStorage } from '@explorins/pers-sdk/core';
+import { AsyncStorageTokenStorage } from '../storage/async-storage-token-storage';
+import type { TokenStorage } from '@explorins/pers-sdk/core';
+
+// Use React Native's built-in platform detection
+const isWebPlatform = Platform.OS === 'web';
 
 /**
- * Configuration options for React Native Auth Provider
+ * Configuration for React Native Auth Provider
  */
 export interface ReactNativeAuthConfig {
-  /** Use secure storage (Keychain) for tokens when available */
-  useSecureStorage?: boolean;
-  /** Custom key prefix for storage */
+  /** Custom storage key prefix */
   keyPrefix?: string;
   /** Enable debug logging */
   debug?: boolean;
+  /** Custom token storage implementation */
+  customStorage?: TokenStorage;
+  /** Authentication type (default: 'user') */
+  authType?: AuthType;
 }
 
 /**
- * React Native Authentication Provider
+ * Create a React Native auth provider with platform-appropriate storage
+ * 
+ * Automatically selects storage implementation:
+ * - Web: Uses LocalStorageTokenStorage (from core SDK)
+ * - Mobile: Uses AsyncStorageTokenStorage (React Native specific)
  * 
- * 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)
+ * @param projectKey - PERS project key
+ * @param authApi - Optional auth API instance
+ * @param config - Configuration options
+ * @returns DefaultAuthProvider configured for the current platform
  */
-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();
-
-  constructor(
-    projectKey: string,
-    config: ReactNativeAuthConfig = {}
-  ) {
-    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 = {
-      useSecureStorage: true, // Default to secure storage when available
-      keyPrefix: `pers_${projectKey.slice(0, 8)}`,
-      debug: false,
-      ...config
-    };
-
-    // Create storage keys
-    this.ACCESS_TOKEN_KEY = `${this.config.keyPrefix}_access_token`;
-    this.REFRESH_TOKEN_KEY = `${this.config.keyPrefix}_refresh_token`;
-
-    if (this.config.debug) {
-      console.log('ReactNativeAuthProvider initialized:', { 
-        projectKey: projectKey.slice(0, 8) + '...', 
-        useSecureStorage: this.config.useSecureStorage 
-      });
-    }
-  }
-
-  async getProjectKey(): Promise<string | null> {
-    return this.projectKey;
-  }
-
-  async getToken(): Promise<string | null> {
-    return this.getStoredValue(this.ACCESS_TOKEN_KEY);
-  }
-
-  async setAccessToken(token: string): Promise<void> {
-    await this.storeValue(this.ACCESS_TOKEN_KEY, token);
-    if (this.config.debug) {
-      console.log('Access token stored securely');
-    }
-  }
-
-  async setRefreshToken(token: string): Promise<void> {
-    await this.storeValue(this.REFRESH_TOKEN_KEY, token);
-    if (this.config.debug) {
-      console.log('Refresh token stored securely');
-    }
-  }
-
-  async getRefreshToken(): Promise<string | null> {
-    return this.getStoredValue(this.REFRESH_TOKEN_KEY);
-  }
-
-  async clearTokens(): Promise<void> {
-    await Promise.all([
-      this.removeStoredValue(this.ACCESS_TOKEN_KEY),
-      this.removeStoredValue(this.REFRESH_TOKEN_KEY)
-    ]);
-    
-    if (this.config.debug) {
-      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 {
-    return true; // Actual validation happens in getToken()
-  }
-
-  hasRefreshToken(): boolean {
-    return true; // Actual validation happens in getRefreshToken()
-  }
-
-  // Storage implementation methods
-  private async storeValue(key: string, value: string): Promise<void> {
-    try {
-      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 for key ${key}:`, error);
-      // Fallback to memory storage
-      this.memoryStorage.set(key, value);
-    }
-  }
-
-  private async getStoredValue(key: string): Promise<string | null> {
-    try {
-      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 for key ${key}:`, error);
-      // Fallback to memory storage
-      return this.memoryStorage.get(key) || null;
-    }
-  }
-
-  private async removeStoredValue(key: string): Promise<void> {
-    try {
-      if (this.config.useSecureStorage && await this.isKeychainAvailable()) {
-        await this.removeFromKeychain(key);
-      } else {
-        await AsyncStorage.removeItem(key);
-      }
-    } catch (error) {
-      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 {
-      const Keychain = require('react-native-keychain');
-      return !!Keychain && typeof Keychain.setInternetCredentials === 'function';
-    } catch {
-      return false;
-    }
-  }
-
-  private async storeInKeychain(key: string, value: string): Promise<void> {
-    const Keychain = require('react-native-keychain');
-    await Keychain.setInternetCredentials(key, 'pers-token', value);
-  }
-
-  private async getFromKeychain(key: string): Promise<string | null> {
-    const Keychain = require('react-native-keychain');
-    const credentials = await Keychain.getInternetCredentials(key);
-    return credentials ? credentials.password : null;
-  }
+export function createReactNativeAuthProvider(
+  projectKey: string,
+  config: ReactNativeAuthConfig = {}
+): DefaultAuthProvider {
+  if (!projectKey || typeof projectKey !== 'string') {
+    throw new Error('createReactNativeAuthProvider: projectKey is required and must be a string');
+  }
+
+  const {
+    keyPrefix = `pers_${projectKey.slice(0, 8)}_`,
+    debug = false,
+    customStorage,
+    authType = 'user'
+  } = config;
+
+  // Platform-specific storage selection
+  const tokenStorage = customStorage || (
+    isWebPlatform 
+      ? new LocalStorageTokenStorage()
+      : new AsyncStorageTokenStorage(keyPrefix)
+  );
+
+  // Return DefaultAuthProvider configured with platform-appropriate storage
+  return new DefaultAuthProvider({
+    authType,
+    projectKey,
+    storage: tokenStorage
+  });
+}
 
-  private async removeFromKeychain(key: string): Promise<void> {
-    const Keychain = require('react-native-keychain');
-    await Keychain.resetInternetCredentials(key);
-  }
-}

package/src/storage/async-storage-token-storage.ts

@@ -0,0 +1,133 @@
+/**
+ * AsyncStorage Token Storage for React Native Mobile Platforms
+ * 
+ * Bundler-agnostic AsyncStorage implementation for mobile platforms
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { TokenStorage } from '@explorins/pers-sdk/core';
+
+/**
+ * Bundler-agnostic AsyncStorage wrapper
+ * Handles different module resolution patterns across bundlers (Metro, Webpack, Rollup, etc.)
+ */
+class BundlerAgnosticAsyncStorage {
+  private storage: any;
+
+  constructor(asyncStorageModule: any) {
+    // Try different import patterns to handle various bundlers
+    if (asyncStorageModule?.default?.getItem) {
+      // Metro/Webpack pattern: { default: { getItem, setItem, ... } }
+      this.storage = asyncStorageModule.default;
+    } else if (asyncStorageModule?.getItem) {
+      // Direct export pattern: { getItem, setItem, ... }
+      this.storage = asyncStorageModule;
+    } else if (typeof asyncStorageModule === 'function') {
+      // Function export pattern (some bundlers)
+      this.storage = asyncStorageModule();
+    } else {
+      // Log the structure for debugging
+      console.error('[BundlerAgnosticAsyncStorage] Unknown AsyncStorage structure:', asyncStorageModule);
+      throw new Error(
+        'AsyncStorage methods not found. Expected structure with getItem/setItem methods. ' +
+        'Make sure @react-native-async-storage/async-storage is properly installed.'
+      );
+    }
+
+    // Validate that we have the required methods
+    const requiredMethods = ['getItem', 'setItem', 'removeItem', 'getAllKeys', 'multiRemove'];
+    const missingMethods = requiredMethods.filter(method => typeof this.storage[method] !== 'function');
+    
+    if (missingMethods.length > 0) {
+      throw new Error(
+        `AsyncStorage missing required methods: ${missingMethods.join(', ')}. ` +
+        'Ensure @react-native-async-storage/async-storage is properly installed and compatible.'
+      );
+    }
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    return this.storage.getItem(key);
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    return this.storage.setItem(key, value);
+  }
+
+  async removeItem(key: string): Promise<void> {
+    return this.storage.removeItem(key);
+  }
+
+  async getAllKeys(): Promise<readonly string[]> {
+    return this.storage.getAllKeys();
+  }
+
+  async multiRemove(keys: string[]): Promise<void> {
+    return this.storage.multiRemove(keys);
+  }
+}
+
+/**
+ * AsyncStorage implementation for mobile platforms
+ * 
+ * This class is only used on mobile platforms (iOS/Android).
+ * Web platforms use LocalStorageTokenStorage from core SDK.
+ */
+export class AsyncStorageTokenStorage implements TokenStorage {
+  private keyPrefix: string;
+  private asyncStorage: BundlerAgnosticAsyncStorage;
+
+  constructor(keyPrefix: string = 'pers_tokens_') {
+    this.keyPrefix = keyPrefix;
+    
+    try {
+      // Initialize bundler-agnostic AsyncStorage wrapper
+      this.asyncStorage = new BundlerAgnosticAsyncStorage(AsyncStorage);
+    } catch (error) {
+      console.error('[AsyncStorageTokenStorage] Failed to initialize:', error);
+      throw new Error(
+        'Failed to initialize AsyncStorage. Make sure @react-native-async-storage/async-storage is installed and ' +
+        'this code is running on a React Native mobile platform (not web).'
+      );
+    }
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    try {
+      await this.asyncStorage.setItem(`${this.keyPrefix}${key}`, value);
+    } catch (error) {
+      console.error(`Failed to store token ${key}:`, error);
+      throw new Error(`Token storage failed: ${error}`);
+    }
+  }
+
+  async get(key: string): Promise<string | null> {
+    try {
+      return await this.asyncStorage.getItem(`${this.keyPrefix}${key}`);
+    } catch (error) {
+      console.error(`Failed to retrieve token ${key}:`, error);
+      return null;
+    }
+  }
+
+  async remove(key: string): Promise<void> {
+    try {
+      await this.asyncStorage.removeItem(`${this.keyPrefix}${key}`);
+    } catch (error) {
+      console.error(`Failed to remove token ${key}:`, error);
+    }
+  }
+
+  async clear(): Promise<void> {
+    try {
+      const allKeys = await this.asyncStorage.getAllKeys();
+      const ourKeys = allKeys.filter(key => key.startsWith(this.keyPrefix));
+      
+      if (ourKeys.length > 0) {
+        await this.asyncStorage.multiRemove(ourKeys);
+      }
+    } catch (error) {
+      console.error('Failed to clear token storage:', error);
+    }
+  }
+}