@oxyhq/auth 1.0.0

package/src/hooks/queries/useAccountQueries.ts

@@ -0,0 +1,152 @@
+import { useQuery, useQueries } from '@tanstack/react-query';
+import type { User } from '@oxyhq/core';
+import { queryKeys } from './queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+import { authenticatedApiCall } from '../../utils/authHelpers';
+
+/**
+ * Get user profile by session ID
+ */
+export const useUserProfile = (sessionId: string | null, options?: { enabled?: boolean }) => {
+  const { oxyServices } = useWebOxy();
+
+  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 } = useWebOxy();
+
+  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 } = useWebOxy();
+
+  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 } = useWebOxy();
+
+  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 } = useWebOxy();
+
+  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 } = useWebOxy();
+
+  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,
+  });
+};
+
+/**
+ * Get privacy settings for a user
+ */
+export const usePrivacySettings = (userId?: string, options?: { enabled?: boolean }) => {
+  const { oxyServices, activeSessionId, user } = useWebOxy();
+  const targetUserId = userId || user?.id;
+
+  return useQuery({
+    queryKey: queryKeys.privacy.settings(targetUserId),
+    queryFn: async () => {
+      if (!targetUserId) {
+        throw new Error('User ID is required');
+      }
+
+      return authenticatedApiCall(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getPrivacySettings(targetUserId)
+      );
+    },
+    enabled: (options?.enabled !== false) && !!targetUserId,
+    staleTime: 2 * 60 * 1000, // 2 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+

package/src/hooks/queries/useSecurityQueries.ts

@@ -0,0 +1,64 @@
+import { useQuery } from '@tanstack/react-query';
+import { queryKeys } from './queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+import type { SecurityActivity, SecurityEventType } from '@oxyhq/core';
+
+/**
+ * Get user's security activity with pagination
+ */
+export const useSecurityActivity = (
+  options?: {
+    limit?: number;
+    offset?: number;
+    eventType?: SecurityEventType;
+    enabled?: boolean;
+  }
+) => {
+  const { oxyServices, activeSessionId } = useWebOxy();
+
+  return useQuery({
+    queryKey: queryKeys.security.activity(
+      options?.limit,
+      options?.offset,
+      options?.eventType
+    ),
+    queryFn: async () => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+
+      const response = await oxyServices.getSecurityActivity(
+        options?.limit,
+        options?.offset,
+        options?.eventType
+      );
+
+      return response;
+    },
+    enabled: (options?.enabled !== false) && !!activeSessionId,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+
+/**
+ * Get recent security activity (convenience hook)
+ */
+export const useRecentSecurityActivity = (limit: number = 10) => {
+  const { oxyServices, activeSessionId } = useWebOxy();
+
+  return useQuery<SecurityActivity[]>({
+    queryKey: queryKeys.security.recent(limit),
+    queryFn: async () => {
+      if (!activeSessionId) {
+        throw new Error('No active session');
+      }
+
+      return await oxyServices.getRecentSecurityActivity(limit);
+    },
+    enabled: !!activeSessionId,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+  });
+};
+

package/src/hooks/queries/useServicesQueries.ts

@@ -0,0 +1,126 @@
+import { useQuery } from '@tanstack/react-query';
+import type { ClientSession } from '@oxyhq/core';
+import { queryKeys } from './queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
+import { authenticatedApiCall } from '../../utils/authHelpers';
+
+/**
+ * Get all active sessions for the current user
+ */
+export const useSessions = (userId?: string, options?: { enabled?: boolean }) => {
+  const { oxyServices, activeSessionId } = useWebOxy();
+
+  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 } = useWebOxy();
+
+  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 } = useWebOxy();
+
+  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, activeSessionId } = useWebOxy();
+
+  return useQuery({
+    queryKey: queryKeys.devices.list(),
+    queryFn: async () => {
+      return authenticatedApiCall(
+        oxyServices,
+        activeSessionId,
+        () => 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 } = useWebOxy();
+
+  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/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();
+};
+