@oxyhq/services 5.16.44 → 5.17.0

package/src/ui/hooks/useDeviceManagement.ts

@@ -0,0 +1,108 @@
+import { useCallback } from 'react';
+import type { ApiError } from '../../models/interfaces';
+import { DeviceManager } from '../../utils/deviceManager';
+import type { OxyServices } from '../../core';
+import { handleAuthError } from '../utils/errorHandlers';
+
+export interface UseDeviceManagementOptions {
+  oxyServices: OxyServices;
+  activeSessionId: string | null;
+  onError?: (error: ApiError) => void;
+  clearSessionState: () => Promise<void>;
+  logger?: (message: string, error?: unknown) => void;
+}
+
+export interface UseDeviceManagementResult {
+  getDeviceSessions: () => Promise<
+    Array<{
+      sessionId: string;
+      deviceId: string;
+      deviceName?: string;
+      lastActive?: string;
+      expiresAt?: string;
+    }>
+  >;
+  logoutAllDeviceSessions: () => Promise<void>;
+  updateDeviceName: (deviceName: string) => Promise<void>;
+}
+
+/**
+ * Provide device session management helpers tied to the current active session.
+ *
+ * @param options - Device management configuration
+ */
+export const useDeviceManagement = ({
+  oxyServices,
+  activeSessionId,
+  onError,
+  clearSessionState,
+  logger,
+}: UseDeviceManagementOptions): UseDeviceManagementResult => {
+  const getDeviceSessions = useCallback(async (): Promise<
+    Array<{
+      sessionId: string;
+      deviceId: string;
+      deviceName?: string;
+      lastActive?: string;
+      expiresAt?: string;
+    }>
+  > => {
+    if (!activeSessionId) throw new Error('No active session');
+    try {
+      return await oxyServices.getDeviceSessions(activeSessionId);
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: 'Failed to get device sessions',
+        code: 'GET_DEVICE_SESSIONS_ERROR',
+        onError,
+        logger,
+      });
+      throw error instanceof Error ? error : new Error('Failed to get device sessions');
+    }
+  }, [activeSessionId, logger, onError, oxyServices]);
+
+  const logoutAllDeviceSessions = useCallback(async (): Promise<void> => {
+    if (!activeSessionId) throw new Error('No active session');
+
+    try {
+      await oxyServices.logoutAllDeviceSessions(activeSessionId);
+      await clearSessionState();
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: 'Failed to logout all device sessions',
+        code: 'LOGOUT_ALL_DEVICES_ERROR',
+        onError,
+        logger,
+      });
+      throw error instanceof Error ? error : new Error('Failed to logout all device sessions');
+    }
+  }, [activeSessionId, clearSessionState, logger, onError, oxyServices]);
+
+  const updateDeviceName = useCallback(
+    async (deviceName: string): Promise<void> => {
+      if (!activeSessionId) throw new Error('No active session');
+
+      try {
+        await oxyServices.updateDeviceName(activeSessionId, deviceName);
+        await DeviceManager.updateDeviceName(deviceName);
+      } catch (error) {
+        handleAuthError(error, {
+          defaultMessage: 'Failed to update device name',
+          code: 'UPDATE_DEVICE_NAME_ERROR',
+          onError,
+          logger,
+        });
+        throw error instanceof Error ? error : new Error('Failed to update device name');
+      }
+    },
+    [activeSessionId, logger, onError, oxyServices],
+  );
+
+  return {
+    getDeviceSessions,
+    logoutAllDeviceSessions,
+    updateDeviceName,
+  };
+};
+
+

package/src/ui/hooks/useProfileEditing.ts

@@ -1,7 +1,7 @@
 import { useCallback } from 'react';
 import { useI18n } from './useI18n';
 import { useUpdateProfile } from './mutations/useAccountMutations';
