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

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

@@ -1,110 +1,110 @@
-/**
- * React Native Unified Auth Provider
- * 
- * Creates a platform-specific auth provider that automatically selects the appropriate storage:
- * - Web: Uses IndexedDBTokenStorage for DPoP (CryptoKey persistence) or LocalStorage
- * - Mobile: Uses AsyncStorage-based storage
- */
-
-import { Platform } from 'react-native';
-import { DefaultAuthProvider, AccountOwnerType, LocalStorageTokenStorage, IndexedDBTokenStorage } from '@explorins/pers-sdk/core';
-import { ReactNativeSecureStorage } from '../storage/rn-secure-storage';
-import type { TokenStorage } from '@explorins/pers-sdk/core';
-
-// Use React Native's built-in platform detection
-const isWebPlatform = Platform.OS === 'web';
-
-/**
- * Check if IndexedDB is available (web environments only)
- * Uses globalThis to avoid TypeScript errors in React Native context
- */
-function hasIndexedDB(): boolean {
-  return typeof globalThis !== 'undefined' && 
-         typeof (globalThis as Record<string, unknown>).indexedDB !== 'undefined';
-}
-
-/**
- * Configuration for React Native Auth Provider
- */
-export interface ReactNativeAuthConfig {
-  /** Custom storage key prefix */
-  keyPrefix?: string;
-  /** Enable debug logging */
-  debug?: boolean;
-  /** Custom token storage implementation */
-  customStorage?: TokenStorage;
-  /** Authentication type (default: AccountOwnerType.USER) */
-  authType?: AccountOwnerType;
-  /** DPoP Configuration (optional) */
-  dpop?: {
-    enabled?: boolean;
-    cryptoProvider?: import('@explorins/pers-sdk/core').DPoPCryptoProvider;
-  };
-}
-
-/**
- * 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)
- * 
- * @param projectKey - PERS project key
- * @param config - Configuration options
- * @returns DefaultAuthProvider configured for the current platform
- */
-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 = AccountOwnerType.USER,
-    dpop
-  } = config;
-
-  // Platform-specific storage selection
-  // Web with DPoP: Use IndexedDB for CryptoKey persistence
-  // Web without DPoP or no IndexedDB: Use LocalStorage
-  // Mobile: Use ReactNativeSecureStorage
-  let tokenStorage: TokenStorage;
-  
-  if (customStorage) {
-    tokenStorage = customStorage;
-  } else if (isWebPlatform) {
-    // On web, prefer IndexedDB when DPoP is enabled for proper CryptoKey persistence
-    const dpopEnabled = dpop?.enabled ?? true;
-    
-    if (dpopEnabled && hasIndexedDB()) {
-      tokenStorage = new IndexedDBTokenStorage();
-    } else {
-      if (dpopEnabled && !hasIndexedDB()) {
-        console.warn('[ReactNativeAuthProvider] DPoP requested but IndexedDB not available. Falling back to LocalStorage (DPoP will be disabled by DefaultAuthProvider).');
-      }
-      tokenStorage = new LocalStorageTokenStorage();
-    }
-  } else {
-    tokenStorage = new ReactNativeSecureStorage(keyPrefix);
-  }
-
-  // Prepare DPoP config ensuring enabled is boolean (default true)
-  const dpopConfig = dpop ? {
-    enabled: dpop.enabled ?? true,
-    cryptoProvider: dpop.cryptoProvider
-  } : undefined;
-
-  // Return DefaultAuthProvider configured with platform-appropriate storage
-  return new DefaultAuthProvider({
-    authType,
-    projectKey,
-    storage: tokenStorage,
-    dpop: dpopConfig
-  });
-}
-
+/**
+ * React Native Unified Auth Provider
+ * 
+ * Creates a platform-specific auth provider that automatically selects the appropriate storage:
+ * - Web: Uses IndexedDBTokenStorage for DPoP (CryptoKey persistence) or LocalStorage
+ * - Mobile: Uses AsyncStorage-based storage
+ */
+
+import { Platform } from 'react-native';
+import { DefaultAuthProvider, AccountOwnerType, LocalStorageTokenStorage, IndexedDBTokenStorage } from '@explorins/pers-sdk/core';
+import { ReactNativeSecureStorage } from '../storage/rn-secure-storage';
+import type { TokenStorage } from '@explorins/pers-sdk/core';
+
+// Use React Native's built-in platform detection
+const isWebPlatform = Platform.OS === 'web';
+
+/**
+ * Check if IndexedDB is available (web environments only)
+ * Uses globalThis to avoid TypeScript errors in React Native context
+ */
+function hasIndexedDB(): boolean {
+  return typeof globalThis !== 'undefined' && 
+         typeof (globalThis as Record<string, unknown>).indexedDB !== 'undefined';
+}
+
+/**
+ * Configuration for React Native Auth Provider
+ */
+export interface ReactNativeAuthConfig {
+  /** Custom storage key prefix */
+  keyPrefix?: string;
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Custom token storage implementation */
+  customStorage?: TokenStorage;
+  /** Authentication type (default: AccountOwnerType.USER) */
+  authType?: AccountOwnerType;
+  /** DPoP Configuration (optional) */
+  dpop?: {
+    enabled?: boolean;
+    cryptoProvider?: import('@explorins/pers-sdk/core').DPoPCryptoProvider;
+  };
+}
+
+/**
+ * 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)
+ * 
+ * @param projectKey - PERS project key
+ * @param config - Configuration options
+ * @returns DefaultAuthProvider configured for the current platform
+ */
+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 = AccountOwnerType.USER,
+    dpop
+  } = config;
+
+  // Platform-specific storage selection
+  // Web with DPoP: Use IndexedDB for CryptoKey persistence
+  // Web without DPoP or no IndexedDB: Use LocalStorage
+  // Mobile: Use ReactNativeSecureStorage
+  let tokenStorage: TokenStorage;
+  
+  if (customStorage) {
+    tokenStorage = customStorage;
+  } else if (isWebPlatform) {
+    // On web, prefer IndexedDB when DPoP is enabled for proper CryptoKey persistence
+    const dpopEnabled = dpop?.enabled ?? true;
+    
+    if (dpopEnabled && hasIndexedDB()) {
+      tokenStorage = new IndexedDBTokenStorage();
+    } else {
+      if (dpopEnabled && !hasIndexedDB()) {
+        console.warn('[ReactNativeAuthProvider] DPoP requested but IndexedDB not available. Falling back to LocalStorage (DPoP will be disabled by DefaultAuthProvider).');
+      }
+      tokenStorage = new LocalStorageTokenStorage();
+    }
+  } else {
+    tokenStorage = new ReactNativeSecureStorage(keyPrefix);
+  }
+
+  // Prepare DPoP config ensuring enabled is boolean (default true)
+  const dpopConfig = dpop ? {
+    enabled: dpop.enabled ?? true,
+    cryptoProvider: dpop.cryptoProvider
+  } : undefined;
+
+  // Return DefaultAuthProvider configured with platform-appropriate storage
+  return new DefaultAuthProvider({
+    authType,
+    projectKey,
+    storage: tokenStorage,
+    dpop: dpopConfig
+  });
+}
+

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

