@oxyhq/services 5.17.17 → 5.18.0

package/src/ui/hooks/useProfileEditing.ts

@@ -1,7 +1,7 @@
 import { useCallback } from 'react';
 import { useI18n } from './useI18n';
 import { useUpdateProfile } from './mutations/useAccountMutations';
-import { useCurrentUser } from './queries/useAccountQueries';
+import { useAuthStore } from '../stores/authStore';
 
 export interface ProfileUpdateData {
     displayName?: string;
@@ -34,7 +34,6 @@ 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
@@ -72,6 +71,7 @@ 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, currentUser]);
+    }, [updateProfileMutation, t]);
 
     /**
      * Update a single profile field

package/src/ui/hooks/useSessionManagement.ts

@@ -9,9 +9,6 @@ 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;
@@ -147,8 +144,7 @@ export const useSessionManagement = ({
     try {
       await storage.removeItem(storageKeys.activeSessionId);
       await storage.removeItem(storageKeys.sessionIds);
-      // Clear identity sync state
-      await storage.removeItem('oxy_identity_synced').catch(() => {});
+      // Note: Identity sync state ('oxy_identity_synced') is managed by accounts app
     } catch (error) {
       handleAuthError(error, {
         defaultMessage: CLEAR_STORAGE_ERROR,
@@ -164,7 +160,6 @@ export const useSessionManagement = ({
     setSessions([]);
     setActiveSessionId(null);
     logoutStore();
-    oxyServices.clearTokens();
     
     // Clear TanStack Query cache (in-memory)
     if (queryClient) {
@@ -184,12 +179,11 @@ export const useSessionManagement = ({
     
     await clearSessionStorage();
     onAuthStateChange?.(null);
-  }, [clearSessionStorage, logoutStore, onAuthStateChange, queryClient, storage, logger, oxyServices]);
+  }, [clearSessionStorage, logoutStore, onAuthStateChange, queryClient, storage, logger]);
 
   const activateSession = useCallback(
     async (sessionId: string, user: User): Promise<void> => {
-      const deviceId = getDeviceIdForSession(sessions, sessionId);
-      await oxyServices.getTokenBySession(sessionId, deviceId);
+      await oxyServices.getTokenBySession(sessionId);
       setTokenReady?.(true);
       setActiveSessionId(sessionId);
       loginSuccess(user);
@@ -199,7 +193,6 @@ export const useSessionManagement = ({
     },
     [
       applyLanguagePreference,
-      sessions,
       loginSuccess,
       onAuthStateChange,
       oxyServices,
@@ -403,3 +396,5 @@ export const useSessionManagement = ({
     isRefreshInFlight,
   };
 };
+
+

package/src/ui/hooks/useSessionSocket.ts

@@ -2,7 +2,6 @@ import { useEffect, useRef } from 'react';
 import io from 'socket.io-client';
 import { toast } from '../../lib/sonner';
 import { logger } from '../../utils/loggerUtils';
-import { tokenService } from '../../core/services/TokenService';
 
 interface UseSessionSocketProps {
   userId: string | null | undefined;
@@ -12,19 +11,15 @@ interface UseSessionSocketProps {
   logout: () => Promise<void>;
   clearSessionState: () => Promise<void>;
   baseURL: string;
-  getAccessToken: () => string | null;
   onRemoteSignOut?: () => void;
   onSessionRemoved?: (sessionId: string) => void;
 }
 
-export function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, getAccessToken, onRemoteSignOut, onSessionRemoved }: UseSessionSocketProps) {
+export function useSessionSocket({ userId, activeSessionId, currentDeviceId, refreshSessions, logout, clearSessionState, baseURL, onRemoteSignOut, onSessionRemoved }: UseSessionSocketProps) {
   const socketRef = useRef<any>(null);
   const joinedRoomRef = useRef<string | null>(null);
-  const accessTokenRef = useRef<string | null>(null);
-  const handlersSetupRef = useRef<boolean>(false);
-  const lastRegisteredSocketIdRef = useRef<string | null>(null);
-  const getAccessTokenRef = useRef(getAccessToken);
   
+  // Store callbacks in refs to avoid re-joining when they change
   const refreshSessionsRef = useRef(refreshSessions);
   const logoutRef = useRef(logout);
   const clearSessionStateRef = useRef(clearSessionState);
@@ -33,6 +28,7 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
   const activeSessionIdRef = useRef(activeSessionId);
   const currentDeviceIdRef = useRef(currentDeviceId);
 
+  // Update refs when callbacks change
   useEffect(() => {
     refreshSessionsRef.current = refreshSessions;
     logoutRef.current = logout;
@@ -41,130 +37,47 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
     onSessionRemovedRef.current = onSessionRemoved;
     activeSessionIdRef.current = activeSessionId;
     currentDeviceIdRef.current = currentDeviceId;
-    getAccessTokenRef.current = getAccessToken;
-  }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId, getAccessToken]);
+  }, [refreshSessions, logout, clearSessionState, onRemoteSignOut, onSessionRemoved, activeSessionId, currentDeviceId]);
 
   useEffect(() => {
     if (!userId || !baseURL) {
-      if (socketRef.current) {
-        socketRef.current.disconnect();
-        socketRef.current = null;
-        joinedRoomRef.current = null;
-      }
-      return;
-    }
-    const freshToken = getAccessTokenRef.current();
-    if (!freshToken) {
-      logger.debug('Deferring socket creation - no access token available yet', { component: 'useSessionSocket', userId });
-      if (socketRef.current) {
-        socketRef.current.disconnect();
-        socketRef.current = null;
+      // Clean up if userId or baseURL becomes invalid
+      if (socketRef.current && joinedRoomRef.current) {
+        socketRef.current.emit('leave', { userId: joinedRoomRef.current });
         joinedRoomRef.current = null;
       }
       return;
     }
 
-    const initializeSocket = async () => {
-      try {
-        await tokenService.refreshTokenIfNeeded();
-      } catch (error) {
-        logger.debug('Token refresh failed before socket connection', { component: 'useSessionSocket', userId, error });
-      }
-
-      const accessToken = getAccessTokenRef.current();
-      const tokenChanged = accessTokenRef.current !== accessToken;
-      if (!socketRef.current || tokenChanged) {
-        if (socketRef.current) {
-          socketRef.current.disconnect();
-          socketRef.current = null;
-        }
+    const roomId = `user:${userId}`;
+    
+    // Only create socket if it doesn't exist
+    if (!socketRef.current) {
+      socketRef.current = io(baseURL, {
+        transports: ['websocket'],
+      });
+    }
+    const socket = socketRef.current;
 
-        const socketOptions: any = {
-          transports: ['websocket'],
-        };
-        
-        const freshToken = getAccessTokenRef.current();
-        if (freshToken) {
-          socketOptions.auth = {
-            token: freshToken,
-          };
-        } else {
-          logger.debug('No access token available for socket authentication', { component: 'useSessionSocket', userId });
-          return;
-        }
-        
-        socketRef.current = io(baseURL, socketOptions);
-        accessTokenRef.current = freshToken;
-        joinedRoomRef.current = null;
-        handlersSetupRef.current = false;
+    // Only join if we haven't already joined this room
+    if (joinedRoomRef.current !== roomId) {
+      // Leave previous room if switching users
+      if (joinedRoomRef.current) {
+        socket.emit('leave', { userId: joinedRoomRef.current });
       }
       
-      const socket = socketRef.current;
-      if (!socket) return;
+      socket.emit('join', { userId: roomId });
+      joinedRoomRef.current = roomId;
       
-      if (!joinedRoomRef.current && socket.connected) {
-        joinedRoomRef.current = `user:${userId}`;
-      }
-
-      const handleConnect = () => {
-      const currentToken = getAccessTokenRef.current();
       if (__DEV__) {
-        console.log('[useSessionSocket] Socket connected', {
-          socketId: socket.id,
-          userId,
-          room: `user:${userId}`,
-          hasAuth: !!currentToken,
-        });
-        logger.debug('Socket connected', { component: 'useSessionSocket', socketId: socket.id, userId });
-      }
-      // Server auto-joins room on connection when authenticated
-      // Just track that we're connected
-      if (userId) {
-        joinedRoomRef.current = `user:${userId}`;
+        console.log('Emitting join for room:', roomId);
       }
-    };
-
-    const handleDisconnect = async (reason: string) => {
-      logger.debug('Socket disconnected', { component: 'useSessionSocket', reason, userId });
-      joinedRoomRef.current = null;
-      
-      // If disconnected due to auth error, try to refresh token and reconnect
-      if (reason === 'io server disconnect' || reason.includes('auth') || reason.includes('Authentication')) {
-        try {
-          // Refresh token and reconnect
-          await tokenService.refreshTokenIfNeeded();
-          const freshToken = getAccessTokenRef.current();
-          if (freshToken && socketRef.current) {
-            // Update auth and reconnect
-            socketRef.current.auth = { token: freshToken };
-            socketRef.current.connect();
-          }
-        } catch (error) {
-          logger.debug('Failed to refresh token after disconnect', { component: 'useSessionSocket', userId, error });
-        }
-      }
-    };
-
-    const handleError = (error: Error) => {
-      logger.error('Socket error', error, { component: 'useSessionSocket', userId });
-    };
+    }
 
-    const handleConnectError = async (error: Error) => {
-      logger.debug('Socket connection error', { component: 'useSessionSocket', userId, error: error.message });
-      
-      // If error is due to expired/invalid token, try to refresh and reconnect
-      if (error.message.includes('Authentication') || error.message.includes('expired') || error.message.includes('token')) {
-        try {
-          await tokenService.refreshTokenIfNeeded();
-          const freshToken = getAccessTokenRef.current();
-          if (freshToken && socketRef.current) {
-            // Update auth and reconnect
-            socketRef.current.auth = { token: freshToken };
-            socketRef.current.connect();
-          }
-        } catch (refreshError) {
-          logger.debug('Failed to refresh token after connection error', { component: 'useSessionSocket', userId, error: refreshError });
-        }
+    // Set up event handlers (only once per socket instance)
+    const handleConnect = () => {
+      if (__DEV__) {
+        console.log('Socket connected:', socket.id);
       }
     };
 
@@ -174,13 +87,9 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
       deviceId?: string; 
       sessionIds?: string[] 
     }) => {
-      logger.debug('Received session_update event', {
-        component: 'useSessionSocket',
-        type: data.type,
-        socketId: socket.id,
-        socketConnected: socket.connected,
-        roomId: joinedRoomRef.current,
-      });
+      if (__DEV__) {
+        console.log('Received session_update:', data);
+      }
       
       const currentActiveSessionId = activeSessionIdRef.current;
       const currentDeviceId = currentDeviceIdRef.current;
@@ -304,64 +213,26 @@ export function useSessionSocket({ userId, activeSessionId, currentDeviceId, ref
           try {
             await clearSessionStateRef.current();
           } catch (error) {
-            logger.error('Failed to clear session state after session_update', error instanceof Error ? error : new Error(String(error)), { component: 'useSessionSocket' });
+            if (__DEV__) {
+              console.error('Failed to clear session state after session_update:', error);
+            }
           }
         }
       }
     };
 
-    // Register event handlers (only once per socket instance)
-    // Track by socket.id to prevent duplicate registrations when socket reconnects
-    const currentSocketId = socket.id || 'pending';
-    
-    if (!handlersSetupRef.current || lastRegisteredSocketIdRef.current !== currentSocketId) {
-      // Remove old handlers if socket changed (reconnection)
-      if (socketRef.current && handlersSetupRef.current && lastRegisteredSocketIdRef.current) {
-        try {
-          socketRef.current.off('connect', handleConnect);
-          socketRef.current.off('disconnect', handleDisconnect);
-          socketRef.current.off('error', handleError);
-          socketRef.current.off('session_update', handleSessionUpdate);
-        } catch (error) {
-          // Ignore errors when removing handlers
-        }
-      }
-      
-      // Register handlers on current socket
-      socket.on('connect', handleConnect);
-      socket.on('disconnect', handleDisconnect);
-      socket.on('error', handleError);
-      socket.on('connect_error', handleConnectError);
-      socket.on('session_update', handleSessionUpdate);
-      
-      handlersSetupRef.current = true;
-      lastRegisteredSocketIdRef.current = currentSocketId;
-      
-      logger.debug('Event handlers set up', { component: 'useSessionSocket', socketId: socket.id, userId });
-    }
-
-      if (!socket.connected) {
-        logger.debug('Socket not connected, connecting...', { component: 'useSessionSocket', userId });
-        socket.connect();
-      }
-    };
-
-    initializeSocket();
+    socket.on('connect', handleConnect);
+    socket.on('session_update', handleSessionUpdate);
 
     return () => {
-      // Only clean up handlers if socket still exists and handlers were set up
-      if (socketRef.current && handlersSetupRef.current) {
-        try {
-          socketRef.current.off('connect');
-          socketRef.current.off('disconnect');
-          socketRef.current.off('error');
-          socketRef.current.off('connect_error');
-          socketRef.current.off('session_update');
-        } catch (error) {
-          // Ignore errors when removing handlers
-        }
-        handlersSetupRef.current = false;
+      socket.off('connect', handleConnect);
+      socket.off('session_update', handleSessionUpdate);
+      
+      // Only leave on unmount if we're still in this room
+      if (joinedRoomRef.current === roomId) {
+        socket.emit('leave', { userId: roomId });
+        joinedRoomRef.current = null;
       }
     };
-  }, [userId, baseURL]); // Only depend on userId and baseURL - functions are in refs
-}
+  }, [userId, baseURL]); // Only depend on userId and baseURL - callbacks are in refs
+} 

package/src/ui/hooks/useSettingToggle.ts

@@ -0,0 +1,147 @@
+import { useState, useCallback, useEffect } from 'react';
+import { toast } from '../../lib/sonner';
+
+interface UseSettingToggleOptions {
+    /** Initial value of the setting */
+    initialValue: boolean;
+    /** Function to save the setting to the server */
+    onSave: (value: boolean) => Promise<void>;
+    /** Success message when saving */
+    successMessage?: string;
+    /** Error message when save fails */
+    errorMessage?: string;
+    /** Whether to revert on error (default: true) */
+    revertOnError?: boolean;
+    /** Whether to show success toast (default: false) */
+    showSuccessToast?: boolean;
+}
+
+interface UseSettingToggleReturn {
+    /** Current value */
+    value: boolean;
+    /** Whether the setting is being saved */
+    isSaving: boolean;
+    /** Toggle the setting (optimistic update with revert on error) */
+    toggle: () => Promise<void>;
+    /** Set the value directly */
+    setValue: (value: boolean) => void;
+}
+
+/**
+ * Hook for handling boolean toggle settings with optimistic updates.
+ * Automatically reverts to the previous value if the save fails.
+ *
+ * @example
+ * const { value, toggle, isSaving } = useSettingToggle({
+ *   initialValue: user.notificationsEnabled,
+ *   onSave: (value) => api.updateNotifications(value),
+ *   errorMessage: 'Failed to update notifications',
+ * });
+ *
+ * <Switch value={value} onValueChange={toggle} disabled={isSaving} />
+ */
+export function useSettingToggle(options: UseSettingToggleOptions): UseSettingToggleReturn {
+    const {
+        initialValue,
+        onSave,
+        successMessage,
+        errorMessage = 'Failed to save setting',
+        revertOnError = true,
+        showSuccessToast = false,
+    } = options;
+
+    const [value, setValue] = useState(initialValue);
+    const [isSaving, setIsSaving] = useState(false);
+
+    // Update value when initialValue changes (e.g., from server)
+    useEffect(() => {
+        setValue(initialValue);
+    }, [initialValue]);
+
+    const toggle = useCallback(async () => {
+        const previousValue = value;
+        const newValue = !value;
+
+        // Optimistic update
+        setValue(newValue);
+        setIsSaving(true);
+
+        try {
+            await onSave(newValue);
+
+            if (showSuccessToast && successMessage) {
+                toast.success(successMessage);
+            }
+        } catch (err: any) {
+            // Revert on error
+            if (revertOnError) {
+                setValue(previousValue);
+            }
+
+            toast.error(errorMessage || err?.message || 'An error occurred');
+        } finally {
+            setIsSaving(false);
+        }
+    }, [value, onSave, successMessage, errorMessage, revertOnError, showSuccessToast]);
+
+    return { value, isSaving, toggle, setValue };
+}
+
+/**
+ * Hook for managing multiple toggle settings at once.
+ * Useful when you have several related boolean settings.
+ */
+export function useSettingToggles<T extends Record<string, boolean>>(options: {
+    initialValues: T;
+    onSave: (key: keyof T, value: boolean) => Promise<void>;
+    errorMessage?: string | ((key: keyof T) => string);
+    revertOnError?: boolean;
+}): {
+    values: T;
+    savingKeys: Set<keyof T>;
+    toggle: (key: keyof T) => Promise<void>;
+    setValues: (values: T) => void;
+} {
+    const { initialValues, onSave, errorMessage = 'Failed to save setting', revertOnError = true } = options;
+
+    const [values, setValues] = useState<T>(initialValues);
+    const [savingKeys, setSavingKeys] = useState<Set<keyof T>>(new Set());
+
+    // Update values when initialValues change
+    useEffect(() => {
+        setValues(initialValues);
+    }, [initialValues]);
+
+    const toggle = useCallback(async (key: keyof T) => {
+        const previousValue = values[key];
+        const newValue = !previousValue;
+
+        // Optimistic update
+        setValues(prev => ({ ...prev, [key]: newValue }));
+        setSavingKeys(prev => new Set(prev).add(key));
+
+        try {
+            await onSave(key, newValue);
+        } catch (err: any) {
+            // Revert on error
+            if (revertOnError) {
+                setValues(prev => ({ ...prev, [key]: previousValue }));
+            }
+
+            const message = typeof errorMessage === 'function'
+                ? errorMessage(key)
+                : errorMessage;
+            toast.error(message || err?.message || 'An error occurred');
+        } finally {
+            setSavingKeys(prev => {
+                const next = new Set(prev);
+                next.delete(key);
+                return next;
+            });
+        }
+    }, [values, onSave, errorMessage, revertOnError]);
+
+    return { values, savingKeys, toggle, setValues };
+}
+
+export default useSettingToggle;

