@oxyhq/services 5.16.4 → 5.16.7

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

@@ -1,4 +1,25 @@
-// Export all mutation hooks
-export * from './useAccountMutations';
-export * from './useServicesMutations';
+/**
+ * Mutation Hooks
+ * 
+ * TanStack Query mutation hooks for updating Oxy services data.
+ * All mutations handle authentication, error handling, and query invalidation.
+ */
+
+// Account mutation hooks
+export {
+  useUpdateProfile,
+  useUploadAvatar,
+  useUpdateAccountSettings,
+  useUpdatePrivacySettings,
+  useUploadFile,
+} from './useAccountMutations';
+
+// Service mutation hooks (sessions, devices)
+export {
+  useSwitchSession,
+  useLogoutSession,
+  useLogoutAll,
+  useUpdateDeviceName,
+  useRemoveDevice,
+} from './useServicesMutations';
 

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

@@ -275,3 +275,208 @@ export const useUpdateAccountSettings = () => {
   });
 };
 
+/**
+ * Update privacy settings with optimistic updates and authentication handling
+ */
+export const useUpdatePrivacySettings = () => {
+  const { oxyServices, activeSessionId, user, syncIdentity } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ settings, userId }: { settings: Record<string, any>; userId?: string }) => {
+      const targetUserId = userId || user?.id;
+      if (!targetUserId) {
+        throw new Error('User ID is required');
+      }
+
+      // 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.updatePrivacySettings(settings, targetUserId);
+      } 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.updatePrivacySettings(settings, targetUserId);
+            } 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 ({ settings, userId }) => {
+      const targetUserId = userId || user?.id;
+      if (!targetUserId) return;
+
+      // Cancel outgoing refetches
+      await queryClient.cancelQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
+      await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+
+      // Snapshot previous values
+      const previousPrivacySettings = queryClient.getQueryData(queryKeys.privacy.settings(targetUserId));
+      const previousUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+
+      // Optimistically update privacy settings
+      if (previousPrivacySettings) {
+        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), {
+          ...previousPrivacySettings,
+          ...settings,
+        });
+      }
+
+      // Also update user query if available
+      if (previousUser) {
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+          ...previousUser,
+          privacySettings: {
+            ...previousUser.privacySettings,
+            ...settings,
+          },
+        });
+      }
+
+      return { previousPrivacySettings, previousUser };
+    },
+    // On error, rollback
+    onError: (error, { userId }, context) => {
+      const targetUserId = userId || user?.id;
+      if (context?.previousPrivacySettings && targetUserId) {
+        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), context.previousPrivacySettings);
+      }
+      if (context?.previousUser) {
+        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+      }
+      toast.error(error instanceof Error ? error.message : 'Failed to update privacy settings');
+    },
+    // On success, invalidate and refetch
+    onSuccess: (data, { userId }) => {
+      const targetUserId = userId || user?.id;
+      if (targetUserId) {
+        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), data);
+      }
+      // Also update account query if it contains privacy settings
+      const currentUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
+      if (currentUser) {
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+          ...currentUser,
+          privacySettings: data,
+        });
+      }
+      invalidateAccountQueries(queryClient);
+    },
+    // Always refetch after error or success
+    onSettled: (data, error, { userId }) => {
+      const targetUserId = userId || user?.id;
+      if (targetUserId) {
+        queryClient.invalidateQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
+      }
+      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.current() });
+    },
+  });
+};
+
+/**
+ * Upload file with authentication handling and progress tracking
+ */
+export const useUploadFile = () => {
+  const { oxyServices, activeSessionId, syncIdentity } = useOxy();
+
+  return useMutation({
+    mutationFn: async ({ 
+      file, 
+      visibility, 
+      metadata, 
+      onProgress 
+    }: { 
+      file: File; 
+      visibility?: 'private' | 'public' | 'unlisted'; 
+      metadata?: Record<string, any>;
+      onProgress?: (progress: number) => void;
+    }) => {
+      // 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.assetUpload(file as any, visibility, metadata, onProgress);
+      } 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 upload after getting token
+              return await oxyServices.assetUpload(file as any, visibility, metadata, onProgress);
+            } 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;
+      }
+    },
+  });
+};
+

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

