@explorins/pers-sdk-react-native 2.3.6 → 2.3.8

package/src/storage/rn-secure-storage.ts

@@ -1,170 +1,182 @@
-import { Platform } from 'react-native';
-import { 
-  TokenStorage, 
-  DPOP_STORAGE_KEYS, 
-  AUTH_STORAGE_KEYS 
-} from '@explorins/pers-sdk/core';
-import { AsyncStorageTokenStorage } from './async-storage-token-storage';
-
-// Conditionally require Keychain to avoid Web bundler errors
-let Keychain: any;
-if (Platform.OS !== 'web') {
-  try {
-    Keychain = require('react-native-keychain');
-  } catch (e) {
-    console.warn('ReactNativeSecureStorage: Failed to load react-native-keychain', e);
-  }
-}
-
-/**
- * Secure Storage implementation for React Native
- * Uses Keychain/Keystore for sensitive data and AsyncStorage for non-sensitive data.
- */
-export class ReactNativeSecureStorage implements TokenStorage {
-  // Set to false because Keychain stores strings, so we need extractable (serializable) keys
-  readonly supportsObjects = false;
-  
-  // Define which keys MUST go to secure hardware storage
-  private readonly SECURE_KEYS = new Set([
-     DPOP_STORAGE_KEYS.PRIVATE,
-     AUTH_STORAGE_KEYS.ACCESS_TOKEN,
-     AUTH_STORAGE_KEYS.REFRESH_TOKEN,
-     AUTH_STORAGE_KEYS.PROVIDER_TOKEN
-  ]);
-
-  private fallbackStorage: AsyncStorageTokenStorage;
-
-  constructor(private keyPrefix: string = 'pers_tokens_') {
-    this.fallbackStorage = new AsyncStorageTokenStorage(keyPrefix);
-  }
-
-  async set(key: string, value: unknown): Promise<void> {
-    const prefixedKey = this.getKeyName(key);
-    const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-
-    // Cast key to any to bypass strict literal type checking of the Set.has method
-    // In runtime, 'key' is just a string, so this is safe.
-    if (this.SECURE_KEYS.has(key as any)) {
-      // Store in Keychain/Keystore
-      try {
-        if (Keychain) {
-          // Service name acts as the key identifier in simple usage
-          await Keychain.setGenericPassword(prefixedKey, stringValue, { service: prefixedKey });
-        } else {
-          throw new Error('RN Keychain not available');
-        }
-      } catch (e) {
-        console.warn(`[ReactNativeSecureStorage] Keychain set failed for ${key}, falling back to AsyncStorage`, e);
-        // Fallback to AsyncStorage if Keychain fails
-        await this.fallbackStorage.set(key, stringValue);
-      }
-    } else {
-      // Store standard config/metadata in AsyncStorage
-      await this.fallbackStorage.set(key, stringValue);
-    }
-  }
-
-  async get(key: string): Promise<unknown | null> {
-    const prefixedKey = this.getKeyName(key);
-
-    if (this.SECURE_KEYS.has(key as any)) {
-      try {
-        if (Keychain) {
-          const credentials = await Keychain.getGenericPassword({ service: prefixedKey });
-          if (credentials) {
-            return this.tryParse(credentials.password);
-          }
-        }
-      } catch (e) {
-        console.warn(`[ReactNativeSecureStorage] Failed to access keychain for ${key}`, e);
-        // Continue to fallback check...
-      }
-      
-      // Fallback: Check AsyncStorage if not found in Keychain or Keychain failed
-      try {
-        const val = await this.fallbackStorage.get(key);
-        return val ? this.tryParse(val) : null;
-      } catch (e) {
-        return null;
-      }
-    } else {
-      try {
-        const val = await this.fallbackStorage.get(key);
-        return val ? this.tryParse(val) : null;
-      } catch (e) {
-        console.warn(`[ReactNativeSecureStorage] Failed to access AsyncStorage for ${key}`, e);
-        return null;
-      }
-    }
-  }
-
-  async remove(key: string): Promise<void> {
-    const prefixedKey = this.getKeyName(key);
-
-    if (this.SECURE_KEYS.has(key as any)) {
-      try {
-        if (Keychain) {
-          await Keychain.resetGenericPassword({ service: prefixedKey });
-        }
-      } catch (e) {
-        console.warn(`[ReactNativeSecureStorage] Failed to reset keychain for ${key}`, e);
-      }
-      // Always remove from fallback storage too, just in case
-      await this.fallbackStorage.remove(key);
-    } else {
-      await this.fallbackStorage.remove(key);
-    }
-  }
-
-  async clear(): Promise<void> {
-    const clearPromises: Promise<void>[] = [];
-    
-    // Clear all known secure keys with retry logic
-    for (const key of this.SECURE_KEYS) {
-      clearPromises.push(
-        (async () => {
-          try {
-            if (Keychain) {
-              await Keychain.resetGenericPassword({ service: this.getKeyName(key) });
-            }
-          } catch (e) {
-            console.warn(`[ReactNativeSecureStorage] Retry clearing ${key}`);
-            // Retry once
-            try {
-              if (Keychain) {
-                await Keychain.resetGenericPassword({ service: this.getKeyName(key) });
-              }
-            } catch (retryError) {
-              console.error(`[ReactNativeSecureStorage] Failed to clear ${key} after retry:`, retryError);
-            }
-          }
-        })()
-      );
-    }
-    
-    // Wait for all Keychain clearing to complete (or fail)
-    await Promise.allSettled(clearPromises);
-    
-    // Always clear AsyncStorage fallback
-    try {
-      await this.fallbackStorage.clear();
-    } catch (e) {
-      console.error('[ReactNativeSecureStorage] Failed to clear AsyncStorage:', e);
-    }
-  }
-
-  private getKeyName(key: string): string {
-    // For Keychain, we might want to avoid prefixes if we want to share across apps, 
-    // but for simple isolation, prefix is fine to avoid collisions if multiple instances exist.
-    // However, Keychain services are global to the app bundle ID usually.
-    return `${this.keyPrefix}${key}`;
-  }
-
-  private tryParse(val: string): unknown {
-      try {
-          return JSON.parse(val);
-      } catch {
-          return val;
-      }
-  }
-}
+import { Platform } from 'react-native';
+import { 
+  TokenStorage, 
+  DPOP_STORAGE_KEYS, 
+  AUTH_STORAGE_KEYS 
+} from '@explorins/pers-sdk/core';
+import { AsyncStorageTokenStorage } from './async-storage-token-storage';
+
+// Conditionally require Keychain to avoid Web bundler errors
+let Keychain: any;
+if (Platform.OS !== 'web') {
+  try {
+    Keychain = require('react-native-keychain');
+  } catch (e) {
+    console.warn('ReactNativeSecureStorage: Failed to load react-native-keychain', e);
+  }
+}
+
+/**
+ * Secure Storage implementation for React Native
+ * Uses Keychain/Keystore for sensitive data and AsyncStorage for non-sensitive data.
+ */
+export class ReactNativeSecureStorage implements TokenStorage {
+  // Set to false because Keychain stores strings, so we need extractable (serializable) keys
+  readonly supportsObjects = false;
+  
+  // Define which keys MUST go to secure hardware storage
+  private readonly SECURE_KEYS = new Set([
+     DPOP_STORAGE_KEYS.PRIVATE,
+     AUTH_STORAGE_KEYS.ACCESS_TOKEN,
+     AUTH_STORAGE_KEYS.REFRESH_TOKEN,
+     AUTH_STORAGE_KEYS.PROVIDER_TOKEN
+  ]);
+
+  private fallbackStorage: AsyncStorageTokenStorage;
+
+  constructor(private keyPrefix: string = 'pers_tokens_') {
+    this.fallbackStorage = new AsyncStorageTokenStorage(keyPrefix);
+  }
+
+  async set(key: string, value: unknown): Promise<void> {
+    const prefixedKey = this.getKeyName(key);
+    const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+
+    // Cast key to any to bypass strict literal type checking of the Set.has method
+    // In runtime, 'key' is just a string, so this is safe.
+    if (this.SECURE_KEYS.has(key as any)) {
+      // Store in Keychain/Keystore
+      try {
+        if (Keychain) {
+          // Service name acts as the key identifier in simple usage
+          await Keychain.setGenericPassword(prefixedKey, stringValue, { service: prefixedKey });
+        } else {
+          throw new Error('RN Keychain not available');
+        }
+      } catch (e) {
+        console.warn(`[ReactNativeSecureStorage] Keychain set failed for ${key}, falling back to AsyncStorage`, e);
+        // Fallback to AsyncStorage if Keychain fails
+        await this.fallbackStorage.set(key, stringValue);
+      }
+    } else {
+      // Store standard config/metadata in AsyncStorage
+      await this.fallbackStorage.set(key, stringValue);
+    }
+  }
+
+  async get(key: string): Promise<unknown | null> {
+    const prefixedKey = this.getKeyName(key);
+
+    if (this.SECURE_KEYS.has(key as any)) {
+      // The iOS Keychain can be briefly unreadable (device locked, background launch), so retry before giving up
+      let keychainError: unknown;
+      if (Keychain) {
+        for (let attempt = 0; attempt < 3; attempt++) {
+          try {
+            const credentials = await Keychain.getGenericPassword({ service: prefixedKey });
+            if (credentials) {
+              return this.tryParse(credentials.password);
+            }
+            keychainError = undefined;
+            break;
+          } catch (e) {
+            keychainError = e;
+            if (attempt < 2) await new Promise(resolve => setTimeout(resolve, 150 * (attempt + 1)));
+          }
+        }
+      }
+
+      if (keychainError) {
+        console.warn(`[ReactNativeSecureStorage] Failed to access keychain for ${key}`, keychainError);
+        // Returning "missing" here would make the DPoP manager regenerate the key pair and log the user out
+        if (key === DPOP_STORAGE_KEYS.PRIVATE) throw keychainError;
+      }
+      
+      // Fallback: Check AsyncStorage if not found in Keychain or Keychain failed
+      try {
+        const val = await this.fallbackStorage.get(key);
+        return val ? this.tryParse(val) : null;
+      } catch (e) {
+        return null;
+      }
+    } else {
+      try {
+        const val = await this.fallbackStorage.get(key);
+        return val ? this.tryParse(val) : null;
+      } catch (e) {
+        console.warn(`[ReactNativeSecureStorage] Failed to access AsyncStorage for ${key}`, e);
+        return null;
+      }
+    }
+  }
+
+  async remove(key: string): Promise<void> {
+    const prefixedKey = this.getKeyName(key);
+
+    if (this.SECURE_KEYS.has(key as any)) {
+      try {
+        if (Keychain) {
+          await Keychain.resetGenericPassword({ service: prefixedKey });
+        }
+      } catch (e) {
+        console.warn(`[ReactNativeSecureStorage] Failed to reset keychain for ${key}`, e);
+      }
+      // Always remove from fallback storage too, just in case
+      await this.fallbackStorage.remove(key);
+    } else {
+      await this.fallbackStorage.remove(key);
+    }
+  }
+
+  async clear(): Promise<void> {
+    const clearPromises: Promise<void>[] = [];
+    
+    // Clear all known secure keys with retry logic
+    for (const key of this.SECURE_KEYS) {
+      clearPromises.push(
+        (async () => {
+          try {
+            if (Keychain) {
+              await Keychain.resetGenericPassword({ service: this.getKeyName(key) });
+            }
+          } catch (e) {
+            console.warn(`[ReactNativeSecureStorage] Retry clearing ${key}`);
+            // Retry once
+            try {
+              if (Keychain) {
+                await Keychain.resetGenericPassword({ service: this.getKeyName(key) });
+              }
+            } catch (retryError) {
+              console.error(`[ReactNativeSecureStorage] Failed to clear ${key} after retry:`, retryError);
+            }
+          }
+        })()
+      );
+    }
+    
+    // Wait for all Keychain clearing to complete (or fail)
+    await Promise.allSettled(clearPromises);
+    
+    // Always clear AsyncStorage fallback
+    try {
+      await this.fallbackStorage.clear();
+    } catch (e) {
+      console.error('[ReactNativeSecureStorage] Failed to clear AsyncStorage:', e);
+    }
+  }
+
+  private getKeyName(key: string): string {
+    // For Keychain, we might want to avoid prefixes if we want to share across apps, 
+    // but for simple isolation, prefix is fine to avoid collisions if multiple instances exist.
+    // However, Keychain services are global to the app bundle ID usually.
+    return `${this.keyPrefix}${key}`;
+  }
+
+  private tryParse(val: string): unknown {
+      try {
+          return JSON.parse(val);
+      } catch {
+          return val;
+      }
+  }
+}

