@oxyhq/services 5.16.29 → 5.16.31

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

@@ -499,3 +499,39 @@ export const useUploadFile = () => {
   });
 };
 
+/**
+ * Unblock a user with query invalidation
+ */
+export const useUnblockUser = () => {
+  const { oxyServices } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (userId: string) => {
+      return await oxyServices.unblockUser(userId);
+    },
+    onSuccess: () => {
+      // Invalidate blocked users query to refetch the list
+      queryClient.invalidateQueries({ queryKey: queryKeys.privacy.blocked() });
+    },
+  });
+};
+
+/**
+ * Unrestrict a user with query invalidation
+ */
+export const useUnrestrictUser = () => {
+  const { oxyServices } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (userId: string) => {
+      return await oxyServices.unrestrictUser(userId);
+    },
+    onSuccess: () => {
+      // Invalidate restricted users query to refetch the list
+      queryClient.invalidateQueries({ queryKey: queryKeys.privacy.restricted() });
+    },
+  });
+};
+

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

@@ -14,6 +14,8 @@ export {
   useUserByUsername,
   useUsersBySessions,
   usePrivacySettings,
+  useBlockedUsers,
+  useRestrictedUsers,
 } from './useAccountQueries';
 
 // Service query hooks (sessions, devices, security)

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

@@ -53,6 +53,8 @@ export const queryKeys = {
   privacy: {
     all: ['privacy'] as const,
     settings: (userId?: string) => [...queryKeys.privacy.all, 'settings', userId || 'current'] as const,
+    blocked: () => [...queryKeys.privacy.all, 'blocked'] as const,
+    restricted: () => [...queryKeys.privacy.all, 'restricted'] as const,
   },
 
   // Security activity queries

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

@@ -195,3 +195,37 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
   });
 };
 
+/**
+ * Get blocked users
+ */
+export const useBlockedUsers = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.privacy.blocked(),
+    queryFn: async () => {
+      return await oxyServices.getBlockedUsers();
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    staleTime: 1 * 60 * 1000, // 1 minute
+    gcTime: 5 * 60 * 1000, // 5 minutes
+  });
+};
+
+/**
+ * Get restricted users
+ */
+export const useRestrictedUsers = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.privacy.restricted(),
+    queryFn: async () => {
+      return await oxyServices.getRestrictedUsers();
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    staleTime: 1 * 60 * 1000, // 1 minute
+    gcTime: 5 * 60 * 1000, // 5 minutes
+  });
+};
+

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

@@ -8,7 +8,7 @@ import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sess
  * Get all active sessions for the current user
  */
 export const useSessions = (userId?: string, options?: { enabled?: boolean }) => {
-  const { oxyServices, activeSessionId } = useOxy();
+  const { oxyServices, activeSessionId, user } = useOxy();
 
   return useQuery({
     queryKey: queryKeys.sessions.list(userId),
@@ -17,12 +17,14 @@ export const useSessions = (userId?: string, options?: { enabled?: boolean }) =>
         throw new Error('No active session');
       }
       
+      const publicKey = user?.publicKey || user?.id || ''; // user.id is now publicKey
       const sessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
         fallbackDeviceId: undefined,
         fallbackUserId: userId,
+        fallbackPublicKey: publicKey,
       });
       
-      return mapSessionsToClient(sessions, activeSessionId);
+      return sessions; // Already mapped by fetchSessionsWithFallback
     },
     enabled: (options?.enabled !== false) && !!activeSessionId,
     staleTime: 2 * 60 * 1000, // 2 minutes (sessions change frequently)
@@ -49,12 +51,15 @@ export const useSession = (sessionId: string | null, options?: { enabled?: boole
       }
 
       const now = new Date();
+      // user.id is now publicKey (canonical identity)
+      const publicKey = validation.user.publicKey || validation.user.id || '';
       return {
         sessionId,
         deviceId: '', // Device ID not available from validation response
         expiresAt: validation.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
         lastActive: validation.lastActivity || now.toISOString(),
-        userId: validation.user.id?.toString() ?? '',
+        publicKey, // Canonical user identity
+        userId: validation.user.id?.toString(), // Optional MongoDB ObjectId
         isCurrent: false,
       } as ClientSession;
     },

package/src/ui/hooks/useSessionManagement.ts

