@oxyhq/services 5.21.5 → 5.21.7

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

@@ -1,8 +1,8 @@
 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';
+import { authenticatedApiCall } from '../../utils/authHelpers';
 
 /**
  * Get user profile by session ID
@@ -138,38 +138,11 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
         throw new Error('User ID is required');
       }
 
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          // If getting token fails, might be an offline session - try syncing
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer (e.g., accounts app's useIdentity hook)
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
-        return await oxyServices.getPrivacySettings(targetUserId);
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      return authenticatedApiCall(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getPrivacySettings(targetUserId)
+      );
     },
     enabled: (options?.enabled !== false) && !!targetUserId,
     staleTime: 2 * 60 * 1000, // 2 minutes

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

@@ -3,6 +3,7 @@ import type { ClientSession } from '../../../models/session';
 import { queryKeys } from './queryKeys';
 import { useOxy } from '../../context/OxyContext';
 import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
+import { authenticatedApiCall } from '../../utils/authHelpers';
 
 /**
  * Get all active sessions for the current user
@@ -94,38 +95,11 @@ export const useUserDevices = (options?: { enabled?: boolean }) => {
   return useQuery({
     queryKey: queryKeys.devices.list(),
     queryFn: async () => {
-      // Ensure we have a valid token before making the request
-      if (!oxyServices.hasValidToken() && activeSessionId) {
-        try {
-          // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId);
-        } catch (tokenError) {
-          // If getting token fails, might be an offline session - try syncing
-          const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
-          if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
-            // Session sync should be handled by the app layer
-            throw new Error('Session needs to be synced. Please try again.');
-          } else {
-            throw tokenError;
-          }
-        }
-      }
-
-      try {
-        return await oxyServices.getUserDevices();
-      } catch (error: any) {
-        const errorMessage = error?.message || '';
-        const status = error?.status || error?.response?.status;
-        
-        // Handle authentication errors
-        if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          // Session sync should be handled by the app layer
-          throw new Error('Authentication failed. Please sign in again.');
-        }
-        
-        // TanStack Query will automatically retry on network errors
-        throw error;
-      }
+      return authenticatedApiCall(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.getUserDevices()
+      );
     },
     enabled: (options?.enabled !== false) && isAuthenticated,
     staleTime: 5 * 60 * 1000,

package/src/ui/hooks/useFileFiltering.ts

@@ -0,0 +1,115 @@
+import { useMemo, useState, useCallback } from 'react';
+import type { FileMetadata } from '../../models/interfaces';
+
+export type ViewMode = 'all' | 'photos' | 'videos' | 'documents' | 'audio';
+export type SortBy = 'date' | 'size' | 'name' | 'type';
+export type SortOrder = 'asc' | 'desc';
+
+interface UseFileFilteringOptions {
+  files: FileMetadata[];
+  initialViewMode?: ViewMode;
+  initialSortBy?: SortBy;
+  initialSortOrder?: SortOrder;
+}
+
+interface UseFileFilteringReturn {
+  filteredFiles: FileMetadata[];
+  viewMode: ViewMode;
+  setViewMode: (mode: ViewMode) => void;
+  searchQuery: string;
+  setSearchQuery: (query: string) => void;
+  sortBy: SortBy;
+  setSortBy: (sort: SortBy) => void;
+  sortOrder: SortOrder;
+  setSortOrder: (order: SortOrder) => void;
+  toggleSortOrder: () => void;
+}
+
+/**
+ * Hook for file filtering, sorting, and search functionality
+ * Extracts common file management logic for reuse across components
+ */
+export function useFileFiltering({
+  files,
+  initialViewMode = 'all',
+  initialSortBy = 'date',
+  initialSortOrder = 'desc',
+}: UseFileFilteringOptions): UseFileFilteringReturn {
+  const [viewMode, setViewMode] = useState<ViewMode>(initialViewMode);
+  const [searchQuery, setSearchQuery] = useState('');
+  const [sortBy, setSortBy] = useState<SortBy>(initialSortBy);
+  const [sortOrder, setSortOrder] = useState<SortOrder>(initialSortOrder);
+
+  const toggleSortOrder = useCallback(() => {
+    setSortOrder((prev) => (prev === 'asc' ? 'desc' : 'asc'));
+  }, []);
+
+  const filteredFiles = useMemo(() => {
+    // Filter by view mode
+    let filteredByMode = files;
+    if (viewMode === 'photos') {
+      filteredByMode = files.filter((file) => file.contentType.startsWith('image/'));
+    } else if (viewMode === 'videos') {
+      filteredByMode = files.filter((file) => file.contentType.startsWith('video/'));
+    } else if (viewMode === 'documents') {
+      filteredByMode = files.filter(
+        (file) =>
+          file.contentType.includes('pdf') ||
+          file.contentType.includes('document') ||
+          file.contentType.includes('text') ||
+          file.contentType.includes('msword') ||
+          file.contentType.includes('excel') ||
+          file.contentType.includes('spreadsheet') ||
+          file.contentType.includes('presentation') ||
+          file.contentType.includes('powerpoint')
+      );
+    } else if (viewMode === 'audio') {
+      filteredByMode = files.filter((file) => file.contentType.startsWith('audio/'));
+    }
+
+    // Filter by search query
+    let filtered = filteredByMode;
+    if (searchQuery.trim()) {
+      const query = searchQuery.toLowerCase();
+      filtered = filteredByMode.filter(
+        (file) =>
+          file.filename.toLowerCase().includes(query) ||
+          file.contentType.toLowerCase().includes(query) ||
+          (file.metadata?.description &&
+            file.metadata.description.toLowerCase().includes(query))
+      );
+    }
+
+    // Sort files
+    const sorted = [...filtered].sort((a, b) => {
+      let comparison = 0;
+      if (sortBy === 'date') {
+        const dateA = new Date(a.uploadDate || 0).getTime();
+        const dateB = new Date(b.uploadDate || 0).getTime();
+        comparison = dateA - dateB;
+      } else if (sortBy === 'size') {
+        comparison = (a.length || 0) - (b.length || 0);
+      } else if (sortBy === 'name') {
+        comparison = (a.filename || '').localeCompare(b.filename || '');
+      } else if (sortBy === 'type') {
+        comparison = (a.contentType || '').localeCompare(b.contentType || '');
+      }
+      return sortOrder === 'asc' ? comparison : -comparison;
+    });
+
+    return sorted;
+  }, [files, searchQuery, viewMode, sortBy, sortOrder]);
+
+  return {
+    filteredFiles,
+    viewMode,
+    setViewMode,
+    searchQuery,
+    setSearchQuery,
+    sortBy,
+    setSortBy,
+    sortOrder,
+    setSortOrder,
+    toggleSortOrder,
+  };
+}