@@ -1,5 +1,30 @@
-// Export all query hooks
-export * from './useAccountQueries';
-export * from './useServicesQueries';
-export * from './queryKeys';
+/**
+ * Query Hooks
+ * 
+ * TanStack Query hooks for fetching Oxy services data.
+ * All hooks follow the same pattern with optional `enabled` parameter.
+ */
+
+// Account and user query hooks
+export {
+  useUserProfile,
+  useUserProfiles,
+  useCurrentUser,
+  useUserById,
+  useUserByUsername,
+  useUsersBySessions,
+  usePrivacySettings,
+} from './useAccountQueries';
+
+// Service query hooks (sessions, devices, security)
+export {
+  useSessions,
+  useSession,
+  useDeviceSessions,
+  useUserDevices,
+  useSecurityInfo,
+} from './useServicesQueries';
+
+// Query keys and invalidation helpers (for advanced usage)
+export { queryKeys, invalidateAccountQueries, invalidateUserQueries, invalidateSessionQueries } from './queryKeys';
 

package/src/ui/hooks/queries/queryKeys.ts

@@ -48,6 +48,12 @@ export const queryKeys = {
     details: () => [...queryKeys.devices.all, 'detail'] as const,
     detail: (deviceId: string) => [...queryKeys.devices.details(), deviceId] as const,
   },
+
+  // Privacy settings queries
+  privacy: {
+    all: ['privacy'] as const,
+    settings: (userId?: string) => [...queryKeys.privacy.all, 'settings', userId || 'current'] as const,
+  },
 } as const;
 
 /**

package/src/ui/hooks/queries/useAccountQueries.ts

@@ -124,3 +124,72 @@ export const useUsersBySessions = (sessionIds: string[], options?: { enabled?: b
   });
 };
 
+/**
+ * Get privacy settings for a user
+ */
+export const usePrivacySettings = (userId?: string, options?: { enabled?: boolean }) => {
+  const { oxyServices, activeSessionId, syncIdentity, user } = useOxy();
+  const targetUserId = userId || user?.id;
+
+  return useQuery({
+    queryKey: queryKeys.privacy.settings(userId),
+    queryFn: async () => {
+      if (!targetUserId) {
+        throw new Error('User ID is required');
+      }
+
+      // 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.getPrivacySettings(targetUserId);
+      } 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 request after getting token
+              return await oxyServices.getPrivacySettings(targetUserId);
+            } 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;
+      }
+    },
+    enabled: (options?.enabled !== false) && !!targetUserId,
+    staleTime: 2 * 60 * 1000, // 2 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+

package/src/ui/hooks/queries/useServicesQueries.ts

