@oxyhq/services 5.16.28 → 5.16.30

package/src/ui/hooks/auth/useUsernameValidation.ts

@@ -0,0 +1,177 @@
+import { useMemo } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import type { OxyServices } from '../../../core';
+import { handleHttpError, ErrorCodes } from '../../../utils/errorUtils';
+import { useDebounce } from '../../../utils/hookUtils';
+
+/**
+ * Username validation constants
+ */
+export const USERNAME_MIN_LENGTH = 4;
+export const USERNAME_REGEX = /^[a-z0-9]+$/i;
+export const USERNAME_FORMAT_ERROR = 'You can use a-z, 0-9. Minimum length is 4 characters.';
+export const USERNAME_DEBOUNCE_MS = 500;
+
+/**
+ * Username validation result interface
+ */
+export interface UsernameValidationResult {
+  isValid: boolean;
+  isAvailable: boolean | null; // null = not checked yet
+  error: string | null;
+  isChecking: boolean;
+}
+
+/**
+ * Validate username format using services validation utilities
+ */
+function validateUsernameFormat(username: string): boolean {
+  // Use stricter validation: lowercase alphanumeric only, min 4 chars
+  return username.length >= USERNAME_MIN_LENGTH && USERNAME_REGEX.test(username);
+}
+
+/**
+ * Check if an error is a network or timeout error
+ */
+function isNetworkOrTimeoutError(error: unknown): boolean {
+  const apiError = handleHttpError(error);
+  return (
+    apiError.code === ErrorCodes.NETWORK_ERROR ||
+    apiError.code === ErrorCodes.TIMEOUT ||
+    apiError.code === ErrorCodes.CONNECTION_FAILED
+  );
+}
+
+/**
+ * Extract error message from an unknown error shape
+ */
+function extractAuthErrorMessage(error: unknown, fallbackMessage = 'An error occurred'): string {
+  const apiError = handleHttpError(error);
+  return apiError.message || fallbackMessage;
+}
+
+/**
+ * Hook for username validation with debouncing and availability checking
+ * 
+ * Uses TanStack Query for efficient API calls with:
+ * - Automatic request cancellation when username changes
+ * - Built-in caching (same username checked multiple times = cached result)
+ * - Request deduplication (multiple components checking same username = single request)
+ * - Proper error handling
+ * 
+ * @param username - The username to validate
+ * @param oxyServices - OxyServices instance for API calls
+ * @returns Username validation state and result
+ */
+export function useUsernameValidation(
+  username: string,
+  oxyServices: OxyServices | null
+): UsernameValidationResult {
+  // Debounce the username input to avoid excessive API calls
+  const debouncedUsername = useDebounce(username.trim().toLowerCase(), USERNAME_DEBOUNCE_MS);
+  
+  // Validate format synchronously (no API call needed)
+  const isValid = useMemo(() => validateUsernameFormat(username), [username]);
+  
+  // Determine if we should check availability
+  const shouldCheckAvailability = useMemo(() => {
+    if (!debouncedUsername || debouncedUsername.length < USERNAME_MIN_LENGTH) {
+      return false;
+    }
+    return validateUsernameFormat(debouncedUsername);
+  }, [debouncedUsername]);
+  
+  // Use TanStack Query for the API call
+  // This provides automatic caching, request cancellation, and deduplication
+  const {
+    data: availabilityResult,
+    isLoading: isChecking,
+    error: queryError,
+    isFetching,
+  } = useQuery({
+    queryKey: ['username', 'availability', debouncedUsername],
+    queryFn: async () => {
+      if (!oxyServices) {
+        throw new Error('OxyServices not available');
+      }
+      return await oxyServices.checkUsernameAvailability(debouncedUsername);
+    },
+    enabled: shouldCheckAvailability && !!oxyServices,
+    staleTime: 5 * 60 * 1000, // Cache for 5 minutes (usernames don't change often)
+    gcTime: 30 * 60 * 1000, // Keep in cache for 30 minutes
+    retry: (failureCount, error) => {
+      // Don't retry on network/timeout errors (user might be offline)
+      if (isNetworkOrTimeoutError(error)) {
+        return false;
+      }
+      // Retry up to 2 times for other errors
+      return failureCount < 2;
+    },
+    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 3000),
+  });
+  
+  // Compute the result based on validation and query state
+  return useMemo(() => {
+    // If username is too short or invalid format, return early validation
+    if (!username || username.length < USERNAME_MIN_LENGTH) {
+      return {
+        isValid: false,
+        isAvailable: null,
+        error: null,
+        isChecking: false,
+      };
+    }
+    
+    if (!isValid) {
+      return {
+        isValid: false,
+        isAvailable: false,
+        error: USERNAME_FORMAT_ERROR,
+        isChecking: false,
+      };
+    }
+    
+    // If we're not checking yet (debounce period), show checking state only if user is typing
+    const isCurrentlyChecking = isChecking || isFetching;
+    
+    // Handle network/timeout errors gracefully
+    if (queryError && isNetworkOrTimeoutError(queryError)) {
+      // Allow proceeding if offline/network issue (optimistic)
+      return {
+        isValid: true,
+        isAvailable: true, // Optimistic: allow proceeding
+        error: null,
+        isChecking: false,
+      };
+    }
+    
+    // Handle other errors
+    if (queryError) {
+      return {
+        isValid: true,
+        isAvailable: false,
+        error: extractAuthErrorMessage(queryError, 'Failed to check username availability'),
+        isChecking: false,
+      };
+    }
+    
+    // If we have a result, use it
+    if (availabilityResult) {
+      return {
+        isValid: true,
+        isAvailable: availabilityResult.available,
+        error: availabilityResult.available ? null : (availabilityResult.message || 'Username is already taken'),
+        isChecking: false,
+      };
+    }
+    
+    // Still checking (or waiting for debounce)
+    return {
+      isValid: true,
+      isAvailable: null,
+      error: null,
+      isChecking: isCurrentlyChecking,
+    };
+  }, [username, isValid, availabilityResult, isChecking, isFetching, queryError]);
+}
+

