@oxyhq/services 5.13.1 → 5.13.2

package/src/ui/stores/accountStore.ts

@@ -0,0 +1,285 @@
+import { create } from 'zustand';
+import { shallow } from 'zustand/shallow';
+import type { OxyServices } from '../../core';
+
+export interface QuickAccount {
+    sessionId: string;
+    userId?: string; // User ID for deduplication
+    username: string;
+    displayName: string;
+    avatar?: string;
+    avatarUrl?: string; // Cached avatar URL to prevent recalculation
+}
+
+interface AccountState {
+    // Account data
+    accounts: Record<string, QuickAccount>;
+    accountOrder: string[]; // Maintain order for display
+    accountsArray: QuickAccount[]; // Cached array to prevent infinite loops
+    
+    // Loading states
+    loading: boolean;
+    loadingSessionIds: Set<string>;
+    
+    // Error state
+    error: string | null;
+    
+    // Actions
+    setAccounts: (accounts: QuickAccount[]) => void;
+    addAccount: (account: QuickAccount) => void;
+    updateAccount: (sessionId: string, updates: Partial<QuickAccount>) => void;
+    removeAccount: (sessionId: string) => void;
+    moveAccountToTop: (sessionId: string) => void;
+    
+    // Loading actions
+    setLoading: (loading: boolean) => void;
+    setLoadingSession: (sessionId: string, loading: boolean) => void;
+    
+    // Error actions
+    setError: (error: string | null) => void;
+    
+    // Load accounts from API
+    loadAccounts: (sessionIds: string[], oxyServices: OxyServices, existingAccounts?: QuickAccount[], preserveOrder?: boolean) => Promise<void>;
+    
+    // Reset store
+    reset: () => void;
+}
+
+const initialState = {
+    accounts: {} as Record<string, QuickAccount>,
+    accountOrder: [] as string[],
+    accountsArray: [] as QuickAccount[],
+    loading: false,
+    loadingSessionIds: new Set<string>(),
+    error: null,
+};
+
+// Helper: Build accounts array from accounts map and order
+const buildAccountsArray = (accounts: Record<string, QuickAccount>, order: string[]): QuickAccount[] => {
+    const result: QuickAccount[] = [];
+    for (const id of order) {
+        const account = accounts[id];
+        if (account) result.push(account);
+    }
+    return result;
+};
+
+// Helper: Create QuickAccount from user data
+const createQuickAccount = (sessionId: string, userData: any, existingAccount?: QuickAccount, oxyServices?: OxyServices): QuickAccount => {
+    const displayName = userData.name?.full || userData.name?.first || userData.username || 'Account';
+    const userId = userData.id || userData._id?.toString();
+    
+    // Preserve existing avatarUrl if avatar hasn't changed (prevents image reload)
+    let avatarUrl: string | undefined;
+    if (existingAccount && existingAccount.avatar === userData.avatar && existingAccount.avatarUrl) {
+        avatarUrl = existingAccount.avatarUrl; // Reuse existing URL
+    } else if (userData.avatar && oxyServices) {
+        avatarUrl = oxyServices.getFileDownloadUrl(userData.avatar, 'thumb');
+    }
+    
+    return {
+        sessionId,
+        userId,
+        username: userData.username || '',
+        displayName,
+        avatar: userData.avatar,
+        avatarUrl,
+    };
+};
+
+export const useAccountStore = create<AccountState>((set, get) => ({
+    ...initialState,
+    
+    setAccounts: (accounts) => set((state) => {
+        const accountMap: Record<string, QuickAccount> = {};
+        const order: string[] = [];
+        const seenSessionIds = new Set<string>();
+        
+        for (const account of accounts) {
+            if (seenSessionIds.has(account.sessionId)) continue;
+            seenSessionIds.add(account.sessionId);
+            accountMap[account.sessionId] = account;
+            order.push(account.sessionId);
+        }
+        
+        const accountsArray = buildAccountsArray(accountMap, order);
+        const sameOrder = order.length === state.accountOrder.length && 
+            order.every((id, i) => id === state.accountOrder[i]);
+        const sameAccounts = sameOrder && 
+            order.every(id => {
+                const existing = state.accounts[id];
+                const newAccount = accountMap[id];
+                return existing && 
+                    existing.sessionId === newAccount.sessionId &&
+                    existing.userId === newAccount.userId &&
+                    existing.avatar === newAccount.avatar &&
+                    existing.avatarUrl === newAccount.avatarUrl;
+            });
+        
+        if (sameAccounts) return {} as any;
+        
+        return { accounts: accountMap, accountOrder: order, accountsArray };
+    }),
+    
+    addAccount: (account) => set((state) => {
+        // Check if account with same sessionId exists
+        if (state.accounts[account.sessionId]) {
+            // Update existing
+            const existing = state.accounts[account.sessionId];
+            if (existing.avatar === account.avatar && existing.avatarUrl === account.avatarUrl) {
+                return {} as any; // No change
+            }
+            const newAccounts = { ...state.accounts, [account.sessionId]: account };
+            return {
+                accounts: newAccounts,
+                accountsArray: buildAccountsArray(newAccounts, state.accountOrder),
+            };
+        }
+        
+        const newAccounts = { ...state.accounts, [account.sessionId]: account };
+        const newOrder = [account.sessionId, ...state.accountOrder];
+        return {
+            accounts: newAccounts,
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(newAccounts, newOrder),
+        };
+    }),
+    
+    updateAccount: (sessionId, updates) => set((state) => {
+        const existing = state.accounts[sessionId];
+        if (!existing) return {} as any;
+        
+        const updated = { ...existing, ...updates };
+        if (existing.avatar === updated.avatar && existing.avatarUrl === updated.avatarUrl) {
+            return {} as any; // No change
+        }
+        
+        const newAccounts = { ...state.accounts, [sessionId]: updated };
+        return {
+            accounts: newAccounts,
+            accountsArray: buildAccountsArray(newAccounts, state.accountOrder),
+        };
+    }),
+    
+    removeAccount: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId]) return {} as any;
+        
+        const { [sessionId]: _removed, ...rest } = state.accounts;
+        const newOrder = state.accountOrder.filter(id => id !== sessionId);
+        
+        return {
+            accounts: rest,
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(rest, newOrder),
+        };
+    }),
+    
+    moveAccountToTop: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId]) return {} as any;
+        
+        const filtered = state.accountOrder.filter(id => id !== sessionId);
+        const newOrder = [sessionId, ...filtered];
+        
+        return {
+            accountOrder: newOrder,
+            accountsArray: buildAccountsArray(state.accounts, newOrder),
+        };
+    }),
+    
+    setLoading: (loading) => set({ loading }),
+    
+    setLoadingSession: (sessionId, loading) => set((state) => {
+        const newSet = new Set(state.loadingSessionIds);
+        if (loading) {
+            newSet.add(sessionId);
+        } else {
+            newSet.delete(sessionId);
+        }
+        return { loadingSessionIds: newSet };
+    }),
+    
+    setError: (error) => set({ error }),
+    
+    loadAccounts: async (sessionIds, oxyServices, existingAccounts = [], preserveOrder = true) => {
+        const state = get();
+        
+        const uniqueSessionIds = Array.from(new Set(sessionIds));
+        if (uniqueSessionIds.length === 0) {
+            get().setAccounts([]);
+            return;
+        }
+        
+        const existingMap = new Map(existingAccounts.map(a => [a.sessionId, a]));
+        for (const account of Object.values(state.accounts)) {
+            existingMap.set(account.sessionId, account);
+        }
+        
+        const missingSessionIds = uniqueSessionIds.filter(id => !existingMap.has(id));
+        
+        if (missingSessionIds.length === 0) {
+            const ordered = uniqueSessionIds
+                .map(id => existingMap.get(id))
+                .filter((acc): acc is QuickAccount => acc !== undefined);
+            get().setAccounts(ordered);
+            return;
+        }
+        
+        if (state.loading) {
+            return;
+        }
+        
+        set({ loading: true, error: null });
+        
+        try {
+            const batchResults = await oxyServices.getUsersBySessions(missingSessionIds);
+            
+            const accountMap = new Map<string, QuickAccount>();
+            
+            for (const { sessionId, user: userData } of batchResults) {
+                if (userData && !accountMap.has(sessionId)) {
+                    const existing = existingMap.get(sessionId);
+                    accountMap.set(sessionId, createQuickAccount(sessionId, userData, existing, oxyServices));
+                }
+            }
+            
+            for (const [sessionId, account] of accountMap) {
+                existingMap.set(sessionId, account);
+            }
+            
+            const orderToUse = preserveOrder ? uniqueSessionIds : [...uniqueSessionIds, ...state.accountOrder];
+            const seen = new Set<string>();
+            const ordered: QuickAccount[] = [];
+            
+            for (const sessionId of orderToUse) {
+                if (seen.has(sessionId)) continue;
+                seen.add(sessionId);
+                
+                const account = existingMap.get(sessionId);
+                if (account) ordered.push(account);
+            }
+            
+            get().setAccounts(ordered);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to load accounts';
+            if (__DEV__) {
+                console.error('AccountStore: Failed to load accounts:', error);
+            }
+            set({ error: errorMessage });
+        } finally {
+            set({ loading: false });
+        }
+    },
+    
+    reset: () => set(initialState),
+}));
+
+// Selectors for performance - return cached array to prevent infinite loops
+export const useAccounts = (): QuickAccount[] => {
+    return useAccountStore(state => state.accountsArray);
+};
+
+export const useAccountLoading = () => useAccountStore(s => s.loading);
+export const useAccountError = () => useAccountStore(s => s.error);
+export const useAccountLoadingSession = (sessionId: string) => 
+    useAccountStore(s => s.loadingSessionIds.has(sessionId));
+