package/src/ui/navigation/bottomSheetManager.ts

@@ -3,189 +3,82 @@ import { isValidRoute } from './routes';
 import { createStore } from 'zustand/vanilla';
 
 /**
- * Bottom Sheet Manager - Pure state management module
- * 
- * Uses Zustand (vanilla) for robust state management without React dependencies.
- * This ensures the manager can be imported safely anywhere.
+ * Bottom Sheet State Manager
  */
 
-export interface NavigationHistoryEntry {
-    screen: RouteName;
-    props: Record<string, unknown>;
-    step?: number; // For step-based screens
-}
-
-export interface BottomSheetRouterState {
+export interface BottomSheetState {
     currentScreen: RouteName | null;
     screenProps: Record<string, unknown>;
-    currentStep?: number; // Current step in step-based screen
-    navigationHistory: NavigationHistoryEntry[];
+    currentStep?: number;
+    history: Array<{ screen: RouteName; props: Record<string, unknown>; step?: number }>;
     isOpen: boolean;
 }
 
-// Initial state
-const initialState: BottomSheetRouterState = {
+const initialState: BottomSheetState = {
     currentScreen: null,
     screenProps: {},
     currentStep: undefined,
-    navigationHistory: [],
+    history: [],
     isOpen: false,
 };
 
-// Create vanilla store
-export const bottomSheetStore = createStore<BottomSheetRouterState>(() => initialState);
+export const bottomSheetStore = createStore<BottomSheetState>(() => initialState);
 
-// Use a generic ref type to avoid importing React types
-type BottomSheetRefObject = { current: { present: () => void; dismiss: () => void } | null } | null;
-let bottomSheetRef: BottomSheetRefObject = null;
-
-/**
- * Set the bottom sheet ref so showBottomSheet can control it
- */
-export const setBottomSheetRef = (ref: BottomSheetRefObject) => {
-    bottomSheetRef = ref;
-};
+export const getState = () => bottomSheetStore.getState();
 
-/**
- * Update the bottom sheet state
- * (Kept for backward compatibility, but prefer using store directly if possible)
- */
-export const updateBottomSheetState = (updates: Partial<BottomSheetRouterState>) => {
-    bottomSheetStore.setState((state) => ({ ...state, ...updates }));
-};
+export const showBottomSheet = (
+    screenOrConfig: RouteName | { screen: RouteName; props?: Record<string, unknown> },
+): void => {
+    const screen = typeof screenOrConfig === 'string' ? screenOrConfig : screenOrConfig.screen;
+    const props = typeof screenOrConfig === 'string' ? {} : (screenOrConfig.props || {});
 
-/**
- * Subscribe to bottom sheet state changes
- * (Wrapper around store.subscribe for backward compatibility)
- */
-export const subscribeToBottomSheetState = (listener: (state: BottomSheetRouterState) => void) => {
-    return bottomSheetStore.subscribe(listener);
-};
+    if (!isValidRoute(screen)) {
+        if (__DEV__) console.warn(`[BottomSheet] Invalid route: ${screen}`);
+        return;
+    }
 
-/**
- * Get the current bottom sheet state
- * (Wrapper around store.getState for backward compatibility)
- */
-export const getBottomSheetState = (): BottomSheetRouterState => {
-    return bottomSheetStore.getState();
-};
+    const state = bottomSheetStore.getState();
 
-/**
- * Show the bottom sheet with a specific screen (internal - no route validation)
- */
-export const managerShowBottomSheet = (
-    screen: RouteName,
-    props?: Record<string, unknown>,
-    options?: { addToHistory?: boolean; step?: number },
-): void => {
-    const currentState = bottomSheetStore.getState();
-    const addToHistory = options?.addToHistory !== false; // Default to true
-    
-    // If adding to history and there's a current screen, push it to history
-    if (addToHistory && currentState.currentScreen) {
-        const historyEntry: NavigationHistoryEntry = {
-            screen: currentState.currentScreen,
-            props: { ...currentState.screenProps },
-            step: currentState.currentStep,
-        };
-        
-        // We need to create a new array for immutability
-        const newHistory = [...currentState.navigationHistory, historyEntry];
-        bottomSheetStore.setState({ navigationHistory: newHistory });
+    // Push current screen to history if navigating to different screen
+    if (state.currentScreen && state.currentScreen !== screen) {
+        bottomSheetStore.setState({
+            history: [...state.history, {
+                screen: state.currentScreen,
+                props: state.screenProps,
+                step: state.currentStep,
+            }],
+        });
     }
-    
-    // Determine the new step
-    const newStep = options?.step ?? 
-        (props?.initialStep !== undefined ? props.initialStep : 
-         (addToHistory ? undefined : currentState.currentStep));
-    
+
     bottomSheetStore.setState({
         currentScreen: screen,
-        screenProps: props || {},
-        currentStep: newStep !== null && newStep !== undefined ? (newStep as number) : undefined,
+        screenProps: props,
+        currentStep: typeof props.initialStep === 'number' ? props.initialStep : undefined,
         isOpen: true,
     });
-
-    // Present the sheet after state update
-    if (bottomSheetRef?.current) {
-        bottomSheetRef.current.present();
-    }
 };
 
-/**
- * Close the bottom sheet (internal)
- */
-export const managerCloseBottomSheet = (): void => {
-    bottomSheetStore.setState({
-        currentScreen: null,
-        screenProps: {},
-        currentStep: undefined,
-        navigationHistory: [],
-        isOpen: false,
-    });
-
-    if (bottomSheetRef?.current) {
-        bottomSheetRef.current.dismiss();
-    }
+export const closeBottomSheet = (): void => {
+    bottomSheetStore.setState(initialState);
 };
 
-/**
- * Go back in navigation history
- * Returns true if back navigation was successful, false if history is empty
- */
-export const managerGoBack = (): boolean => {
-    const currentState = bottomSheetStore.getState();
+export const goBack = (): boolean => {
+    const { history } = bottomSheetStore.getState();
 
-    // If there's history, pop and navigate to previous screen
-    if (currentState.navigationHistory.length > 0) {
-        const previous = currentState.navigationHistory[currentState.navigationHistory.length - 1];
-        const newHistory = currentState.navigationHistory.slice(0, -1);
-        
+    if (history.length > 0) {
+        const prev = history[history.length - 1];
         bottomSheetStore.setState({
-            currentScreen: previous.screen,
-            screenProps: previous.props,
-            currentStep: previous.step,
-            navigationHistory: newHistory,
-            isOpen: true,
+            currentScreen: prev.screen,
+            screenProps: prev.props,
+            currentStep: prev.step,
+            history: history.slice(0, -1),
         });
-        
         return true;
     }
-    
-    return false;
-};
-
-/**
- * Public API for showing bottom sheets
- */
-export const showBottomSheet = (
-    screenOrConfig: RouteName | { screen: RouteName; props?: Record<string, unknown> },
-): void => {
-    let screen: RouteName;
-    let props: Record<string, unknown> = {};
-
-    if (typeof screenOrConfig === 'string') {
-        screen = screenOrConfig;
-    } else {
-        screen = screenOrConfig.screen;
-        props = screenOrConfig.props || {};
-    }
-
-    if (!isValidRoute(screen)) {
-        if (__DEV__) {
-            console.warn(`[BottomSheetAPI] Invalid route: ${screen}`);
-        }
-        return;
-    }
 
-    managerShowBottomSheet(screen, props);
+    return false;
 };
 
-/**
- * Public API for closing bottom sheets
- */
-export const closeBottomSheet = (): void => {
-    managerCloseBottomSheet();
+export const updateState = (updates: Partial<BottomSheetState>) => {
+    bottomSheetStore.setState((state) => ({ ...state, ...updates }));
 };
-
-

package/src/ui/screens/AccountSettingsScreen.tsx

@@ -29,7 +29,6 @@ import { useThemeStyles } from '../hooks/useThemeStyles';
 import { useColorScheme } from '../hooks/use-color-scheme';
 import { Colors } from '../constants/theme';
 import { normalizeColorScheme, normalizeTheme } from '../utils/themeUtils';
-import { useHapticPress } from '../hooks/use-haptic-press';
 import { EditDisplayNameModal } from '../components/profile/EditDisplayNameModal';
 import { EditUsernameModal } from '../components/profile/EditUsernameModal';
 import { EditEmailModal } from '../components/profile/EditEmailModal';
@@ -176,7 +175,6 @@ const AccountSettingsScreen: React.FC<BaseScreenProps & { initialField?: string;
     // Get theme colors using centralized hook
     const colorScheme = useColorScheme();
     const themeStyles = useThemeStyles(theme || 'light', colorScheme);
-    const handlePressIn = useHapticPress();
 
     // Extract colors for convenience - ensure it's always defined
     // useThemeStyles always returns colors, but add safety check for edge cases

package/src/ui/screens/FileManagementScreen.tsx

@@ -549,8 +549,8 @@ const FileManagementScreen: React.FC<FileManagementScreenProps> = ({
                     });
 
                     // Attempt to refresh file list incrementally – fetch single file metadata if API allows
-                    if (result?.file || result?.files?.[0]) {
-                        const f = result.file || result.files[0];
+                    const f = result?.file ?? result?.files?.[0];
+                    if (f) {
                         const merged: FileMetadata = {
                             id: f.id,
                             filename: f.originalName || f.sha256 || raw.name,

package/src/ui/utils/authHelpers.ts

@@ -0,0 +1,183 @@
+/**
+ * Authentication helper utilities to reduce code duplication across hooks and utilities.
+ * These functions handle common token validation and authentication error patterns.
+ */
+
+import type { OxyServices } from '../../core';
+
+/**
+ * Error thrown when session sync is required
+ */
+export class SessionSyncRequiredError extends Error {
+  constructor(message = 'Session needs to be synced. Please try again.') {
+    super(message);
+    this.name = 'SessionSyncRequiredError';
+  }
+}
+
+/**
+ * Error thrown when authentication fails
+ */
+export class AuthenticationFailedError extends Error {
+  constructor(message = 'Authentication failed. Please sign in again.') {
+    super(message);
+    this.name = 'AuthenticationFailedError';
+  }
+}
+
+/**
+ * Ensures a valid token exists before making authenticated API calls.
+ * If no valid token exists and an active session ID is available,
+ * attempts to refresh the token using the session.
+ *
+ * @param oxyServices - The OxyServices instance
+ * @param activeSessionId - The active session ID (if available)
+ * @throws {SessionSyncRequiredError} If the session needs to be synced (offline session)
+ * @throws {Error} If token refresh fails for other reasons
+ *
+ * @example
+ * ```ts
+ * // In a mutation or query function:
+ * await ensureValidToken(oxyServices, activeSessionId);
+ * return await oxyServices.updateProfile(updates);
+ * ```
+ */
+export async function ensureValidToken(
+  oxyServices: OxyServices,
+  activeSessionId: string | null | undefined
+): Promise<void> {
+  if (oxyServices.hasValidToken() || !activeSessionId) {
+    return;
+  }
+
+  try {
+    await oxyServices.getTokenBySession(activeSessionId);
+  } catch (tokenError) {
+    const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+
+    if (errorMessage.includes('AUTH_REQUIRED_OFFLINE_SESSION') || errorMessage.includes('offline')) {
+      throw new SessionSyncRequiredError();
+    }
+
+    throw tokenError;
+  }
+}
+
+/**
+ * Options for handling API authentication errors
+ */
+export interface HandleApiErrorOptions {
+  /** Optional callback to attempt session sync and retry */
+  syncSession?: () => Promise<unknown>;
+  /** The active session ID for retry attempts */
+  activeSessionId?: string | null;
+  /** The OxyServices instance for retry attempts */
+  oxyServices?: OxyServices;
+}
+
+/**
+ * Checks if an error is an authentication error (401 or auth-related message)
+ *
+ * @param error - The error to check
+ * @returns True if the error is an authentication error
+ */
+export function isAuthenticationError(error: unknown): boolean {
+  if (!error || typeof error !== 'object') {
+    return false;
+  }
+
+  const errorObj = error as { message?: string; status?: number; response?: { status?: number } };
+  const errorMessage = errorObj.message || '';
+  const status = errorObj.status || errorObj.response?.status;
+
+  return (
+    status === 401 ||
+    errorMessage.includes('Authentication required') ||
+    errorMessage.includes('Invalid or missing authorization header')
+  );
+}
+
+/**
+ * Wraps an API call with authentication error handling.
+ * If an authentication error occurs, it can optionally attempt to sync the session and retry.
+ *
+ * @param apiCall - The API call function to execute
+ * @param options - Optional error handling configuration
+ * @returns The result of the API call
+ * @throws {AuthenticationFailedError} If authentication fails and cannot be recovered
+ * @throws {Error} If the API call fails for non-auth reasons
+ *
+ * @example
+ * ```ts
+ * // Simple usage:
+ * const result = await withAuthErrorHandling(
+ *   () => oxyServices.updateProfile(updates)
+ * );
+ *
+ * // With retry on auth failure:
+ * const result = await withAuthErrorHandling(
+ *   () => oxyServices.updateProfile(updates),
+ *   { syncSession, activeSessionId, oxyServices }
+ * );
+ * ```
+ */
+export async function withAuthErrorHandling<T>(
+  apiCall: () => Promise<T>,
+  options?: HandleApiErrorOptions
+): Promise<T> {
+  try {
+    return await apiCall();
+  } catch (error) {
+    if (!isAuthenticationError(error)) {
+      throw error;
+    }
+
+    // If we have sync capabilities, try to recover
+    if (options?.syncSession && options?.activeSessionId && options?.oxyServices) {
+      try {
+        await options.syncSession();
+        await options.oxyServices.getTokenBySession(options.activeSessionId);
+        // Retry the API call after refreshing token
+        return await apiCall();
+      } catch {
+        throw new AuthenticationFailedError();
+      }
+    }
+
+    throw new AuthenticationFailedError();
+  }
+}
+
+/**
+ * Combines token validation and auth error handling for a complete authenticated API call.
+ * This is the recommended helper for most authenticated API operations.
+ *
+ * @param oxyServices - The OxyServices instance
+ * @param activeSessionId - The active session ID
+ * @param apiCall - The API call function to execute
+ * @param syncSession - Optional callback to sync session on auth failure
+ * @returns The result of the API call
+ *
+ * @example
+ * ```ts
+ * return await authenticatedApiCall(
+ *   oxyServices,
+ *   activeSessionId,
+ *   () => oxyServices.updateProfile(updates)
+ * );
+ * ```
+ */
+export async function authenticatedApiCall<T>(
+  oxyServices: OxyServices,
+  activeSessionId: string | null | undefined,
+  apiCall: () => Promise<T>,
+  syncSession?: () => Promise<unknown>
+): Promise<T> {
+  await ensureValidToken(oxyServices, activeSessionId);
+
+  return withAuthErrorHandling(apiCall, {
+    syncSession,
+    activeSessionId,
+    oxyServices,
+  });
+}