-import { useAuthStore } from '../stores/authStore';
+import { useCurrentUser } from './queries/useAccountQueries';
 
 export interface ProfileUpdateData {
     displayName?: string;
@@ -34,6 +34,7 @@ export interface ProfileUpdateData {
 export const useProfileEditing = () => {
     const { t } = useI18n();
     const updateProfileMutation = useUpdateProfile();
+    const { data: currentUser } = useCurrentUser();
 
     /**
      * Save profile updates to the server using TanStack Query
@@ -71,7 +72,6 @@ export const useProfileEditing = () => {
 
         // Handle name field
         if (updates.displayName !== undefined || updates.lastName !== undefined) {
-            const currentUser = useAuthStore.getState().user;
             const currentName = currentUser?.name;
             updateData.name = {
                 first: updates.displayName ?? (typeof currentName === 'object' ? currentName?.first : '') ?? '',
@@ -86,7 +86,7 @@ export const useProfileEditing = () => {
             // Error toast is handled by the mutation
             return false;
         }
-    }, [updateProfileMutation, t]);
+    }, [updateProfileMutation, t, currentUser]);
 
     /**
      * Update a single profile field

package/src/ui/hooks/useSessionManagement.ts

@@ -0,0 +1,405 @@
+import { useCallback, useMemo, useRef, useState } from 'react';
+import type { ApiError, User } from '../../models/interfaces';
+import type { ClientSession } from '../../models/session';
+import { mergeSessions, normalizeAndSortSessions, sessionsArraysEqual } from '../../utils/sessionUtils';
+import { fetchSessionsWithFallback, mapSessionsToClient, validateSessionBatch } from '../utils/sessionHelpers';
+import { getStorageKeys, type StorageInterface } from '../utils/storageHelpers';
+import { handleAuthError, isInvalidSessionError } from '../utils/errorHandlers';
+import type { OxyServices } from '../../core';
+import type { QueryClient } from '@tanstack/react-query';
+import { clearQueryCache } from './queryClient';
+
+const getDeviceIdForSession = (sessions: ClientSession[] = [], sessionId: string | null) =>
+  sessionId ? sessions.find((s) => s.sessionId === sessionId)?.deviceId : undefined;
+
+export interface UseSessionManagementOptions {
+  oxyServices: OxyServices;
+  storage: StorageInterface | null;
+  storageKeyPrefix?: string;
+  loginSuccess: (user: User) => void;
+  logoutStore: () => void;
+  applyLanguagePreference: (user: User) => Promise<void>;
+  onAuthStateChange?: (user: User | null) => void;
+  onError?: (error: ApiError) => void;
+  setAuthError?: (message: string | null) => void;
+  logger?: (message: string, error?: unknown) => void;
+  setTokenReady?: (ready: boolean) => void;
+  queryClient?: QueryClient | null;
+}
+
+export interface UseSessionManagementResult {
+  sessions: ClientSession[];
+  activeSessionId: string | null;
+  setActiveSessionId: (sessionId: string | null) => void;
+  updateSessions: (incoming: ClientSession[], options?: { merge?: boolean }) => void;
+  switchSession: (sessionId: string) => Promise<User>;
+  refreshSessions: (activeUserId?: string) => Promise<void>;
+  clearSessionState: () => Promise<void>;
+  saveActiveSessionId: (sessionId: string) => Promise<void>;
+  trackRemovedSession: (sessionId: string) => void;
+  storageKeys: ReturnType<typeof getStorageKeys>;
+  isRefreshInFlight: boolean;
+}
+
+const DEFAULT_SAVE_ERROR_MESSAGE = 'Failed to save session data';
+const CLEAR_STORAGE_ERROR = 'Failed to clear storage';
+
+/**
+ * Manage session state, persistence, and high-level multi-session operations.
+ *
+ * @param options - Session management configuration
+ */
+export const useSessionManagement = ({
+  oxyServices,
+  storage,
+  storageKeyPrefix,
+  loginSuccess,
+  logoutStore,
+  applyLanguagePreference,
+  onAuthStateChange,
+  onError,
+  setAuthError,
+  logger,
+  setTokenReady,
+  queryClient,
+}: UseSessionManagementOptions): UseSessionManagementResult => {
+  const [sessions, setSessions] = useState<ClientSession[]>([]);
+  const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
+
+  const refreshInFlightRef = useRef<Promise<void> | null>(null);
+  const removedSessionsRef = useRef<Set<string>>(new Set());
+  const lastRefreshRef = useRef<number>(0);
+
+  const storageKeys = useMemo(() => getStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
+
+  const saveSessionIds = useCallback(
+    async (sessionIds: string[]): Promise<void> => {
+      if (!storage) return;
+      try {
+        const uniqueIds = Array.from(new Set(sessionIds));
+        await storage.setItem(storageKeys.sessionIds, JSON.stringify(uniqueIds));
+      } catch (error) {
+        if (logger) {
+          logger(DEFAULT_SAVE_ERROR_MESSAGE, error);
+        } else if (__DEV__) {
+          console.warn('Failed to save session IDs:', error);
+        }
+      }
+    },
+    [logger, storage, storageKeys.sessionIds],
+  );
+
+  const updateSessions = useCallback(
+    (incoming: ClientSession[], options: { merge?: boolean } = {}): void => {
+      setSessions((prevSessions) => {
+        const processed = options.merge
+          ? mergeSessions(prevSessions, incoming, activeSessionId, false)
+          : normalizeAndSortSessions(incoming, activeSessionId, false);
+
+        if (storage) {
+          void saveSessionIds(processed.map((session) => session.sessionId));
+        }
+
+        if (sessionsArraysEqual(prevSessions, processed)) {
+          return prevSessions;
+        }
+        return processed;
+      });
+    },
+    [activeSessionId, saveSessionIds, storage],
+  );
+
+  const saveActiveSessionId = useCallback(
+    async (sessionId: string): Promise<void> => {
+      if (!storage) return;
+      try {
+        await storage.setItem(storageKeys.activeSessionId, sessionId);
+      } catch (error) {
+        handleAuthError(error, {
+          defaultMessage: DEFAULT_SAVE_ERROR_MESSAGE,
+          code: 'SESSION_PERSISTENCE_ERROR',
+          onError,
+          setAuthError,
+          logger,
+        });
+      }
+    },
+    [logger, onError, setAuthError, storage, storageKeys.activeSessionId],
+  );
+
+  const removeActiveSessionId = useCallback(async (): Promise<void> => {
+    if (!storage) return;
+    try {
+      await storage.removeItem(storageKeys.activeSessionId);
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: DEFAULT_SAVE_ERROR_MESSAGE,
+        code: 'SESSION_PERSISTENCE_ERROR',
+        onError,
+        setAuthError,
+        logger,
+      });
+    }
+  }, [logger, onError, setAuthError, storage, storageKeys.activeSessionId]);
+
+  const clearSessionStorage = useCallback(async (): Promise<void> => {
+    if (!storage) return;
+    try {
+      await storage.removeItem(storageKeys.activeSessionId);
+      await storage.removeItem(storageKeys.sessionIds);
+      // Clear identity sync state
+      await storage.removeItem('oxy_identity_synced').catch(() => {});
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: CLEAR_STORAGE_ERROR,
+        code: 'STORAGE_ERROR',
+        onError,
+        setAuthError,
+        logger,
+      });
+    }
+  }, [logger, onError, setAuthError, storage, storageKeys.activeSessionId, storageKeys.sessionIds]);
+
+  const clearSessionState = useCallback(async (): Promise<void> => {
+    setSessions([]);
+    setActiveSessionId(null);
+    logoutStore();
+    oxyServices.clearTokens();
+    
+    // Clear TanStack Query cache (in-memory)
+    if (queryClient) {
+      queryClient.clear();
+    }
+    
+    // Clear persisted query cache
+    if (storage) {
+      try {
+        await clearQueryCache(storage);
+      } catch (error) {
+        if (logger) {
+          logger('Failed to clear persisted query cache', error);
+        }
+      }
+    }
+    
+    await clearSessionStorage();
+    onAuthStateChange?.(null);
+  }, [clearSessionStorage, logoutStore, onAuthStateChange, queryClient, storage, logger, oxyServices]);
+
+  const activateSession = useCallback(
+    async (sessionId: string, user: User): Promise<void> => {
+      const deviceId = getDeviceIdForSession(sessions, sessionId);
+      await oxyServices.getTokenBySession(sessionId, deviceId);
+      setTokenReady?.(true);
+      setActiveSessionId(sessionId);
+      loginSuccess(user);
+      await saveActiveSessionId(sessionId);
+      await applyLanguagePreference(user);
+      onAuthStateChange?.(user);
+    },
+    [
+      applyLanguagePreference,
+      sessions,
+      loginSuccess,
+      onAuthStateChange,
+      oxyServices,
+      saveActiveSessionId,
+      setTokenReady,
+    ],
+  );
+
+  const trackRemovedSession = useCallback((sessionId: string) => {
+    removedSessionsRef.current.add(sessionId);
+    setTimeout(() => {
+      removedSessionsRef.current.delete(sessionId);
+    }, 5000);
+  }, []);
+
+  const findReplacementSession = useCallback(
+    async (sessionIds: string[]): Promise<User | null> => {
+      if (!sessionIds.length) {
+        return null;
+      }
+
+      const validationResults = await validateSessionBatch(oxyServices, sessionIds, {
+        maxConcurrency: 3,
+      });
+
+      const validSession = validationResults.find((result) => result.valid);
+      if (!validSession) {
+        return null;
+      }
+
+      const validation = await oxyServices.validateSession(validSession.sessionId, {
+        useHeaderValidation: true,
+      });
+
+      if (!validation?.valid || !validation.user) {
+        return null;
+      }
+
+      const user = validation.user as User;
+      await activateSession(validSession.sessionId, user);
+      return user;
+    },
+    [activateSession, oxyServices],
+  );
+
+  const switchSession = useCallback(
+    async (sessionId: string): Promise<User> => {
+      try {
+        const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation: true });
+        if (!validation?.valid) {
+          throw new Error('Session is invalid or expired');
+        }
+
+        if (!validation.user) {
+          throw new Error('User data not available from session validation');
+        }
+
+        const user = validation.user as User;
+        await activateSession(sessionId, user);
+
+        try {
+          const deviceSessions = await fetchSessionsWithFallback(oxyServices, sessionId, {
+            fallbackUserId: user.id,
+            logger,
+          });
+          updateSessions(deviceSessions, { merge: true });
+        } catch (error) {
+          if (__DEV__) {
+            console.warn('Failed to synchronize sessions after switch:', error);
+          }
+        }
+
+        return user;
+      } catch (error) {
+        const invalidSession = isInvalidSessionError(error);
+
+        if (invalidSession) {
+          updateSessions(sessions.filter((session) => session.sessionId !== sessionId), {
+            merge: false,
+          });
+          if (sessionId === activeSessionId) {
+            const otherSessionIds = sessions
+              .filter(
+                (session) =>
+                  session.sessionId !== sessionId && !removedSessionsRef.current.has(session.sessionId),
+              )
+              .map((session) => session.sessionId);
+
+            const replacementUser = await findReplacementSession(otherSessionIds);
+            if (replacementUser) {
+              return replacementUser;
+            }
+          }
+        }
+
+        handleAuthError(error, {
+          defaultMessage: 'Failed to switch session',
+          code: invalidSession ? 'INVALID_SESSION' : 'SESSION_SWITCH_ERROR',
+          onError,
+          setAuthError,
+          logger,
+        });
+        throw error instanceof Error ? error : new Error('Failed to switch session');
+      }
+    },
+    [
+      activateSession,
+      activeSessionId,
+      findReplacementSession,
+      logger,
+      loginSuccess,
+      onError,
+      oxyServices,
+      sessions,
+      setAuthError,
+      updateSessions,
+    ],
+  );
+
+  const refreshSessions = useCallback(
+    async (activeUserId?: string): Promise<void> => {
+      if (!activeSessionId) return;
+
+      if (refreshInFlightRef.current) {
+        await refreshInFlightRef.current;
+        return;
+      }
+
+      const now = Date.now();
+      if (now - lastRefreshRef.current < 500) {
+        return;
+      }
+      lastRefreshRef.current = now;
+
+      const refreshPromise = (async () => {
+        try {
+          const deviceSessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
+            fallbackUserId: activeUserId,
+            logger,
+          });
+          updateSessions(deviceSessions, { merge: true });
+        } catch (error) {
+          if (isInvalidSessionError(error)) {
+            const otherSessions = sessions
+              .filter(
+                (session) =>
+                  session.sessionId !== activeSessionId &&
+                  !removedSessionsRef.current.has(session.sessionId),
+              )
+              .map((session) => session.sessionId);
+
+            const replacementUser = await findReplacementSession(otherSessions);
+            if (!replacementUser) {
+              await clearSessionState();
+            }
+            return;
+          }
+
+          handleAuthError(error, {
+            defaultMessage: 'Failed to refresh sessions',
+            code: 'SESSION_REFRESH_ERROR',
+            onError,
+            setAuthError,
+            logger,
+          });
+        } finally {
+          refreshInFlightRef.current = null;
+          lastRefreshRef.current = Date.now();
+        }
+      })();
+
+      refreshInFlightRef.current = refreshPromise;
+      await refreshPromise;
+    },
+    [
+      activeSessionId,
+      clearSessionState,
+      findReplacementSession,
+      logger,
+      onError,
+      oxyServices,
+      sessions,
+      setAuthError,
+      updateSessions,
+    ],
+  );
+
+  const isRefreshInFlight = Boolean(refreshInFlightRef.current);
+
+  return {
+    sessions,
+    activeSessionId,
+    setActiveSessionId,
+    updateSessions,
+    switchSession,
+    refreshSessions,
+    clearSessionState,
+    saveActiveSessionId,
+    trackRemovedSession,
+    storageKeys,
+    isRefreshInFlight,
+  };
+};

