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

package/dist/hooks/useAnalytics.js

@@ -0,0 +1,73 @@
+import { useCallback } from 'react';
+import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * React hook for analytics operations in the PERS SDK
+ *
+ * Provides methods for retrieving transaction analytics and insights.
+ * Supports various analytics queries for business intelligence and reporting.
+ *
+ * @returns Analytics hook with methods for data analysis
+ *
+ * @example
+ * ```typescript
+ * function AnalyticsComponent() {
+ *   const { getTransactionAnalytics } = useAnalytics();
+ *
+ *   const loadAnalytics = async () => {
+ *     try {
+ *       const analytics = await getTransactionAnalytics({
+ *         timeRange: 'last_30_days',
+ *         groupBy: 'day'
+ *       });
+ *       console.log('Transaction analytics:', analytics);
+ *     } catch (error) {
+ *       console.error('Failed to load analytics:', error);
+ *     }
+ *   };
+ *
+ *   return <button onClick={loadAnalytics}>Load Analytics</button>;
+ * }
+ * ```
+ */
+export const useAnalytics = () => {
+    const { sdk, isInitialized } = usePersSDK();
+    /**
+     * Retrieves transaction analytics data based on request parameters
+     *
+     * @param request - Analytics request parameters (time range, grouping, filters, etc.)
+     * @returns Promise resolving to analytics data with results and metadata
+     * @throws Error if SDK is not initialized
+     *
+     * @example
+     * ```typescript
+     * const { getTransactionAnalytics } = useAnalytics();
+     * const analytics = await getTransactionAnalytics({
+     *   groupBy: ['day'],
+     *   metrics: ['count', 'sum'],
+     *   startDate: '2024-01-01',
+     *   endDate: '2024-01-31',
+     *   filters: { status: 'completed' }
+     * });
+     * console.log('Daily transaction analytics:', analytics.results);
+     * console.log('Execution time:', analytics.metadata.executionTime);
+     * ```
+     */
+    const getTransactionAnalytics = useCallback(async (request) => {
+        if (!isInitialized || !sdk) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const result = await sdk.analytics.getTransactionAnalytics(request);
+            console.log('Transaction analytics fetched successfully:', result);
+            return result;
+        }
+        catch (error) {
+            console.error('Failed to fetch transaction analytics:', error);
+            throw error;
+        }
+    }, [sdk, isInitialized]);
+    return {
+        getTransactionAnalytics,
+        isAvailable: isInitialized && !!sdk?.analytics,
+    };
+};

package/dist/hooks/useAuth.d.ts

@@ -1,12 +1,57 @@
-export interface AuthHook {
+import type { RawUserData } from '@explorins/pers-sdk/core';
+import type { UserDTO, AdminDTO, SessionAuthContextResponseDTO } from '@explorins/pers-shared';
+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 declare const useAuth: () => {
     isInitialized: boolean;
     isAuthenticated: boolean;
-    user: any | null;
+    user: UserDTO | AdminDTO | null;
     accountAddress: string | null;
-    initialize: (config: any) => Promise<void>;
-    login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<any>;
-    loginWithRawData: (rawUserData: any) => Promise<any>;
+    login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<SessionAuthContextResponseDTO>;
+    loginWithRawData: (rawUserData: RawUserData) => Promise<void>;
     logout: () => Promise<void>;
-}
-export declare const useAuth: () => AuthHook;
+    refreshUserData: () => Promise<void>;
+    getCurrentUser: () => Promise<UserDTO>;
+    checkIsAuthenticated: () => Promise<boolean>;
+    refreshTokens: (refreshToken?: string) => Promise<import("@explorins/pers-shared").SessionAuthResponseDTO>;
+    clearAuth: () => Promise<void>;
+    hasValidAuth: () => boolean;
+};
+export type AuthHook = ReturnType<typeof useAuth>;
 //# sourceMappingURL=useAuth.d.ts.map

