@explorins/pers-sdk-react-native 1.3.2

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

@@ -0,0 +1,332 @@
+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;
+  /** 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.
+ * 
+ * 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
+ */
+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;
+  
+  // In-memory fallback storage
+  private memoryStorage: Map<string, string> = new Map();
+
+  constructor(
+    projectKey: string,
+    config: ReactNativeAuthConfig = {}
+  ) {
+    // Validate projectKey
+    if (!projectKey || typeof projectKey !== 'string') {
+      throw new Error('ReactNativeAuthProvider: projectKey is required and must be a string');
+    }
+
+    // Set default configuration
+    this.config = {
+      accessTokenStrategy: StorageStrategy.ASYNC_STORAGE,
+      refreshTokenStrategy: StorageStrategy.KEYCHAIN,
+      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`;
+    this.PROJECT_KEY_KEY = `${this.config.keyPrefix}_project_key`;
+
+    if (this.config.debug) {
+      console.log('🔧 ReactNativeAuthProvider initialized with config:', this.config);
+    }
+  }
+
+  // Core token management methods
+  async getToken(): Promise<string | null> {
+    return this.getStoredValue(this.ACCESS_TOKEN_KEY, this.config.accessTokenStrategy);
+  }
+
+  async setAccessToken(token: string): Promise<void> {
+    await this.storeValue(this.ACCESS_TOKEN_KEY, token, this.config.accessTokenStrategy);
+    if (this.config.debug) {
+      console.log('✅ Access token stored securely');
+    }
+  }
+
+  async setRefreshToken(token: string): Promise<void> {
+    await this.storeValue(this.REFRESH_TOKEN_KEY, token, this.config.refreshTokenStrategy);
+    if (this.config.debug) {
+      console.log('✅ Refresh token stored securely');
+    }
+  }
+
+  async getRefreshToken(): Promise<string | null> {
+    return this.getStoredValue(this.REFRESH_TOKEN_KEY, this.config.refreshTokenStrategy);
+  }
+
+  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)
+    ]);
+    
+    if (this.config.debug) {
+      console.log('✅ All tokens cleared from storage');
+    }
+  }
+
+  // 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> {
+    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;
+      }
+    } catch (error) {
+      console.error(`Failed to store value with strategy ${strategy}:`, error);
+      // Fallback to memory storage
+      this.memoryStorage.set(key, value);
+    }
+  }
+
+  protected async getStoredValue(key: string, strategy: StorageStrategy): 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;
+      }
+    } catch (error) {
+      console.warn(`Failed to get value with strategy ${strategy}:`, error);
+      // Fallback to memory storage
+      return this.memoryStorage.get(key) || null;
+    }
+  }
+
+  protected async removeStoredValue(key: string, strategy: StorageStrategy): 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;
+      }
+    } catch (error) {
+      console.error(`Failed to remove value with strategy ${strategy}:`, 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 {
+      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;
+  }
+
+  private async removeFromKeychain(key: string): Promise<void> {
+    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');
+    }
+  }
+}

package/src/providers/react-native-http-client.ts

@@ -0,0 +1,129 @@
+/**
+ * HTTP Client implementation for React Native
+ * 
+ * This implementation properly implements the core SDK's HttpClient interface
+ * and uses fetch API which is available in React Native.
+ */
+
+export interface RequestOptions {
+  headers?: Record<string, string>;
+  params?: Record<string, string>;
+  timeout?: number;
+  responseType?: 'json' | 'blob' | 'text' | 'arraybuffer'; 
+}
+
+export interface HttpClient {
+  get<T>(url: string, options?: RequestOptions): Promise<T>;
+  post<T>(url: string, body: any, options?: RequestOptions): Promise<T>;
+  put<T>(url: string, body: any, options?: RequestOptions): Promise<T>;
+  delete<T>(url: string, options?: RequestOptions): Promise<T>;
+}
+
+export class ReactNativeHttpClient implements HttpClient {
+  private baseURL?: string;
+
+  constructor(baseURL?: string) {
+    this.baseURL = baseURL;
+  }
+
+  async get<T = any>(url: string, options?: RequestOptions): Promise<T> {
+    return this.request<T>('GET', url, undefined, options);
+  }
+
+  async post<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T> {
+    return this.request<T>('POST', url, body, options);
+  }
+
+  async put<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T> {
+    return this.request<T>('PUT', url, body, options);
+  }
+
+  async delete<T = any>(url: string, options?: RequestOptions): Promise<T> {
+    return this.request<T>('DELETE', url, undefined, options);
+  }
+
+  private async request<T>(
+    method: string,
+    url: string,
+    body?: any,
+    options?: RequestOptions
+  ): Promise<T> {
+    const fullUrl = this.buildUrl(url, options?.params);
+    
+    const config: RequestInit = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...options?.headers,
+      },
+    };
+
+    // Add timeout if specified
+    if (options?.timeout) {
+      const controller = new AbortController();
+      config.signal = controller.signal;
+      setTimeout(() => controller.abort(), options.timeout);
+    }
+
+    // Add body for POST/PUT requests
+    if (body && (method === 'POST' || method === 'PUT')) {
+      config.body = JSON.stringify(body);
+    }
+
+    try {
+      const response = await fetch(fullUrl, config);
+      
+      if (!response.ok) {
+        // Try to get error details from response
+        let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+        try {
+          const errorBody = await response.text();
+          if (errorBody) {
+            errorMessage += ` - ${errorBody}`;
+          }
+        } catch (e) {
+          // Ignore errors when reading error body
+        }
+        throw new Error(errorMessage);
+      }
+
+      // Handle different response types
+      switch (options?.responseType) {
+        case 'text':
+          return response.text() as Promise<T>;
+        case 'blob':
+          return response.blob() as Promise<T>;
+        case 'arraybuffer':
+          return response.arrayBuffer() as Promise<T>;
+        case 'json':
+        default:
+          // Check if response has content
+          const contentLength = response.headers.get('content-length');
+          if (contentLength === '0' || response.status === 204) {
+            return undefined as T;
+          }
+          return response.json();
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error(`Request timeout after ${options?.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+
+  private buildUrl(url: string, params?: Record<string, string>): string {
+    const fullUrl = this.baseURL ? `${this.baseURL}${url}` : url;
+    
+    if (!params || Object.keys(params).length === 0) {
+      return fullUrl;
+    }
+
+    const urlObj = new URL(fullUrl);
+    Object.entries(params).forEach(([key, value]) => {
+      urlObj.searchParams.append(key, value);
+    });
+    
+    return urlObj.toString();
+  }
+}

package/src/types/external-modules.d.ts

@@ -0,0 +1,13 @@
+// Type declarations for externalized dependencies
+declare module '@explorins/pers-shared' {
+  // Re-export all types from pers-shared
+  export * from '@explorins/pers-shared/dist/types';
+}
+
+declare module 'ethers/providers' {
+  export * from 'ethers/lib/providers';
+}
+
+declare module 'ethers/utils' {
+  export * from 'ethers/lib/utils';
+}

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

@@ -0,0 +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;
+  };
+}
+
+export {};