@oxyhq/services 5.14.0 → 5.15.1

package/src/ui/hooks/useProfileEditing.ts

@@ -0,0 +1,151 @@
+import { useState, useCallback } from 'react';
+import { useOxy } from '../context/OxyContext';
+import { useAuthStore } from '../stores/authStore';
+import { toast } from '../../lib/sonner';
+import { useI18n } from './useI18n';
+
+export interface ProfileUpdateData {
+    displayName?: string;
+    lastName?: string;
+    username?: string;
+    email?: string;
+    bio?: string;
+    location?: string;
+    locations?: Array<{
+        id: string;
+        name: string;
+        label?: string;
+        coordinates?: { lat: number; lon: number };
+    }>;
+    links?: string[];
+    linksMetadata?: Array<{
+        url: string;
+        title?: string;
+        description?: string;
+        image?: string;
+        id: string;
+    }>;
+    avatar?: string;
+}
+
+/**
+ * Hook for managing profile editing operations
+ * Provides functions to update profile fields and handle saving
+ */
+export const useProfileEditing = () => {
+    const { oxyServices, activeSessionId } = useOxy();
+    const updateUser = useAuthStore((state) => state.updateUser);
+    const { t } = useI18n();
+    const [isSaving, setIsSaving] = useState(false);
+
+    /**
+     * Save profile updates to the server
+     */
+    const saveProfile = useCallback(async (updates: ProfileUpdateData) => {
+        if (!oxyServices) {
+            toast.error(t('editProfile.toasts.serviceUnavailable') || 'Service not available');
+            return false;
+        }
+
+        try {
+            setIsSaving(true);
+
+            // Prepare update object
+            const updateData: Record<string, any> = {};
+
+            if (updates.username !== undefined) {
+                updateData.username = updates.username;
+            }
+            if (updates.email !== undefined) {
+                updateData.email = updates.email;
+            }
+            if (updates.bio !== undefined) {
+                updateData.bio = updates.bio;
+            }
+            if (updates.location !== undefined || updates.locations !== undefined) {
+                updateData.location = updates.locations && updates.locations.length > 0 
+                    ? updates.locations[0].name 
+                    : updates.location || '';
+                if (updates.locations) {
+                    updateData.locations = updates.locations;
+                }
+            }
+            if (updates.links !== undefined) {
+                updateData.links = updates.links;
+            }
+            if (updates.linksMetadata !== undefined) {
+                updateData.linksMetadata = updates.linksMetadata;
+            }
+            if (updates.avatar !== undefined) {
+                updateData.avatar = updates.avatar;
+            }
+
+            // Handle name field
+            if (updates.displayName !== undefined || updates.lastName !== undefined) {
+                const currentUser = useAuthStore.getState().user;
+                const currentName = currentUser?.name;
+                updateData.name = {
+                    first: updates.displayName ?? (typeof currentName === 'object' ? currentName?.first : '') ?? '',
+                    last: updates.lastName ?? (typeof currentName === 'object' ? currentName?.last : '') ?? '',
+                };
+            }
+
+            await updateUser(updateData, oxyServices);
+            toast.success(t('editProfile.toasts.profileUpdated') || 'Profile updated successfully');
+            return true;
+        } catch (error: any) {
+            console.error('Failed to update profile:', error);
+            toast.error(error?.message || t('editProfile.toasts.updateFailed') || 'Failed to update profile');
+            return false;
+        } finally {
+            setIsSaving(false);
+        }
+    }, [oxyServices, updateUser, t]);
+
+    /**
+     * Update a single profile field
+     */
+    const updateField = useCallback(async (field: string, value: any) => {
+        const updates: ProfileUpdateData = {};
+        
+        switch (field) {
+            case 'displayName':
+                updates.displayName = value;
+                break;
+            case 'username':
+                updates.username = value;
+                break;
+            case 'email':
+                updates.email = value;
+                break;
+            case 'bio':
+                updates.bio = value;
+                break;
+            case 'location':
+                updates.locations = value;
+                break;
+            case 'links':
+                updates.linksMetadata = value;
+                updates.links = value.map((link: any) => link.url || link);
+                break;
+            default:
+                return false;
+        }
+
+        return await saveProfile(updates);
+    }, [saveProfile]);
+
+    return {
+        saveProfile,
+        updateField,
+        isSaving,
+    };
+};
+
+
+
+
+
+
+
+

