@oxyhq/services 5.16.11 → 5.16.13

package/src/ui/context/OxyContext.tsx

@@ -30,8 +30,7 @@ import { useQueryClient } from '@tanstack/react-query';
 import { clearQueryCache } from '../hooks/queryClient';
 import { KeyManager } from '../../crypto/keyManager';
 import { translate } from '../../i18n';
-import { useUpdateProfile } from '../hooks/mutations/useAccountMutations';
-import { updateAvatarVisibility } from '../utils/avatarUtils';
+import { updateAvatarVisibility, updateProfileWithAvatar } from '../utils/avatarUtils';
 import { useAccountStore } from '../stores/accountStore';
 
 export interface OxyContextState {
@@ -202,7 +201,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
     const checkAndRestoreIdentity = async () => {
       try {
-        const { KeyManager } = await import('../../crypto/index.js');
         // Check if identity exists and verify integrity
         const hasIdentity = await KeyManager.hasIdentity();
         if (hasIdentity) {
@@ -210,14 +208,11 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
           if (!isValid) {
             // Try to restore from backup
             const restored = await KeyManager.restoreIdentityFromBackup();
-            if (restored) {
-              if (__DEV__) {
-                logger('Identity restored from backup successfully');
-              }
-            } else {
-              if (__DEV__) {
-                logger('Identity integrity check failed - user may need to restore from recovery phrase');
-              }
+            if (__DEV__) {
+              logger(restored
+                ? 'Identity restored from backup successfully'
+                : 'Identity integrity check failed - user may need to restore from recovery phrase'
+              );
             }
           } else {
             // Identity is valid - ensure backup is up to date
@@ -259,7 +254,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   });
 
   const queryClient = useQueryClient();
-  const updateProfileMutation = useUpdateProfile();
 
   const {
     sessions,
@@ -319,9 +313,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
   });
 
   // syncIdentity - TanStack Query handles offline mutations automatically
-  const syncIdentity = useCallback(async () => {
-    return await syncIdentityBase();
-  }, [syncIdentityBase]);
+  const syncIdentity = useCallback(() => syncIdentityBase(), [syncIdentityBase]);
 
   // Clear all account data when identity is lost (for accounts app)
   // In accounts app, identity = account, so losing identity means losing everything
@@ -334,9 +326,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       try {
         await clearQueryCache(storage);
       } catch (error) {
-        if (logger) {
-          logger('Failed to clear persisted query cache', error);
-        }
+        logger('Failed to clear persisted query cache', error);
       }
     }
 
@@ -348,9 +338,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
       try {
         await storage.removeItem('oxy_identity_synced');
       } catch (error) {
-        if (logger) {
-          logger('Failed to clear identity sync state', error);
-        }
+        logger('Failed to clear identity sync state', error);
       }
     }
 
@@ -421,20 +409,21 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
 
         // If we were offline and now we're online, sync identity if needed
         if (wasOffline) {
-          if (__DEV__ && logger) {
-            logger('Network reconnected, checking identity sync...');
-          }
+          logger('Network reconnected, checking identity sync...');
 
           // Sync identity first (if not synced)
           try {
-            const isSynced = await storage.getItem('oxy_identity_synced');
-            if (isSynced === 'false') {
-              await syncIdentity();
+            const hasIdentityValue = await hasIdentity();
+            if (hasIdentityValue) {
+              // Check sync status directly - sync if not explicitly 'true'
+              // undefined = not synced yet, 'false' = explicitly not synced, 'true' = synced
+              const syncStatus = await storage.getItem('oxy_identity_synced');
+              if (syncStatus !== 'true') {
+                await syncIdentity();
+              }
             }
           } catch (syncError) {
-            if (__DEV__ && logger) {
-              logger('Error syncing identity on reconnect', syncError);
-            }
+            logger('Error syncing identity on reconnect', syncError);
           }
 
           // TanStack Query will automatically retry pending mutations
@@ -517,7 +506,11 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
               });
             }
           } catch (validationError) {
-            logger('Session validation failed during init', validationError);
+            // Silently handle expected 401 errors (expired/invalid sessions) during restoration
+            // Only log unexpected errors
+            if (!isInvalidSessionError(validationError)) {
+              logger('Session validation failed during init', validationError);
+            }
           }
         }
 
