@oxyhq/services 5.16.1 → 5.16.2

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() });
+    },
+  });
+};
+

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

@@ -0,0 +1,164 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type { User } from '../../../models/interfaces';
+import { queryKeys, invalidateSessionQueries } from '../queries/queryKeys';
+import { useOxy } from '../../context/OxyContext';
+import { toast } from '../../../lib/sonner';
+
+/**
+ * Switch active session
+ */
+export const useSwitchSession = () => {
+  const { switchSession, activeSessionId } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (sessionId: string) => {
+      return await switchSession(sessionId);
+    },
+    onSuccess: (user) => {
+      // Invalidate all session queries
+      invalidateSessionQueries(queryClient);
+      
+      // Update current user query
+      queryClient.setQueryData(queryKeys.accounts.current(), user);
+      
+      // Invalidate account queries
+      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.all });
+    },
+    onError: (error) => {
+      toast.error(error instanceof Error ? error.message : 'Failed to switch session');
+    },
+  });
+};
+
+/**
+ * Logout from a session
+ */
+export const useLogoutSession = () => {
+  const { oxyServices, activeSessionId, sessions } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (targetSessionId?: string) => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+      
+      const sessionToLogout = targetSessionId || activeSessionId;
+      await oxyServices.logoutSession(activeSessionId, sessionToLogout);
+      
+      return sessionToLogout;
+    },
+    onMutate: async (targetSessionId) => {
+      // Cancel outgoing queries
+      await queryClient.cancelQueries({ queryKey: queryKeys.sessions.all });
+      
+      // Snapshot previous sessions
+      const previousSessions = queryClient.getQueryData(queryKeys.sessions.list());
+      
+      // Optimistically remove session
+      if (previousSessions) {
+        const sessionToLogout = targetSessionId || activeSessionId;
+        const updatedSessions = (previousSessions as any[]).filter(
+          (s: any) => s.sessionId !== sessionToLogout
+        );
+        queryClient.setQueryData(queryKeys.sessions.list(), updatedSessions);
+      }
+      
+      return { previousSessions };
+    },
+    onError: (error, targetSessionId, context) => {
+      // Rollback on error
+      if (context?.previousSessions) {
+        queryClient.setQueryData(queryKeys.sessions.list(), context.previousSessions);
+      }
+      toast.error(error instanceof Error ? error.message : 'Failed to logout');
+    },
+    onSuccess: () => {
+      // Invalidate all session queries
+      invalidateSessionQueries(queryClient);
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+    },
+  });
+};
+
+/**
+ * Logout from all sessions
+ */
+export const useLogoutAll = () => {
+  const { oxyServices, activeSessionId, clearSessionState } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async () => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+      
+      await oxyServices.logoutAllSessions(activeSessionId);
+      await clearSessionState();
+    },
+    onSuccess: () => {
+      // Clear all queries
+      queryClient.clear();
+      toast.success('Logged out from all sessions');
+    },
+    onError: (error) => {
+      toast.error(error instanceof Error ? error.message : 'Failed to logout from all sessions');
+    },
+  });
+};
+
+/**
+ * Update device name
+ */
+export const useUpdateDeviceName = () => {
+  const { oxyServices, activeSessionId } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (deviceName: string) => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+      
+      return await oxyServices.updateDeviceName(activeSessionId, deviceName);
+    },
+    onSuccess: () => {
+      // Invalidate device and session queries
+      queryClient.invalidateQueries({ queryKey: queryKeys.devices.all });
+      queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+      toast.success('Device name updated');
+    },
+    onError: (error) => {
+      toast.error(error instanceof Error ? error.message : 'Failed to update device name');
+    },
+  });
+};
+
+/**
+ * Remove a device
+ */
+export const useRemoveDevice = () => {
+  const { oxyServices } = useOxy();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (deviceId: string) => {
+      await oxyServices.removeDevice(deviceId);
+      return deviceId;
+    },
+    onSuccess: () => {
+      // Invalidate device queries
+      queryClient.invalidateQueries({ queryKey: queryKeys.devices.all });
+      queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+      toast.success('Device removed');
+    },
+    onError: (error) => {
+      toast.error(error instanceof Error ? error.message : 'Failed to remove device');
+    },
+  });
+};
+

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

@@ -0,0 +1,5 @@
+// Export all query hooks
+export * from './useAccountQueries';
+export * from './useServicesQueries';
+export * from './queryKeys';
+

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

