@oxyhq/services 5.1.33 → 5.1.34

package/lib/typescript/ui/screens/SessionManagementScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionManagementScreen.d.ts","sourceRoot":"","sources":["../../../../src/ui/screens/SessionManagementScreen.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA8B,MAAM,OAAO,CAAC;AAYnD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAiBtD,QAAA,MAAM,uBAAuB,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAgUtD,CAAC;AAiIF,eAAe,uBAAuB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@oxyhq/services",
-    "version": "5.1.33",
+    "version": "5.1.34",
     "description": "Reusable OxyHQ module to handle authentication, user management, karma system and more 🚀",
     "main": "lib/commonjs/node/index.js",
     "module": "lib/module/node/index.js",

package/src/core/index.ts

@@ -41,7 +41,7 @@ import {
 } from '../models/interfaces';
 
 /**
- * Default cloud URL for Oxy services
+ * Default cloud URL for Oxy services, cloud is where the user files are. (e.g. images, videos, etc.). Not the API.
  */
 export const OXY_CLOUD_URL = 'https://cloud.oxy.so';
 
@@ -277,6 +277,61 @@ export class OxyServices {
     }
   }
 
+  /* Session Management Methods */
+
+  /**
+   * Get active sessions for the authenticated user
+   * @returns Array of active session objects
+   */
+  async getUserSessions(): Promise<any[]> {
+    try {
+      const res = await this.client.get('/sessions');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Logout from a specific session
+   * @param sessionId - The session ID to logout from
+   * @returns Success status
+   */
+  async logoutSession(sessionId: string): Promise<{ success: boolean; message: string }> {
+    try {
+      const res = await this.client.delete(`/sessions/${sessionId}`);
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Logout from all other sessions (keep current session active)
+   * @returns Success status
+   */
+  async logoutOtherSessions(): Promise<{ success: boolean; message: string }> {
+    try {
+      const res = await this.client.post('/sessions/logout-others');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Logout from all sessions
+   * @returns Success status
+   */
+  async logoutAllSessions(): Promise<{ success: boolean; message: string }> {
+    try {
+      const res = await this.client.post('/sessions/logout-all');
+      return res.data;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
   /* Profile Methods */
 
   /**

package/src/index.ts

@@ -17,6 +17,7 @@ import {
   SignInScreen, 
   SignUpScreen, 
   AccountCenterScreen,
+  SessionManagementScreen,
   
   // Components
   OxySignInButton,
@@ -50,6 +51,7 @@ export {
   SignInScreen, 
   SignUpScreen,
   AccountCenterScreen,
+  SessionManagementScreen,
   
   // Components
   OxySignInButton,

package/src/ui/context/OxyContext.tsx

@@ -2,19 +2,34 @@ import React, { createContext, useContext, useState, useEffect, useCallback, Rea
 import { OxyServices } from '../../core';
 import { User, LoginResponse } from '../../models/interfaces';
 
+// Define authenticated user with tokens
+export interface AuthenticatedUser extends User {
+    accessToken: string;
+    refreshToken?: string;
+    sessionId?: string;
+}
+
 // Define the context shape
 export interface OxyContextState {
-    // Authentication state
-    user: User | null;
+    // Multi-user authentication state
+    user: User | null; // Current active user
+    users: AuthenticatedUser[]; // All authenticated users
     isAuthenticated: boolean;
     isLoading: boolean;
     error: string | null;
 
     // Auth methods
     login: (username: string, password: string) => Promise<User>;
-    logout: () => Promise<void>;
+    logout: (userId?: string) => Promise<void>; // Optional userId for multi-user logout
+    logoutAll: () => Promise<void>; // Logout all users
     signUp: (username: string, email: string, password: string) => Promise<User>;
 
+    // Multi-user methods
+    switchUser: (userId: string) => Promise<void>;
+    removeUser: (userId: string) => Promise<void>;
+    getUserSessions: (userId?: string) => Promise<any[]>; // Get sessions for user
+    logoutSession: (sessionId: string, userId?: string) => Promise<void>; // Logout specific session
+
     // Access to services
     oxyServices: OxyServices;
     bottomSheetRef?: React.RefObject<any>;
@@ -94,6 +109,9 @@ const getStorage = async (): Promise<StorageInterface> => {
 
 // Storage keys
 const getStorageKeys = (prefix = 'oxy') => ({
+    users: `${prefix}_users`, // Array of authenticated users with tokens
+    activeUserId: `${prefix}_active_user_id`, // ID of currently active user
+    // Legacy keys for migration
     accessToken: `${prefix}_access_token`,
     refreshToken: `${prefix}_refresh_token`,
     user: `${prefix}_user`,
@@ -108,6 +126,7 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
 }) => {
     // Authentication state
     const [user, setUser] = useState<User | null>(null);
+    const [users, setUsers] = useState<AuthenticatedUser[]>([]);
     const [isLoading, setIsLoading] = useState(true);
     const [error, setError] = useState<string | null>(null);
     const [storage, setStorage] = useState<StorageInterface | null>(null);
@@ -137,41 +156,41 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
 
             setIsLoading(true);
             try {
-                // Try to load tokens from storage
-                const accessToken = await storage.getItem(keys.accessToken);
-                const refreshToken = await storage.getItem(keys.refreshToken);
-                const storedUser = await storage.getItem(keys.user);
-
-                if (accessToken) {
-                    // Set tokens in OxyServices
-                    if (refreshToken) {
-                        oxyServices.setTokens(accessToken, refreshToken);
-                    } else {
-                        // Use setTokens with the same token if setToken is not available
-                        oxyServices.setTokens(accessToken, accessToken);
-                    }
-
-                    // Validate the tokens
-                    const isValid = await oxyServices.validate();
-
-                    if (isValid && storedUser) {
-                        // Set user state
-                        const parsedUser = JSON.parse(storedUser);
-                        setUser(parsedUser);
-
-                        // Notify about auth state change
-                        if (onAuthStateChange) {
-                            onAuthStateChange(parsedUser);
+                // Check for multi-user data first
+                const usersData = await storage.getItem(keys.users);
+                const activeUserId = await storage.getItem(keys.activeUserId);
+
+                if (usersData) {
+                    // Multi-user setup exists
+                    const parsedUsers: AuthenticatedUser[] = JSON.parse(usersData);
+                    setUsers(parsedUsers);
+
+                    if (activeUserId && parsedUsers.length > 0) {
+                        const activeUser = parsedUsers.find(u => u._id === activeUserId);
+                        if (activeUser) {
+                            setUser(activeUser);
+                            oxyServices.setTokens(activeUser.accessToken, activeUser.refreshToken || activeUser.accessToken);
+                            
+                            // Validate the tokens
+                            const isValid = await oxyServices.validate();
+                            if (!isValid) {
+                                // Remove invalid user
+                                await removeUser(activeUser._id);
+                            } else {
+                                // Notify about auth state change
+                                if (onAuthStateChange) {
+                                    onAuthStateChange(activeUser);
+                                }
+                            }
                         }
-                    } else {
-                        // Tokens are invalid, clear everything
-                        await clearStorage();
-                        oxyServices.clearTokens();
                     }
+                } else {
+                    // Check for legacy single-user data and migrate
+                    await migrateLegacyAuth();
                 }
             } catch (err) {
                 console.error('Auth initialization error:', err);
-                await clearStorage();
+                await clearAllStorage();
                 oxyServices.clearTokens();
             } finally {
                 setIsLoading(false);
@@ -181,9 +200,57 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
         if (storage) {
             initAuth();
         }
-    }, [storage, oxyServices, keys.accessToken, keys.refreshToken, keys.user, onAuthStateChange]);
+    }, [storage, oxyServices, keys.users, keys.activeUserId, onAuthStateChange]);
+
+    // Migrate legacy single-user authentication to multi-user
+    const migrateLegacyAuth = async (): Promise<void> => {
+        if (!storage) return;
+
+        try {
+            const accessToken = await storage.getItem(keys.accessToken);
+            const refreshToken = await storage.getItem(keys.refreshToken);
+            const storedUser = await storage.getItem(keys.user);
+
+            if (accessToken && storedUser) {
+                // Set tokens in OxyServices
+                oxyServices.setTokens(accessToken, refreshToken || accessToken);
+
+                // Validate the tokens
+                const isValid = await oxyServices.validate();
+
+                if (isValid) {
+                    const parsedUser = JSON.parse(storedUser);
+                    const authenticatedUser: AuthenticatedUser = {
+                        ...parsedUser,
+                        accessToken,
+                        refreshToken: refreshToken || undefined,
+                    };
+
+                    // Store in new multi-user format
+                    await storage.setItem(keys.users, JSON.stringify([authenticatedUser]));
+                    await storage.setItem(keys.activeUserId, authenticatedUser._id);
+
+                    // Set state
+                    setUsers([authenticatedUser]);
+                    setUser(authenticatedUser);
+
+                    // Notify about auth state change
+                    if (onAuthStateChange) {
+                        onAuthStateChange(authenticatedUser);
+                    }
+                }
 
-    // Helper to clear storage
+                // Clear legacy storage
+                await storage.removeItem(keys.accessToken);
+                await storage.removeItem(keys.refreshToken);
+                await storage.removeItem(keys.user);
+            }
+        } catch (err) {
+            console.error('Migration error:', err);
+        }
+    };
+
+    // Helper to clear legacy storage
     const clearStorage = async (): Promise<void> => {
         if (!storage) return;
 
@@ -196,6 +263,32 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
         }
     };
 
+    // Helper to clear all storage (multi-user)
+    const clearAllStorage = async (): Promise<void> => {
+        if (!storage) return;
+
+        try {
+            await storage.removeItem(keys.users);
+            await storage.removeItem(keys.activeUserId);
+            // Also clear legacy keys
+            await clearStorage();
+        } catch (err) {
+            console.error('Clear all storage error:', err);
+        }
+    };
+
+    // Save users to storage
+    const saveUsersToStorage = async (usersList: AuthenticatedUser[]): Promise<void> => {
+        if (!storage) return;
+        await storage.setItem(keys.users, JSON.stringify(usersList));
+    };
+
+    // Save active user ID to storage
+    const saveActiveUserId = async (userId: string): Promise<void> => {
+        if (!storage) return;
+        await storage.setItem(keys.activeUserId, userId);
+    };
+
     // Utility function to handle different token response formats
     const storeTokens = async (response: any) => {
         // Store token and user data
@@ -211,7 +304,7 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
         await storage?.setItem(keys.user, JSON.stringify(response.user));
     };
 
-    // Login method
+    // Login method (updated for multi-user)
     const login = async (username: string, password: string): Promise<User> => {
         if (!storage) throw new Error('Storage not initialized');
 
@@ -220,17 +313,46 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
 
         try {
             const response = await oxyServices.login(username, password);
-            setUser(response.user);
+            const accessToken = response.accessToken || (response as any).token;
+            
+            if (!accessToken) {
+                throw new Error('No access token received from login');
+            }
 
-            // Store tokens
-            await storeTokens(response);
+            const newUser: AuthenticatedUser = {
+                ...response.user,
+                accessToken,
+                refreshToken: response.refreshToken,
+                // sessionId will be set by backend, but we don't get it in response yet
+            };
+
+            // Check if user already exists
+            const existingUserIndex = users.findIndex(u => u._id === newUser._id);
+            let updatedUsers: AuthenticatedUser[];
+
+            if (existingUserIndex >= 0) {
+                // Update existing user
+                updatedUsers = [...users];
+                updatedUsers[existingUserIndex] = newUser;
+            } else {
+                // Add new user
+                updatedUsers = [...users, newUser];
+            }
+
+            // Update state
+            setUsers(updatedUsers);
+            setUser(newUser);
+
+            // Save to storage
+            await saveUsersToStorage(updatedUsers);
+            await saveActiveUserId(newUser._id);
 
             // Notify about auth state change
             if (onAuthStateChange) {
-                onAuthStateChange(response.user);
+                onAuthStateChange(newUser);
             }
 
-            return response.user;
+            return newUser;
         } catch (err: any) {
             setError(err.message || 'Login failed');
             throw err;
@@ -239,30 +361,242 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
         }
     };
 
-    // Logout method
-    const logout = async (): Promise<void> => {
+    // Logout method (supports multi-user)
+    const logout = async (userId?: string): Promise<void> => {
         if (!storage) throw new Error('Storage not initialized');
 
         setIsLoading(true);
         setError(null);
 
         try {
-            await oxyServices.logout();
-            await clearStorage();
+            const targetUserId = userId || user?._id;
+            if (!targetUserId) return;
+
+            const targetUser = users.find(u => u._id === targetUserId);
+            if (targetUser) {
+                // Set the target user's tokens to logout
+                oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
+                
+                try {
+                    await oxyServices.logout();
+                } catch (logoutError) {
+                    console.warn('Logout API call failed:', logoutError);
+                }
+
+                // Remove user from list
+                const updatedUsers = users.filter(u => u._id !== targetUserId);
+                setUsers(updatedUsers);
+
+                // If logging out current user, switch to another user or clear
+                if (targetUserId === user?._id) {
+                    if (updatedUsers.length > 0) {
+                        // Switch to first available user
+                        const nextUser = updatedUsers[0];
+                        setUser(nextUser);
+                        oxyServices.setTokens(nextUser.accessToken, nextUser.refreshToken || nextUser.accessToken);
+                        await saveActiveUserId(nextUser._id);
+                        
+                        if (onAuthStateChange) {
+                            onAuthStateChange(nextUser);
+                        }
+                    } else {
+                        // No users left
+                        setUser(null);
+                        oxyServices.clearTokens();
+                        await storage.removeItem(keys.activeUserId);
+                        
+                        if (onAuthStateChange) {
+                            onAuthStateChange(null);
+                        }
+                    }
+                }
+
+                // Save updated users list
+                await saveUsersToStorage(updatedUsers);
+            }
+        } catch (err: any) {
+            setError(err.message || 'Logout failed');
+            throw err;
+        } finally {
+            setIsLoading(false);
+        }
+    };
+
+    // Logout all users
+    const logoutAll = async (): Promise<void> => {
+        if (!storage) throw new Error('Storage not initialized');
+
+        setIsLoading(true);
+        setError(null);
+
+        try {
+            // Logout each user
+            for (const userItem of users) {
+                try {
+                    oxyServices.setTokens(userItem.accessToken, userItem.refreshToken || userItem.accessToken);
+                    await oxyServices.logout();
+                } catch (logoutError) {
+                    console.warn(`Logout failed for user ${userItem._id}:`, logoutError);
+                }
+            }
+
+            // Clear all state and storage
+            setUsers([]);
             setUser(null);
+            oxyServices.clearTokens();
+            await clearAllStorage();
 
             // Notify about auth state change
             if (onAuthStateChange) {
                 onAuthStateChange(null);
             }
         } catch (err: any) {
-            setError(err.message || 'Logout failed');
+            setError(err.message || 'Logout all failed');
             throw err;
         } finally {
             setIsLoading(false);
         }
     };
 
+    // Switch user
+    const switchUser = async (userId: string): Promise<void> => {
+        if (!storage) throw new Error('Storage not initialized');
+
+        setError(null);
+
+        try {
+            const targetUser = users.find(u => u._id === userId);
+            if (!targetUser) {
+                throw new Error('User not found');
+            }
+
+            // Validate tokens before switching
+            oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
+            const isValid = await oxyServices.validate();
+
+            if (!isValid) {
+                // Remove invalid user
+                await removeUser(userId);
+                throw new Error('User session is invalid');
+            }
+
+            // Switch to the user
+            setUser(targetUser);
+            await saveActiveUserId(userId);
+
+            // Notify about auth state change
+            if (onAuthStateChange) {
+                onAuthStateChange(targetUser);
+            }
+        } catch (err: any) {
+            setError(err.message || 'Switch user failed');
+            throw err;
+        }
+    };
+
+    // Remove user
+    const removeUser = async (userId: string): Promise<void> => {
+        if (!storage) throw new Error('Storage not initialized');
+
+        try {
+            const updatedUsers = users.filter(u => u._id !== userId);
+            setUsers(updatedUsers);
+
+            // If removing current user, switch to another or clear
+            if (userId === user?._id) {
+                if (updatedUsers.length > 0) {
+                    await switchUser(updatedUsers[0]._id);
+                } else {
+                    setUser(null);
+                    oxyServices.clearTokens();
+                    await storage.removeItem(keys.activeUserId);
+                    
+                    if (onAuthStateChange) {
+                        onAuthStateChange(null);
+                    }
+                }
+            }
+
+            // Save updated users list
+            await saveUsersToStorage(updatedUsers);
+        } catch (err: any) {
+            setError(err.message || 'Remove user failed');
+            throw err;
+        }
+    };
+
+    // Get user sessions
+    const getUserSessions = async (userId?: string): Promise<any[]> => {
+        try {
+            const targetUserId = userId || user?._id;
+            if (!targetUserId) return [];
+
+            const targetUser = users.find(u => u._id === targetUserId);
+            if (!targetUser) return [];
+
+            // Store current tokens to restore later
+            const currentUser = user;
+            const wasCurrentUser = targetUserId === user?._id;
+
+            if (!wasCurrentUser) {
+                // Temporarily switch to target user's tokens
+                oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
+            }
+
+            try {
+                // Use the new OxyServices method
+                const sessions = await oxyServices.getUserSessions();
+                return sessions;
+            } finally {
+                if (!wasCurrentUser && currentUser) {
+                    // Restore original tokens
+                    oxyServices.setTokens(currentUser.accessToken, currentUser.refreshToken || currentUser.accessToken);
+                }
+            }
+        } catch (err: any) {
+            console.error('Get user sessions failed:', err);
+            return [];
+        }
+    };
+
+    // Logout specific session
+    const logoutSession = async (sessionId: string, userId?: string): Promise<void> => {
+        try {
+            const targetUserId = userId || user?._id;
+            if (!targetUserId) return;
+
+            const targetUser = users.find(u => u._id === targetUserId);
+            if (!targetUser) return;
+
+            // Store current tokens to restore later
+            const currentUser = user;
+            const wasCurrentUser = targetUserId === user?._id;
+
+            if (!wasCurrentUser) {
+                // Temporarily switch to target user's tokens
+                oxyServices.setTokens(targetUser.accessToken, targetUser.refreshToken || targetUser.accessToken);
+            }
+
+            try {
+                // Use the new OxyServices method
+                await oxyServices.logoutSession(sessionId);
+                
+                // If this is the current user's session, remove them from local state
+                if (wasCurrentUser && sessionId === targetUser.sessionId) {
+                    await removeUser(targetUserId);
+                }
+            } finally {
+                if (!wasCurrentUser && currentUser) {
+                    // Restore original tokens
+                    oxyServices.setTokens(currentUser.accessToken, currentUser.refreshToken || currentUser.accessToken);
+                }
+            }
+        } catch (err: any) {
+            console.error('Logout session failed:', err);
+            throw err;
+        }
+    };
+
     // Sign up method
     const signUp = async (username: string, email: string, password: string): Promise<User> => {
         if (!storage) throw new Error('Storage not initialized');
@@ -322,14 +656,31 @@ export const OxyContextProvider: React.FC<OxyContextProviderProps> = ({
 
     // Build context value
     const contextValue: OxyContextState = {
+        // Single user state (current active user)
         user,
         isAuthenticated: !!user,
         isLoading,
         error,
+        
+        // Multi-user state
+        users,
+        
+        // Auth methods
         login,
         logout,
+        logoutAll,
         signUp,
+        
+        // Multi-user methods
+        switchUser,
+        removeUser,
+        getUserSessions,
+        logoutSession,
+        
+        // OxyServices instance
         oxyServices,
+        
+        // Bottom sheet methods
         bottomSheetRef,
         showBottomSheet,
         hideBottomSheet,

package/src/ui/index.ts

@@ -23,6 +23,7 @@ export { fontFamilies, fontStyles } from './styles/fonts';
 export { default as SignInScreen } from './screens/SignInScreen';
 export { default as SignUpScreen } from './screens/SignUpScreen';
 export { default as AccountCenterScreen } from './screens/AccountCenterScreen';
+export { default as SessionManagementScreen } from './screens/SessionManagementScreen';
 export { default as AccountOverviewScreen } from './screens/AccountOverviewScreen';
 export { default as AccountSettingsScreen } from './screens/AccountSettingsScreen';