package/src/types/react-native-globals.d.ts

@@ -1,46 +1,46 @@
-/**
- * React Native Global Type Declarations
- * 
- * This file declares global types that are available in React Native
- * but might not be available in TypeScript compilation.
- */
-
-// React Native global type declarations
-declare global {
-  interface Navigator {
-    product?: string;
-  }
-  
-  var navigator: Navigator | undefined;
-  var localStorage: Storage | undefined;
-  
-  interface Storage {
-    getItem(key: string): string | null;
-    setItem(key: string, value: string): void;
-    removeItem(key: string): void;
-  }
-
-  // Global object - React Native environment
-  var global: typeof globalThis & {
-    global: typeof globalThis;
-    Buffer: typeof Buffer;
-    process: NodeJS.Process;
-  };
-
-  // Process object for Node.js compatibility
-  namespace NodeJS {
-    interface Process {
-      env: Record<string, string | undefined>;
-    }
-  }
-
-  var process: NodeJS.Process;
-
-  // Buffer for Node.js compatibility  
-  var Buffer: {
-    from(data: any, encoding?: string): any;
-    alloc(size: number): any;
-  };
-}
-
+/**
+ * React Native Global Type Declarations
+ * 
+ * This file declares global types that are available in React Native
+ * but might not be available in TypeScript compilation.
+ */
+
+// React Native global type declarations
+declare global {
+  interface Navigator {
+    product?: string;
+  }
+  
+  var navigator: Navigator | undefined;
+  var localStorage: Storage | undefined;
+  
+  interface Storage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+  }
+
+  // Global object - React Native environment
+  var global: typeof globalThis & {
+    global: typeof globalThis;
+    Buffer: typeof Buffer;
+    process: NodeJS.Process;
+  };
+
+  // Process object for Node.js compatibility
+  namespace NodeJS {
+    interface Process {
+      env: Record<string, string | undefined>;
+    }
+  }
+
+  var process: NodeJS.Process;
+
+  // Buffer for Node.js compatibility  
+  var Buffer: {
+    from(data: any, encoding?: string): any;
+    alloc(size: number): any;
+  };
+}
+
 export {};

