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

package/src/hooks/useAuth.ts

@@ -1,32 +1,284 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import type { RawUserData } from '@explorins/pers-sdk/core';
+import type { UserDTO, AdminDTO, SessionAuthContextResponseDTO } from '@explorins/pers-shared';
 
-export interface AuthHook {
-  // State
-  isInitialized: boolean;
-  isAuthenticated: boolean;
-  user: any | null;
-  accountAddress: string | null;
-  
-  // Actions
-  initialize: (config: any) => Promise<void>;
-  login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<any>;
-  loginWithRawData: (rawUserData: any) => Promise<any>;
-  logout: () => Promise<void>;
-}
-
-export const useAuth = (): AuthHook => {
-  const {
-    isInitialized,
-    isAuthenticated,
-    user,
-    accountAddress,
-    initialize,
-    login,
-    loginWithRawData,
-    logout,
+// Re-export RawUserData for convenience
+export type { RawUserData };
+
+/**
+ * React hook for authentication operations in the PERS SDK
+ * 
+ * Provides methods for user login, logout, token management, and authentication state.
+ * Automatically manages authentication state and user data synchronization.
+ * 
+ * @returns Authentication hook with methods and state
+ * 
+ * @example
+ * ```typescript
+ * function LoginComponent() {
+ *   const { login, logout, isAuthenticated, user } = useAuth();
+ *   
+ *   const handleLogin = async (token: string) => {
+ *     try {
+ *       await login(token, 'user');
+ *       console.log('Login successful');
+ *     } catch (error) {
+ *       console.error('Login failed:', error);
+ *     }
+ *   };
+ * 
+ *   return (
+ *     <div>
+ *       {isAuthenticated ? (
+ *         <div>
+ *           <p>Welcome, {user?.name}</p>
+ *           <button onClick={logout}>Logout</button>
+ *         </div>
+ *       ) : (
+ *         <button onClick={() => handleLogin('jwt-token')}>Login</button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export const useAuth = () => {
+  const { 
+    sdk,
+    authProvider, 
+    isInitialized, 
+    isAuthenticated, 
+    user, 
+    accountAddress, 
+    setAuthenticationState, 
+    refreshUserData 
   } = usePersSDK();
+  
+  /**
+   * Authenticates a user with a JWT token
+   * 
+   * @param jwtToken - The JWT token to authenticate with
+   * @param userType - The type of user ('user' | 'admin'), defaults to 'user'
+   * @returns Promise resolving to session auth context with user data
+   * @throws Error if SDK is not initialized or authentication fails
+   * 
+   * @example
+   * ```typescript
+   * const { login } = useAuth();
+   * const result = await login(jwtToken, 'user');
+   * console.log('Logged in user:', result.user);
+   * ```
+   */
+  const login = useCallback(async (jwtToken: string, userType: 'user' | 'admin' = 'user'): Promise<SessionAuthContextResponseDTO> => {
+    if (!sdk || !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 using the manager
+      const result = await sdk.auth.loginWithToken(jwtToken, userType);
+      
+      const userData = result.user || result.admin;
+      
+      if (userData) {
+        const userAccountAddress = ('accountAddress' in userData && userData.accountAddress) ||
+                                  ('wallets' in userData && userData.wallets?.[0]?.address) ||
+                                  null;
+        
+        setAuthenticationState(userData, userAccountAddress as string | null, true);
+        
+        console.log('Login successful');
+        return result;
+      } else {
+        throw new Error('No user data returned from login');
+      }
+    } catch (error) {
+      console.error('Login failed:', error);
+      throw error;
+    }
+  }, [sdk, authProvider, setAuthenticationState]);
+
+  /**
+   * Logs in a user using raw user data (direct authentication bypass)
+   * 
+   * @param rawUserData - Raw user data for direct authentication
+   * @throws Error if SDK is not initialized or authentication fails
+   * 
+   * @example
+   * ```typescript
+   * const { loginWithRawData } = useAuth();
+   * await loginWithRawData({ userId: '123', email: 'user@example.com' });
+   * ```
+   */
+  const loginWithRawData = useCallback(async (rawUserData: RawUserData): Promise<void> => {
+    if (!sdk || !authProvider) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+
+    try {
+      console.log('Logging in with raw user data...');
+      
+      // Use the raw data login from the API client directly
+      const result = await sdk.api().loginUserWithRawData(rawUserData);
+      
+      // Set token from result
+      if (result.accessToken) {
+        await authProvider.setToken(result.accessToken);
+      }
+      
+      const userData = result.user;
+      
+      if (userData) {
+        const userAccountAddress = userData.accountAddress ||
+                                  (userData as UserDTO & { wallets?: Array<{ address: string }> })?.wallets?.[0]?.address ||
+                                  null;
+        
+        setAuthenticationState(userData, userAccountAddress, true);
+        
+        console.log('Raw data login successful');
+      } else {
+        throw new Error('No user data returned from raw data login');
+      }
+    } catch (error) {
+      console.error('Raw data login failed:', error);
+      throw error;
+    }
+  }, [sdk, authProvider, setAuthenticationState]);
+
+  /**
+   * Logs out the current user and clears authentication state
+   * 
+   * @throws Error if logout process fails
+   * 
+   * @example
+   * ```typescript
+   * const { logout } = useAuth();
+   * await logout();
+   * console.log('User logged out');
+   * ```
+   */
+  const logout = useCallback(async (): Promise<void> => {
+    try {
+      console.log('Logging out...');
+      
+      if (authProvider) {
+        await authProvider.setToken(null);
+      }
+      
+      setAuthenticationState(null, null, false);
+      
+      console.log('Logout successful');
+    } catch (error) {
+      console.error('Logout failed:', error);
+      throw error;
+    }
+  }, [authProvider, setAuthenticationState]);
+
+  /**
+   * Retrieves the current authenticated user data
+   * 
+   * @returns Promise resolving to current user data
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getCurrentUser } = useAuth();
+   * const user = await getCurrentUser();
+   * console.log('Current user:', user.email);
+   * ```
+   */
+  const getCurrentUser = useCallback(async (): Promise<UserDTO> => {
+    if (!sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    return sdk.auth.getCurrentUser();
+  }, [sdk]);
+
+  /**
+   * Checks if the current session is authenticated
+   * 
+   * @returns Promise resolving to authentication status
+   * 
+   * @example
+   * ```typescript
+   * const { checkIsAuthenticated } = useAuth();
+   * const isAuth = await checkIsAuthenticated();
+   * console.log('Is authenticated:', isAuth);
+   * ```
+   */
+  const checkIsAuthenticated = useCallback(async (): Promise<boolean> => {
+    if (!sdk) {
+      return false;
+    }
+    return sdk.auth.isAuthenticated();
+  }, [sdk]);
+
+  /**
+   * Refreshes authentication tokens
+   * 
+   * @param refreshToken - Optional refresh token to use
+   * @returns Promise resolving to new session auth response
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { refreshTokens } = useAuth();
+   * const tokens = await refreshTokens();
+   * console.log('Tokens refreshed:', tokens);
+   * ```
+   */
+  const refreshTokens = useCallback(async (refreshToken?: string) => {
+    if (!sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    return sdk.auth.refreshTokens(refreshToken);
+  }, [sdk]);
+
+  /**
+   * Clears all authentication data and resets auth state
+   * 
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { clearAuth } = useAuth();
+   * await clearAuth();
+   * console.log('Auth data cleared');
+   * ```
+   */
+  const clearAuth = useCallback(async (): Promise<void> => {
+    if (!sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    await sdk.auth.clearAuth();
+    setAuthenticationState(null, null, false);
+  }, [sdk, setAuthenticationState]);
+
+  /**
+   * Checks if the current authentication is valid (non-expired)
+   * 
+   * @returns Boolean indicating if auth is valid
+   * 
+   * @example
+   * ```typescript
+   * const { hasValidAuth } = useAuth();
+   * const isValid = hasValidAuth();
+   * console.log('Auth is valid:', isValid);
+   * ```
+   */
+  const hasValidAuth = useCallback((): boolean => {
+    if (!sdk) {
+      return false;
+    }
+    return sdk.auth.hasValidAuth();
+  }, [sdk]);
+  
   return {
     // State
     isInitialized,
@@ -34,10 +286,17 @@ export const useAuth = (): AuthHook => {
     user,
     accountAddress,
     
-    // Actions
-    initialize,
+    // Methods
     login,
     loginWithRawData,
     logout,
+    refreshUserData,
+    getCurrentUser,
+    checkIsAuthenticated,
+    refreshTokens,
+    clearAuth,
+    hasValidAuth,
   };
-};
+};
+
+export type AuthHook = ReturnType<typeof useAuth>;

package/src/hooks/useBusiness.ts

@@ -1,69 +1,232 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import type { BusinessDTO, BusinessTypeDTO, BusinessUpdateRequestDTO, BusinessToggleActiveRequestDTO } from '@explorins/pers-shared';
 
+/**
+ * React hook for business operations in the PERS SDK
+ * 
+ * Provides methods for fetching, creating, and managing businesses within the platform.
+ * Includes both public business queries and administrative operations.
+ * 
+ * @returns Business hook with methods for business management
+ * 
+ * @example
+ * ```typescript
+ * function BusinessesComponent() {
+ *   const { 
+ *     getActiveBusinesses, 
+ *     getBusinessById, 
+ *     createBusiness 
+ *   } = useBusiness();
+ *   
+ *   const loadBusinesses = async () => {
+ *     try {
+ *       const businesses = await getActiveBusinesses();
+ *       console.log('Active businesses:', businesses);
+ *     } catch (error) {
+ *       console.error('Failed to load businesses:', error);
+ *     }
+ *   };
+ * 
+ *   return (
+ *     <div>
+ *       <button onClick={loadBusinesses}>Load Businesses</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
 export const useBusiness = () => {
-  const { business, isInitialized } = usePersSDK();
+  const { sdk, isInitialized } = usePersSDK();
 
-  const getActiveBusinesses = useCallback(async () => {
-    if (!isInitialized) {
+  /**
+   * Retrieves all currently active businesses in the system
+   * 
+   * @returns Promise resolving to array of active businesses
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getActiveBusinesses } = useBusiness();
+   * const businesses = await getActiveBusinesses();
+   * console.log('Active businesses:', businesses);
+   * ```
+   */
+  const getActiveBusinesses = useCallback(async (): Promise<BusinessDTO[]> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!business?.getActiveBusinesses) {
-      console.warn('getActiveBusinesses method not available');
-      return [];
+    
+    try {
+      const result = await sdk.businesses.getActiveBusinesses();
+      console.log('Active businesses fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch active businesses:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  /**
+   * Retrieves all available business types/categories
+   * 
+   * @returns Promise resolving to array of business types
+   * @throws Error if SDK is not initialized
+   * 
+   * @example
+   * ```typescript
+   * const { getBusinessTypes } = useBusiness();
+   * const types = await getBusinessTypes();
+   * console.log('Business types:', types);
+   * ```
+   */
+  const getBusinessTypes = useCallback(async (): Promise<BusinessTypeDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.businesses.getBusinessTypes();
+      console.log('Business types fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch business types:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getBusinessById = useCallback(async (businessId: string): Promise<BusinessDTO | null> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.businesses.getBusinessById(businessId);
+      console.log('Business fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch business:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getBusinesses = useCallback(async (): Promise<BusinessDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await business.getActiveBusinesses();
-      console.log('✅ Active businesses fetched successfully:', result);
+      const result = await sdk.businesses.getBusinesses();
+      console.log('All businesses fetched successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch active businesses:', error);
+      console.error('Failed to fetch all businesses:', error);
       throw error;
     }
-  }, [business]);
+  }, [sdk, isInitialized]);
 
-  const getAllBusinessTypes = useCallback(async () => {
-    if (!isInitialized) {
+  const getBusinessByAccount = useCallback(async (accountAddress: string): Promise<BusinessDTO> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!business?.getAllBusinessTypes) {
-      console.warn('getAllBusinessTypes method not available');
-      return [];
+    
+    try {
+      const result = await sdk.businesses.getBusinessByAccount(accountAddress);
+      console.log('Business by account fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch business by account:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const getBusinessesByType = useCallback(async (typeId: string): Promise<BusinessDTO[]> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
+    }
+    
+    try {
+      const result = await sdk.businesses.getBusinessesByType(typeId);
+      console.log('Businesses by type fetched successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to fetch businesses by type:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  // Admin methods
+  /**
+   * Creates a new business (Admin operation)
+   * 
+   * @param displayName - The display name for the new business
+   * @returns Promise resolving to the created business data
+   * @throws Error if SDK is not initialized or user lacks permissions
+   * 
+   * @example
+   * ```typescript
+   * const { createBusiness } = useBusiness();
+   * const business = await createBusiness('My Coffee Shop');
+   * console.log('Business created:', business);
+   * ```
+   */
+  const createBusiness = useCallback(async (displayName: string): Promise<BusinessDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await business.getAllBusinessTypes();
-      console.log('✅ Business types fetched successfully:', result);
+      const result = await sdk.businesses.createBusiness(displayName);
+      console.log('Business created successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch business types:', error);
+      console.error('Failed to create business:', error);
       throw error;
     }
-  }, [business]);
+  }, [sdk, isInitialized]);
 
-  const getBusinessById = useCallback(async (businessId: string) => {
-    if (!isInitialized) {
+  const updateBusiness = useCallback(async (businessId: string, businessData: BusinessUpdateRequestDTO): Promise<BusinessDTO> => {
+    if (!isInitialized || !sdk) {
       throw new Error('SDK not initialized. Call initialize() first.');
     }
-    if (!business?.getBusinessById) {
-      throw new Error('getBusinessById method not available');
+    
+    try {
+      const result = await sdk.businesses.updateBusiness(businessId, businessData);
+      console.log('Business updated successfully:', result);
+      return result;
+    } catch (error) {
+      console.error('Failed to update business:', error);
+      throw error;
+    }
+  }, [sdk, isInitialized]);
+
+  const toggleBusinessStatus = useCallback(async (businessId: string, toggleData: BusinessToggleActiveRequestDTO): Promise<BusinessDTO> => {
+    if (!isInitialized || !sdk) {
+      throw new Error('SDK not initialized. Call initialize() first.');
     }
     
     try {
-      const result = await business.getBusinessById(businessId);
-      console.log('✅ Business fetched successfully:', result);
+      const result = await sdk.businesses.toggleBusinessStatus(businessId, toggleData);
+      console.log('Business status toggled successfully:', result);
       return result;
     } catch (error) {
-      console.error('❌ Failed to fetch business:', error);
+      console.error('Failed to toggle business status:', error);
       throw error;
     }
-  }, [business]);
+  }, [sdk, isInitialized]);
 
   return {
     getActiveBusinesses,
-    getAllBusinessTypes,
+    getBusinessTypes,
+    getBusinesses,
     getBusinessById,
-    isAvailable: isInitialized && !!business,
+    getBusinessByAccount,
+    getBusinessesByType,
+    createBusiness,
+    updateBusiness,
+    toggleBusinessStatus,
+    isAvailable: isInitialized && !!sdk?.businesses,
   };
-};
+};
+
+export type BusinessHook = ReturnType<typeof useBusiness>;