@oxyhq/services 5.13.11 → 5.13.15

package/src/core/OxyServices.ts

@@ -64,7 +64,9 @@ import type {
   Notification, 
   AssetInitResponse, 
   AssetUrlResponse, 
-  AssetVariant 
+  AssetVariant,
+  BlockedUser,
+  RestrictedUser
 } from '../models/interfaces';
 import { normalizeLanguageCode, getLanguageMetadata, getLanguageName, getNativeLanguageName } from '../utils/languageUtils';
 import type { LanguageMetadata } from '../utils/languageUtils';
@@ -838,6 +840,177 @@ export class OxyServices {
     }
   }
 
+  // ============================================================================
+  // BLOCKED USERS METHODS
+  // ============================================================================
+
+  /**
+   * Get list of blocked users
+   * @returns Array of blocked users
+   */
+  async getBlockedUsers(): Promise<BlockedUser[]> {
+    try {
+      return await this.makeRequest<BlockedUser[]>('GET', '/api/privacy/blocked', undefined, {
+        cache: true,
+        cacheTTL: 1 * 60 * 1000, // 1 minute cache
+      });
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Block a user
+   * @param userId - The user ID to block
+   * @returns Success message
+   */
+  async blockUser(userId: string): Promise<{ message: string }> {
+    try {
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+      return await this.makeRequest<{ message: string }>('POST', `/api/privacy/blocked/${userId}`, undefined, {
+        cache: false,
+      });
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Unblock a user
+   * @param userId - The user ID to unblock
+   * @returns Success message
+   */
+  async unblockUser(userId: string): Promise<{ message: string }> {
+    try {
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+      return await this.makeRequest<{ message: string }>('DELETE', `/api/privacy/blocked/${userId}`, undefined, {
+        cache: false,
+      });
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Extract user ID from blocked/restricted user object
+   * @private
+   */
+  private extractUserId(userIdField: string | { _id: string; username?: string; avatar?: string }): string {
+    return typeof userIdField === 'string' ? userIdField : userIdField._id;
+  }
+
+  /**
+   * Check if a user is in a list (blocked or restricted)
+   * @private
+   */
+  private async isUserInList<T extends BlockedUser | RestrictedUser>(
+    userId: string,
+    getUserList: () => Promise<T[]>,
+    getIdField: (item: T) => string | { _id: string; username?: string; avatar?: string }
+  ): Promise<boolean> {
+    try {
+      if (!userId) {
+        return false;
+      }
+      const users = await getUserList();
+      return users.some(item => {
+        const itemId = this.extractUserId(getIdField(item));
+        return itemId === userId;
+      });
+    } catch (error) {
+      // If there's an error, assume not in list to avoid breaking functionality
+      if (__DEV__) {
+        console.warn('Error checking user list:', error);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Check if a user is blocked
+   * @param userId - The user ID to check
+   * @returns True if the user is blocked, false otherwise
+   */
+  async isUserBlocked(userId: string): Promise<boolean> {
+    return this.isUserInList(
+      userId,
+      () => this.getBlockedUsers(),
+      (block) => block.blockedId
+    );
+  }
+
+  // ============================================================================
+  // RESTRICTED USERS METHODS
+  // ============================================================================
+
+  /**
+   * Get list of restricted users
+   * @returns Array of restricted users
+   */
+  async getRestrictedUsers(): Promise<RestrictedUser[]> {
+    try {
+      return await this.makeRequest<RestrictedUser[]>('GET', '/api/privacy/restricted', undefined, {
+        cache: true,
+        cacheTTL: 1 * 60 * 1000, // 1 minute cache
+      });
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Restrict a user (limit their interactions without fully blocking)
+   * @param userId - The user ID to restrict
+   * @returns Success message
+   */
+  async restrictUser(userId: string): Promise<{ message: string }> {
+    try {
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+      return await this.makeRequest<{ message: string }>('POST', `/api/privacy/restricted/${userId}`, undefined, {
+        cache: false,
+      });
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Unrestrict a user
+   * @param userId - The user ID to unrestrict
+   * @returns Success message
+   */
+  async unrestrictUser(userId: string): Promise<{ message: string }> {
+    try {
+      if (!userId) {
+        throw new Error('User ID is required');
+      }
+      return await this.makeRequest<{ message: string }>('DELETE', `/api/privacy/restricted/${userId}`, undefined, {
+        cache: false,
+      });
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Check if a user is restricted
+   * @param userId - The user ID to check
+   * @returns True if the user is restricted, false otherwise
+   */
+  async isUserRestricted(userId: string): Promise<boolean> {
+    return this.isUserInList(
+      userId,
+      () => this.getRestrictedUsers(),
+      (restrict) => restrict.restrictedId
+    );
+  }
+
   /**
    * Request account verification
    */

package/src/index.ts

@@ -65,6 +65,10 @@ export type {
   DeviceSessionsResponse,
   DeviceSessionLogoutResponse,
   UpdateDeviceNameResponse,
+  // Blocked users
+  BlockedUser,
+  // Restricted users
+  RestrictedUser,
   // Central Asset Service types
   FileVisibility,
   AssetLink,

package/src/models/interfaces.ts

@@ -90,6 +90,34 @@ export interface Transaction {
   // Add other transaction fields as needed
 }
 
+export interface BlockedUser {
+  _id?: string;
+  blockedId: string | {
+    _id: string;
+    username: string;
+    avatar?: string;
+  };
+  userId: string;
+  createdAt?: string;
+  blockedAt?: string;
+  username?: string;
+  avatar?: string;
+}
+
+export interface RestrictedUser {
+  _id?: string;
+  restrictedId: string | {
+    _id: string;
+    username: string;
+    avatar?: string;
+  };
+  userId: string;
+  createdAt?: string;
+  restrictedAt?: string;
+  username?: string;
+  avatar?: string;
+}
+
 export interface TransferFundsRequest {
   fromUserId: string;
   toUserId: string;

package/src/ui/context/OxyContext.tsx

@@ -1,6 +1,5 @@
 import type React from 'react';
 import { createContext, useContext, useEffect, useCallback, useMemo, useRef, useState, type ReactNode } from 'react';
-import type { UseFollowHook } from '../hooks/useFollow.types';
 import { OxyServices } from '../../core';
 import type { User, ApiError } from '../../models/interfaces';
 import type { SessionLoginResponse, ClientSession, MinimalUserData } from '../../models/session';
@@ -15,9 +14,6 @@ import { getLanguageMetadata, getLanguageName, getNativeLanguageName, normalizeL
 import type { LanguageMetadata } from '../../utils/languageUtils';
 
 // Define the context shape
-// NOTE: We intentionally avoid importing useFollow here to prevent a require cycle.
-// If consumers relied on `const { useFollow } = useOxy()`, we provide a lazy proxy below.
-
 export interface OxyContextState {
   // Authentication state
   user: User | null; // Current active user (loaded from server)
@@ -62,34 +58,8 @@ export interface OxyContextState {
   // Methods to directly control the bottom sheet
   showBottomSheet?: (screenOrConfig?: RouteName | string | { screen: RouteName | string; props?: Record<string, any> }) => void;
   hideBottomSheet?: () => void;
-
-  /**
-   * (Deprecated) useFollow hook access via context. Prefer: import { useFollow } from '@oxyhq/services';
-   * Kept for backward compatibility; implemented as a lazy dynamic require to avoid circular dependency.
-   */
-  useFollow: UseFollowHook; // Back-compat; prefer direct import
 }
 
-// Empty follow hook fallback
-const createEmptyFollowHook = (): UseFollowHook => {
-  const emptyResult = {
-    isFollowing: false,
-    isLoading: false,
-    error: null,
-    toggleFollow: async () => { },
-    setFollowStatus: () => { },
-    fetchStatus: async () => { },
-    clearError: () => { },
-    followerCount: null,
-    followingCount: null,
-    isLoadingCounts: false,
-    fetchUserCounts: async () => { },
-    setFollowerCount: () => { },
-    setFollowingCount: () => { },
-  };
-  return () => emptyResult;
-};
-
 // Create the context with default values
 const OxyContext = createContext<OxyContextState | null>(null);
 
@@ -903,29 +873,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     }, [logout]),
   });
 
-  // Context value - optimized to prevent unnecessary re-renders
-  // Lazy proxy to load the hook only when accessed, breaking the static import cycle.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-  const useFollowProxy: UseFollowHook = (userId?: string | string[]) => {
-    try {
-      // Dynamically require to avoid top-level cycle
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const mod = require('../hooks/useFollow');
-      if (mod && typeof mod.useFollow === 'function') {
-        return mod.useFollow(userId);
-      }
-      if (__DEV__) {
-        console.warn('useFollow module did not export a function as expected');
-      }
-      return createEmptyFollowHook()(userId);
-    } catch (e) {
-      if (__DEV__) {
-        console.warn('Failed to dynamically load useFollow hook:', e);
-      }
-      return createEmptyFollowHook()(userId);
-    }
-  };
-
   // Compute language metadata from currentLanguage
   const languageMetadata = useMemo(() => getLanguageMetadata(currentLanguage), [currentLanguage]);
   const languageName = useMemo(() => getLanguageName(currentLanguage), [currentLanguage]);
@@ -960,7 +907,6 @@ export const OxyProvider: React.FC<OxyContextProviderProps> = ({
     bottomSheetRef,
     showBottomSheet,
     hideBottomSheet,
-    useFollow: useFollowProxy,
   }), [
     user?.id, // Only depend on user ID, not the entire user object
     minimalUser?.id,

package/src/ui/navigation/types.ts

@@ -80,7 +80,6 @@ export interface OxyProviderProps {
   /**
    * @internal
    * Reference to the bottom sheet component (for internal use only)
-   * @deprecated External bottom sheet ref is no longer required as OxyProvider handles the bottom sheet internally
    * @hidden
    */
   bottomSheetRef?: React.RefObject<BottomSheetController | null>;

package/src/ui/screens/PrivacySettingsScreen.tsx

@@ -6,12 +6,14 @@ import {
     ScrollView,
     Switch,
     ActivityIndicator,
+    TouchableOpacity,
 } from 'react-native';
 import type { BaseScreenProps } from '../navigation/types';
 import { useOxy } from '../context/OxyContext';
 import { toast } from '../../lib/sonner';
-import { Header, Section } from '../components';
+import { Header, Section, Avatar } from '../components';
 import { useI18n } from '../hooks/useI18n';
+import type { BlockedUser, RestrictedUser } from '../../models/interfaces';
 
 interface PrivacySettings {
     isPrivateAccount: boolean;
@@ -67,8 +69,11 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
     });
     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
+    // Load settings and users
     useEffect(() => {
         const loadSettings = async () => {
             try {
@@ -90,6 +95,28 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
         loadSettings();
     }, [user?.id, 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]);
+
     const updateSetting = useCallback(async (key: keyof PrivacySettings, value: boolean) => {
         try {
             setIsSaving(true);
@@ -110,6 +137,113 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
         }
     }, [settings, user?.id, oxyServices, 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]);
+
+    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]);
+
+    // Helper to extract user info from blocked/restricted objects
+    const extractUserInfo = useCallback((
+        item: BlockedUser | RestrictedUser,
+        idField: 'blockedId' | 'restrictedId'
+    ) => {
+        let userIdField: string | { _id: string; username?: string; avatar?: string };
+        let username: string;
+        let avatar: string | undefined;
+
+        if (idField === 'blockedId' && 'blockedId' in item) {
+            userIdField = item.blockedId;
+            username = typeof item.blockedId === 'string'
+                ? (item.username || 'Unknown')
+                : (item.blockedId.username || 'Unknown');
+            avatar = typeof item.blockedId === 'string' ? item.avatar : item.blockedId.avatar;
+        } else if (idField === 'restrictedId' && 'restrictedId' in item) {
+            userIdField = item.restrictedId;
+            username = typeof item.restrictedId === 'string'
+                ? (item.username || 'Unknown')
+                : (item.restrictedId.username || 'Unknown');
+            avatar = typeof item.restrictedId === 'string' ? item.avatar : item.restrictedId.avatar;
+        } else {
+            // Fallback (should not happen)
+            return { userId: '', username: 'Unknown', avatar: undefined };
+        }
+
+        const userId = typeof userIdField === 'string' ? userIdField : userIdField._id;
+        return { userId, username, avatar };
+    }, []);
+
+    // Reusable user list item component
+    const UserListItem: React.FC<{
+        item: BlockedUser | RestrictedUser;
+        idField: 'blockedId' | 'restrictedId';
+        onAction: (userId: string) => void;
+        actionLabel: string;
+        actionColor: string;
+        subtitle?: string;
+    }> = ({ item, idField, onAction, actionLabel, actionColor, subtitle }) => {
+        const { userId, username, avatar } = extractUserInfo(item, idField);
+        // Convert avatar file ID to URI if needed
+        const avatarUri = avatar && oxyServices 
+            ? oxyServices.getFileDownloadUrl(avatar, 'thumb') 
+            : undefined;
+        
+        return (
+            <View style={[styles.userRow, { borderBottomColor: themeStyles.borderColor }]}>
+                <View style={styles.userInfo}>
+                    <Avatar
+                        uri={avatarUri}
+                        name={username}
+                        size={40}
+                        theme={theme}
+                    />
+                    <View style={styles.userDetails}>
+                        <Text style={[styles.username, { color: themeStyles.textColor }]}>
+                            {username}
+                        </Text>
+                        {subtitle && (
+                            <Text style={[styles.userSubtext, { color: themeStyles.mutedTextColor }]}>
+                                {subtitle}
+                            </Text>
+                        )}
+                    </View>
+                </View>
+                <TouchableOpacity
+                    onPress={() => onAction(userId)}
+                    style={[styles.actionButton, { backgroundColor: themeStyles.secondaryBackgroundColor }]}
+                >
+                    <Text style={[styles.actionButtonText, { color: actionColor }]}>
+                        {actionLabel}
+                    </Text>
+                </TouchableOpacity>
+            </View>
+        );
+    };
+
     const themeStyles = useMemo(() => {
         const isDarkTheme = theme === 'dark';
         return {
@@ -288,6 +422,65 @@ const PrivacySettingsScreen: React.FC<BaseScreenProps> = ({
                         onValueChange={(value) => updateSetting('blockScreenshots', value)}
                     />
                 </Section>
+
+                {/* Blocked Users */}
+                <Section title={t('privacySettings.sections.blockedUsers') || 'BLOCKED USERS'} theme={theme}>
+                    {isLoadingUsers ? (
+                        <View style={styles.loadingUsersContainer}>
+                            <ActivityIndicator size="small" color={themeStyles.textColor} />
+                        </View>
+                    ) : blockedUsers.length === 0 ? (
+                        <View style={styles.emptyContainer}>
+                            <Text style={[styles.emptyText, { color: themeStyles.mutedTextColor }]}>
+                                {t('privacySettings.noBlockedUsers') || 'No blocked users'}
+                            </Text>
+                        </View>
+                    ) : (
+                        blockedUsers.map((blocked) => {
+                            const { userId } = extractUserInfo(blocked, 'blockedId');
+                            return (
+                                <UserListItem
+                                    key={userId}
+                                    item={blocked}
+                                    idField="blockedId"
+                                    onAction={handleUnblock}
+                                    actionLabel={t('privacySettings.unblock') || 'Unblock'}
+                                    actionColor="#FF3B30"
+                                />
+                            );
+                        })
+                    )}
+                </Section>
+
+                {/* Restricted Users */}
+                <Section title={t('privacySettings.sections.restrictedUsers') || 'RESTRICTED USERS'} theme={theme}>
+                    {isLoadingUsers ? (
+                        <View style={styles.loadingUsersContainer}>
+                            <ActivityIndicator size="small" color={themeStyles.textColor} />
+                        </View>
+                    ) : restrictedUsers.length === 0 ? (
+                        <View style={styles.emptyContainer}>
+                            <Text style={[styles.emptyText, { color: themeStyles.mutedTextColor }]}>
+                                {t('privacySettings.noRestrictedUsers') || 'No restricted users'}
+                            </Text>
+                        </View>
+                    ) : (
+                        restrictedUsers.map((restricted) => {
+                            const { userId } = extractUserInfo(restricted, 'restrictedId');
+                            return (
+                                <UserListItem
+                                    key={userId}
+                                    item={restricted}
+                                    idField="restrictedId"
+                                    onAction={handleUnrestrict}
+                                    actionLabel={t('privacySettings.unrestrict') || 'Unrestrict'}
+                                    actionColor="#007AFF"
+                                    subtitle={t('privacySettings.restrictedDescription') || 'Limited interactions'}
+                                />
+                            );
+                        })
+                    )}
+                </Section>
             </ScrollView>
         </View>
     );
@@ -326,6 +519,51 @@ const styles = StyleSheet.create({
         fontSize: 14,
         opacity: 0.7,
     },
+    loadingUsersContainer: {
+        paddingVertical: 20,
+        alignItems: 'center',
+    },
+    emptyContainer: {
+        paddingVertical: 20,
+        alignItems: 'center',
+    },
+    emptyText: {
+        fontSize: 14,
+    },
+    userRow: {
+        flexDirection: 'row',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+        paddingVertical: 12,
+        borderBottomWidth: 1,
+    },
+    userInfo: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        flex: 1,
+        marginRight: 12,
+    },
+    userDetails: {
+        marginLeft: 12,
+        flex: 1,
+    },
+    username: {
+        fontSize: 16,
+        fontWeight: '500',
+        marginBottom: 2,
+    },
+    userSubtext: {
+        fontSize: 13,
+    },
+    actionButton: {
+        paddingHorizontal: 16,
+        paddingVertical: 8,
+        borderRadius: 8,
+    },
+    actionButtonText: {
+        fontSize: 14,
+        fontWeight: '600',
+    },
 });
 
 export default React.memo(PrivacySettingsScreen);

package/src/utils/apiUtils.ts

@@ -70,20 +70,6 @@ export interface ErrorResponse {
   details?: any;
 }
 
-/**
- * Validate required parameters
- * @param params Object to validate
- * @param requiredKeys Array of required keys
- * @throws Error if any required key is missing
- */
-export function validateRequiredParams(params: Record<string, any>, requiredKeys: string[]): void {
-  const missing = requiredKeys.filter(key => params[key] === undefined || params[key] === null);
-  
-  if (missing.length > 0) {
-    throw new Error(`Missing required parameters: ${missing.join(', ')}`);
-  }
-}
-
 /**
  * Safe JSON parsing with error handling
  * @param data Data to parse

package/src/utils/asyncUtils.ts

@@ -196,26 +196,6 @@ export async function withTimeout<T>(
   return Promise.race([operation, timeoutPromise]);
 }
 
-/**
- * Cache async operation results
- * @deprecated Use TTLCache from '../utils/cache' instead
- * This function is kept for backward compatibility but will be removed in a future version
- */
-export function createAsyncCache<T>(
-  ttl: number = 5 * 60 * 1000 // 5 minutes default
-) {
-  // Re-export from centralized cache utility
-  const cache = new TTLCache<T>(ttl);
-  registerCacheForCleanup(cache);
-  
-  return {
-    get: (key: string): T | null => cache.get(key),
-    set: (key: string, data: T): void => cache.set(key, data),
-    clear: (): void => cache.clear(),
-    delete: (key: string): boolean => cache.delete(key),
-  };
-}
-
 /**
  * Execute async operation with loading state
  */