@oxyhq/services 5.13.40 → 5.15.0

package/src/ui/context/utils/sessionHelpers.ts

@@ -0,0 +1,146 @@
+import type { OxyServices } from '../../../core';
+import type { ClientSession } from '../../../models/session';
+
+interface DeviceSession {
+  sessionId: string;
+  deviceId?: string;
+  deviceName?: string;
+  expiresAt?: string;
+  lastActive?: string;
+  user?: { id?: string; _id?: { toString(): string } };
+  userId?: string;
+  isCurrent?: boolean;
+}
+
+export interface FetchSessionsWithFallbackOptions {
+  fallbackDeviceId?: string;
+  fallbackUserId?: string;
+  logger?: (message: string, error?: unknown) => void;
+}
+
+export interface ValidateSessionBatchOptions {
+  useHeaderValidation?: boolean;
+  maxConcurrency?: number;
+}
+
+export interface SessionValidationResult {
+  sessionId: string;
+  valid: boolean;
+  user?: unknown;
+  raw?: unknown;
+  error?: unknown;
+}
+
+/**
+ * Normalize backend session payloads into `ClientSession` objects.
+ *
+ * @param sessions - Raw session array returned from the API
+ * @param fallbackDeviceId - Device identifier to use when missing from payload
+ * @param fallbackUserId - User identifier to use when missing from payload
+ */
+export const mapSessionsToClient = (
+  sessions: DeviceSession[],
+  fallbackDeviceId?: string,
+  fallbackUserId?: string,
+): ClientSession[] => {
+  const now = new Date();
+
+  return sessions.map((session) => ({
+    sessionId: session.sessionId,
+    deviceId: session.deviceId || fallbackDeviceId || '',
+    expiresAt: session.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+    lastActive: session.lastActive || now.toISOString(),
+    userId:
+      session.user?.id ||
+      session.userId ||
+      (session.user?._id ? session.user._id.toString() : undefined) ||
+      fallbackUserId ||
+      '',
+    isCurrent: Boolean(session.isCurrent),
+  }));
+};
+
+/**
+ * Fetch device sessions with fallback to the legacy session endpoint when needed.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionId - Session identifier to fetch
+ * @param options - Optional fallback options
+ */
+export const fetchSessionsWithFallback = async (
+  oxyServices: Pick<OxyServices, 'getDeviceSessions' | 'getSessionsBySessionId'>,
+  sessionId: string,
+  {
+    fallbackDeviceId,
+    fallbackUserId,
+    logger,
+  }: FetchSessionsWithFallbackOptions = {},
+): Promise<ClientSession[]> => {
+  try {
+    const deviceSessions = await oxyServices.getDeviceSessions(sessionId);
+    return mapSessionsToClient(deviceSessions, fallbackDeviceId, fallbackUserId);
+  } catch (error) {
+    if (__DEV__ && logger) {
+      logger('Failed to get device sessions, falling back to user sessions', error);
+    } else if (__DEV__) {
+      console.warn('Failed to get device sessions, falling back to user sessions:', error);
+    }
+
+    const userSessions = await oxyServices.getSessionsBySessionId(sessionId);
+    return mapSessionsToClient(userSessions, fallbackDeviceId, fallbackUserId);
+  }
+};
+
+/**
+ * Validate multiple sessions concurrently with configurable concurrency.
+ *
+ * @param oxyServices - Oxy service instance
+ * @param sessionIds - Session identifiers to validate
+ * @param options - Validation options
+ */
+export const validateSessionBatch = async (
+  oxyServices: Pick<OxyServices, 'validateSession'>,
+  sessionIds: string[],
+  { useHeaderValidation = true, maxConcurrency = 5 }: ValidateSessionBatchOptions = {},
+): Promise<SessionValidationResult[]> => {
+  if (!sessionIds.length) {
+    return [];
+  }
+
+  const uniqueSessionIds = Array.from(new Set(sessionIds));
+  const safeConcurrency = Math.max(1, Math.min(maxConcurrency, uniqueSessionIds.length));
+  const results: SessionValidationResult[] = [];
+  let index = 0;
+
+  const worker = async () => {
+    while (index < uniqueSessionIds.length) {
+      const currentIndex = index;
+      index += 1;
+      const sessionId = uniqueSessionIds[currentIndex];
+
+      try {
+        const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation });
+        const valid = Boolean(validation?.valid);
+
+        results.push({
+          sessionId,
+          valid,
+          user: validation?.user,
+          raw: validation,
+        });
+      } catch (error) {
+        results.push({
+          sessionId,
+          valid: false,
+          error,
+        });
+      }
+    }
+  };
+
+  await Promise.all(Array.from({ length: safeConcurrency }, worker));
+
+  return results;
+};
+
+