@@ -1,146 +1,151 @@
-/**
- * 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.
- */
-
-/**
- * Request options for HTTP client operations
- * 
- * @interface RequestOptions
- * @property {Record<string, string>} [headers] - HTTP headers to include
- * @property {Record<string, string>} [params] - URL parameters
- * @property {number} [timeout] - Request timeout in milliseconds
- * @property {'json' | 'blob' | 'text' | 'arraybuffer'} [responseType] - Expected response type
- */
-export interface RequestOptions {
-  headers?: Record<string, string>;
-  params?: Record<string, string>;
-  timeout?: number;
-  responseType?: 'json' | 'blob' | 'text' | 'arraybuffer'; 
-}
-
-/**
- * HTTP Client interface for React Native
- * 
- * @interface HttpClient
- * @template T - Response type
- */
-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) {
-        // Get raw error response for ErrorUtils to handle
-        let errorText = '';
-        try {
-          errorText = await response.text();
-        } catch (e) {
-          // Ignore errors when reading error body
-        }
-
-        // Create simple error with HTTP status and raw response
-        const httpError = new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
-        (httpError as any).status = response.status;
-        
-        throw httpError;
-      }
-
-      // 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();
-  }
+/**
+ * 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.
+ */
+
+/**
+ * Request options for HTTP client operations
+ * 
+ * @interface RequestOptions
+ * @property {Record<string, string>} [headers] - HTTP headers to include
+ * @property {Record<string, string>} [params] - URL parameters
+ * @property {number} [timeout] - Request timeout in milliseconds
+ * @property {'json' | 'blob' | 'text' | 'arraybuffer'} [responseType] - Expected response type
+ */
+export interface RequestOptions {
+  headers?: Record<string, string>;
+  params?: Record<string, string>;
+  timeout?: number;
+  responseType?: 'json' | 'blob' | 'text' | 'arraybuffer'; 
+}
+
+/**
+ * HTTP Client interface for React Native
+ * 
+ * @interface HttpClient
+ * @template T - Response type
+ */
+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>;
+  patch<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 patch<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T> {
+    return this.request<T>('PATCH', 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/PATCH requests
+    if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+      config.body = JSON.stringify(body);
+    }
+
+    try {
+      const response = await fetch(fullUrl, config);
+      
+      if (!response.ok) {
+        // Get raw error response for ErrorUtils to handle
+        let errorText = '';
+        try {
+          errorText = await response.text();
+        } catch (e) {
+          // Ignore errors when reading error body
+        }
+
+        // Create simple error with HTTP status and raw response
+        const httpError = new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
+        (httpError as any).status = response.status;
+        
+        throw httpError;
+      }
+
+      // 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();
+  }
 }