@oxyhq/services 5.16.43 → 5.17.0

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

@@ -0,0 +1,108 @@
+import { useCallback } from 'react';
+import type { ApiError } from '../../../models/interfaces';
+import { DeviceManager } from '../../../utils/deviceManager';
+import type { OxyServices } from '../../../core';
+import { handleAuthError } from '../../utils/errorHandlers';
+
+export interface UseDeviceManagementOptions {
+  oxyServices: OxyServices;
+  activeSessionId: string | null;
+  onError?: (error: ApiError) => void;
+  clearSessionState: () => Promise<void>;
+  logger?: (message: string, error?: unknown) => void;
+}
+
+export interface UseDeviceManagementResult {
+  getDeviceSessions: () => Promise<
+    Array<{
+      sessionId: string;
+      deviceId: string;
+      deviceName?: string;
+      lastActive?: string;
+      expiresAt?: string;
+    }>
+  >;
+  logoutAllDeviceSessions: () => Promise<void>;
+  updateDeviceName: (deviceName: string) => Promise<void>;
+}
+
+/**
+ * Provide device session management helpers tied to the current active session.
+ *
+ * @param options - Device management configuration
+ */
+export const useDeviceManagement = ({
+  oxyServices,
+  activeSessionId,
+  onError,
+  clearSessionState,
+  logger,
+}: UseDeviceManagementOptions): UseDeviceManagementResult => {
+  const getDeviceSessions = useCallback(async (): Promise<
+    Array<{
+      sessionId: string;
+      deviceId: string;
+      deviceName?: string;
+      lastActive?: string;
+      expiresAt?: string;
+    }>
+  > => {
+    if (!activeSessionId) throw new Error('No active session');
+    try {
+      return await oxyServices.getDeviceSessions(activeSessionId);
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: 'Failed to get device sessions',
+        code: 'GET_DEVICE_SESSIONS_ERROR',
+        onError,
+        logger,
+      });
+      throw error instanceof Error ? error : new Error('Failed to get device sessions');
+    }
+  }, [activeSessionId, logger, onError, oxyServices]);
+
+  const logoutAllDeviceSessions = useCallback(async (): Promise<void> => {
+    if (!activeSessionId) throw new Error('No active session');
+
+    try {
+      await oxyServices.logoutAllDeviceSessions(activeSessionId);
+      await clearSessionState();
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: 'Failed to logout all device sessions',
+        code: 'LOGOUT_ALL_DEVICES_ERROR',
+        onError,
+        logger,
+      });
+      throw error instanceof Error ? error : new Error('Failed to logout all device sessions');
+    }
+  }, [activeSessionId, clearSessionState, logger, onError, oxyServices]);
+
+  const updateDeviceName = useCallback(
+    async (deviceName: string): Promise<void> => {
+      if (!activeSessionId) throw new Error('No active session');
+
+      try {
+        await oxyServices.updateDeviceName(activeSessionId, deviceName);
+        await DeviceManager.updateDeviceName(deviceName);
+      } catch (error) {
+        handleAuthError(error, {
+          defaultMessage: 'Failed to update device name',
+          code: 'UPDATE_DEVICE_NAME_ERROR',
+          onError,
+          logger,
+        });
+        throw error instanceof Error ? error : new Error('Failed to update device name');
+      }
+    },
+    [activeSessionId, logger, onError, oxyServices],
+  );
+
+  return {
+    getDeviceSessions,
+    logoutAllDeviceSessions,
+    updateDeviceName,
+  };
+};
+
+

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

@@ -0,0 +1,104 @@
+import { useCallback, 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
+ */
+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]);
+
+  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;
+      }
+      return callback(resolvedStorage);
+    },
+    [refresh, storage],
+  );
+
+  return {
+    storage,
+    isReady: Boolean(storage) && !error,
+    error,
+    refresh,
+    withStorage,
+  };
+};
+
+

package/src/ui/hooks/index.ts

@@ -1,5 +1,4 @@
 export { useFollow, useFollowerCounts } from './useFollow';
 export { useFileDownloadUrl, setOxyFileUrlInstance } from './useFileDownloadUrl';
 export { useThemeStyles } from './useThemeStyles';
-export { useThemeColors } from './useThemeColors';
-export * from './auth';
+export { useThemeColors } from './useThemeColors';

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

