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

package/src/polyfills/web3-polyfills.ts

@@ -0,0 +1,98 @@
+/**
+ * Web3 specific polyfills for React Native
+ * Addresses instanceof and constructor issues in React Native environments
+ */
+
+export const setupWeb3InstanceofPolyfill = () => {
+  try {
+    // Store the original instanceof behavior
+    const originalInstanceof = Function.prototype[Symbol.hasInstance];
+    
+    // Override Symbol.hasInstance for better Web3 detection in React Native
+    if (typeof global !== 'undefined' && global.Symbol && global.Symbol.hasInstance) {
+      // Create a safer instanceof check for Web3
+      const createSafeInstanceofCheck = (constructor: any) => {
+        return function(instance: any) {
+          // Try the original check first
+          try {
+            if (originalInstanceof) {
+              return originalInstanceof.call(constructor, instance);
+            }
+            return instance instanceof constructor;
+          } catch (error) {
+            // Fallback to constructor and duck-typing checks
+            if (!instance || typeof instance !== 'object') {
+              return false;
+            }
+            
+            // Check constructor name
+            if (instance.constructor && instance.constructor.name === constructor.name) {
+              return true;
+            }
+            
+            // Check constructor reference
+            if (instance.constructor === constructor) {
+              return true;
+            }
+            
+            // For Web3 specifically, check characteristic properties
+            if (constructor.name === 'Web3' && 
+                'currentProvider' in instance && 
+                'eth' in instance && 
+                'utils' in instance) {
+              return true;
+            }
+            
+            return false;
+          }
+        };
+      };
+      
+      // Apply the polyfill to global scope for dynamic loading
+      (global as any).__PERS_SDK_SAFE_INSTANCEOF__ = createSafeInstanceofCheck;
+      
+    }
+    
+    return true;
+  } catch (error) {
+    console.warn('[PERS SDK] Web3 instanceof polyfill setup failed:', error);
+    return false;
+  }
+};
+
+export const createSafeWeb3Check = (provider: unknown): boolean => {
+  if (!provider || typeof provider !== 'object') {
+    return false;
+  }
+  
+  try {
+    // Method 1: Check if it's already a Web3 instance using multiple approaches
+    const providerObj = provider as any;
+    
+    // Constructor name check
+    if (providerObj.constructor?.name === 'Web3') {
+      return true;
+    }
+    
+    // Duck typing for Web3 properties
+    if ('currentProvider' in providerObj && 
+        'eth' in providerObj && 
+        'utils' in providerObj &&
+        typeof providerObj.eth === 'object') {
+      return true;
+    }
+    
+    // Check for Web3 version property
+    if ('version' in providerObj && typeof providerObj.version === 'string') {
+      return true;
+    }
+    
+    return false;
+  } catch (error) {
+    console.warn('Safe Web3 check failed:', error);
+    return false;
+  }
+};
+
+// Auto-initialize
+setupWeb3InstanceofPolyfill();

package/src/providers/PersSDKProvider.tsx

@@ -1,71 +1,83 @@
-import React, { createContext, useContext, useEffect, useState, ReactNode, useCallback, useRef } from 'react';
-import { PersApiClient } from '@explorins/pers-sdk/core';
-import { TokenSDK } from '@explorins/pers-sdk/token';
-import { createTransactionSDK } from '@explorins/pers-sdk/transaction';
-import { createBusinessSDK } from '@explorins/pers-sdk/business';
-import { createCampaignSDK } from '@explorins/pers-sdk/campaign';
-import { createRedemptionSDK } from '@explorins/pers-sdk/redemption';
-import { createWeb3SDK } from '@explorins/pers-sdk/web3';
+import React, { createContext, useContext, useState, ReactNode, useCallback, useRef } from 'react';
+import { PersSDK, PersConfig, createAuthProvider } from '@explorins/pers-sdk/core';
 import { ReactNativeHttpClient } from './react-native-http-client';
