@oxyhq/services 5.16.0 → 5.16.2

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

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

@@ -0,0 +1,121 @@
+import { useQuery } from '@tanstack/react-query';
+import type { ClientSession } from '../../../models/session';
+import { queryKeys } from './queryKeys';
+import { useOxy } from '../../context/OxyContext';
+import { fetchSessionsWithFallback, mapSessionsToClient } from '../../context/utils/sessionHelpers';
+
+/**
+ * Get all active sessions for the current user
+ */
+export const useSessions = (userId?: string, options?: { enabled?: boolean }) => {
+  const { oxyServices, activeSessionId } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.sessions.list(userId),
+    queryFn: async () => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+      
+      const sessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
+        fallbackDeviceId: undefined,
+        fallbackUserId: userId,
+      });
+      
+      return mapSessionsToClient(sessions, activeSessionId);
+    },
+    enabled: (options?.enabled !== false) && !!activeSessionId,
+    staleTime: 2 * 60 * 1000, // 2 minutes (sessions change frequently)
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+
+/**
+ * Get specific session by ID
+ */
+export const useSession = (sessionId: string | null, options?: { enabled?: boolean }) => {
+  const { oxyServices } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.sessions.detail(sessionId || ''),
+    queryFn: async () => {
+      if (!sessionId) {
+        throw new Error('Session ID is required');
+      }
+      
+      const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation: true });
+      if (!validation?.valid || !validation.user) {
+        throw new Error('Session not found or invalid');
+      }
+
+      const now = new Date();
+      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() ?? '',
+        isCurrent: false,
+      } as ClientSession;
+    },
+    enabled: (options?.enabled !== false) && !!sessionId,
+    staleTime: 2 * 60 * 1000,
+    gcTime: 10 * 60 * 1000,
+  });
+};
+
+/**
+ * Get device sessions for the current active session
+ */
+export const useDeviceSessions = (options?: { enabled?: boolean }) => {
+  const { oxyServices, activeSessionId } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.sessions.active(),
+    queryFn: async () => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+      
+      return await oxyServices.getDeviceSessions(activeSessionId);
+    },
+    enabled: (options?.enabled !== false) && !!activeSessionId,
+    staleTime: 2 * 60 * 1000,
+    gcTime: 10 * 60 * 1000,
+  });
+};
+
+/**
+ * Get user devices
+ */
+export const useUserDevices = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated } = useOxy();
+
+  return useQuery({
+    queryKey: queryKeys.devices.list(),
+    queryFn: async () => {
+      return await oxyServices.getUserDevices();
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
+  });
+};
+
+/**
+ * Get security information
+ */
+export const useSecurityInfo = (options?: { enabled?: boolean }) => {
+  const { oxyServices, isAuthenticated } = useOxy();
+
+  return useQuery({
+    queryKey: [...queryKeys.devices.all, 'security'],
+    queryFn: async () => {
+      return await oxyServices.getSecurityInfo();
+    },
+    enabled: (options?.enabled !== false) && isAuthenticated,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
+  });
+};
+

package/src/ui/hooks/queryClient.ts

@@ -0,0 +1,112 @@
+import { QueryClient } from '@tanstack/react-query';
+import type { StorageInterface } from '../utils/storageHelpers';
+
+const QUERY_CACHE_KEY = 'oxy_query_cache';
+const QUERY_CACHE_VERSION = '1';
+
+/**
+ * Custom persistence adapter for TanStack Query using our StorageInterface
+ */
+export const createPersistenceAdapter = (storage: StorageInterface) => {
+  return {
+    persistClient: async (client: any) => {
+      try {
+        const serialized = JSON.stringify({
+          clientState: client,
+          timestamp: Date.now(),
+          version: QUERY_CACHE_VERSION,
+        });
+        await storage.setItem(QUERY_CACHE_KEY, serialized);
+      } catch (error) {
+        if (__DEV__) {
+          console.warn('[QueryClient] Failed to persist cache:', error);
+        }
+      }
+    },
+    restoreClient: async () => {
+      try {
+        const cached = await storage.getItem(QUERY_CACHE_KEY);
+        if (!cached) return undefined;
+
+        const parsed = JSON.parse(cached);
+        
+        // Check version compatibility
+        if (parsed.version !== QUERY_CACHE_VERSION) {
+          // Clear old cache on version mismatch
+          await storage.removeItem(QUERY_CACHE_KEY);
+          return undefined;
+        }
+
+        // Check if cache is too old (30 days)
+        const maxAge = 30 * 24 * 60 * 60 * 1000;
+        if (parsed.timestamp && Date.now() - parsed.timestamp > maxAge) {
+          await storage.removeItem(QUERY_CACHE_KEY);
+          return undefined;
+        }
+
+        return parsed.clientState;
+      } catch (error) {
+        if (__DEV__) {
+          console.warn('[QueryClient] Failed to restore cache:', error);
+        }
+        return undefined;
+      }
+    },
+    removeClient: async () => {
+      try {
+        await storage.removeItem(QUERY_CACHE_KEY);
+      } catch (error) {
+        if (__DEV__) {
+          console.warn('[QueryClient] Failed to remove cache:', error);
+        }
+      }
+    },
+  };
+};
+
+/**
+ * Create a QueryClient with offline-first configuration
+ */
+export const createQueryClient = (storage?: StorageInterface | null): QueryClient => {
+  const client = new QueryClient({
+    defaultOptions: {
+      queries: {
+        // Data is fresh for 5 minutes
+        staleTime: 5 * 60 * 1000,
+        // Keep unused data in cache for 30 minutes
+        gcTime: 30 * 60 * 1000,
+        // Retry 3 times with exponential backoff
+        retry: 3,
+        retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
+        // Refetch on reconnect
+        refetchOnReconnect: true,
+        // Don't refetch on window focus (better for mobile)
+        refetchOnWindowFocus: false,
+        // Offline-first: use cache when offline
+        networkMode: 'offlineFirst',
+      },
+      mutations: {
+        // Retry once for mutations
+        retry: 1,
+        // Offline-first: queue mutations when offline
+        networkMode: 'offlineFirst',
+      },
+    },
+  });
+
+  // Note: Persistence is handled by TanStack Query's built-in persistence
+  // For now, we rely on the query client's default behavior with networkMode: 'offlineFirst'
+  // The cache will be available in memory and queries will use cached data when offline
+  // Full persistence to AsyncStorage can be added later with @tanstack/react-query-persist-client if needed
+
+  return client;
+};
+
+/**
+ * Clear persisted query cache
+ */
+export const clearQueryCache = async (storage: StorageInterface): Promise<void> => {
+  const adapter = createPersistenceAdapter(storage);
+  await adapter.removeClient();
+};
+