@@ -89,12 +89,59 @@ export const useDeviceSessions = (options?: { enabled?: boolean }) => {
  * Get user devices
  */
 export const useUserDevices = (options?: { enabled?: boolean }) => {
-  const { oxyServices, isAuthenticated } = useOxy();
+  const { oxyServices, isAuthenticated, activeSessionId, syncIdentity } = useOxy();
 
   return useQuery({
     queryKey: queryKeys.devices.list(),
     queryFn: async () => {
-      return await oxyServices.getUserDevices();
+      // 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.getUserDevices();
+      } 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 request after getting token
+              return await oxyServices.getUserDevices();
+            } 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;
+      }
     },
     enabled: (options?.enabled !== false) && isAuthenticated,
     staleTime: 5 * 60 * 1000,

package/src/ui/hooks/useAssets.ts

@@ -58,43 +58,23 @@ export const useAssets = () => {
       clearErrors();
       setUploading(true);
       
-      // Calculate SHA256 for progress tracking
-      const sha256 = await oxyInstance.calculateSHA256(file);
-      
-      // Initialize progress tracking
-      const initialProgress: AssetUploadProgress = {
-        fileId: '', // Will be set after init
-        uploaded: 0,
-        total: file.size,
-        percentage: 0,
-        status: 'uploading'
-      };
-      
-      // Upload with progress callback (visibility undefined, metadata, then onProgress)
-      const result = await oxyInstance.assetUpload(file as any, undefined, metadata, (percentage: number) => {
-        if (initialProgress.fileId) {
-          setUploadProgress(initialProgress.fileId, {
-            ...initialProgress,
-            uploaded: Math.round((percentage / 100) * file.size),
-            percentage,
-            status: percentage < 100 ? 'uploading' : 'processing'
-          });
-        }
-      });
+      // Upload file (progress tracking simplified for now)
+      const result = await oxyInstance.assetUpload(file as any, undefined, metadata);
 
       // Update progress with final status
-      if (result.file && initialProgress.fileId) {
-        setUploadProgress(initialProgress.fileId, {
-          ...initialProgress,
-          fileId: result.file.id,
+      if (result?.file) {
+        const fileId = result.file.id;
+        setUploadProgress(fileId, {
+          fileId,
           uploaded: file.size,
+          total: file.size,
           percentage: 100,
           status: 'complete'
         });
         
         // Remove progress after a short delay
         setTimeout(() => {
-          removeUploadProgress(result.file.id);
+          removeUploadProgress(fileId);
         }, 2000);
       }
 

package/src/ui/screens/FileManagementScreen.tsx

@@ -14,6 +14,7 @@ import {
     Alert,
 } from 'react-native';
 import { Image as ExpoImage } from 'expo-image';
+import * as DocumentPicker from 'expo-document-picker';
 import type { FileManagementScreenProps } from '../types/fileManagement';
 import { toast } from '../../lib/sonner';
 import { Ionicons } from '@expo/vector-icons';
@@ -28,13 +29,13 @@ import { useThemeStyles } from '../hooks/useThemeStyles';
 import { useColorScheme } from '../hooks/use-color-scheme';
 import { normalizeTheme } from '../utils/themeUtils';
 import { useOxy } from '../context/OxyContext';
+import { useUploadFile } from '../hooks/mutations/useAccountMutations';
 import {
     confirmAction,
     convertDocumentPickerAssetToFile,
     formatFileSize,
     getFileIcon,
     getSafeDownloadUrl,
-    uploadFileRaw
 } from '../utils/fileManagement';
 import { FileViewer } from '../components/fileManagement/FileViewer';
 import { FileDetailsModal } from '../components/fileManagement/FileDetailsModal';
@@ -115,6 +116,7 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
 }) => {
     // Use useOxy() hook for OxyContext values
     const { user, oxyServices } = useOxy();
+    const uploadFileMutation = useUploadFile();
     const files = useFiles();
     // Ensure containerWidth is a number (TypeScript guard)
     const safeContainerWidth: number = typeof containerWidth === 'number' ? containerWidth : 400;
@@ -528,7 +530,11 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                     };
                     useFileStore.getState().addFile(optimisticFile, { prepend: true });
 
-                    const result = await uploadFileRaw(raw, targetUserId, oxyServices, defaultVisibility);
+                    // Use the mutation hook with authentication handling
+                    const result = await uploadFileMutation.mutateAsync({
+                        file: raw,
+                        visibility: defaultVisibility,
+                    });
 
                     // Attempt to refresh file list incrementally – fetch single file metadata if API allows
                     if (result?.file || result?.files?.[0]) {
@@ -764,15 +770,8 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
         try {
             setIsPickingDocument(true);
             
-            // Dynamically import expo-document-picker (Expo 54 supports it on all platforms)
-            const DocumentPicker = await import('expo-document-picker').catch(() => null);
-
-            if (!DocumentPicker || !DocumentPicker.getDocumentAsync) {
-                toast.error('File picker not available. Please install expo-document-picker');
-                return;
-            }
-
-            // Use getDocumentAsync directly - it will handle platform availability
+            // Use expo-document-picker (works on all platforms including web)
+            // On web, it uses the native file input and provides File objects directly
             const result = await DocumentPicker.getDocumentAsync({
                 type: '*/*',
                 multiple: true,