-import { BaseReactNativeAuthProvider } from './react-native-auth-provider';
-
-// Types for the SDK context
-export interface PersSDKConfig {
-  apiProjectKey: string;
-  environment?: 'development' | 'staging' | 'production';
-  timeout?: number;
-}
+import { ReactNativeAuthProvider } from './react-native-auth-provider';
+import { UserDTO, AdminDTO } from '@explorins/pers-shared';
+
+// Import manager types for TypeScript
+import type {
+  AuthManager,
+  UserManager,
+  TokenManager,
+  BusinessManager,
+  CampaignManager,
+  RedemptionManager,
+  TransactionManager,
+  PurchaseManager,
+  TenantManager,
+  AnalyticsManager,
+  DonationManager
+} from '@explorins/pers-sdk/core';
+
+// Re-export PersConfig for external use
+export type { PersConfig } from '@explorins/pers-sdk/core';
 
 export interface PersSDKContext {
-  // SDK instances
-  tokens: any | null;
-  transactions: any | null;
-  business: any | null;
-  campaigns: any | null;
-  redemptions: any | null;
-  web3: any | null;
-  apiClient: PersApiClient | null;
+  // Main SDK instance
+  sdk: PersSDK | null;
+  
+  // Manager shortcuts for convenience
+  auth: AuthManager | null;
+  users: UserManager | null;
+  tokens: TokenManager | null;
+  businesses: BusinessManager | null;
+  campaigns: CampaignManager | null;
+  redemptions: RedemptionManager | null;
+  transactions: TransactionManager | null;
+  purchases: PurchaseManager | null;
+  tenants: TenantManager | null;
+  analytics: AnalyticsManager | null;
+  donations: DonationManager | null;
+  
+  // Legacy support (deprecated but kept for backward compatibility)
+  business: BusinessManager | null;
+  
+  // Platform-specific providers
+  authProvider: ReactNativeSDKAuthProvider | null;
   
   // State
   isInitialized: boolean;
   isAuthenticated: boolean;
-  user: any | null;
+  user: UserDTO | AdminDTO | null;
   accountAddress: string | null;
   
   // Methods
-  initialize: (config: PersSDKConfig) => Promise<void>;
-  login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<any>;
-  loginWithRawData: (rawUserData: any) => Promise<any>;
-  logout: () => Promise<void>;
+  initialize: (config: PersConfig) => Promise<void>;
+  setAuthenticationState: (user: UserDTO | AdminDTO | null, accountAddress: string | null, isAuthenticated: boolean) => void;
+  refreshUserData: () => Promise<void>;
 }
 
 // Create the context
 const SDKContext = createContext<PersSDKContext | null>(null);
 