package/src/ui/stores/authStore.ts

@@ -56,7 +56,8 @@ export const useAuthStore = create<AuthState>((set: (state: Partial<AuthState>)
     try {
       await oxyServices.updateProfile(updates);
       // Immediately fetch the latest user data after update
-      await useAuthStore.getState().fetchUser({ getCurrentUser: oxyServices.getCurrentUser }, true);
+      // Use arrow function to preserve 'this' context
+      await useAuthStore.getState().fetchUser({ getCurrentUser: () => oxyServices.getCurrentUser() }, true);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Failed to update user';
       if (__DEV__) {

package/src/ui/styles/authStyles.ts

@@ -191,13 +191,20 @@ export const createAuthStyles = (colors: AuthThemeColors, theme: string) => Styl
     paddingHorizontal: 32,
     borderRadius: 16,
     marginVertical: 8,
-    shadowOffset: {
-      width: 0,
-      height: 4,
-    },
-    shadowOpacity: 0.3,
-    shadowRadius: 8,
-    elevation: 6,
+    ...Platform.select({
+      web: {
+        boxShadow: '0 4px 8px rgba(0,0,0,0.3)',
+      },
+      default: {
+        shadowOffset: {
+          width: 0,
+          height: 4,
+        },
+        shadowOpacity: 0.3,
+        shadowRadius: 8,
+        elevation: 6,
+      }
+    }),
     gap: 8,
     width: '100%',
   },

package/src/utils/asyncUtils.ts

@@ -2,6 +2,8 @@
  * Async utilities for common asynchronous patterns and error handling
  */
 
+import { TTLCache, registerCacheForCleanup } from './cache';
+
 /**
  * Wrapper for async operations with automatic error handling
  */
@@ -196,36 +198,20 @@ export async function withTimeout<T>(
 
 /**
  * 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
 ) {
-  const cache = new Map<string, { data: T; timestamp: number }>();
+  const cache = new TTLCache<T>(ttl);
+  registerCacheForCleanup(cache);
   
   return {
-    get: (key: string): T | null => {
-      const item = cache.get(key);
-      if (!item) return null;
-      
-      if (Date.now() - item.timestamp > ttl) {
-        cache.delete(key);
-        return null;
-      }
-      
-      return item.data;
-    },
-    
-    set: (key: string, data: T): void => {
-      cache.set(key, { data, timestamp: Date.now() });
-    },
-    
-    clear: (): void => {
-      cache.clear();
-    },
-    
-    delete: (key: string): boolean => {
-      return cache.delete(key);
-    }
+    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),
   };
 }
 

package/src/utils/cache.ts

@@ -0,0 +1,264 @@
+/**
+ * Centralized cache utility with TTL support
+ * 
+ * This is a production-ready cache implementation used across the codebase
+ * for consistent caching behavior and performance optimization.
+ */
+
+/**
+ * Cache entry with expiration tracking
+ */
+interface CacheEntry<T> {
+  data: T;
+  timestamp: number;
+  expiresAt: number;
+}
+
+/**
+ * Cache statistics
+ */
+export interface CacheStats {
+  size: number;
+  hits: number;
+  misses: number;
+  hitRate: number;
+}
+
+/**
+ * TTL-based cache implementation
+ * 
+ * Features:
+ * - Automatic expiration based on TTL
+ * - Manual cleanup of expired entries
+ * - Statistics tracking (hits, misses, hit rate)
+ * - Type-safe generic interface
+ * 
+ * @example
+ * ```typescript
+ * const cache = new TTLCache<string>(5 * 60 * 1000); // 5 minutes
+ * 
+ * // Set with default TTL
+ * cache.set('key', 'value');
+ * 
+ * // Set with custom TTL
+ * cache.set('key', 'value', 10 * 60 * 1000); // 10 minutes
+ * 
+ * // Get value
+ * const value = cache.get('key');
+ * 
+ * // Get statistics
+ * const stats = cache.getStats();
+ * ```
+ */
+export class TTLCache<T> {
+  private cache = new Map<string, CacheEntry<T>>();
+  private defaultTTL: number;
+  private hits = 0;
+  private misses = 0;
+
+  /**
+   * Create a new TTL cache
+   * @param defaultTTL Default TTL in milliseconds (default: 5 minutes)
+   */
+  constructor(defaultTTL: number = 5 * 60 * 1000) {
+    this.defaultTTL = defaultTTL;
+  }
+
+  /**
+   * Get a value from cache
+   * @param key Cache key
+   * @returns Cached value or null if not found or expired
+   */
+  get(key: string): T | null {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+
+    const now = Date.now();
+    if (now > entry.expiresAt) {
+      this.cache.delete(key);
+      this.misses++;
+      return null;
+    }
+
+    this.hits++;
+    return entry.data;
+  }
+
+  /**
+   * Set a value in cache
+   * @param key Cache key
+   * @param data Data to cache
+   * @param ttl Optional TTL override (uses default if not provided)
+   */
+  set(key: string, data: T, ttl?: number): void {
+    const now = Date.now();
+    const expiresAt = now + (ttl || this.defaultTTL);
+    this.cache.set(key, { data, timestamp: now, expiresAt });
+  }
+
+  /**
+   * Delete a specific cache entry
+   * @param key Cache key
+   * @returns true if entry was deleted, false if not found
+   */
+  delete(key: string): boolean {
+    return this.cache.delete(key);
+  }
+
+  /**
+   * Clear all cache entries
+   */
+  clear(): void {
+    this.cache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+
+  /**
+   * Check if a key exists and is not expired
+   * @param key Cache key
+   * @returns true if key exists and is valid
+   */
+  has(key: string): boolean {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Get all valid cache keys
+   * @returns Array of valid cache keys
+   */
+  keys(): string[] {
+    const now = Date.now();
+    const validKeys: string[] = [];
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (now <= entry.expiresAt) {
+        validKeys.push(key);
+      } else {
+        this.cache.delete(key);
+      }
+    }
+
+    return validKeys;
+  }
+
+  /**
+   * Clean up expired entries
+   * @returns Number of entries removed
+   */
+  cleanup(): number {
+    const now = Date.now();
+    let removed = 0;
+
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expiresAt) {
+        this.cache.delete(key);
+        removed++;
+      }
+    }
+
+    return removed;
+  }
+
+  /**
+   * Get cache size (number of entries)
+   */
+  size(): number {
+    return this.cache.size;
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats(): CacheStats {
+    const total = this.hits + this.misses;
+    return {
+      size: this.cache.size,
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0,
+    };
+  }
+
+  /**
+   * Reset statistics (keeps cache entries)
+   */
+  resetStats(): void {
+    this.hits = 0;
+    this.misses = 0;
+  }
+}
+
+/**
+ * Create a TTL cache instance (convenience function)
+ * 
+ * @example
+ * ```typescript
+ * const cache = createCache<string>(5 * 60 * 1000);
+ * ```
+ */
+export function createCache<T>(ttl: number = 5 * 60 * 1000): TTLCache<T> {
+  return new TTLCache<T>(ttl);
+}
+
+/**
+ * Global cache cleanup interval (runs every minute)
+ * This helps prevent memory leaks from expired cache entries
+ */
+let cleanupInterval: NodeJS.Timeout | null = null;
+const activeCaches = new Set<TTLCache<any>>();
+
+/**
+ * Register a cache for automatic cleanup
+ * @param cache Cache instance to register
+ */
+export function registerCacheForCleanup(cache: TTLCache<any>): void {
+  activeCaches.add(cache);
+
+  // Start cleanup interval if not already running
+  if (!cleanupInterval) {
+    cleanupInterval = setInterval(() => {
+      for (const cache of activeCaches) {
+        cache.cleanup();
+      }
+    }, 60000); // Every minute
+  }
+}
+
+/**
+ * Unregister a cache from automatic cleanup
+ * @param cache Cache instance to unregister
+ */
+export function unregisterCacheFromCleanup(cache: TTLCache<any>): void {
+  activeCaches.delete(cache);
+
+  // Stop cleanup interval if no caches are registered
+  if (activeCaches.size === 0 && cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+  }
+}
+
+/**
+ * Stop all cache cleanup intervals
+ * Useful for tests to prevent Jest from hanging
+ */
+export function stopAllCacheCleanup(): void {
+  if (cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+  }
+  activeCaches.clear();
+}
+

package/src/utils/index.ts

@@ -1,2 +1,21 @@
 export { DeviceManager } from './deviceManager';
 export type { DeviceFingerprint, StoredDeviceInfo } from './deviceManager';
+
+// Request utilities
+export { RequestDeduplicator, RequestQueue, SimpleLogger } from './requestUtils';
+
+// Cache utilities
+export { TTLCache, createCache, registerCacheForCleanup, unregisterCacheFromCleanup, stopAllCacheCleanup } from './cache';
+export type { CacheStats } from './cache';
+
+// Session utilities
+export { 
+  normalizeSession, 
+  sortSessions, 
+  deduplicateSessions,
+  deduplicateSessionsByUserId,
+  normalizeAndSortSessions, 
+  mergeSessions, 
+  sessionsEqual, 
+  sessionsArraysEqual 
+} from './sessionUtils';