@@ -530,13 +523,16 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         try {
           await switchSession(storedActiveSessionId);
         } catch (switchError) {
+          // Silently handle expected 401 errors (expired/invalid active session)
           if (isInvalidSessionError(switchError)) {
             await storage.removeItem(storageKeys.activeSessionId);
             updateSessions(
               validSessions.filter((session) => session.sessionId !== storedActiveSessionId),
               { merge: false },
             );
+            // Don't log expected session errors during restoration
           } else {
+            // Only log unexpected errors
             logger('Active session validation error', switchError);
           }
         }
@@ -638,8 +634,14 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
             // Update file visibility to public for avatar
             await updateAvatarVisibility(file.id, oxyServices, 'OxyContext');
 
-            // Update user profile using mutation (handles query invalidation and accountStore update)
-            await updateProfileMutation.mutateAsync({ avatar: file.id });
+            // Update user profile (handles query invalidation and accountStore update)
+            await updateProfileWithAvatar(
+              { avatar: file.id },
+              oxyServices,
+              activeSessionId,
+              queryClient,
+              syncIdentity
+            );
 
             toast.success(translate(currentLanguage, 'editProfile.toasts.avatarUpdated') || 'Avatar updated');
           } catch (e: any) {
@@ -648,7 +650,7 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
         },
       },
     });
-  }, [oxyServices, currentLanguage, showBottomSheetForContext, updateProfileMutation]);
+  }, [oxyServices, currentLanguage, showBottomSheetForContext, activeSessionId, queryClient, syncIdentity]);
 
   const contextValue: OxyContextState = useMemo(() => ({
     user,

package/src/ui/context/hooks/useSessionManagement.ts

@@ -7,7 +7,7 @@ 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 '../../hooks/queryClient.js';
+import { clearQueryCache } from '../../hooks/queryClient';
 
 export interface UseSessionManagementOptions {
   oxyServices: OxyServices;

package/src/ui/context/utils/errorHandlers.ts

@@ -53,11 +53,21 @@ export const isInvalidSessionError = (error: unknown): boolean => {
     return false;
   }
 
+  // Check error.status directly (HttpService sets this)
+  if ((error as any).status === 401) {
+    return true;
+  }
+
   const normalizedMessage = extractErrorMessage(error)?.toLowerCase();
   if (!normalizedMessage) {
     return false;
   }
 
+  // Check for HTTP 401 in message (HttpService creates errors with "HTTP 401:" format)
+  if (normalizedMessage.includes('http 401') || normalizedMessage.includes('401')) {
+    return true;
+  }
+
   return DEFAULT_INVALID_SESSION_MESSAGES.some((msg) =>
     normalizedMessage.includes(msg.toLowerCase()),
   );

package/src/ui/hooks/mutations/useAccountMutations.ts

@@ -219,15 +219,17 @@ export const useUploadAvatar = () => {
       if (activeSessionId) {
         queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
       }
+      
+      // Refresh accountStore with cache-busted URL if avatar was updated
+      if (data?.avatar && activeSessionId && oxyServices) {
+        refreshAvatarInStore(activeSessionId, data.avatar, oxyServices);
+      }
+      
+      // Invalidate all related queries to refresh everywhere
       invalidateUserQueries(queryClient);
+      invalidateAccountQueries(queryClient);
       toast.success('Avatar updated successfully');
     },
-    onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.current() });
-      if (activeSessionId) {
-        queryClient.invalidateQueries({ queryKey: queryKeys.users.profile(activeSessionId) });
-      }
-    },
   });
 };
 