-// Custom auth provider for React Native
-class ReactNativeSDKAuthProvider extends BaseReactNativeAuthProvider {
-  public authType: 'admin' | 'user' = 'user';
-  private _token: string | null = null;
-  
-  constructor(private projectKey: string) {
-    super(projectKey);
-  }
-
-  async getToken(): Promise<string | null> {
-    return this._token;
+// Simple wrapper for SDK integration
+class ReactNativeSDKAuthProvider extends ReactNativeAuthProvider {
+  constructor(projectKey: string) {
+    super(projectKey, { debug: true });
   }
 
+  // Override setAccessToken to provide backward compatibility
   async setToken(token: string | null): Promise<void> {
-    this._token = token;
-  }
-
-  async getProjectKey(): Promise<string | null> {
-    return this.projectKey;
+    if (token) {
+      await this.setAccessToken(token);
+    } else {
+      await this.clearTokens();
+    }
   }
 
-  async onTokenExpired(): Promise<void> {
-    console.log('Token expired - clearing token');
-    this._token = null;
+  // Override getToken for backward compatibility
+  async getToken(): Promise<string | null> {
+    return await super.getToken();
   }
 }
 
@@ -74,73 +86,47 @@ export const PersSDKProvider: React.FC<{
   children: ReactNode;
 }> = ({ children }) => {
   const initializingRef = useRef(false);
-  const [apiClient, setApiClient] = useState<PersApiClient | null>(null);
+  const [sdk, setSdk] = useState<PersSDK | null>(null);
   const [authProvider, setAuthProvider] = useState<ReactNativeSDKAuthProvider | null>(null);
-  const [sdks, setSdks] = useState<{
-    tokens: any | null;
-    transactions: any | null;
-    business: any | null;
-    campaigns: any | null;
-    redemptions: any | null;
-    web3: any | null;
-  }>({
-    tokens: null,
-    transactions: null,
-    business: null,
-    campaigns: null,
-    redemptions: null,
-    web3: null,
-  });
   
   const [isInitialized, setIsInitialized] = useState(false);
   const [isAuthenticated, setIsAuthenticated] = useState(false);
-  const [user, setUser] = useState<any>(null);
+  const [user, setUser] = useState<UserDTO | AdminDTO | null>(null);
   const [accountAddress, setAccountAddress] = useState<string | null>(null);
 
-  const initialize = useCallback(async (config: PersSDKConfig) => {
+  const initialize = useCallback(async (config: PersConfig) => {
     // Prevent multiple initializations
     if (isInitialized || initializingRef.current) {
-      console.log('⚠️ SDK already initialized or initializing, skipping...');
+      console.log('SDK already initialized or initializing, skipping...');
       return;
     }
     
     initializingRef.current = true;
     
     try {
-      console.log('🚀 Initializing PERS SDK with config:', config);
+      console.log('Initializing PERS SDK with config:', config);
       
-      // Create auth provider
-      const auth = new ReactNativeSDKAuthProvider(config.apiProjectKey);
+      // Create React Native auth provider
+      const auth = new ReactNativeSDKAuthProvider(config.apiProjectKey || 'default-project');
       setAuthProvider(auth);
       
       // Create HTTP client
       const httpClient = new ReactNativeHttpClient();
       
-      // Create API client
-      const client = new PersApiClient(httpClient, {
-        apiProjectKey: config.apiProjectKey,
-        authProvider: auth,
-        environment: config.environment || 'development',
-      });
-      
-      setApiClient(client);
-      
-      // Initialize domain SDKs
-      const domainSDKs = {
-        tokens: new TokenSDK(client),
-        transactions: createTransactionSDK(client),
-        business: createBusinessSDK(client),
-        campaigns: createCampaignSDK(client),
-        redemptions: createRedemptionSDK(client),
-        web3: createWeb3SDK(client),
+      // Create config with auth provider - use the ReactNative auth provider directly
+      const sdkConfig: PersConfig = {
+        ...config,
+        authProvider: auth
       };
       
-      setSdks(domainSDKs);
+      // Initialize PersSDK with manager pattern
+      const sdkInstance = new PersSDK(httpClient, sdkConfig);
+      setSdk(sdkInstance);
       setIsInitialized(true);
       
-      console.log('✅ PERS SDK initialized successfully');
+      console.log('PERS SDK initialized successfully');
     } catch (error) {
-      console.error('❌ Failed to initialize PERS SDK:', error);
+      console.error('Failed to initialize PERS SDK:', error);
       initializingRef.current = false;
       throw error;
     } finally {
@@ -148,99 +134,50 @@ export const PersSDKProvider: React.FC<{
     }
   }, []);
 
-  const login = useCallback(async (jwtToken: string, userType: 'user' | 'admin' = 'user') => {
-    if (!apiClient || !authProvider) {
-      throw new Error('SDK not initialized. Call initialize() first.');
-    }
-
-    try {
-      console.log(`🔐 Logging in as ${userType}...`);
-      
-      // Set token in auth provider
-      await authProvider.setToken(jwtToken);
-      
-      // Perform login with API client
-      const result = userType === 'admin' 
-        ? await apiClient.loginAdmin(jwtToken)
-        : await apiClient.loginUser(jwtToken);
-      
-      const userData = result.user || result.admin;
-      const userAccountAddress = (userData as any)?.accountAddress || 
-                                (userData as any)?.wallets?.[0]?.address || 
-                                null;
-      
-      setUser(userData);
-      setAccountAddress(userAccountAddress);
-      setIsAuthenticated(true);
-      
-      console.log('✅ Login successful');
-      return result;
-    } catch (error) {
-      console.error('❌ Login failed:', error);
-      throw error;
-    }
-  }, [apiClient, authProvider]);
-
-  const loginWithRawData = useCallback(async (rawUserData: any) => {
-    if (!apiClient || !authProvider) {
-      throw new Error('SDK not initialized. Call initialize() first.');
-    }
+  const setAuthenticationState = useCallback((user: UserDTO | AdminDTO | null, accountAddress: string | null, isAuthenticated: boolean) => {
+    setUser(user);
+    setAccountAddress(accountAddress);
+    setIsAuthenticated(isAuthenticated);
+  }, []);
 
-    try {
-      console.log('🔐 Logging in with raw user data...');
-      
-      const result = await apiClient.loginUserWithRawData(rawUserData);
-      
-      // Set token from result
-      if (result.accessToken) {
-        await authProvider.setToken(result.accessToken);
-      }
-      
-      const userData = result.user;
-      const userAccountAddress = (userData as any)?.accountAddress || 
-                                (userData as any)?.wallets?.[0]?.address || 
-                                null;
-      
-      setUser(userData);
-      setAccountAddress(userAccountAddress);
-      setIsAuthenticated(true);
-      
-      console.log('✅ Raw data login successful');
-      return result;
-    } catch (error) {
-      console.error('❌ Raw data login failed:', error);
-      throw error;
+  const refreshUserData = useCallback(async (): Promise<void> => {
+    if (!sdk || !isAuthenticated || !isInitialized) {
+      throw new Error('SDK not initialized or not authenticated. Cannot refresh user data.');
     }
-  }, [apiClient, authProvider]);
-
-  const logout = useCallback(async () => {
+    
     try {
-      console.log('🔓 Logging out...');
-      
-      if (authProvider) {
-        await authProvider.setToken(null);
-      }
-      
-      setUser(null);
-      setAccountAddress(null);
-      setIsAuthenticated(false);
-      
-      console.log('✅ Logout successful');
+      console.log('Refreshing user data from remote server...');
+      const freshUserData = await sdk.users.getCurrentUser();
+      setUser(freshUserData);
+      console.log('User data refreshed successfully:', freshUserData);
     } catch (error) {
-      console.error('❌ Logout failed:', error);
+      console.error('Failed to refresh user data:', error);
       throw error;
     }
-  }, [authProvider]);
+  }, [sdk, isAuthenticated, isInitialized]);
 
   const contextValue: PersSDKContext = {
-    // SDK instances
-    tokens: sdks.tokens,
-    transactions: sdks.transactions,
-    business: sdks.business,
-    campaigns: sdks.campaigns,
-    redemptions: sdks.redemptions,
-    web3: sdks.web3,
-    apiClient,
+    // Main SDK instance
+    sdk,
+    
+    // Manager shortcuts for convenience
+    auth: sdk?.auth || null,
+    users: sdk?.users || null,
+    tokens: sdk?.tokens || null,
+    businesses: sdk?.businesses || null,
+    campaigns: sdk?.campaigns || null,
+    redemptions: sdk?.redemptions || null,
+    transactions: sdk?.transactions || null,
+    purchases: sdk?.purchases || null,
+    tenants: sdk?.tenants || null,
+    analytics: sdk?.analytics || null,
+    donations: sdk?.donations || null,
+    
+    // Legacy support (deprecated but kept for backward compatibility)
+    business: sdk?.businesses || null,
+    
+    // Platform-specific providers
+    authProvider,
     
     // State
     isInitialized,
@@ -250,9 +187,8 @@ export const PersSDKProvider: React.FC<{
     
     // Methods
     initialize,
-    login,
-    loginWithRawData,
-    logout,
+    setAuthenticationState,
+    refreshUserData,
   };
 
   return (