@@ -12,8 +12,6 @@ export {
   useUpdateAccountSettings,
   useUpdatePrivacySettings,
   useUploadFile,
-  useUnblockUser,
-  useUnrestrictUser,
 } from './useAccountMutations';
 
 // Service mutation hooks (sessions, devices)

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

@@ -1,16 +1,19 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import type { User } from '../../../models/interfaces';
+import type { ClientSession } from '../../../models/session';
 import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
 import { useOxy } from '../../context/OxyContext';
 import { toast } from '../../../lib/sonner';
 import { refreshAvatarInStore } from '../../utils/avatarUtils';
-import { useAuthStore } from '../../stores/authStore';
+
+const getDeviceIdForSession = (sessions: ClientSession[] = [], sessionId: string | null) =>
+  sessionId ? sessions.find((s) => s.sessionId === sessionId)?.deviceId : undefined;
 
 /**
  * Update user profile with optimistic updates and offline queue support
  */
 export const useUpdateProfile = () => {
-  const { oxyServices, activeSessionId, user, syncIdentity } = useOxy();
+  const { oxyServices, activeSessionId, user, syncIdentity, sessions } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -19,7 +22,7 @@ export const useUpdateProfile = () => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
+          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
         } catch (tokenError) {
           // If getting token fails, might be an offline session - try syncing
           const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
@@ -27,7 +30,7 @@ export const useUpdateProfile = () => {
             try {
               await syncIdentity();
               // Retry getting token after sync
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
             } catch (syncError) {
               throw new Error('Session needs to be synced. Please try again.');
             }
@@ -49,7 +52,7 @@ export const useUpdateProfile = () => {
           if (activeSessionId) {
             try {
               await syncIdentity();
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
               // Retry the update after getting token
               return await oxyServices.updateProfile(updates);
             } catch (retryError) {
@@ -108,9 +111,6 @@ export const useUpdateProfile = () => {
         queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
       }
       
-      // Update authStore so frontend components see the changes immediately
-      useAuthStore.getState().setUser(data);
-      
       // If avatar was updated, refresh accountStore with cache-busted URL
       if (updates.avatar && activeSessionId && oxyServices) {
         refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);
@@ -127,7 +127,7 @@ export const useUpdateProfile = () => {
  * Upload avatar with progress tracking and offline queue support
  */
 export const useUploadAvatar = () => {
-  const { oxyServices, activeSessionId, syncIdentity } = useOxy();
+  const { oxyServices, activeSessionId, syncIdentity, sessions } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -135,13 +135,13 @@ export const useUploadAvatar = () => {
       // Ensure we have a valid token before making the request
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
-          await oxyServices.getTokenBySession(activeSessionId);
+          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, 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);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
             } catch (syncError) {
               throw new Error('Session needs to be synced. Please try again.');
             }
@@ -171,7 +171,7 @@ export const useUploadAvatar = () => {
           if (activeSessionId) {
             try {
               await syncIdentity();
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
               // Retry upload
               const uploadResult = await oxyServices.assetUpload(file as any, 'public');
               const fileId = uploadResult?.file?.id || uploadResult?.id || uploadResult;
@@ -224,9 +224,6 @@ export const useUploadAvatar = () => {
         queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
       }
       
-      // Update authStore so frontend components see the changes immediately
-      useAuthStore.getState().setUser(data);
-      
       // Refresh accountStore with cache-busted URL if avatar was updated
       if (data?.avatar && activeSessionId && oxyServices) {
         refreshAvatarInStore(activeSessionId, data.avatar, oxyServices);
@@ -276,9 +273,6 @@ export const useUpdateAccountSettings = () => {
     onSuccess: (data) => {
       queryClient.setQueryData(queryKeys.accounts.current(), data);
       
-      // Update authStore so frontend components see the changes immediately
-      useAuthStore.getState().setUser(data);
-      
       invalidateAccountQueries(queryClient);
       toast.success('Settings updated successfully');
     },
@@ -292,7 +286,7 @@ export const useUpdateAccountSettings = () => {
  * Update privacy settings with optimistic updates and authentication handling
  */
 export const useUpdatePrivacySettings = () => {
-  const { oxyServices, activeSessionId, syncIdentity } = useOxy();
+  const { oxyServices, activeSessionId, syncIdentity, sessions } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -308,7 +302,7 @@ export const useUpdatePrivacySettings = () => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
+          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
         } catch (tokenError) {
           // If getting token fails, might be an offline session - try syncing
           const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
@@ -316,7 +310,7 @@ export const useUpdatePrivacySettings = () => {
             try {
               await syncIdentity();
               // Retry getting token after sync
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
             } catch (syncError) {
               throw new Error('Session needs to be synced. Please try again.');
             }
@@ -338,7 +332,7 @@ export const useUpdatePrivacySettings = () => {
           if (activeSessionId) {
             try {
               await syncIdentity();
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
               // Retry the update after getting token
               return await oxyServices.updatePrivacySettings(settings, targetUserId);
             } catch (retryError) {
@@ -412,9 +406,6 @@ export const useUpdatePrivacySettings = () => {
           privacySettings: data,
         };
         queryClient.setQueryData<User>(queryKeys.accounts.current(), updatedUser);
-        
-        // Update authStore so frontend components see the changes immediately
-        useAuthStore.getState().setUser(updatedUser);
       }
       invalidateAccountQueries(queryClient);
     },
@@ -433,7 +424,7 @@ export const useUpdatePrivacySettings = () => {
  * Upload file with authentication handling and progress tracking
  */
 export const useUploadFile = () => {
-  const { oxyServices, activeSessionId, syncIdentity } = useOxy();
+  const { oxyServices, activeSessionId, syncIdentity, sessions } = useOxy();
 
   return useMutation({
     mutationFn: async ({ 
@@ -451,7 +442,7 @@ export const useUploadFile = () => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
+          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
         } catch (tokenError) {
           // If getting token fails, might be an offline session - try syncing
           const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
@@ -459,7 +450,7 @@ export const useUploadFile = () => {
             try {
               await syncIdentity();
               // Retry getting token after sync
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
             } catch (syncError) {
               throw new Error('Session needs to be synced. Please try again.');
             }
@@ -481,7 +472,7 @@ export const useUploadFile = () => {
           if (activeSessionId) {
             try {
               await syncIdentity();
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
               // Retry the upload after getting token
               return await oxyServices.assetUpload(file as any, visibility, metadata, onProgress);
             } catch (retryError) {
@@ -498,40 +489,3 @@ 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,8 +14,6 @@ export {
   useUserByUsername,
   useUsersBySessions,
   usePrivacySettings,
-  useBlockedUsers,
-  useRestrictedUsers,
 } from './useAccountQueries';
 
 // Service query hooks (sessions, devices, security)

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

@@ -53,8 +53,6 @@ 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

@@ -19,8 +19,8 @@ export const useUserProfile = (sessionId: string | null, options?: { enabled?: b
       return await oxyServices.getUserBySession(sessionId);
     },
     enabled: (options?.enabled !== false) && !!sessionId,
-    staleTime: 5 * 60 * 1000, // 5 minutes
-    gcTime: 30 * 60 * 1000, // 30 minutes
+    staleTime: 0, // Always fetch fresh - Services never caches profile
+    gcTime: 0, // No garbage collection time - always fetch fresh
   });
 };
 
@@ -38,8 +38,8 @@ export const useUserProfiles = (sessionIds: string[], options?: { enabled?: bool
         return results[0]?.user || null;
       },
       enabled: (options?.enabled !== false) && !!sessionId,
-      staleTime: 5 * 60 * 1000,
-      gcTime: 30 * 60 * 1000,
+      staleTime: 0, // Always fetch fresh - Services never caches profile
+      gcTime: 0, // No garbage collection time - always fetch fresh
     })),
   });
 };
@@ -59,8 +59,8 @@ export const useCurrentUser = (options?: { enabled?: boolean }) => {
       return await oxyServices.getUserBySession(activeSessionId);
     },
     enabled: (options?.enabled !== false) && isAuthenticated && !!activeSessionId,
-    staleTime: 1 * 60 * 1000, // 1 minute for current user
-    gcTime: 30 * 60 * 1000,
+    staleTime: 0, // Always fetch fresh - Services never caches profile
+    gcTime: 0, // No garbage collection time - always fetch fresh
   });
 };
 
@@ -79,8 +79,8 @@ export const useUserById = (userId: string | null, options?: { enabled?: boolean
       return await oxyServices.getUserById(userId);
     },
     enabled: (options?.enabled !== false) && !!userId,
-    staleTime: 5 * 60 * 1000,
-    gcTime: 30 * 60 * 1000,
+    staleTime: 0, // Always fetch fresh - Services never caches profile
+    gcTime: 0, // No garbage collection time - always fetch fresh
   });
 };
 
@@ -99,8 +99,8 @@ export const useUserByUsername = (username: string | null, options?: { enabled?:
       return await oxyServices.getProfileByUsername(username);
     },
     enabled: (options?.enabled !== false) && !!username,
-    staleTime: 5 * 60 * 1000,
-    gcTime: 30 * 60 * 1000,
+    staleTime: 0, // Always fetch fresh - Services never caches profile
+    gcTime: 0, // No garbage collection time - always fetch fresh
   });
 };
 
@@ -119,8 +119,8 @@ export const useUsersBySessions = (sessionIds: string[], options?: { enabled?: b
       return await oxyServices.getUsersBySessions(sessionIds);
     },
     enabled: (options?.enabled !== false) && sessionIds.length > 0,
-    staleTime: 5 * 60 * 1000,
-    gcTime: 30 * 60 * 1000,
+    staleTime: 0, // Always fetch fresh - Services never caches profile
+    gcTime: 0, // No garbage collection time - always fetch fresh
   });
 };
 
@@ -128,10 +128,11 @@ 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 } = useOxy();
+  const { oxyServices, activeSessionId, syncIdentity, sessions } = useOxy();
   // Use getCurrentUserId() which returns MongoDB ObjectId from JWT token
   // Never use user?.id as it may be set to publicKey
   const targetUserId = userId || oxyServices.getCurrentUserId() || undefined;
+  const deviceId = activeSessionId ? sessions.find((s) => s.sessionId === activeSessionId)?.deviceId : undefined;
 
   return useQuery({
     queryKey: queryKeys.privacy.settings(targetUserId),
@@ -144,7 +145,7 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
+          await oxyServices.getTokenBySession(activeSessionId, deviceId);
         } catch (tokenError) {
           // If getting token fails, might be an offline session - try syncing
           const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
@@ -152,7 +153,7 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
             try {
               await syncIdentity();
               // Retry getting token after sync
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, deviceId);
             } catch (syncError) {
               throw new Error('Session needs to be synced. Please try again.');
             }
@@ -174,7 +175,7 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
           if (activeSessionId) {
             try {
               await syncIdentity();
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, deviceId);
               // Retry the request after getting token
               return await oxyServices.getPrivacySettings(targetUserId);
             } catch (retryError) {
@@ -190,42 +191,7 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
       }
     },
     enabled: (options?.enabled !== false) && !!targetUserId,
-    staleTime: 2 * 60 * 1000, // 2 minutes
-    gcTime: 10 * 60 * 1000, // 10 minutes
+    staleTime: 0, // Always fetch fresh - Services never caches profile
+    gcTime: 0, // No garbage collection time - always fetch fresh
   });
 };
-
-/**
- * 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

@@ -89,7 +89,8 @@ export const useDeviceSessions = (options?: { enabled?: boolean }) => {
  * Get user devices
  */
 export const useUserDevices = (options?: { enabled?: boolean }) => {
-  const { oxyServices, isAuthenticated, activeSessionId, syncIdentity } = useOxy();
+  const { oxyServices, isAuthenticated, activeSessionId, syncIdentity, sessions } = useOxy();
+  const deviceId = activeSessionId ? sessions.find((s) => s.sessionId === activeSessionId)?.deviceId : undefined;
 
   return useQuery({
     queryKey: queryKeys.devices.list(),
@@ -98,7 +99,7 @@ export const useUserDevices = (options?: { enabled?: boolean }) => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
+          await oxyServices.getTokenBySession(activeSessionId, deviceId);
         } catch (tokenError) {
           // If getting token fails, might be an offline session - try syncing
           const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
@@ -106,7 +107,7 @@ export const useUserDevices = (options?: { enabled?: boolean }) => {
             try {
               await syncIdentity();
               // Retry getting token after sync
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, deviceId);
             } catch (syncError) {
               throw new Error('Session needs to be synced. Please try again.');
             }
@@ -128,7 +129,7 @@ export const useUserDevices = (options?: { enabled?: boolean }) => {
           if (activeSessionId) {
             try {
               await syncIdentity();
-              await oxyServices.getTokenBySession(activeSessionId);
+              await oxyServices.getTokenBySession(activeSessionId, deviceId);
               // Retry the request after getting token
               return await oxyServices.getUserDevices();
             } catch (retryError) {
@@ -165,4 +166,3 @@ export const useSecurityInfo = (options?: { enabled?: boolean }) => {
     gcTime: 30 * 60 * 1000,
   });
 };
-