package/src/ui/index.ts

@@ -79,6 +79,5 @@ export {
   toast
 };
 
-// Re-export core services for convenience in UI context
-export { OxyServices } from '../core';
+// Removed convenience re-export of core services from UI context.
 export type { User, LoginResponse, ApiError } from '../models/interfaces';

package/src/ui/navigation/routes.ts

@@ -30,22 +30,18 @@ export type RouteName =
     | 'UserLinks'
     | 'HistoryView'
     | 'SavesCollections'
-    | 'EditProfile' // For backward compatibility, maps to AccountSettings
     | 'KarmaCenter'
     | 'KarmaLeaderboard'
     | 'KarmaRewards'
     | 'KarmaRules'
     | 'AboutKarma'
     | 'KarmaFAQ'
-    // Legacy aliases for backward compatibility
-    | 'SignIn';  // Maps to OxyAuth
+    | 'EditProfile'
 
 // Lazy screen loaders - functions that return screen components on-demand
 // This breaks the require cycle by deferring imports until screens are actually needed
 const screenLoaders: Record<RouteName, () => ComponentType<BaseScreenProps>> = {
     OxyAuth: () => require('../screens/OxyAuthScreen').default,
-    // Legacy alias - SignIn now maps to OxyAuth
-    SignIn: () => require('../screens/OxyAuthScreen').default,
     AccountOverview: () => require('../screens/AccountOverviewScreen').default,
     AccountSettings: () => require('../screens/AccountSettingsScreen').default,
     AccountCenter: () => require('../screens/AccountCenterScreen').default,
@@ -67,7 +63,7 @@ const screenLoaders: Record<RouteName, () => ComponentType<BaseScreenProps>> = {
     UserLinks: () => require('../screens/UserLinksScreen').default,
     HistoryView: () => require('../screens/HistoryViewScreen').default,
     SavesCollections: () => require('../screens/SavesCollectionsScreen').default,
-    // Backward compatibility - EditProfile maps to AccountSettings
+    // EditProfile kept for historical references
     EditProfile: () => require('../screens/AccountSettingsScreen').default,
     // Karma screens
     KarmaCenter: () => require('../screens/karma/KarmaCenterScreen').default,

package/src/ui/screens/AccountCenterScreen.tsx

@@ -86,14 +86,9 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
     return (
         <View style={[styles.container, { backgroundColor }]}>
             {/* Header with user profile */}
-            {user && user.username && (
+            {user && (
                 <ProfileCard
-                    user={{
-                        username: user.username,
-                        email: user.email,
-                        name: user.name,
-                        avatar: user.avatar,
-                    }}
+                    user={user}
                     theme={normalizedTheme}
                     onEditPress={() => navigate?.('EditProfile', { activeTab: 'profile' })}
                     onClosePress={onClose}
@@ -194,7 +189,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                                     iconColor: colors.iconPersonalInfo,
                                     title: t('accountCenter.items.addAccount.title') || 'Add Another Account',
                                     subtitle: t('accountCenter.items.addAccount.subtitle') || 'Sign in with a different account',
-                                    onPress: () => navigate?.('SignIn'),
+                                    onPress: () => navigate?.('OxyAuth'),
                                 },
                             ], [sessions.length, navigate, t, colors])}
 
@@ -213,7 +208,7 @@ const AccountCenterScreen: React.FC<BaseScreenProps> = ({
                                     iconColor: colors.iconPersonalInfo,
                                     title: t('accountCenter.items.addAccount.title') || 'Add Another Account',
                                     subtitle: t('accountCenter.items.addAccount.subtitle') || 'Sign in with a different account',
-                                    onPress: () => navigate?.('SignIn'),
+                                    onPress: () => navigate?.('OxyAuth'),
                                 },
                             ], [navigate, t, colors])}