package/src/ui/hooks/useStorage.ts

@@ -1,104 +1,52 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import type { ApiError } from '../../models/interfaces';
 import { createPlatformStorage, type StorageInterface } from '../utils/storageHelpers';
-import { extractErrorMessage } from '../utils/errorHandlers';
 
 export interface UseStorageOptions {
   onError?: (error: ApiError) => void;
   logger?: (message: string, error?: unknown) => void;
-  errorCode?: string;
 }
 
 export interface UseStorageResult {
   storage: StorageInterface | null;
   isReady: boolean;
-  error: string | null;
-  refresh: () => Promise<StorageInterface | null>;
-  withStorage: <T>(callback: (storage: StorageInterface) => Promise<T>) => Promise<T | null>;
 }
 
-const DEFAULT_ERROR_CODE = 'STORAGE_INIT_ERROR';
-
 /**
- * React hook that exposes a platform-agnostic storage reference.
- * Handles initialization, error propagation, and lazy re-initialization.
- *
- * @param options - Optional configuration for error reporting and logging
+ * Simple React hook that initializes platform-appropriate storage.
+ * Returns storage instance once ready, or null if initialization failed.
  */
 export const useStorage = ({
   onError,
   logger,
-  errorCode = DEFAULT_ERROR_CODE,
 }: UseStorageOptions = {}): UseStorageResult => {
   const [storage, setStorage] = useState<StorageInterface | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const initializingRef = useRef<Promise<StorageInterface | null> | null>(null);
-
-  const notifyError = useCallback(
-    (err: unknown) => {
-      const message = extractErrorMessage(err, 'Failed to initialize storage');
-      setError(message);
-
-      if (logger) {
-        logger(message, err);
-      }
-
-      onError?.({
-        message,
-        code: errorCode,
-        status: 500,
-      });
-    },
-    [errorCode, logger, onError],
-  );
-
-  const createStorageInstance = useCallback(async (): Promise<StorageInterface | null> => {
-    try {
-      const platformStorage = await createPlatformStorage();
-      setStorage(platformStorage);
-      setError(null);
-      return platformStorage;
-    } catch (err) {
-      notifyError(err);
-      setStorage(null);
-      return null;
-    }
-  }, [notifyError]);
-
-  const refresh = useCallback(async (): Promise<StorageInterface | null> => {
-    if (!initializingRef.current) {
-      initializingRef.current = createStorageInstance().finally(() => {
-        initializingRef.current = null;
-      });
-    }
-
-    return initializingRef.current;
-  }, [createStorageInstance]);
+  const initRef = useRef<Promise<void> | null>(null);
 
   useEffect(() => {
-    refresh().catch((err) => {
-      notifyError(err);
-    });
-  }, [refresh, notifyError]);
-
-  const withStorage = useCallback(
-    async <T,>(callback: (resolvedStorage: StorageInterface) => Promise<T>): Promise<T | null> => {
-      const resolvedStorage = storage ?? (await refresh());
-      if (!resolvedStorage) {
-        return null;
+    // Prevent multiple initializations
+    if (initRef.current) return;
+
+    initRef.current = (async () => {
+      try {
+        const storageInstance = await createPlatformStorage();
+        setStorage(storageInstance);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to initialize storage';
+        if (logger) {
+          logger(message, err);
+        }
+        onError?.({
+          message,
+          code: 'STORAGE_INIT_ERROR',
+          status: 500,
+        });
       }
-      return callback(resolvedStorage);
-    },
-    [refresh, storage],
-  );
+    })();
+  }, [logger, onError]);
 
   return {
     storage,
-    isReady: Boolean(storage) && !error,
-    error,
-    refresh,
-    withStorage,
+    isReady: storage !== null,
   };
 };
-
-