package/src/ui/utils/avatarUtils.ts

@@ -1,5 +1,8 @@
 import type { OxyServices } from '../../core';
+import type { User } from '../../models/interfaces';
 import { useAccountStore } from '../stores/accountStore';
+import { QueryClient } from '@tanstack/react-query';
+import { queryKeys, invalidateUserQueries, invalidateAccountQueries } from '../hooks/queries/queryKeys';
 
 /**
  * Updates file visibility to public for avatar use.
@@ -22,12 +25,11 @@ export async function updateAvatarVisibility(
 
   try {
     await oxyServices.assetUpdateVisibility(fileId, 'public');
-    console.log(`[${contextName}] Avatar visibility updated to public`);
+    // Visibility update is logged by the API
   } catch (visError: any) {
-    // Only log non-404 errors (404 means asset doesn't exist yet, which is OK)
-    if (visError?.response?.status !== 404) {
-      console.warn(`[${contextName}] Failed to update avatar visibility, continuing anyway:`, visError);
-    }
+    // Silently handle errors - 404 means asset doesn't exist yet (which is OK)
+    // Other errors are logged by the API, so no need to log here
+    // Function continues gracefully regardless of visibility update success
   }
 }
 
@@ -51,3 +53,87 @@ export function refreshAvatarInStore(
   });
 }
 
+/**
+ * Updates user profile with avatar and handles all side effects (query invalidation, accountStore update).
+ * This function can be used from within OxyContext provider without requiring useOxy hook.
+ * 
+ * @param updates - Profile updates including avatar
+ * @param oxyServices - OxyServices instance
+ * @param activeSessionId - Active session ID
+ * @param queryClient - TanStack Query client
+ * @param syncIdentity - Optional sync identity function for handling auth errors
+ * @returns Promise that resolves with updated user data
+ */
+export async function updateProfileWithAvatar(
+  updates: Partial<User>,
+  oxyServices: OxyServices,
+  activeSessionId: string | null,
+  queryClient: QueryClient,
+  syncIdentity?: () => Promise<User>
+): Promise<User> {
+  // Ensure we have a valid token before making the request
+  if (!oxyServices.hasValidToken() && activeSessionId) {
+    try {
+      await oxyServices.getTokenBySession(activeSessionId);
+    } catch (tokenError) {
+      const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+      if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
+        if (syncIdentity) {
+          try {
+            await syncIdentity();
+            await oxyServices.getTokenBySession(activeSessionId);
+          } catch (syncError) {
+            throw new Error('Session needs to be synced. Please try again.');
+          }
+        } else {
+          throw tokenError;
+        }
+      } else {
+        throw tokenError;
+      }
+    }
+  }
+
+  try {
+    const data = await oxyServices.updateProfile(updates);
+    
+    // Update cache with server response
+    queryClient.setQueryData(queryKeys.accounts.current(), data);
+    if (activeSessionId) {
+      queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
+    }
+    
+    // If avatar was updated, refresh accountStore with cache-busted URL
+    if (updates.avatar && activeSessionId) {
+      refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);
+    }
+    
+    // Invalidate all related queries to refresh everywhere
+    invalidateUserQueries(queryClient);
+    invalidateAccountQueries(queryClient);
+    
+    return data;
+  } catch (error: any) {
+    const errorMessage = error?.message || '';
+    const status = error?.status || error?.response?.status;
+    
+    // Handle authentication errors
+    if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
+      if (activeSessionId && syncIdentity) {
+        try {
+          await syncIdentity();
+          await oxyServices.getTokenBySession(activeSessionId);
+          // Retry the update after getting token
+          return await updateProfileWithAvatar(updates, oxyServices, activeSessionId, queryClient, syncIdentity);
+        } catch (retryError) {
+          throw new Error('Authentication failed. Please sign in again.');
+        }
+      } else {
+        throw new Error('No active session. Please sign in.');
+      }
+    }
+    
+    throw error;
+  }
+}
+