package/dist/hooks/useAuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,QAAQ;IAEvB,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,IAAI,EAAE,GAAG,GAAG,IAAI,CAAC;IACjB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAG9B,UAAU,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACvE,gBAAgB,EAAE,CAAC,WAAW,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;IACrD,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B;AAED,eAAO,MAAM,OAAO,QAAO,QAyB1B,CAAC"}
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAG/F,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,OAAO;;;;;sBA2ByB,MAAM,aAAY,MAAM,GAAG,OAAO,KAAY,QAAQ,6BAA6B,CAAC;oCA8CtE,WAAW,KAAG,QAAQ,IAAI,CAAC;kBA+C/C,QAAQ,IAAI,CAAC;;0BA8BL,QAAQ,OAAO,CAAC;gCAmBV,QAAQ,OAAO,CAAC;mCAqBX,MAAM;qBAmBtB,QAAQ,IAAI,CAAC;wBAoBhB,OAAO;CAyB7C,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}

package/dist/hooks/useAuth.js

@@ -1,16 +1,263 @@
+import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+/**
+ * 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 { isInitialized, isAuthenticated, user, accountAddress, initialize, login, loginWithRawData, logout, } = usePersSDK();
+    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, userType = 'user') => {
+        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, 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) => {
+        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?.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 () => {
+        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 () => {
+        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 () => {
+        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) => {
+        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 () => {
+        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(() => {
+        if (!sdk) {
+            return false;
+        }
+        return sdk.auth.hasValidAuth();
+    }, [sdk]);
     return {
         // State
         isInitialized,
         isAuthenticated,
         user,
         accountAddress,
-        // Actions
-        initialize,
+        // Methods
         login,
         loginWithRawData,
         logout,
+        refreshUserData,
+        getCurrentUser,
+        checkIsAuthenticated,
+        refreshTokens,
+        clearAuth,
+        hasValidAuth,
     };
 };

package/dist/hooks/useBusiness.d.ts

@@ -1,7 +1,49 @@
+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 declare const useBusiness: () => {
-    getActiveBusinesses: () => Promise<any>;
-    getAllBusinessTypes: () => Promise<any>;
-    getBusinessById: (businessId: string) => Promise<any>;
+    getActiveBusinesses: () => Promise<BusinessDTO[]>;
+    getBusinessTypes: () => Promise<BusinessTypeDTO[]>;
+    getBusinesses: () => Promise<BusinessDTO[]>;
+    getBusinessById: (businessId: string) => Promise<BusinessDTO | null>;
+    getBusinessByAccount: (accountAddress: string) => Promise<BusinessDTO>;
+    getBusinessesByType: (typeId: string) => Promise<BusinessDTO[]>;
+    createBusiness: (displayName: string) => Promise<BusinessDTO>;
+    updateBusiness: (businessId: string, businessData: BusinessUpdateRequestDTO) => Promise<BusinessDTO>;
+    toggleBusinessStatus: (businessId: string, toggleData: BusinessToggleActiveRequestDTO) => Promise<BusinessDTO>;
     isAvailable: boolean;
 };
+export type BusinessHook = ReturnType<typeof useBusiness>;
 //# sourceMappingURL=useBusiness.d.ts.map

package/dist/hooks/useBusiness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useBusiness.d.ts","sourceRoot":"","sources":["../../src/hooks/useBusiness.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW;;;kCAyCiC,MAAM;;CAwB9D,CAAC"}
+{"version":3,"file":"useBusiness.d.ts","sourceRoot":"","sources":["../../src/hooks/useBusiness.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,wBAAwB,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AAErI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,WAAW;+BAgB4B,QAAQ,WAAW,EAAE,CAAC;4BA4BzB,QAAQ,eAAe,EAAE,CAAC;yBA8B7B,QAAQ,WAAW,EAAE,CAAC;kCAfX,MAAM,KAAG,QAAQ,WAAW,GAAG,IAAI,CAAC;2CA8B3B,MAAM,KAAG,QAAQ,WAAW,CAAC;kCAetC,MAAM,KAAG,QAAQ,WAAW,EAAE,CAAC;kCA8B/B,MAAM,KAAG,QAAQ,WAAW,CAAC;iCAe9B,MAAM,gBAAgB,wBAAwB,KAAG,QAAQ,WAAW,CAAC;uCAe/D,MAAM,cAAc,8BAA8B,KAAG,QAAQ,WAAW,CAAC;;CA2BtI,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC"}