package/src/utils/index.ts

@@ -1,8 +1,8 @@
-/**
- * Utility exports for React Native SDK
- */
-
-export { 
-  detectReactNativePlatform, 
-  detectReactNativePlatformSync 
-} from './platform-detection';
+/**
+ * Utility exports for React Native SDK
+ */
+
+export { 
+  detectReactNativePlatform, 
+  detectReactNativePlatformSync 
+} from './platform-detection';

package/src/utils/platform-detection.ts

@@ -1,86 +1,86 @@
-/**
- * React Native Platform Detection Utilities
- * 
- * Provides automatic platform info detection for React Native apps.
- * 
- * @module @explorins/pers-sdk-react-native/utils
- */
-
-import { Platform as RNPlatform } from 'react-native';
-import type { Platform } from '@explorins/pers-sdk/core';
-
-// DeviceInfo is optional - dynamically loaded if available
-let DeviceInfo: any = null;
-try {
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  DeviceInfo = require('react-native-device-info').default;
-} catch {
-  // react-native-device-info not installed - will use basic detection
-}
-
-/**
- * Detect platform info for React Native apps
- * 
- * Automatically gathers OS, version, app info, and device type.
- * Uses react-native-device-info for enhanced detection if installed.
- * 
- * @example
- * ```typescript
- * import { detectReactNativePlatform } from '@explorins/pers-sdk-react-native';
- * 
- * // Get platform info
- * const platform = await detectReactNativePlatform();
- * // { os: 'iOS', osVersion: '17.4', app: 'MyApp', appVersion: '2.3.1', deviceType: 'phone' }
- * 
- * // Set in SDK
- * sdk.setPlatform(platform);
- * ```
- */
-export async function detectReactNativePlatform(): Promise<Platform> {
-  const platform: Platform = {
-    os: RNPlatform.OS === 'ios' ? 'iOS' : RNPlatform.OS === 'android' ? 'Android' : RNPlatform.OS,
-    osVersion: RNPlatform.Version?.toString(),
-    deviceType: 'phone', // Default fallback
-  };
-
-  if (DeviceInfo) {
-    try {
-      // App info
-      platform.app = await DeviceInfo.getApplicationName();
-      platform.appVersion = DeviceInfo.getVersion();
-      
-      // Device type detection
-      const isTablet = await DeviceInfo.isTablet();
-      platform.deviceType = isTablet ? 'tablet' : 'phone';
-    } catch (error) {
-      console.debug('[Platform] DeviceInfo error, using basic detection');
-    }
-  }
-
-  return platform;
-}
-
-/**
- * Synchronous version for immediate use (limited info)
- * 
- * Use when you need platform info immediately without async.
- * For full info including device type, use detectReactNativePlatform().
- */
-export function detectReactNativePlatformSync(): Platform {
-  const platform: Platform = {
-    os: RNPlatform.OS === 'ios' ? 'iOS' : RNPlatform.OS === 'android' ? 'Android' : RNPlatform.OS,
-    osVersion: RNPlatform.Version?.toString(),
-    deviceType: 'phone', // Default, can't detect tablet sync without DeviceInfo
-  };
-
-  if (DeviceInfo) {
-    try {
-      platform.app = DeviceInfo.getApplicationNameSync?.();
-      platform.appVersion = DeviceInfo.getVersion?.();
-    } catch {
-      // Ignore if DeviceInfo methods fail
-    }
-  }
-
-  return platform;
-}
+/**
+ * React Native Platform Detection Utilities
+ * 
+ * Provides automatic platform info detection for React Native apps.
+ * 
+ * @module @explorins/pers-sdk-react-native/utils
+ */
+
+import { Platform as RNPlatform } from 'react-native';
+import type { Platform } from '@explorins/pers-sdk/core';
+
+// DeviceInfo is optional - dynamically loaded if available
+let DeviceInfo: any = null;
+try {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  DeviceInfo = require('react-native-device-info').default;
+} catch {
+  // react-native-device-info not installed - will use basic detection
+}
+
+/**
+ * Detect platform info for React Native apps
+ * 
+ * Automatically gathers OS, version, app info, and device type.
+ * Uses react-native-device-info for enhanced detection if installed.
+ * 
+ * @example
+ * ```typescript
+ * import { detectReactNativePlatform } from '@explorins/pers-sdk-react-native';
+ * 
+ * // Get platform info
+ * const platform = await detectReactNativePlatform();
+ * // { os: 'iOS', osVersion: '17.4', app: 'MyApp', appVersion: '2.3.1', deviceType: 'phone' }
+ * 
+ * // Set in SDK
+ * sdk.setPlatform(platform);
+ * ```
+ */
+export async function detectReactNativePlatform(): Promise<Platform> {
+  const platform: Platform = {
+    os: RNPlatform.OS === 'ios' ? 'iOS' : RNPlatform.OS === 'android' ? 'Android' : RNPlatform.OS,
+    osVersion: RNPlatform.Version?.toString(),
+    deviceType: 'phone', // Default fallback
+  };
+
+  if (DeviceInfo) {
+    try {
+      // App info
+      platform.app = await DeviceInfo.getApplicationName();
+      platform.appVersion = DeviceInfo.getVersion();
+      
+      // Device type detection
+      const isTablet = await DeviceInfo.isTablet();
+      platform.deviceType = isTablet ? 'tablet' : 'phone';
+    } catch (error) {
+      console.debug('[Platform] DeviceInfo error, using basic detection');
+    }
+  }
+
+  return platform;
+}
+
+/**
+ * Synchronous version for immediate use (limited info)
+ * 
+ * Use when you need platform info immediately without async.
+ * For full info including device type, use detectReactNativePlatform().
+ */
+export function detectReactNativePlatformSync(): Platform {
+  const platform: Platform = {
+    os: RNPlatform.OS === 'ios' ? 'iOS' : RNPlatform.OS === 'android' ? 'Android' : RNPlatform.OS,
+    osVersion: RNPlatform.Version?.toString(),
+    deviceType: 'phone', // Default, can't detect tablet sync without DeviceInfo
+  };
+
+  if (DeviceInfo) {
+    try {
+      platform.app = DeviceInfo.getApplicationNameSync?.();
+      platform.appVersion = DeviceInfo.getVersion?.();
+    } catch {
+      // Ignore if DeviceInfo methods fail
+    }
+  }
+
+  return platform;
+}