@oxyhq/services 5.16.0 → 5.16.2

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

@@ -85,7 +85,7 @@ export const useAuthOperations = ({
 }: UseAuthOperationsOptions): UseAuthOperationsResult => {
   
   /**
-   * Internal function to perform challenge-response sign in
+   * Internal function to perform challenge-response sign in (works offline)
    */
   const performSignIn = useCallback(
     async (publicKey: string): Promise<User> => {
@@ -94,8 +94,36 @@ export const useAuthOperations = ({
       const deviceInfo = await DeviceManager.getDeviceInfo();
       const deviceName = deviceInfo.deviceName || DeviceManager.getDefaultDeviceName();
 
-      // Request challenge
-      const { challenge } = await oxyServices.requestChallenge(publicKey);
+      let challenge: string;
+      let isOffline = false;
+
+      // Try to request challenge from server (online)
+      try {
+        const challengeResponse = await oxyServices.requestChallenge(publicKey);
+        challenge = challengeResponse.challenge;
+      } catch (error) {
+        // Network error - generate challenge locally for offline sign-in
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const isNetworkError = 
+          errorMessage.includes('Network') ||
+          errorMessage.includes('network') ||
+          errorMessage.includes('Failed to fetch') ||
+          errorMessage.includes('fetch failed') ||
+          (error as any)?.code === 'NETWORK_ERROR' ||
+          (error as any)?.status === 0;
+
+        if (isNetworkError) {
+          if (__DEV__ && logger) {
+            logger('Network unavailable, performing offline sign-in');
+          }
+          // Generate challenge locally
+          challenge = await SignatureService.generateChallenge();
+          isOffline = true;
+        } else {
+          // Re-throw non-network errors
+          throw error;
+        }
+      }
 
       // Note: Biometric authentication check should be handled by the app layer
       // (e.g., accounts app) before calling signIn. The biometric preference is stored
@@ -104,66 +132,129 @@ export const useAuthOperations = ({
       // Sign the challenge
       const { challenge: signature, timestamp } = await SignatureService.signChallenge(challenge);
 
-      // Verify and create session
-      const sessionResponse = await oxyServices.verifyChallenge(
-        publicKey,
-        challenge,
-        signature,
-        timestamp,
-        deviceName,
-        deviceFingerprint,
-      );
-
-      // Get token for the session
-      await oxyServices.getTokenBySession(sessionResponse.sessionId);
-
-      // Get full user data
-      const fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
-      await applyLanguagePreference(fullUser);
-      loginSuccess(fullUser);
+      let fullUser: User;
+      let sessionResponse: SessionLoginResponse;
 
-      // Fetch device sessions
-      let allDeviceSessions: ClientSession[] = [];
-      try {
-        allDeviceSessions = await fetchSessionsWithFallback(oxyServices, sessionResponse.sessionId, {
-          fallbackDeviceId: sessionResponse.deviceId,
-          fallbackUserId: fullUser.id,
-          logger,
-        });
-      } catch (error) {
-        if (__DEV__) {
-          console.warn('Failed to fetch device sessions after login:', error);
+      if (isOffline) {
+        // Offline sign-in: create local session and minimal user object
+        if (__DEV__ && logger) {
+          logger('Creating offline session');
         }
-      }
 
-      // Check for existing session for same user
-      const existingSession = allDeviceSessions.find(
-        (session) =>
-          session.userId?.toString() === fullUser.id?.toString() &&
-          session.sessionId !== sessionResponse.sessionId,
-      );
+        // Generate a local session ID
+        const localSessionId = `offline_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const localDeviceId = `device_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(); // 7 days
+
+        // Create minimal user object with publicKey as id
+        fullUser = {
+          id: publicKey, // Use publicKey as id (per migration document)
+          publicKey,
+          username: '',
+          privacySettings: {},
+        } as User;
+
+        sessionResponse = {
+          sessionId: localSessionId,
+          deviceId: localDeviceId,
+          expiresAt,
+          user: {
+            id: publicKey,
+            username: '',
+          },
+        };
+
+        // Store offline session locally
+        const offlineSession: ClientSession = {
+          sessionId: localSessionId,
+          deviceId: localDeviceId,
+          expiresAt,
+          lastActive: new Date().toISOString(),
+          userId: publicKey,
+          isCurrent: true,
+        };
+
+        setActiveSessionId(localSessionId);
+        await saveActiveSessionId(localSessionId);
+        updateSessions([offlineSession], { merge: true });
+
+        // Mark session as offline for later sync
+        if (storage) {
+          await storage.setItem(`oxy_session_${localSessionId}_offline`, 'true');
+        }
+
+        if (__DEV__ && logger) {
+          logger('Offline sign-in successful');
+        }
+      } else {
+        // Online sign-in: use normal flow
+        // Verify and create session
+        sessionResponse = await oxyServices.verifyChallenge(
+          publicKey,
+          challenge,
+          signature,
+          timestamp,
+          deviceName,
+          deviceFingerprint,
+        );
+
+        // Get token for the session
+        await oxyServices.getTokenBySession(sessionResponse.sessionId);
 
-      if (existingSession) {
-        // Logout duplicate session
+        // Get full user data
+        fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
+        
+        // Ensure id is set to publicKey (per migration document)
+        if (fullUser.id !== fullUser.publicKey) {
+          fullUser.id = fullUser.publicKey;
+        }
+
+        // Fetch device sessions
+        let allDeviceSessions: ClientSession[] = [];
         try {
-          await oxyServices.logoutSession(sessionResponse.sessionId, sessionResponse.sessionId);
-        } catch (logoutError) {
+          allDeviceSessions = await fetchSessionsWithFallback(oxyServices, sessionResponse.sessionId, {
+            fallbackDeviceId: sessionResponse.deviceId,
+            fallbackUserId: fullUser.id,
+            logger,
+          });
+        } catch (error) {
           if (__DEV__) {
-            console.warn('Failed to logout duplicate session:', logoutError);
+            console.warn('Failed to fetch device sessions after login:', error);
           }
         }
-        await switchSession(existingSession.sessionId);
-        updateSessions(
-          allDeviceSessions.filter((session) => session.sessionId !== sessionResponse.sessionId),
-          { merge: false },
+
+        // Check for existing session for same user
+        const existingSession = allDeviceSessions.find(
+          (session) =>
+            session.userId?.toString() === fullUser.id?.toString() &&
+            session.sessionId !== sessionResponse.sessionId,
         );
-        onAuthStateChange?.(fullUser);
-        return fullUser;
+
+        if (existingSession) {
+          // Logout duplicate session
+          try {
+            await oxyServices.logoutSession(sessionResponse.sessionId, sessionResponse.sessionId);
+          } catch (logoutError) {
+            if (__DEV__) {
+              console.warn('Failed to logout duplicate session:', logoutError);
+            }
+          }
+          await switchSession(existingSession.sessionId);
+          updateSessions(
+            allDeviceSessions.filter((session) => session.sessionId !== sessionResponse.sessionId),
+            { merge: false },
+          );
+          onAuthStateChange?.(fullUser);
+          return fullUser;
+        }
+
+        setActiveSessionId(sessionResponse.sessionId);
+        await saveActiveSessionId(sessionResponse.sessionId);
+        updateSessions(allDeviceSessions, { merge: true });
       }
 
-      setActiveSessionId(sessionResponse.sessionId);
-      await saveActiveSessionId(sessionResponse.sessionId);
-      updateSessions(allDeviceSessions, { merge: true });
+      await applyLanguagePreference(fullUser);
+      loginSuccess(fullUser);
       onAuthStateChange?.(fullUser);
       
       return fullUser;
@@ -178,6 +269,7 @@ export const useAuthOperations = ({
       setActiveSessionId,
       switchSession,
       updateSessions,
+      storage,
     ],
   );
 
@@ -224,10 +316,27 @@ export const useAuthOperations = ({
           };
         }
       } catch (error) {
-        // Clean up identity if generation failed
-        await KeyManager.deleteIdentity().catch(() => {});
-        await storage.removeItem('oxy_identity_synced').catch(() => {});
-        setIdentitySynced(true);
+        // CRITICAL: Never delete identity on error - it may have been successfully created
+        // Only log the error and let the user recover using their recovery phrase
+        // Identity deletion should ONLY happen when explicitly requested by the user
+        if (__DEV__ && logger) {
+          logger('Error during identity creation (identity may still exist):', error);
+        }
+        
+        // Check if identity was actually created (keys exist)
+        const hasIdentity = await KeyManager.hasIdentity().catch(() => false);
+        if (hasIdentity) {
+          // Identity exists - don't delete it! Just mark as not synced
+          await storage.setItem('oxy_identity_synced', 'false').catch(() => {});
+          setIdentitySynced(false);
+          if (__DEV__ && logger) {
+            logger('Identity was created but sync failed - user can sync later using recovery phrase');
+          }
+        } else {
+          // No identity exists - this was a generation failure, safe to clean up sync flag
+          await storage.removeItem('oxy_identity_synced').catch(() => {});
+          setIdentitySynced(false);
+        }
         
         const message = handleAuthError(error, {
           defaultMessage: 'Failed to create identity',
@@ -258,6 +367,7 @@ export const useAuthOperations = ({
 
   /**
    * Sync local identity with server (call when online)
+   * TanStack Query handles offline mutations automatically
    */
   const syncIdentity = useCallback(
     async (): Promise<User> => {
@@ -275,7 +385,6 @@ export const useAuthOperations = ({
         // Check if already synced
         const alreadySynced = await storage.getItem('oxy_identity_synced');
         if (alreadySynced === 'true') {
-          // Already synced, just sign in
           setIdentitySynced(true);
           return await performSignIn(publicKey);
         }
@@ -294,7 +403,11 @@ export const useAuthOperations = ({
         setIdentitySynced(true);
 
         // Sign in
-        return await performSignIn(publicKey);
+        const user = await performSignIn(publicKey);
+
+        // TanStack Query will automatically retry any pending mutations
+
+        return user;
       } catch (error) {
         const message = handleAuthError(error, {
           defaultMessage: 'Failed to sync identity',

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

@@ -6,6 +6,8 @@ import { fetchSessionsWithFallback, mapSessionsToClient, validateSessionBatch }
 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';
 
 export interface UseSessionManagementOptions {
   oxyServices: OxyServices;
@@ -19,6 +21,7 @@ export interface UseSessionManagementOptions {
   setAuthError?: (message: string | null) => void;
   logger?: (message: string, error?: unknown) => void;
   setTokenReady?: (ready: boolean) => void;
+  queryClient?: QueryClient | null;
 }
 
 export interface UseSessionManagementResult {
@@ -55,6 +58,7 @@ export const useSessionManagement = ({
   setAuthError,
   logger,
   setTokenReady,
+  queryClient,
 }: UseSessionManagementOptions): UseSessionManagementResult => {
   const [sessions, setSessions] = useState<ClientSession[]>([]);
   const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
@@ -140,6 +144,8 @@ 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(() => {});
     } catch (error) {
       handleAuthError(error, {
         defaultMessage: CLEAR_STORAGE_ERROR,
@@ -155,9 +161,26 @@ export const useSessionManagement = ({
     setSessions([]);
     setActiveSessionId(null);
     logoutStore();
+    
+    // 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]);
+  }, [clearSessionStorage, logoutStore, onAuthStateChange, queryClient, storage, logger]);
 
   const activateSession = useCallback(
     async (sessionId: string, user: User): Promise<void> => {

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

@@ -0,0 +1,4 @@
+// Export all mutation hooks
+export * from './useAccountMutations';
+export * from './useServicesMutations';
+

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

@@ -0,0 +1,277 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type { User } from '../../../models/interfaces';
+import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
+import { useOxy } from '../../context/OxyContext';
+import { toast } from '../../../lib/sonner';
+
+/**
+ * Update user profile with optimistic updates and offline queue support
+ */
+export const useUpdateProfile = () => {
+  const { oxyServices, activeSessionId, user, syncIdentity } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (updates: Partial<User>) => {
+      // Ensure we have a valid token before making the request
+      if (!oxyServices.hasValidToken() && activeSessionId) {
+        try {
+          // Try to get token for the session
+          await oxyServices.getTokenBySession(activeSessionId);
+        } catch (tokenError) {
+          // If getting token fails, might be an offline session - try syncing
+          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
+            try {
+              await syncIdentity();
+              // Retry getting token after sync
+              await oxyServices.getTokenBySession(activeSessionId);
+            } catch (syncError) {
+              throw new Error('Session needs to be synced. Please try again.');
+            }
+          } else {
+            throw tokenError;
+          }
+        }
+      }
+
+      try {
+        return await oxyServices.updateProfile(updates);
+      } 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')) {
+          // Try to sync session and get token
+          if (activeSessionId) {
+            try {
+              await syncIdentity();
+              await oxyServices.getTokenBySession(activeSessionId);
+              // Retry the update after getting token
+              return await oxyServices.updateProfile(updates);
+            } catch (retryError) {
+              throw new Error('Authentication failed. Please sign in again.');
+            }
+          } else {
+            throw new Error('No active session. Please sign in.');
+          }
+        }
+        
+        // TanStack Query will automatically retry on network errors
+        throw error;
+      }
+    },
+    // Optimistic update
+    onMutate: async (updates) => {
+      // Cancel outgoing refetches
+      await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+
+      // Snapshot previous value
+      const previousUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+
+      // Optimistically update
+      if (previousUser) {
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+          ...previousUser,
+          ...updates,
+        });
+
+        // Also update profile query if sessionId is available
+        if (activeSessionId) {
+          queryClient.setQueryData<User>(queryKeys.users.profile(activeSessionId), {
+            ...previousUser,
+            ...updates,
+          });
+        }
+      }
+
+      return { previousUser };
+    },
+    // On error, rollback
+    onError: (error, updates, context) => {
+      if (context?.previousUser) {
+        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+        if (activeSessionId) {
+          queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+        }
+      }
+      toast.error(error instanceof Error ? error.message : 'Failed to update profile');
+    },
+    // On success, invalidate and refetch
+    onSuccess: (data) => {
+      // Update cache with server response
+      queryClient.setQueryData(queryKeys.accounts.current(), data);
+      if (activeSessionId) {
+        queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
+      }
+      
+      // Invalidate related queries
+      invalidateUserQueries(queryClient);
+    },
+    // Always refetch after error or success
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.current() });
+      if (activeSessionId) {
+        queryClient.invalidateQueries({ queryKey: queryKeys.users.profile(activeSessionId) });
+      }
+    },
+  });
+};
+
+/**
+ * Upload avatar with progress tracking and offline queue support
+ */
+export const useUploadAvatar = () => {
+  const { oxyServices, activeSessionId, syncIdentity } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (file: { uri: string; type?: string; name?: string; size?: number }) => {
+      // 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')) {
+            try {
+              await syncIdentity();
+              await oxyServices.getTokenBySession(activeSessionId);
+            } catch (syncError) {
+              throw new Error('Session needs to be synced. Please try again.');
+            }
+          } else {
+            throw tokenError;
+          }
+        }
+      }
+
+      try {
+        // Upload file first
+        const uploadResult = await oxyServices.assetUpload(file as any, 'public');
+        const fileId = uploadResult?.file?.id || uploadResult?.id || uploadResult;
+
+        if (!fileId || typeof fileId !== 'string') {
+          throw new Error('Failed to get file ID from upload result');
+        }
+
+        // Update profile with file ID
+        return await oxyServices.updateProfile({ avatar: fileId });
+      } 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) {
+            try {
+              await syncIdentity();
+              await oxyServices.getTokenBySession(activeSessionId);
+              // Retry upload
+              const uploadResult = await oxyServices.assetUpload(file as any, 'public');
+              const fileId = uploadResult?.file?.id || uploadResult?.id || uploadResult;
+              if (!fileId || typeof fileId !== 'string') {
+                throw new Error('Failed to get file ID from upload result');
+              }
+              return await oxyServices.updateProfile({ avatar: fileId });
+            } catch (retryError) {
+              throw new Error('Authentication failed. Please sign in again.');
+            }
+          } else {
+            throw new Error('No active session. Please sign in.');
+          }
+        }
+        
+        // TanStack Query will automatically retry on network errors
+        throw error;
+      }
+    },
+    onMutate: async (file) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+      const previousUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+
+      // Optimistically set a temporary avatar (using file URI as placeholder)
+      if (previousUser) {
+        const optimisticUser = {
+          ...previousUser,
+          avatar: file.uri, // Temporary, will be replaced with fileId
+        };
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), optimisticUser);
+        if (activeSessionId) {
+          queryClient.setQueryData<User>(queryKeys.users.profile(activeSessionId), optimisticUser);
+        }
+      }
+
+      return { previousUser };
+    },
+    onError: (error, file, context) => {
+      if (context?.previousUser) {
+        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+        if (activeSessionId) {
+          queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+        }
+      }
+      toast.error(error instanceof Error ? error.message : 'Failed to upload avatar');
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(queryKeys.accounts.current(), data);
+      if (activeSessionId) {
+        queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
+      }
+      invalidateUserQueries(queryClient);
+      toast.success('Avatar updated successfully');
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.current() });
+      if (activeSessionId) {
+        queryClient.invalidateQueries({ queryKey: queryKeys.users.profile(activeSessionId) });
+      }
+    },
+  });
+};
+
+/**
+ * Update account settings
+ */
+export const useUpdateAccountSettings = () => {
+  const { oxyServices, activeSessionId } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (settings: Record<string, any>) => {
+      return await oxyServices.updateProfile({ privacySettings: settings });
+    },
+    onMutate: async (settings) => {
+      await queryClient.cancelQueries({ queryKey: queryKeys.accounts.settings() });
+      const previousUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+
+      if (previousUser) {
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+          ...previousUser,
+          privacySettings: {
+            ...previousUser.privacySettings,
+            ...settings,
+          },
+        });
+      }
+
+      return { previousUser };
+    },
+    onError: (error, settings, context) => {
+      if (context?.previousUser) {
+        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+      }
+      toast.error(error instanceof Error ? error.message : 'Failed to update settings');
+    },
+    onSuccess: (data) => {
+      queryClient.setQueryData(queryKeys.accounts.current(), data);
+      invalidateAccountQueries(queryClient);
+      toast.success('Settings updated successfully');
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.settings() });
+    },
+  });
+};
+