package/src/ui/hooks/index.ts

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

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

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

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/useTransferQueries.ts

@@ -1,5 +1,4 @@
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useOxy } from '../context/OxyContext';
+import { useQuery } from '@tanstack/react-query';
 import { useTransferStore } from '../stores/transferStore';
 import type { OxyServices } from '../../core';
 
@@ -7,66 +6,9 @@ import type { OxyServices } from '../../core';
  * Query keys for transfer-related queries
  */
 export const transferQueryKeys = {
-  all: ['transfers'] as const,
-  completion: (transferId: string) => ['transfers', 'completion', transferId] as const,
   pending: () => ['transfers', 'pending'] as const,
 };
 
-/**
- * Hook to check if a transfer was completed
- * Only runs when authenticated and transferId is provided
- */
-export const useCheckTransferCompletion = (transferId: string | null, enabled: boolean = true) => {
-  const { oxyServices, isAuthenticated } = useOxy();
-  
-  return useQuery({
-    queryKey: transferId ? transferQueryKeys.completion(transferId) : ['transfers', 'completion', 'null'],
-    queryFn: async () => {
-      if (!transferId || !oxyServices) {
-        return null;
-      }
-
-      try {
-        const response = await oxyServices.makeRequest<{
-          completed: boolean;
-          transferId?: string;
-          sourceDeviceId?: string;
-          publicKey?: string;
-          transferCode?: string;
-          completedAt?: string;
-        }>(
-          'GET',
-          `/api/identity/check-transfer/${transferId}`,
-          undefined,
-          { cache: false }
-        );
-
-        return response;
-      } catch (error: any) {
-        // Handle 401 errors gracefully - don't throw, just return null
-        if (error?.status === 401 || error?.message?.includes('401') || error?.message?.includes('authentication')) {
-          if (__DEV__) {
-            console.warn('[useCheckTransferCompletion] Authentication required, skipping check');
-          }
-          return null;
-        }
-        throw error;
-      }
-    },
-    enabled: enabled && !!transferId && isAuthenticated && !!oxyServices,
-    staleTime: 30 * 1000, // 30 seconds - completion status doesn't change frequently
-    gcTime: 5 * 60 * 1000, // 5 minutes
-    retry: (failureCount, error: any) => {
-      // Don't retry on 401 errors
-      if (error?.status === 401 || error?.message?.includes('401')) {
-        return false;
-      }
-      return failureCount < 2;
-    },
-    retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 5000),
-  });
-};
-
 /**
  * Hook to check all pending transfers for completion
  * Used when app comes back online
@@ -158,11 +100,3 @@ export const useCheckPendingTransfers = (
   });
 };
 
-/**
- * Hook version that uses useOxy() - for use outside OxyContext
- */
-export const useCheckPendingTransfersWithContext = () => {
-  const { oxyServices, isAuthenticated } = useOxy();
-  return useCheckPendingTransfers(oxyServices, isAuthenticated);
-};
-

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/stores/transferStore.ts

@@ -192,10 +192,4 @@ export const useTransferCodesForPersistence = () => {
   );
 };
 
-/**
- * Hook to check if store has been restored
- */
-export const useTransferStoreRestored = () => {
-  return useTransferStore((state) => state.isRestored);
-};