package/src/ui/hooks/useSessionManagement.ts

@@ -0,0 +1,378 @@
+import { useCallback, useMemo, useRef, useState } from 'react';
+import type { ApiError, User } from '../../models/interfaces';
+import type { ClientSession } from '../../models/session';
+import { mergeSessions, normalizeAndSortSessions, sessionsArraysEqual } from '../../utils/sessionUtils';
+import { fetchSessionsWithFallback, mapSessionsToClient, validateSessionBatch } from '../utils/sessionHelpers';
+import { getStorageKeys, type StorageInterface } from '../utils/storageHelpers';
+import { handleAuthError, isInvalidSessionError } from '../utils/errorHandlers';
+import type { OxyServices } from '../../core';
+
+export interface UseSessionManagementOptions {
+  oxyServices: OxyServices;
+  storage: StorageInterface | null;
+  storageKeyPrefix?: string;
+  loginSuccess: (user: User) => void;
+  logoutStore: () => void;
+  applyLanguagePreference: (user: User) => Promise<void>;
+  onAuthStateChange?: (user: User | null) => void;
+  onError?: (error: ApiError) => void;
+  setAuthError?: (message: string | null) => void;
+  logger?: (message: string, error?: unknown) => void;
+  setTokenReady?: (ready: boolean) => void;
+}
+
+export interface UseSessionManagementResult {
+  sessions: ClientSession[];
+  activeSessionId: string | null;
+  setActiveSessionId: (sessionId: string | null) => void;
+  updateSessions: (incoming: ClientSession[], options?: { merge?: boolean }) => void;
+  switchSession: (sessionId: string) => Promise<User>;
+  refreshSessions: (activeUserId?: string) => Promise<void>;
+  clearSessionState: () => Promise<void>;
+  saveActiveSessionId: (sessionId: string) => Promise<void>;
+  trackRemovedSession: (sessionId: string) => void;
+  storageKeys: ReturnType<typeof getStorageKeys>;
+  isRefreshInFlight: boolean;
+}
+
+const DEFAULT_SAVE_ERROR_MESSAGE = 'Failed to save session data';
+const CLEAR_STORAGE_ERROR = 'Failed to clear storage';
+
+/**
+ * Manage session state, persistence, and high-level multi-session operations.
+ *
+ * @param options - Session management configuration
+ */
+export const useSessionManagement = ({
+  oxyServices,
+  storage,
+  storageKeyPrefix,
+  loginSuccess,
+  logoutStore,
+  applyLanguagePreference,
+  onAuthStateChange,
+  onError,
+  setAuthError,
+  logger,
+  setTokenReady,
+}: UseSessionManagementOptions): UseSessionManagementResult => {
+  const [sessions, setSessions] = useState<ClientSession[]>([]);
+  const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
+
+  const refreshInFlightRef = useRef<Promise<void> | null>(null);
+  const removedSessionsRef = useRef<Set<string>>(new Set());
+  const lastRefreshRef = useRef<number>(0);
+
+  const storageKeys = useMemo(() => getStorageKeys(storageKeyPrefix), [storageKeyPrefix]);
+
+  const saveSessionIds = useCallback(
+    async (sessionIds: string[]): Promise<void> => {
+      if (!storage) return;
+      try {
+        const uniqueIds = Array.from(new Set(sessionIds));
+        await storage.setItem(storageKeys.sessionIds, JSON.stringify(uniqueIds));
+      } catch (error) {
+        if (logger) {
+          logger(DEFAULT_SAVE_ERROR_MESSAGE, error);
+        } else if (__DEV__) {
+          console.warn('Failed to save session IDs:', error);
+        }
+      }
+    },
+    [logger, storage, storageKeys.sessionIds],
+  );
+
+  const updateSessions = useCallback(
+    (incoming: ClientSession[], options: { merge?: boolean } = {}): void => {
+      setSessions((prevSessions) => {
+        const processed = options.merge
+          ? mergeSessions(prevSessions, incoming, activeSessionId, false)
+          : normalizeAndSortSessions(incoming, activeSessionId, false);
+
+        if (storage) {
+          void saveSessionIds(processed.map((session) => session.sessionId));
+        }
+
+        if (sessionsArraysEqual(prevSessions, processed)) {
+          return prevSessions;
+        }
+        return processed;
+      });
+    },
+    [activeSessionId, saveSessionIds, storage],
+  );
+
+  const saveActiveSessionId = useCallback(
+    async (sessionId: string): Promise<void> => {
+      if (!storage) return;
+      try {
+        await storage.setItem(storageKeys.activeSessionId, sessionId);
+      } catch (error) {
+        handleAuthError(error, {
+          defaultMessage: DEFAULT_SAVE_ERROR_MESSAGE,
+          code: 'SESSION_PERSISTENCE_ERROR',
+          onError,
+          setAuthError,
+          logger,
+        });
+      }
+    },
+    [logger, onError, setAuthError, storage, storageKeys.activeSessionId],
+  );
+
+  const removeActiveSessionId = useCallback(async (): Promise<void> => {
+    if (!storage) return;
+    try {
+      await storage.removeItem(storageKeys.activeSessionId);
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: DEFAULT_SAVE_ERROR_MESSAGE,
+        code: 'SESSION_PERSISTENCE_ERROR',
+        onError,
+        setAuthError,
+        logger,
+      });
+    }
+  }, [logger, onError, setAuthError, storage, storageKeys.activeSessionId]);
+
+  const clearSessionStorage = useCallback(async (): Promise<void> => {
+    if (!storage) return;
+    try {
+      await storage.removeItem(storageKeys.activeSessionId);
+      await storage.removeItem(storageKeys.sessionIds);
+    } catch (error) {
+      handleAuthError(error, {
+        defaultMessage: CLEAR_STORAGE_ERROR,
+        code: 'STORAGE_ERROR',
+        onError,
+        setAuthError,
+        logger,
+      });
+    }
+  }, [logger, onError, setAuthError, storage, storageKeys.activeSessionId, storageKeys.sessionIds]);
+
+  const clearSessionState = useCallback(async (): Promise<void> => {
+    setSessions([]);
+    setActiveSessionId(null);
+    logoutStore();
+    await clearSessionStorage();
+    onAuthStateChange?.(null);
+  }, [clearSessionStorage, logoutStore, onAuthStateChange]);
+
+  const activateSession = useCallback(
+    async (sessionId: string, user: User): Promise<void> => {
+      await oxyServices.getTokenBySession(sessionId);
+      setTokenReady?.(true);
+      setActiveSessionId(sessionId);
+      loginSuccess(user);
+      await saveActiveSessionId(sessionId);
+      await applyLanguagePreference(user);
+      onAuthStateChange?.(user);
+    },
+    [
+      applyLanguagePreference,
+      loginSuccess,
+      onAuthStateChange,
+      oxyServices,
+      saveActiveSessionId,
+      setTokenReady,
+    ],
+  );
+
+  const trackRemovedSession = useCallback((sessionId: string) => {
+    removedSessionsRef.current.add(sessionId);
+    setTimeout(() => {
+      removedSessionsRef.current.delete(sessionId);
+    }, 5000);
+  }, []);
+
+  const findReplacementSession = useCallback(
+    async (sessionIds: string[]): Promise<User | null> => {
+      if (!sessionIds.length) {
+        return null;
+      }
+
+      const validationResults = await validateSessionBatch(oxyServices, sessionIds, {
+        maxConcurrency: 3,
+      });
+
+      const validSession = validationResults.find((result) => result.valid);
+      if (!validSession) {
+        return null;
+      }
+
+      const validation = await oxyServices.validateSession(validSession.sessionId, {
+        useHeaderValidation: true,
+      });
+
+      if (!validation?.valid || !validation.user) {
+        return null;
+      }
+
+      const user = validation.user as User;
+      await activateSession(validSession.sessionId, user);
+      return user;
+    },
+    [activateSession, oxyServices],
+  );
+
+  const switchSession = useCallback(
+    async (sessionId: string): Promise<User> => {
+      try {
+        const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation: true });
+        if (!validation?.valid) {
+          throw new Error('Session is invalid or expired');
+        }
+
+        if (!validation.user) {
+          throw new Error('User data not available from session validation');
+        }
+
+        const user = validation.user as User;
+        await activateSession(sessionId, user);
+
+        try {
+          const deviceSessions = await fetchSessionsWithFallback(oxyServices, sessionId, {
+            fallbackUserId: user.id,
+            logger,
+          });
+          updateSessions(deviceSessions, { merge: true });
+        } catch (error) {
+          if (__DEV__) {
+            console.warn('Failed to synchronize sessions after switch:', error);
+          }
+        }
+
+        return user;
+      } catch (error) {
+        const invalidSession = isInvalidSessionError(error);
+
+        if (invalidSession) {
+          updateSessions(sessions.filter((session) => session.sessionId !== sessionId), {
+            merge: false,
+          });
+          if (sessionId === activeSessionId) {
+            const otherSessionIds = sessions
+              .filter(
+                (session) =>
+                  session.sessionId !== sessionId && !removedSessionsRef.current.has(session.sessionId),
+              )
+              .map((session) => session.sessionId);
+
+            const replacementUser = await findReplacementSession(otherSessionIds);
+            if (replacementUser) {
+              return replacementUser;
+            }
+          }
+        }
+
+        handleAuthError(error, {
+          defaultMessage: 'Failed to switch session',
+          code: invalidSession ? 'INVALID_SESSION' : 'SESSION_SWITCH_ERROR',
+          onError,
+          setAuthError,
+          logger,
+        });
+        throw error instanceof Error ? error : new Error('Failed to switch session');
+      }
+    },
+    [
+      activateSession,
+      activeSessionId,
+      findReplacementSession,
+      logger,
+      loginSuccess,
+      onError,
+      oxyServices,
+      sessions,
+      setAuthError,
+      updateSessions,
+    ],
+  );
+
+  const refreshSessions = useCallback(
+    async (activeUserId?: string): Promise<void> => {
+      if (!activeSessionId) return;
+
+      if (refreshInFlightRef.current) {
+        await refreshInFlightRef.current;
+        return;
+      }
+
+      const now = Date.now();
+      if (now - lastRefreshRef.current < 500) {
+        return;
+      }
+      lastRefreshRef.current = now;
+
+      const refreshPromise = (async () => {
+        try {
+          const deviceSessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
+            fallbackUserId: activeUserId,
+            logger,
+          });
+          updateSessions(deviceSessions, { merge: true });
+        } catch (error) {
+          if (isInvalidSessionError(error)) {
+            const otherSessions = sessions
+              .filter(
+                (session) =>
+                  session.sessionId !== activeSessionId &&
+                  !removedSessionsRef.current.has(session.sessionId),
+              )
+              .map((session) => session.sessionId);
+
+            const replacementUser = await findReplacementSession(otherSessions);
+            if (!replacementUser) {
+              await clearSessionState();
+            }
+            return;
+          }
+
+          handleAuthError(error, {
+            defaultMessage: 'Failed to refresh sessions',
+            code: 'SESSION_REFRESH_ERROR',
+            onError,
+            setAuthError,
+            logger,
+          });
+        } finally {
+          refreshInFlightRef.current = null;
+          lastRefreshRef.current = Date.now();
+        }
+      })();
+
+      refreshInFlightRef.current = refreshPromise;
+      await refreshPromise;
+    },
+    [
+      activeSessionId,
+      clearSessionState,
+      findReplacementSession,
+      logger,
+      onError,
+      oxyServices,
+      sessions,
+      setAuthError,
+      updateSessions,
+    ],
+  );
+
+  const isRefreshInFlight = Boolean(refreshInFlightRef.current);
+
+  return {
+    sessions,
+    activeSessionId,
+    setActiveSessionId,
+    updateSessions,
+    switchSession,
+    refreshSessions,
+    clearSessionState,
+    saveActiveSessionId,
+    trackRemovedSession,
+    storageKeys,
+    isRefreshInFlight,
+  };
+};
+
+