package/src/ui/context/utils/storageHelpers.ts

@@ -0,0 +1,134 @@
+export interface StorageInterface {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+  clear: () => Promise<void>;
+}
+
+export interface SessionStorageKeys {
+  activeSessionId: string;
+  sessionIds: string;
+  language: string;
+}
+
+export interface CreateStorageOptions {
+  prefix?: string;
+}
+
+/**
+ * Create an in-memory storage implementation used as a safe fallback.
+ */
+const MEMORY_STORAGE = (): StorageInterface => {
+  const store = new Map<string, string>();
+
+  return {
+    async getItem(key: string) {
+      return store.has(key) ? store.get(key)! : null;
+    },
+    async setItem(key: string, value: string) {
+      store.set(key, value);
+    },
+    async removeItem(key: string) {
+      store.delete(key);
+    },
+    async clear() {
+      store.clear();
+    },
+  };
+};
+
+/**
+ * Create a web storage implementation backed by `localStorage`.
+ * Falls back to in-memory storage when unavailable.
+ */
+const createWebStorage = (): StorageInterface => {
+  if (typeof window === 'undefined' || typeof window.localStorage === 'undefined') {
+    return MEMORY_STORAGE();
+  }
+
+  return {
+    async getItem(key: string) {
+      try {
+        return window.localStorage.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    async setItem(key: string, value: string) {
+      try {
+        window.localStorage.setItem(key, value);
+      } catch {
+        // Ignore quota or access issues for now.
+      }
+    },
+    async removeItem(key: string) {
+      try {
+        window.localStorage.removeItem(key);
+      } catch {
+        // Ignore failures.
+      }
+    },
+    async clear() {
+      try {
+        window.localStorage.clear();
+      } catch {
+        // Ignore failures.
+      }
+    },
+  };
+};
+
+let asyncStorageInstance: StorageInterface | null = null;
+
+/**
+ * Lazily import React Native AsyncStorage implementation.
+ */
+const createNativeStorage = async (): Promise<StorageInterface> => {
+  if (asyncStorageInstance) {
+    return asyncStorageInstance;
+  }
+
+  try {
+    const asyncStorageModule = await import('@react-native-async-storage/async-storage');
+    asyncStorageInstance = asyncStorageModule.default as unknown as StorageInterface;
+    return asyncStorageInstance;
+  } catch (error) {
+    if (__DEV__) {
+      console.error('Failed to import AsyncStorage:', error);
+    }
+    throw new Error('AsyncStorage is required in React Native environment');
+  }
+};
+
+/**
+ * Detect whether the current runtime is React Native.
+ */
+export const isReactNative = (): boolean =>
+  typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+
+/**
+ * Create a platform-appropriate storage implementation.
+ * Defaults to in-memory storage when no platform storage is available.
+ */
+export const createPlatformStorage = async (): Promise<StorageInterface> => {
+  if (isReactNative()) {
+    return createNativeStorage();
+  }
+
+  return createWebStorage();
+};
+
+export const STORAGE_KEY_PREFIX = 'oxy_session';
+
+/**
+ * Produce strongly typed storage key names for the supplied prefix.
+ *
+ * @param prefix - Storage key prefix
+ */
+export const getStorageKeys = (prefix: string = STORAGE_KEY_PREFIX): SessionStorageKeys => ({
+  activeSessionId: `${prefix}_active_session_id`,
+  sessionIds: `${prefix}_session_ids`,
+  language: `${prefix}_language`,
+});
+
+

package/src/ui/hooks/index.ts

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

package/src/ui/hooks/use-color-scheme.ts

@@ -0,0 +1,24 @@
+import { useContext } from 'react';
+import { useColorScheme as useRNColorScheme } from 'react-native';
+import { ThemeContext } from '../context/ThemeContext';
+
+/**
+ * Hook to get the current color scheme (theme).
+ * Returns the resolved theme from ThemeContext if available, otherwise falls back to React Native's useColorScheme.
+ * 
+ * Always calls hooks in the same order to maintain React hook rules.
+ */
+export function useColorScheme(): 'light' | 'dark' {
+  // Always call hooks in the same order - never conditionally
+  const rnColorScheme = useRNColorScheme();
+  const themeContext = useContext(ThemeContext);
+  
+  // If ThemeContext is available, use it; otherwise fall back to React Native's color scheme
+  if (themeContext?.resolvedTheme) {
+    return themeContext.resolvedTheme;
+  }
+  
+  // Fall back to React Native's color scheme detection
+  return (rnColorScheme ?? 'light') as 'light' | 'dark';
+}
+

package/src/ui/hooks/use-haptic-press.ts

@@ -0,0 +1,15 @@
+import { useCallback } from 'react';
+import * as Haptics from 'expo-haptics';
+
+/**
+ * Hook that returns a memoized callback for haptic feedback on press.
+ * Provides consistent light haptic feedback across the app.
+ * 
+ * @returns A stable callback function that triggers haptic feedback
+ */
+export function useHapticPress() {
+  return useCallback(() => {
+    Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light);
+  }, []);
+}
+

package/src/ui/hooks/useAssets.ts

@@ -71,7 +71,7 @@ export const useAssets = () => {
       };
       
       // Upload with progress callback (visibility undefined, metadata, then onProgress)
-      const result = await oxyInstance.assetUpload(file, undefined, metadata, (percentage: number) => {
+      const result = await oxyInstance.assetUpload(file as any, undefined, metadata, (percentage: number) => {
         if (initialProgress.fileId) {
           setUploadProgress(initialProgress.fileId, {
             ...initialProgress,

package/src/ui/hooks/useDeviceManagement.ts

@@ -0,0 +1,108 @@
+import { useCallback } from 'react';
+import type { ApiError } from '../../models/interfaces';
+import { DeviceManager } from '../../utils/deviceManager';
+import type { OxyServices } from '../../core';
+import { handleAuthError } from '../utils/errorHandlers';
+
+export interface UseDeviceManagementOptions {
+  oxyServices: OxyServices;
+  activeSessionId: string | null;
+  onError?: (error: ApiError) => void;
+  clearSessionState: () => Promise<void>;
+  logger?: (message: string, error?: unknown) => void;
+}
+
+export interface UseDeviceManagementResult {
+  getDeviceSessions: () => Promise<
+    Array<{
+      sessionId: string;
+      deviceId: string;
+      deviceName?: string;
+      lastActive?: string;
+      expiresAt?: string;
+    }>
+  >;
+  logoutAllDeviceSessions: () => Promise<void>;
+  updateDeviceName: (deviceName: string) => Promise<void>;
+}
+
+/**
+ * Provide device session management helpers tied to the current active session.
+ *
+ * @param options - Device management configuration
+ */
+export const useDeviceManagement = ({
+  oxyServices,
+  activeSessionId,
+  onError,
+  clearSessionState,
+  logger,
+}: UseDeviceManagementOptions): UseDeviceManagementResult => {
+  const getDeviceSessions = useCallback(async (): Promise<
+    Array<{
+      sessionId: string;
+      deviceId: string;
+      deviceName?: string;
+      lastActive?: string;
+      expiresAt?: string;
+    }>
+  > => {
+    if (!activeSessionId) throw new Error('No active session');
+    try {
+      return await oxyServices.getDeviceSessions(activeSessionId);
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: 'Failed to get device sessions',
+        code: 'GET_DEVICE_SESSIONS_ERROR',
+        onError,
+        logger,
+      });
+      throw error instanceof Error ? error : new Error('Failed to get device sessions');
+    }
+  }, [activeSessionId, logger, onError, oxyServices]);
+
+  const logoutAllDeviceSessions = useCallback(async (): Promise<void> => {
+    if (!activeSessionId) throw new Error('No active session');
+
+    try {
+      await oxyServices.logoutAllDeviceSessions(activeSessionId);
+      await clearSessionState();
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: 'Failed to logout all device sessions',
+        code: 'LOGOUT_ALL_DEVICES_ERROR',
+        onError,
+        logger,
+      });
+      throw error instanceof Error ? error : new Error('Failed to logout all device sessions');
+    }
+  }, [activeSessionId, clearSessionState, logger, onError, oxyServices]);
+
+  const updateDeviceName = useCallback(
+    async (deviceName: string): Promise<void> => {
+      if (!activeSessionId) throw new Error('No active session');
+
+      try {
+        await oxyServices.updateDeviceName(activeSessionId, deviceName);
+        await DeviceManager.updateDeviceName(deviceName);
+      } catch (error) {
+        handleAuthError(error, {
+          defaultMessage: 'Failed to update device name',
+          code: 'UPDATE_DEVICE_NAME_ERROR',
+          onError,
+          logger,
+        });
+        throw error instanceof Error ? error : new Error('Failed to update device name');
+      }
+    },
+    [activeSessionId, logger, onError, oxyServices],
+  );
+
+  return {
+    getDeviceSessions,
+    logoutAllDeviceSessions,
+    updateDeviceName,
+  };
+};
+
+

package/src/ui/hooks/useLanguageManagement.ts

@@ -0,0 +1,152 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import type { ApiError, User } from '../../models/interfaces';
+import {
+  getLanguageMetadata,
+  getLanguageName,
+  getNativeLanguageName,
+  normalizeLanguageCode,
+  type LanguageMetadata,
+} from '../../utils/languageUtils';
+import type { StorageInterface } from '../utils/storageHelpers';
+import { extractErrorMessage } from '../utils/errorHandlers';
+
+export interface UseLanguageManagementOptions {
+  storage: StorageInterface | null;
+  languageKey: string;
+  onError?: (error: ApiError) => void;
+  logger?: (message: string, error?: unknown) => void;
+}
+
+export interface UseLanguageManagementResult {
+  currentLanguage: string;
+  metadata: LanguageMetadata | null;
+  languageName: string;
+  nativeLanguageName: string;
+  setLanguage: (languageId: string) => Promise<void>;
+  applyLanguagePreference: (user: User | null) => Promise<void>;
+  hydrateLanguage: () => Promise<void>;
+}
+
+const DEFAULT_LANGUAGE = 'en-US';
+
+/**
+ * Manage UI language state, persistence, and metadata derivation.
+ *
+ * @param options - Configuration for storage access and error reporting
+ */
+export const useLanguageManagement = ({
+  storage,
+  languageKey,
+  onError,
+  logger,
+}: UseLanguageManagementOptions): UseLanguageManagementResult => {
+  const [currentLanguage, setCurrentLanguage] = useState<string>(DEFAULT_LANGUAGE);
+
+  const loadLanguageFromStorage = useCallback(async (): Promise<void> => {
+    if (!storage) {
+      return;
+    }
+
+    try {
+      const savedLanguageRaw = await storage.getItem(languageKey);
+      const normalized = normalizeLanguageCode(savedLanguageRaw) || savedLanguageRaw;
+      if (normalized) {
+        setCurrentLanguage(normalized);
+      }
+    } catch (error) {
+      const message = extractErrorMessage(error, 'Failed to load language preference');
+      onError?.({
+        message,
+        code: 'LANGUAGE_LOAD_ERROR',
+        status: 500,
+      });
+      if (logger) {
+        logger(message, error);
+      } else if (__DEV__) {
+        console.warn('Failed to load language preference:', error);
+      }
+    }
+  }, [languageKey, logger, onError, storage]);
+
+  useEffect(() => {
+    loadLanguageFromStorage().catch((error) => {
+      if (logger) {
+        logger('Unexpected error loading language', error);
+      }
+    });
+  }, [loadLanguageFromStorage, logger]);
+
+  const setLanguage = useCallback(
+    async (languageId: string): Promise<void> => {
+      if (!storage) {
+        throw new Error('Storage not initialized');
+      }
+
+      const normalized = normalizeLanguageCode(languageId) || languageId;
+
+      try {
+        await storage.setItem(languageKey, normalized);
+        setCurrentLanguage(normalized);
+      } catch (error) {
+        const message = extractErrorMessage(error, 'Failed to save language preference');
+        onError?.({
+          message,
+          code: 'LANGUAGE_SAVE_ERROR',
+          status: 500,
+        });
+        if (logger) {
+          logger(message, error);
+        } else if (__DEV__) {
+          console.warn('Failed to save language preference:', error);
+        }
+        throw error instanceof Error ? error : new Error(message);
+      }
+    },
+    [languageKey, logger, onError, storage],
+  );
+
+  const applyLanguagePreference = useCallback(
+    async (user: User | null): Promise<void> => {
+      if (!storage || !user) {
+        return;
+      }
+
+      const userLanguage = (user as Record<string, unknown>)?.language as string | undefined;
+      if (!userLanguage) {
+        return;
+      }
+
+      try {
+        const normalized = normalizeLanguageCode(userLanguage) || userLanguage;
+        await storage.setItem(languageKey, normalized);
+        setCurrentLanguage(normalized);
+      } catch (error) {
+        if (logger) {
+          logger('Failed to apply server language preference', error);
+        } else if (__DEV__) {
+          console.warn('Failed to apply server language preference', error);
+        }
+      }
+    },
+    [languageKey, logger, storage],
+  );
+
+  const metadata = useMemo(() => getLanguageMetadata(currentLanguage), [currentLanguage]);
+  const languageName = useMemo(() => getLanguageName(currentLanguage), [currentLanguage]);
+  const nativeLanguageName = useMemo(
+    () => getNativeLanguageName(currentLanguage),
+    [currentLanguage],
+  );
+
+  return {
+    currentLanguage,
+    metadata,
+    languageName,
+    nativeLanguageName,
+    setLanguage,
+    applyLanguagePreference,
+    hydrateLanguage: loadLanguageFromStorage,
+  };
+};
+
+