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

package/dist/providers/react-native-auth-provider.d.ts

@@ -1,92 +1,47 @@
 import type { PersAuthProvider } from '@explorins/pers-sdk/core';
-/**
- * Storage strategy for different types of data
- */
-export declare 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 */
     debug?: boolean;
 }
 /**
- * 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 declare 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 declare class ReactNativeAuthProvider implements PersAuthProvider {
+    readonly authType: 'user';
+    private readonly config;
+    private readonly ACCESS_TOKEN_KEY;
+    private readonly REFRESH_TOKEN_KEY;
+    private readonly projectKey;
     private memoryStorage;
     constructor(projectKey: string, config?: ReactNativeAuthConfig);
+    getProjectKey(): Promise<string | null>;
     getToken(): Promise<string | null>;
     setAccessToken(token: string): Promise<void>;
     setRefreshToken(token: string): Promise<void>;
     getRefreshToken(): Promise<string | null>;
     clearTokens(): Promise<void>;
+    onTokenExpired(): Promise<void>;
     hasValidToken(): boolean;
     hasRefreshToken(): boolean;
-    hasValidTokenAsync(): Promise<boolean>;
-    hasRefreshTokenAsync(): Promise<boolean>;
-    setToken(token: string): void;
-    clearToken(): void;
-    protected storeValue(key: string, value: string, strategy: StorageStrategy): Promise<void>;
-    protected getStoredValue(key: string, strategy: StorageStrategy): Promise<string | null>;
-    protected removeStoredValue(key: string, strategy: StorageStrategy): Promise<void>;
+    private storeValue;
+    private getStoredValue;
+    private removeStoredValue;
     private isKeychainAvailable;
     private storeInKeychain;
     private getFromKeychain;
     private removeFromKeychain;
 }
-/**
- * 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 declare class ReactNativeAuthProvider extends BaseReactNativeAuthProvider {
-    private projectKey;
-    readonly authType: 'user';
-    constructor(projectKey: string, config?: ReactNativeAuthConfig);
-    getProjectKey(): Promise<string | null>;
-    onTokenExpired(): Promise<void>;
-}
-/**
- * Secure React Native Authentication Provider
- *
- * Maximum security implementation using Keychain for all sensitive data.
- */
-export declare class SecureReactNativeAuthProvider extends BaseReactNativeAuthProvider {
-    private projectKey;
-    readonly authType: 'user';
-    constructor(projectKey: string, config?: Omit<ReactNativeAuthConfig, 'accessTokenStrategy' | 'refreshTokenStrategy'>);
-    getProjectKey(): Promise<string | null>;
-    onTokenExpired(): Promise<void>;
-}
 //# sourceMappingURL=react-native-auth-provider.d.ts.map

package/dist/providers/react-native-auth-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react-native-auth-provider.d.ts","sourceRoot":"","sources":["../../src/providers/react-native-auth-provider.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"react-native-auth-provider.d.ts","sourceRoot":"","sources":["../../src/providers/react-native-auth-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAC9D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAU;IAEnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAGpC,OAAO,CAAC,aAAa,CAAkC;gBAGrD,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,qBAA0B;IA4B9B,aAAa,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIvC,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIlC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5C,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7C,eAAe,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIzC,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IASrC,aAAa,IAAI,OAAO;IAIxB,eAAe,IAAI,OAAO;YAKZ,UAAU;YAcV,cAAc;YAcd,iBAAiB;YAgBjB,mBAAmB;YASnB,eAAe;YAKf,eAAe;YAMf,kBAAkB;CAIjC"}

package/dist/providers/react-native-auth-provider.js

@@ -1,40 +1,25 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 /**
- * Storage strategy for different types of data
- */
-export var StorageStrategy;
-(function (StorageStrategy) {
-    /** Use AsyncStorage for general app data */
-    StorageStrategy["ASYNC_STORAGE"] = "async_storage";
-    /** Use Keychain for sensitive tokens (when available) */
-    StorageStrategy["KEYCHAIN"] = "keychain";
-    /** Use in-memory storage (fallback) */
-    StorageStrategy["MEMORY"] = "memory";
-})(StorageStrategy || (StorageStrategy = {}));
-/**
- * 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 class BaseReactNativeAuthProvider {
+export class ReactNativeAuthProvider {
     constructor(projectKey, config = {}) {
+        this.authType = 'user';
         // In-memory fallback storage
         this.memoryStorage = new Map();
-        // 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
@@ -42,151 +27,106 @@ export class BaseReactNativeAuthProvider {
         // 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() {
+        return this.projectKey;
+    }
     async getToken() {
-        return this.getStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy);
+        return this.getStoredValue(this.ACCESS_TOKEN_KEY);
     }
     async setAccessToken(token) {
-        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) {
-        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() {
-        return this.getStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy);
+        return this.getStoredValue(this.REFRESH_TOKEN_KEY);
     }
     async clearTokens() {
         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() {
+        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() {
-        // Synchronous check - for async check use hasValidTokenAsync()
         return true; // Actual validation happens in getToken()
     }
     hasRefreshToken() {
-        // Synchronous check - for async check use hasRefreshTokenAsync()
         return true; // Actual validation happens in getRefreshToken()
     }
-    // Async token validation methods
-    async hasValidTokenAsync() {
-        const token = await this.getToken();
-        return !!token;
-    }
-    async hasRefreshTokenAsync() {
-        const refreshToken = await this.getRefreshToken();
-        return !!refreshToken;
-    }
-    // Legacy methods for backward compatibility
-    setToken(token) {
-        this.setAccessToken(token).catch(error => {
-            console.error('Legacy setToken failed:', error);
-        });
-    }
-    clearToken() {
-        this.clearTokens().catch(error => {
-            console.error('Legacy clearToken failed:', error);
-        });
-    }
-    // Protected storage implementation methods
-    async storeValue(key, value, strategy) {
+    // Storage implementation methods
+    async storeValue(key, value) {
         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);
         }
     }
-    async getStoredValue(key, strategy) {
+    async getStoredValue(key) {
         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;
         }
     }
-    async removeStoredValue(key, strategy) {
+    async removeStoredValue(key) {
         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
     async isKeychainAvailable() {
         try {
-            // Check if react-native-keychain is available
             const Keychain = require('react-native-keychain');
             return !!Keychain && typeof Keychain.setInternetCredentials === 'function';
         }
@@ -208,61 +148,3 @@ export class BaseReactNativeAuthProvider {
         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 {
-    constructor(projectKey, config = {}) {
-        // 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
-        });
-        this.projectKey = projectKey;
-        this.authType = 'user';
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    async onTokenExpired() {
-        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 {
-    constructor(projectKey, config = {}) {
-        // 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,
-        });
-        this.projectKey = projectKey;
-        this.authType = 'user';
-    }
-    async getProjectKey() {
-        return this.projectKey;
-    }
-    async onTokenExpired() {
-        if (this.config.debug) {
-            console.warn('SecureReactNativeAuthProvider: Token expired - implement refresh logic');
-        }
-    }
-}