@@ -255,8 +255,10 @@ export const useSessionManagement = ({
         await activateSession(sessionId, user);
 
         try {
+          const publicKey = user.publicKey || user.id || ''; // user.id is now publicKey
           const deviceSessions = await fetchSessionsWithFallback(oxyServices, sessionId, {
-            fallbackUserId: user.id,
+            fallbackUserId: user.id, // Still pass for backward compatibility
+            fallbackPublicKey: publicKey,
             logger,
           });
           updateSessions(deviceSessions, { merge: true });
@@ -330,8 +332,13 @@ export const useSessionManagement = ({
 
       const refreshPromise = (async () => {
         try {
+          // Get publicKey from active session or current user
+          const activeSession = sessions.find(s => s.sessionId === activeSessionId);
+          const publicKey = activeSession?.publicKey || activeUserId || ''; // Fallback to userId if publicKey not available
+          
           const deviceSessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
             fallbackUserId: activeUserId,
+            fallbackPublicKey: publicKey,
             logger,
           });
           updateSessions(deviceSessions, { merge: true });

package/src/ui/screens/PrivacySettingsScreen.tsx

@@ -1,10 +1,9 @@
-import React, { useState, useCallback, useEffect, useMemo } from 'react';
+import React, { useState, useCallback, useMemo } from 'react';
 import {
     View,
     Text,
     StyleSheet,
     ScrollView,
-    ActivityIndicator,
     TouchableOpacity,
 } from 'react-native';
 import type { BaseScreenProps } from '../types/navigation';
@@ -15,6 +14,8 @@ import { useThemeStyles } from '../hooks/useThemeStyles';
 import { normalizeTheme } from '../utils/themeUtils';
 import type { BlockedUser, RestrictedUser } from '../../models/interfaces';
 import { useOxy } from '../context/OxyContext';
+import { usePrivacySettings, useBlockedUsers, useRestrictedUsers } from '../hooks/queries';
+import { useUpdatePrivacySettings, useUnblockUser, useUnrestrictUser } from '../hooks/mutations';
 
 interface PrivacySettings {
     isPrivateAccount: boolean;
@@ -44,8 +45,20 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
     goBack,
 }) => {
     // Use useOxy() hook for OxyContext values
-    const { oxyServices, user } = useOxy();
+    const { oxyServices } = useOxy();
     const { t } = useI18n();
+    
+    // TanStack Query hooks for server state
+    const { data: privacySettingsData, isLoading: isLoadingSettings, error: settingsError } = usePrivacySettings();
+    const { data: blockedUsers = [], isLoading: isLoadingBlocked } = useBlockedUsers();
+    const { data: restrictedUsers = [], isLoading: isLoadingRestricted } = useRestrictedUsers();
+    
+    // Mutations
+    const updatePrivacySettingsMutation = useUpdatePrivacySettings();
+    const unblockUserMutation = useUnblockUser();
+    const unrestrictUserMutation = useUnrestrictUser();
+    
+    // Client state for optimistic UI updates
     const [settings, setSettings] = useState<PrivacySettings>({
         isPrivateAccount: false,
         hideOnlineStatus: false,
@@ -67,111 +80,64 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
         autoFilter: true,
         muteKeywords: false,
     });
-    const [isLoading, setIsLoading] = useState(true);
-    const [isSaving, setIsSaving] = useState(false);
-    const [blockedUsers, setBlockedUsers] = useState<BlockedUser[]>([]);
-    const [restrictedUsers, setRestrictedUsers] = useState<RestrictedUser[]>([]);
-    const [isLoadingUsers, setIsLoadingUsers] = useState(false);
-
-    // Load settings and users
-    useEffect(() => {
-        const loadSettings = async () => {
-            try {
-                setIsLoading(true);
-                // Use getCurrentUserId() which returns MongoDB ObjectId from JWT token
-                // Never use user?.id as it may be set to publicKey
-                const userId = oxyServices?.getCurrentUserId();
-                if (userId && oxyServices) {
-                    const privacySettings = await oxyServices.getPrivacySettings(userId);
-                    if (privacySettings) {
-                        setSettings(privacySettings);
-                    }
-                }
-            } catch (error) {
-                console.error('Failed to load privacy settings:', error);
-                toast.error(t('privacySettings.loadError') || 'Failed to load privacy settings');
-            } finally {
-                setIsLoading(false);
-            }
-        };
-
-        loadSettings();
-    }, [oxyServices, t]);
-
-    // Load blocked and restricted users
-    useEffect(() => {
-        const loadUsers = async () => {
-            if (!oxyServices) return;
-            try {
-                setIsLoadingUsers(true);
-                const [blocked, restricted] = await Promise.all([
-                    oxyServices.getBlockedUsers(),
-                    oxyServices.getRestrictedUsers(),
-                ]);
-                setBlockedUsers(blocked);
-                setRestrictedUsers(restricted);
-            } catch (error) {
-                console.error('Failed to load blocked/restricted users:', error);
-            } finally {
-                setIsLoadingUsers(false);
-            }
-        };
-
-        loadUsers();
-    }, [oxyServices]);
+    
+    // Update local state when server data changes
+    React.useEffect(() => {
+        if (privacySettingsData) {
+            setSettings(privacySettingsData as PrivacySettings);
+        }
+    }, [privacySettingsData]);
+    
+    // Show error toast if settings failed to load
+    React.useEffect(() => {
+        if (settingsError) {
+            toast.error(t('privacySettings.loadError') || 'Failed to load privacy settings');
+        }
+    }, [settingsError, t]);
+    
+    const isLoading = isLoadingSettings;
+    const isSaving = updatePrivacySettingsMutation.isPending;
+    const isLoadingUsers = isLoadingBlocked || isLoadingRestricted;
 
     const updateSetting = useCallback(async (key: keyof PrivacySettings, value: boolean) => {
-        try {
-            setIsSaving(true);
-            const newSettings = { ...settings, [key]: value };
-            setSettings(newSettings);
-            
-            // Use getCurrentUserId() which returns MongoDB ObjectId from JWT token
-            // Never use user?.id as it may be set to publicKey
-            const userId = oxyServices?.getCurrentUserId();
-            if (userId && oxyServices) {
-                await oxyServices.updatePrivacySettings({ [key]: value }, userId);
-                toast.success(t('privacySettings.updated') || 'Privacy settings updated');
+        // Optimistic update
+        const newSettings = { ...settings, [key]: value };
+        setSettings(newSettings);
+        
+        // Use mutation hook
+        updatePrivacySettingsMutation.mutate(
+            { settings: { [key]: value } },
+            {
+                onError: () => {
+                    // Revert on error
+                    setSettings(settings);
+                    toast.error(t('privacySettings.updateError') || 'Failed to update privacy setting');
+                },
             }
-        } catch (error) {
-            console.error(`Failed to update ${key}:`, error);
-            toast.error(t('privacySettings.updateError') || 'Failed to update privacy setting');
-            // Revert on error
-            setSettings(settings);
-        } finally {
-            setIsSaving(false);
-        }
-    }, [settings, oxyServices, t]);
+        );
+    }, [settings, updatePrivacySettingsMutation, t]);
 
     const handleUnblock = useCallback(async (userId: string) => {
-        if (!oxyServices) return;
-        try {
-            await oxyServices.unblockUser(userId);
-            setBlockedUsers(prev => prev.filter(u => {
-                const id = typeof u.blockedId === 'string' ? u.blockedId : u.blockedId._id;
-                return id !== userId;
-            }));
-            toast.success(t('privacySettings.userUnblocked') || 'User unblocked');
-        } catch (error) {
-            console.error('Failed to unblock user:', error);
-            toast.error(t('privacySettings.unblockError') || 'Failed to unblock user');
-        }
-    }, [oxyServices, t]);
+        unblockUserMutation.mutate(userId, {
+            onSuccess: () => {
+                toast.success(t('privacySettings.userUnblocked') || 'User unblocked');
+            },
+            onError: () => {
+                toast.error(t('privacySettings.unblockError') || 'Failed to unblock user');
+            },
+        });
+    }, [unblockUserMutation, t]);
 
     const handleUnrestrict = useCallback(async (userId: string) => {
-        if (!oxyServices) return;
-        try {
-            await oxyServices.unrestrictUser(userId);
-            setRestrictedUsers(prev => prev.filter(u => {
-                const id = typeof u.restrictedId === 'string' ? u.restrictedId : u.restrictedId._id;
-                return id !== userId;
-            }));
-            toast.success(t('privacySettings.userUnrestricted') || 'User unrestricted');
-        } catch (error) {
-            console.error('Failed to unrestrict user:', error);
-            toast.error(t('privacySettings.unrestrictError') || 'Failed to unrestrict user');
-        }
-    }, [oxyServices, t]);
+        unrestrictUserMutation.mutate(userId, {
+            onSuccess: () => {
+                toast.success(t('privacySettings.userUnrestricted') || 'User unrestricted');
+            },
+            onError: () => {
+                toast.error(t('privacySettings.unrestrictError') || 'Failed to unrestrict user');
+            },
+        });
+    }, [unrestrictUserMutation, t]);
 
     // Helper to extract user info from blocked/restricted objects
     const extractUserInfo = useCallback((

package/src/ui/utils/sessionHelpers.ts

@@ -7,14 +7,16 @@ interface DeviceSession {
   deviceName?: string;
   expiresAt?: string;
   lastActive?: string;
-  user?: { id?: string; _id?: { toString(): string } };
+  user?: { id?: string; publicKey?: string; _id?: { toString(): string } };
   userId?: string;
+  publicKey?: string;
   isCurrent?: boolean;
 }
 
 export interface FetchSessionsWithFallbackOptions {
   fallbackDeviceId?: string;
   fallbackUserId?: string;
+  fallbackPublicKey?: string; // Canonical user identity
   logger?: (message: string, error?: unknown) => void;
 }
 
@@ -37,27 +39,41 @@ export interface SessionValidationResult {
  * @param sessions - Raw session array returned from the API
  * @param fallbackDeviceId - Device identifier to use when missing from payload
  * @param fallbackUserId - User identifier to use when missing from payload
+ * @param fallbackPublicKey - Public key to use when missing from payload (canonical identity)
  */
 export const mapSessionsToClient = (
   sessions: DeviceSession[],
   fallbackDeviceId?: string,
   fallbackUserId?: string,
+  fallbackPublicKey?: string,
 ): ClientSession[] => {
   const now = new Date();
 
-  return sessions.map((session) => ({
-    sessionId: session.sessionId,
-    deviceId: session.deviceId || fallbackDeviceId || '',
-    expiresAt: session.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
-    lastActive: session.lastActive || now.toISOString(),
-    userId:
-      session.user?.id ||
+  return sessions.map((session) => {
+    // publicKey is the canonical user identity (user.id now equals publicKey)
+    // Extract from user.id (which is now publicKey), user.publicKey, or session.publicKey
+    const publicKey =
+      session.user?.id || // user.id is now publicKey (canonical identifier)
+      session.user?.publicKey ||
+      session.publicKey ||
+      fallbackPublicKey ||
+      '';
+
+    // userId is MongoDB ObjectId (internal backend reference, optional)
+    const userId =
       session.userId ||
-      (session.user?._id ? session.user._id.toString() : undefined) ||
-      fallbackUserId ||
-      '',
-    isCurrent: Boolean(session.isCurrent),
-  }));
+      (session.user?._id ? session.user._id.toString() : undefined);
+
+    return {
+      sessionId: session.sessionId,
+      deviceId: session.deviceId || fallbackDeviceId || '',
+      expiresAt: session.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+      lastActive: session.lastActive || now.toISOString(),
+      publicKey, // Canonical user identity - REQUIRED
+      userId, // MongoDB ObjectId (optional, for backward compatibility)
+      isCurrent: Boolean(session.isCurrent),
+    };
+  });
 };
 
 /**
@@ -73,19 +89,20 @@ export const fetchSessionsWithFallback = async (
   {
     fallbackDeviceId,
     fallbackUserId,
+    fallbackPublicKey,
     logger,
   }: FetchSessionsWithFallbackOptions = {},
 ): Promise<ClientSession[]> => {
   try {
     const deviceSessions = await oxyServices.getDeviceSessions(sessionId);
-    return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId);
+    return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId, fallbackPublicKey);
   } catch (error) {
     if (__DEV__ && logger) {
       logger('Failed to get device sessions, falling back to user sessions', error);
     }
 
     const userSessions = await oxyServices.getSessionsBySessionId(sessionId);
-    return mapSessionsToClient(userSessions, fallbackDeviceId, fallbackUserId);
+    return mapSessionsToClient(userSessions, fallbackDeviceId, fallbackUserId, fallbackPublicKey);
   }
 };
 

package/src/utils/sessionUtils.ts

@@ -12,12 +12,19 @@ import type { ClientSession } from '../models/session';
  */
 export function normalizeSession(session: Partial<ClientSession> & { sessionId: string }): ClientSession {
   const now = new Date().toISOString();
+  
+  // publicKey is required (canonical user identity)
+  if (!session.publicKey) {
+    throw new Error(`Session ${session.sessionId} is missing required publicKey field`);
+  }
+  
   return {
     sessionId: session.sessionId,
     deviceId: session.deviceId || '',
     expiresAt: session.expiresAt || now,
     lastActive: session.lastActive || now,
-    userId: session.userId || '',
+    publicKey: session.publicKey, // Canonical user identity - required
+    userId: session.userId, // Optional MongoDB ObjectId for backward compatibility
   };
 }