@@ -0,0 +1,73 @@
+/**
+ * Centralized query keys for TanStack Query
+ * 
+ * Following best practices:
+ * - Use arrays for hierarchical keys
+ * - Include all parameters in the key
+ * - Use consistent naming conventions
+ */
+
+export const queryKeys = {
+  // Account queries
+  accounts: {
+    all: ['accounts'] as const,
+    lists: () => [...queryKeys.accounts.all, 'list'] as const,
+    list: (sessionIds: string[]) => [...queryKeys.accounts.lists(), sessionIds] as const,
+    details: () => [...queryKeys.accounts.all, 'detail'] as const,
+    detail: (sessionId: string) => [...queryKeys.accounts.details(), sessionId] as const,
+    current: () => [...queryKeys.accounts.all, 'current'] as const,
+    settings: () => [...queryKeys.accounts.all, 'settings'] as const,
+  },
+
+  // User queries
+  users: {
+    all: ['users'] as const,
+    lists: () => [...queryKeys.users.all, 'list'] as const,
+    list: (userIds: string[]) => [...queryKeys.users.lists(), userIds] as const,
+    details: () => [...queryKeys.users.all, 'detail'] as const,
+    detail: (userId: string) => [...queryKeys.users.details(), userId] as const,
+    profile: (sessionId: string) => [...queryKeys.users.details(), sessionId, 'profile'] as const,
+  },
+
+  // Session queries
+  sessions: {
+    all: ['sessions'] as const,
+    lists: () => [...queryKeys.sessions.all, 'list'] as const,
+    list: (userId?: string) => [...queryKeys.sessions.lists(), userId] as const,
+    details: () => [...queryKeys.sessions.all, 'detail'] as const,
+    detail: (sessionId: string) => [...queryKeys.sessions.details(), sessionId] as const,
+    active: () => [...queryKeys.sessions.all, 'active'] as const,
+    device: (deviceId: string) => [...queryKeys.sessions.all, 'device', deviceId] as const,
+  },
+
+  // Device queries
+  devices: {
+    all: ['devices'] as const,
+    lists: () => [...queryKeys.devices.all, 'list'] as const,
+    list: (userId?: string) => [...queryKeys.devices.lists(), userId] as const,
+    details: () => [...queryKeys.devices.all, 'detail'] as const,
+    detail: (deviceId: string) => [...queryKeys.devices.details(), deviceId] as const,
+  },
+} as const;
+
+/**
+ * Helper to invalidate all account-related queries
+ */
+export const invalidateAccountQueries = (queryClient: any) => {
+  queryClient.invalidateQueries({ queryKey: queryKeys.accounts.all });
+};
+
+/**
+ * Helper to invalidate all user-related queries
+ */
+export const invalidateUserQueries = (queryClient: any) => {
+  queryClient.invalidateQueries({ queryKey: queryKeys.users.all });
+};
+
+/**
+ * Helper to invalidate all session-related queries
+ */
+export const invalidateSessionQueries = (queryClient: any) => {
+  queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+};
+

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

@@ -0,0 +1,126 @@
+import { useQuery, useQueries } from '@tanstack/react-query';
+import type { User } from '../../../models/interfaces';
+import type { OxyServices } from '../../../core';
+import { queryKeys } from './queryKeys';
+import { useOxy } from '../../context/OxyContext';
+
+/**
+ * Get user profile by session ID
+ */
+export const useUserProfile = (sessionId: string | null, options?: { enabled?: boolean }) => {
+  const { oxyServices } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.users.profile(sessionId || ''),
+    queryFn: async () => {
+      if (!sessionId) {
+        throw new Error('Session ID is required');
+      }
+      return await oxyServices.getUserBySession(sessionId);
+    },
+    enabled: (options?.enabled !== false) && !!sessionId,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 30 * 60 * 1000, // 30 minutes
+  });
+};
+
+/**
+ * Get multiple user profiles by session IDs (batch query)
+ */
+export const useUserProfiles = (sessionIds: string[], options?: { enabled?: boolean }) => {
+  const { oxyServices } = useOxy();
+
+  return useQueries({
+    queries: sessionIds.map((sessionId) => ({
+      queryKey: queryKeys.users.profile(sessionId),
+      queryFn: async () => {
+        const results = await oxyServices.getUsersBySessions([sessionId]);
+        return results[0]?.user || null;
+      },
+      enabled: (options?.enabled !== false) && !!sessionId,
+      staleTime: 5 * 60 * 1000,
+      gcTime: 30 * 60 * 1000,
+    })),
+  });
+};
+
+/**
+ * Get current authenticated user
+ */
+export const useCurrentUser = (options?: { enabled?: boolean }) => {
+  const { oxyServices, activeSessionId, isAuthenticated } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.accounts.current(),
+    queryFn: async () => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+      return await oxyServices.getUserBySession(activeSessionId);
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated && !!activeSessionId,
+    staleTime: 1 * 60 * 1000, // 1 minute for current user
+    gcTime: 30 * 60 * 1000,
+  });
+};
+
+/**
+ * Get user by ID
+ */
+export const useUserById = (userId: string | null, options?: { enabled?: boolean }) => {
+  const { oxyServices } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.users.detail(userId || ''),
+    queryFn: async () => {
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+      return await oxyServices.getUserById(userId);
+    },
+    enabled: (options?.enabled !== false) && !!userId,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
+  });
+};
+
+/**
+ * Get user profile by username
+ */
+export const useUserByUsername = (username: string | null, options?: { enabled?: boolean }) => {
+  const { oxyServices } = useOxy();
+
+  return useQuery({
+    queryKey: [...queryKeys.users.details(), 'username', username || ''],
+    queryFn: async () => {
+      if (!username) {
+        throw new Error('Username is required');
+      }
+      return await oxyServices.getProfileByUsername(username);
+    },
+    enabled: (options?.enabled !== false) && !!username,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
+  });
+};
+
+/**
+ * Batch get users by session IDs (optimized single API call)
+ */
+export const useUsersBySessions = (sessionIds: string[], options?: { enabled?: boolean }) => {
+  const { oxyServices } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.accounts.list(sessionIds),
+    queryFn: async () => {
+      if (sessionIds.length === 0) {
+        return [];
+      }
+      return await oxyServices.getUsersBySessions(sessionIds);
+    },
+    enabled: (options?.enabled !== false) && sessionIds.length > 0,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
+  });
+};
+