package/src/ui/hooks/useStorage.ts

@@ -0,0 +1,104 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { ApiError } from '../../models/interfaces';
+import { createPlatformStorage, type StorageInterface } from '../utils/storageHelpers';
+import { extractErrorMessage } from '../utils/errorHandlers';
+
+export interface UseStorageOptions {
+  onError?: (error: ApiError) => void;
+  logger?: (message: string, error?: unknown) => void;
+  errorCode?: string;
+}
+
+export interface UseStorageResult {
+  storage: StorageInterface | null;
+  isReady: boolean;
+  error: string | null;
+  refresh: () => Promise<StorageInterface | null>;
+  withStorage: <T>(callback: (storage: StorageInterface) => Promise<T>) => Promise<T | null>;
+}
+
+const DEFAULT_ERROR_CODE = 'STORAGE_INIT_ERROR';
+
+/**
+ * React hook that exposes a platform-agnostic storage reference.
+ * Handles initialization, error propagation, and lazy re-initialization.
+ *
+ * @param options - Optional configuration for error reporting and logging
+ */
+export const useStorage = ({
+  onError,
+  logger,
+  errorCode = DEFAULT_ERROR_CODE,
+}: UseStorageOptions = {}): UseStorageResult => {
+  const [storage, setStorage] = useState<StorageInterface | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const initializingRef = useRef<Promise<StorageInterface | null> | null>(null);
+
+  const notifyError = useCallback(
+    (err: unknown) => {
+      const message = extractErrorMessage(err, 'Failed to initialize storage');
+      setError(message);
+
+      if (logger) {
+        logger(message, err);
+      }
+
+      onError?.({
+        message,
+        code: errorCode,
+        status: 500,
+      });
+    },
+    [errorCode, logger, onError],
+  );
+
+  const createStorageInstance = useCallback(async (): Promise<StorageInterface | null> => {
+    try {
+      const platformStorage = await createPlatformStorage();
+      setStorage(platformStorage);
+      setError(null);
+      return platformStorage;
+    } catch (err) {
+      notifyError(err);
+      setStorage(null);
+      return null;
+    }
+  }, [notifyError]);
+
+  const refresh = useCallback(async (): Promise<StorageInterface | null> => {
+    if (!initializingRef.current) {
+      initializingRef.current = createStorageInstance().finally(() => {
+        initializingRef.current = null;
+      });
+    }
+
+    return initializingRef.current;
+  }, [createStorageInstance]);
+
+  useEffect(() => {
+    refresh().catch((err) => {
+      notifyError(err);
+    });
+  }, [refresh, notifyError]);
+
+  const withStorage = useCallback(
+    async <T,>(callback: (resolvedStorage: StorageInterface) => Promise<T>): Promise<T | null> => {
+      const resolvedStorage = storage ?? (await refresh());
+      if (!resolvedStorage) {
+        return null;
+      }
+      return callback(resolvedStorage);
+    },
+    [refresh, storage],
+  );
+
+  return {
+    storage,
+    isReady: Boolean(storage) && !error,
+    error,
+    refresh,
+    withStorage,
+  };
+};
+
+

package/src/ui/hooks/useThemeColors.ts

@@ -0,0 +1,26 @@
+import { useMemo } from 'react';
+import { useColorScheme } from './use-color-scheme';
+import { Colors } from '../constants/theme';
+
+/**
+ * Reusable hook to get theme colors based on current color scheme
+ * Returns the Colors object for the current theme (light or dark)
+ * 
+ * @returns Colors object for the current color scheme
+ * 
+ * @example
+ * ```tsx
+ * const colors = useThemeColors();
+ * <View style={{ backgroundColor: colors.background }}>
+ *   <Text style={{ color: colors.text }}>Hello</Text>
+ * </View>
+ * ```
+ */
+export const useThemeColors = () => {
+  const colorScheme = useColorScheme();
+  
+  return useMemo(() => {
+    return Colors[colorScheme ?? 'light'];
+  }, [colorScheme]);
+};
+