@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/context/hooks/useAuthOperations.js

@@ -0,0 +1,318 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuthOperations = void 0;
+const react_1 = require("react");
+const core_1 = require("@oxyhq/core");
+const sessionHelpers_1 = require("../../utils/sessionHelpers");
+const errorHandlers_1 = require("../../utils/errorHandlers");
+const core_2 = require("@oxyhq/core");
+const Crypto = __importStar(require("expo-crypto"));
+/** Type guard for error objects with optional code and status properties */
+function isErrorWithCodeOrStatus(error) {
+    return typeof error === 'object' && error !== null;
+}
+const LOGIN_ERROR_CODE = 'LOGIN_ERROR';
+const LOGOUT_ERROR_CODE = 'LOGOUT_ERROR';
+const LOGOUT_ALL_ERROR_CODE = 'LOGOUT_ALL_ERROR';
+/**
+ * Authentication operations using public key cryptography.
+ * Accepts public key as parameter - identity management is handled by the app layer.
+ */
+const useAuthOperations = ({ oxyServices, storage, sessions, activeSessionId, setActiveSessionId, updateSessions, saveActiveSessionId, clearSessionState, switchSession, applyLanguagePreference, onAuthStateChange, onError, loginSuccess, loginFailure, logoutStore, setAuthState, logger, }) => {
+    // Ref to avoid recreating callbacks when sessions change
+    const sessionsRef = (0, react_1.useRef)(sessions);
+    sessionsRef.current = sessions;
+    /**
+     * Internal function to perform challenge-response sign in (works offline)
+     */
+    const performSignIn = (0, react_1.useCallback)(async (publicKey) => {
+        const deviceFingerprintObj = core_1.DeviceManager.getDeviceFingerprint();
+        const deviceFingerprint = JSON.stringify(deviceFingerprintObj);
+        const deviceInfo = await core_1.DeviceManager.getDeviceInfo();
+        const deviceName = deviceInfo.deviceName || core_1.DeviceManager.getDefaultDeviceName();
+        let challenge;
+        let isOffline = false;
+        // Try to request challenge from server (online)
+        try {
+            const challengeResponse = await oxyServices.requestChallenge(publicKey);
+            challenge = challengeResponse.challenge;
+        }
+        catch (error) {
+            // Network error - generate challenge locally for offline sign-in
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isNetworkError = errorMessage.includes('Network') ||
+                errorMessage.includes('network') ||
+                errorMessage.includes('Failed to fetch') ||
+                errorMessage.includes('fetch failed') ||
+                (isErrorWithCodeOrStatus(error) && error.code === 'NETWORK_ERROR') ||
+                (isErrorWithCodeOrStatus(error) && error.status === 0);
+            if (isNetworkError) {
+                if (__DEV__ && logger) {
+                    logger('Network unavailable, performing offline sign-in');
+                }
+                // Generate challenge locally
+                challenge = await core_2.SignatureService.generateChallenge();
+                isOffline = true;
+            }
+            else {
+                // Re-throw non-network errors
+                throw error;
+            }
+        }
+        // Note: Biometric authentication check should be handled by the app layer
+        // (e.g., accounts app) before calling signIn. The biometric preference is stored
+        // in local storage as 'oxy_biometric_enabled' and can be checked there.
+        // Sign the challenge
+        const { challenge: signature, timestamp } = await core_2.SignatureService.signChallenge(challenge);
+        let fullUser;
+        let sessionResponse;
+        if (isOffline) {
+            // Offline sign-in: create local session and minimal user object
+            if (__DEV__ && logger) {
+                logger('Creating offline session');
+            }
+            // Generate a local session ID using cryptographically secure randomness
+            const localSessionId = `offline_${Crypto.getRandomUUID()}`;
+            const localDeviceId = `device_${Crypto.getRandomUUID()}`;
+            const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(); // 7 days
+            // Create minimal user object with publicKey as id
+            fullUser = {
+                id: publicKey, // Use publicKey as id (per migration document)
+                publicKey,
+                username: '',
+                privacySettings: {},
+            };
+            sessionResponse = {
+                sessionId: localSessionId,
+                deviceId: localDeviceId,
+                expiresAt,
+                user: {
+                    id: publicKey,
+                    username: '',
+                },
+            };
+            // Store offline session locally
+            const offlineSession = {
+                sessionId: localSessionId,
+                deviceId: localDeviceId,
+                expiresAt,
+                lastActive: new Date().toISOString(),
+                userId: publicKey,
+                isCurrent: true,
+            };
+            setActiveSessionId(localSessionId);
+            await saveActiveSessionId(localSessionId);
+            updateSessions([offlineSession], { merge: true });
+            // Mark session as offline for later sync
+            if (storage) {
+                await storage.setItem(`oxy_session_${localSessionId}_offline`, 'true');
+            }
+            if (__DEV__ && logger) {
+                logger('Offline sign-in successful');
+            }
+        }
+        else {
+            // Online sign-in: use normal flow
+            // Verify and create session
+            sessionResponse = await oxyServices.verifyChallenge(publicKey, challenge, signature, timestamp, deviceName, deviceFingerprint);
+            // Get token for the session
+            try {
+                await oxyServices.getTokenBySession(sessionResponse.sessionId);
+            }
+            catch (tokenError) {
+                const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError);
+                const status = isErrorWithCodeOrStatus(tokenError) ? tokenError.status : undefined;
+                if (status === 404 || errorMessage.includes('404')) {
+                    throw new Error(`Session was created but token could not be retrieved. Session ID: ${sessionResponse.sessionId.substring(0, 8)}...`);
+                }
+                throw tokenError;
+            }
+            // Get full user data
+            fullUser = await oxyServices.getUserBySession(sessionResponse.sessionId);
+            // Fetch device sessions
+            let allDeviceSessions = [];
+            try {
+                allDeviceSessions = await (0, sessionHelpers_1.fetchSessionsWithFallback)(oxyServices, sessionResponse.sessionId, {
+                    fallbackDeviceId: sessionResponse.deviceId,
+                    fallbackUserId: fullUser.id,
+                    logger,
+                });
+            }
+            catch (error) {
+                if (__DEV__ && logger) {
+                    logger('Failed to fetch device sessions after login', error);
+                }
+            }
+            // Check for existing session for same user and switch to it to avoid duplicates
+            const existingSession = allDeviceSessions.find((session) => session.userId?.toString() === fullUser.id?.toString() &&
+                session.sessionId !== sessionResponse.sessionId);
+            if (existingSession) {
+                // Switch to existing session instead of creating duplicate
+                try {
+                    await oxyServices.logoutSession(sessionResponse.sessionId, sessionResponse.sessionId);
+                }
+                catch (logoutError) {
+                    // Non-critical - continue to switch session even if logout fails
+                    if (__DEV__ && logger) {
+                        logger('Failed to logout duplicate session, continuing with switch', logoutError);
+                    }
+                }
+                await switchSession(existingSession.sessionId);
+                updateSessions(allDeviceSessions.filter((session) => session.sessionId !== sessionResponse.sessionId), { merge: false });
+                onAuthStateChange?.(fullUser);
+                return fullUser;
+            }
+            setActiveSessionId(sessionResponse.sessionId);
+            await saveActiveSessionId(sessionResponse.sessionId);
+            updateSessions(allDeviceSessions, { merge: true });
+        }
+        await applyLanguagePreference(fullUser);
+        loginSuccess(fullUser);
+        onAuthStateChange?.(fullUser);
+        return fullUser;
+    }, [
+        applyLanguagePreference,
+        logger,
+        loginSuccess,
+        onAuthStateChange,
+        oxyServices,
+        saveActiveSessionId,
+        setActiveSessionId,
+        switchSession,
+        updateSessions,
+        storage,
+    ]);
+    /**
+     * Sign in with existing public key
+     */
+    const signIn = (0, react_1.useCallback)(async (publicKey, deviceName) => {
+        setAuthState({ isLoading: true, error: null });
+        try {
+            return await performSignIn(publicKey);
+        }
+        catch (error) {
+            const message = (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: 'Sign in failed',
+                code: LOGIN_ERROR_CODE,
+                onError,
+                setAuthError: (msg) => setAuthState({ error: msg }),
+                logger,
+            });
+            loginFailure(message);
+            throw error;
+        }
+        finally {
+            setAuthState({ isLoading: false });
+        }
+    }, [setAuthState, performSignIn, loginFailure, onError, logger]);
+    /**
+     * Logout from session
+     */
+    const logout = (0, react_1.useCallback)(async (targetSessionId) => {
+        if (!activeSessionId)
+            return;
+        try {
+            const sessionToLogout = targetSessionId || activeSessionId;
+            await oxyServices.logoutSession(activeSessionId, sessionToLogout);
+            const filteredSessions = sessionsRef.current.filter((session) => session.sessionId !== sessionToLogout);
+            updateSessions(filteredSessions, { merge: false });
+            if (sessionToLogout === activeSessionId) {
+                if (filteredSessions.length > 0) {
+                    await switchSession(filteredSessions[0].sessionId);
+                }
+                else {
+                    await clearSessionState();
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            const isInvalid = (0, errorHandlers_1.isInvalidSessionError)(error);
+            if (isInvalid && targetSessionId === activeSessionId) {
+                await clearSessionState();
+                return;
+            }
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: 'Logout failed',
+                code: LOGOUT_ERROR_CODE,
+                onError,
+                setAuthError: (msg) => setAuthState({ error: msg }),
+                logger,
+                status: isInvalid ? 401 : undefined,
+            });
+        }
+    }, [
+        activeSessionId,
+        clearSessionState,
+        logger,
+        onError,
+        oxyServices,
+        setAuthState,
+        switchSession,
+        updateSessions,
+    ]);
+    /**
+     * Logout from all sessions
+     */
+    const logoutAll = (0, react_1.useCallback)(async () => {
+        if (!activeSessionId) {
+            const error = new Error('No active session found');
+            setAuthState({ error: error.message });
+            onError?.({ message: error.message, code: LOGOUT_ALL_ERROR_CODE, status: 404 });
+            throw error;
+        }
+        try {
+            await oxyServices.logoutAllSessions(activeSessionId);
+            await clearSessionState();
+        }
+        catch (error) {
+            (0, errorHandlers_1.handleAuthError)(error, {
+                defaultMessage: 'Logout all failed',
+                code: LOGOUT_ALL_ERROR_CODE,
+                onError,
+                setAuthError: (msg) => setAuthState({ error: msg }),
+                logger,
+            });
+            throw error instanceof Error ? error : new Error('Logout all failed');
+        }
+    }, [activeSessionId, clearSessionState, logger, onError, oxyServices, setAuthState]);
+    return {
+        signIn,
+        logout,
+        logoutAll,
+    };
+};
+exports.useAuthOperations = useAuthOperations;

package/src/ui/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { useFollow, useFollowerCounts } from './useFollow';
+export { useFileDownloadUrl, setOxyFileUrlInstance } from './useFileDownloadUrl';
+export { useThemeStyles } from './useThemeStyles';
+export { useThemeColors } from './useThemeColors';
+export { useAsyncAction, executeWithToast } from './useAsyncAction';
+export { useSettingToggle, useSettingToggles } from './useSettingToggle';

package/src/ui/hooks/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSettingToggles = exports.useSettingToggle = exports.executeWithToast = exports.useAsyncAction = exports.useThemeColors = exports.useThemeStyles = exports.setOxyFileUrlInstance = exports.useFileDownloadUrl = exports.useFollowerCounts = exports.useFollow = void 0;
+var useFollow_1 = require("./useFollow");
+Object.defineProperty(exports, "useFollow", { enumerable: true, get: function () { return useFollow_1.useFollow; } });
+Object.defineProperty(exports, "useFollowerCounts", { enumerable: true, get: function () { return useFollow_1.useFollowerCounts; } });
+var useFileDownloadUrl_1 = require("./useFileDownloadUrl");
+Object.defineProperty(exports, "useFileDownloadUrl", { enumerable: true, get: function () { return useFileDownloadUrl_1.useFileDownloadUrl; } });
+Object.defineProperty(exports, "setOxyFileUrlInstance", { enumerable: true, get: function () { return useFileDownloadUrl_1.setOxyFileUrlInstance; } });
+var useThemeStyles_1 = require("./useThemeStyles");
+Object.defineProperty(exports, "useThemeStyles", { enumerable: true, get: function () { return useThemeStyles_1.useThemeStyles; } });
+var useThemeColors_1 = require("./useThemeColors");
+Object.defineProperty(exports, "useThemeColors", { enumerable: true, get: function () { return useThemeColors_1.useThemeColors; } });
+var useAsyncAction_1 = require("./useAsyncAction");
+Object.defineProperty(exports, "useAsyncAction", { enumerable: true, get: function () { return useAsyncAction_1.useAsyncAction; } });
+Object.defineProperty(exports, "executeWithToast", { enumerable: true, get: function () { return useAsyncAction_1.executeWithToast; } });
+var useSettingToggle_1 = require("./useSettingToggle");
+Object.defineProperty(exports, "useSettingToggle", { enumerable: true, get: function () { return useSettingToggle_1.useSettingToggle; } });
+Object.defineProperty(exports, "useSettingToggles", { enumerable: true, get: function () { return useSettingToggle_1.useSettingToggles; } });

package/src/ui/hooks/mutations/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mutation Hooks
+ *
+ * TanStack Query mutation hooks for updating Oxy services data.
+ * All mutations handle authentication, error handling, and query invalidation.
+ */
+export { useUpdateProfile, useUploadAvatar, useUpdateAccountSettings, useUpdatePrivacySettings, useUploadFile, } from './useAccountMutations';
+export { useSwitchSession, useLogoutSession, useLogoutAll, useUpdateDeviceName, useRemoveDevice, } from './useServicesMutations';

package/src/ui/hooks/mutations/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Mutation Hooks
+ *
+ * TanStack Query mutation hooks for updating Oxy services data.
+ * All mutations handle authentication, error handling, and query invalidation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRemoveDevice = exports.useUpdateDeviceName = exports.useLogoutAll = exports.useLogoutSession = exports.useSwitchSession = exports.useUploadFile = exports.useUpdatePrivacySettings = exports.useUpdateAccountSettings = exports.useUploadAvatar = exports.useUpdateProfile = void 0;
+// Account mutation hooks
+var useAccountMutations_1 = require("./useAccountMutations");
+Object.defineProperty(exports, "useUpdateProfile", { enumerable: true, get: function () { return useAccountMutations_1.useUpdateProfile; } });
+Object.defineProperty(exports, "useUploadAvatar", { enumerable: true, get: function () { return useAccountMutations_1.useUploadAvatar; } });
+Object.defineProperty(exports, "useUpdateAccountSettings", { enumerable: true, get: function () { return useAccountMutations_1.useUpdateAccountSettings; } });
+Object.defineProperty(exports, "useUpdatePrivacySettings", { enumerable: true, get: function () { return useAccountMutations_1.useUpdatePrivacySettings; } });
+Object.defineProperty(exports, "useUploadFile", { enumerable: true, get: function () { return useAccountMutations_1.useUploadFile; } });
+// Service mutation hooks (sessions, devices)
+var useServicesMutations_1 = require("./useServicesMutations");
+Object.defineProperty(exports, "useSwitchSession", { enumerable: true, get: function () { return useServicesMutations_1.useSwitchSession; } });
+Object.defineProperty(exports, "useLogoutSession", { enumerable: true, get: function () { return useServicesMutations_1.useLogoutSession; } });
+Object.defineProperty(exports, "useLogoutAll", { enumerable: true, get: function () { return useServicesMutations_1.useLogoutAll; } });
+Object.defineProperty(exports, "useUpdateDeviceName", { enumerable: true, get: function () { return useServicesMutations_1.useUpdateDeviceName; } });
+Object.defineProperty(exports, "useRemoveDevice", { enumerable: true, get: function () { return useServicesMutations_1.useRemoveDevice; } });

package/src/ui/hooks/mutations/mutationFactory.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Mutation Factory - Creates standardized mutations with optimistic updates
+ *
+ * This factory reduces boilerplate code for mutations that follow the common pattern:
+ * 1. Cancel outgoing queries
+ * 2. Snapshot previous data
+ * 3. Apply optimistic update
+ * 4. On error: rollback and show toast
+ * 5. On success: update cache, stores, and invalidate queries
+ */
+import type { QueryClient, UseMutationOptions } from '@tanstack/react-query';
+import type { User } from '@oxyhq/core';
+/**
+ * Configuration for creating a standard profile mutation
+ */
+export interface ProfileMutationConfig<TData, TVariables> {
+    /** The mutation function that makes the API call */
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    /** Query keys to cancel before mutation */
+    cancelQueryKeys?: unknown[][];
+    /** Function to apply optimistic update to the user data */
+    optimisticUpdate?: (previousUser: User, variables: TVariables) => Partial<User>;
+    /** Error message to show on failure */
+    errorMessage?: string | ((error: Error) => string);
+    /** Success message to show (optional) */
+    successMessage?: string;
+    /** Whether to update authStore on success (default: true) */
+    updateAuthStore?: boolean;
+    /** Whether to invalidate user queries on success (default: true) */
+    invalidateUserQueries?: boolean;
+    /** Whether to invalidate account queries on success (default: true) */
+    invalidateAccountQueries?: boolean;
+    /** Custom onSuccess handler */
+    onSuccess?: (data: TData, variables: TVariables, queryClient: QueryClient) => void;
+}
+/**
+ * Creates a standard profile mutation with optimistic updates
+ *
+ * @example
+ * ```ts
+ * const updateProfile = createProfileMutation({
+ *   mutationFn: (updates) => oxyServices.updateProfile(updates),
+ *   optimisticUpdate: (user, updates) => updates,
+ *   errorMessage: 'Failed to update profile',
+ * });
+ * ```
+ */
+export declare function createProfileMutation<TVariables>(config: ProfileMutationConfig<User, TVariables>, queryClient: QueryClient, activeSessionId: string | null): UseMutationOptions<User, Error, TVariables, {
+    previousUser?: User;
+}>;
+/**
+ * Configuration for creating a generic mutation (non-profile)
+ */
+export interface GenericMutationConfig<TData, TVariables, TContext> {
+    /** The mutation function */
+    mutationFn: (variables: TVariables) => Promise<TData>;
+    /** Query key for optimistic data */
+    queryKey: unknown[];
+    /** Function to create optimistic data */
+    optimisticData?: (previous: TData | undefined, variables: TVariables) => TData;
+    /** Error message */
+    errorMessage?: string;
+    /** Success message */
+    successMessage?: string;
+    /** Additional queries to invalidate on success */
+    invalidateQueries?: unknown[][];
+}
+/**
+ * Creates a generic mutation with optimistic updates
+ */
+export declare function createGenericMutation<TData, TVariables>(config: GenericMutationConfig<TData, TVariables, {
+    previous?: TData;
+}>, queryClient: QueryClient): UseMutationOptions<TData, Error, TVariables, {
+    previous?: TData;
+}>;

package/src/ui/hooks/mutations/mutationFactory.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * Mutation Factory - Creates standardized mutations with optimistic updates
+ *
+ * This factory reduces boilerplate code for mutations that follow the common pattern:
+ * 1. Cancel outgoing queries
+ * 2. Snapshot previous data
+ * 3. Apply optimistic update
+ * 4. On error: rollback and show toast
+ * 5. On success: update cache, stores, and invalidate queries
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProfileMutation = createProfileMutation;
+exports.createGenericMutation = createGenericMutation;
+const queryKeys_1 = require("../queries/queryKeys");
+const sonner_1 = require("../../../lib/sonner");
+const authStore_1 = require("../../stores/authStore");
+/**
+ * Creates a standard profile mutation with optimistic updates
+ *
+ * @example
+ * ```ts
+ * const updateProfile = createProfileMutation({
+ *   mutationFn: (updates) => oxyServices.updateProfile(updates),
+ *   optimisticUpdate: (user, updates) => updates,
+ *   errorMessage: 'Failed to update profile',
+ * });
+ * ```
+ */
+function createProfileMutation(config, queryClient, activeSessionId) {
+    const { mutationFn, cancelQueryKeys = [], optimisticUpdate, errorMessage = 'Operation failed', successMessage, updateAuthStore = true, invalidateUserQueries: shouldInvalidateUserQueries = true, invalidateAccountQueries: shouldInvalidateAccountQueries = true, onSuccess: customOnSuccess, } = config;
+    return {
+        mutationFn,
+        onMutate: async (variables) => {
+            // Cancel queries that might conflict
+            await queryClient.cancelQueries({ queryKey: queryKeys_1.queryKeys.accounts.current() });
+            for (const key of cancelQueryKeys) {
+                await queryClient.cancelQueries({ queryKey: key });
+            }
+            // Snapshot previous user data
+            const previousUser = queryClient.getQueryData(queryKeys_1.queryKeys.accounts.current());
+            // Apply optimistic update if provided
+            if (previousUser && optimisticUpdate) {
+                const updates = optimisticUpdate(previousUser, variables);
+                const optimisticUser = { ...previousUser, ...updates };
+                queryClient.setQueryData(queryKeys_1.queryKeys.accounts.current(), optimisticUser);
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys_1.queryKeys.users.profile(activeSessionId), optimisticUser);
+                }
+            }
+            return { previousUser };
+        },
+        onError: (error, _variables, context) => {
+            // Rollback optimistic update
+            if (context?.previousUser) {
+                queryClient.setQueryData(queryKeys_1.queryKeys.accounts.current(), context.previousUser);
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys_1.queryKeys.users.profile(activeSessionId), context.previousUser);
+                }
+            }
+            // Show error toast
+            const message = typeof errorMessage === 'function'
+                ? errorMessage(error)
+                : (error instanceof Error ? error.message : errorMessage);
+            sonner_1.toast.error(message);
+        },
+        onSuccess: (data, variables) => {
+            // Update cache with server response
+            queryClient.setQueryData(queryKeys_1.queryKeys.accounts.current(), data);
+            if (activeSessionId) {
+                queryClient.setQueryData(queryKeys_1.queryKeys.users.profile(activeSessionId), data);
+            }
+            // Update authStore for immediate UI updates
+            if (updateAuthStore) {
+                authStore_1.useAuthStore.getState().setUser(data);
+            }
+            // Invalidate related queries
+            if (shouldInvalidateUserQueries) {
+                (0, queryKeys_1.invalidateUserQueries)(queryClient);
+            }
+            if (shouldInvalidateAccountQueries) {
+                (0, queryKeys_1.invalidateAccountQueries)(queryClient);
+            }
+            // Show success toast if configured
+            if (successMessage) {
+                sonner_1.toast.success(successMessage);
+            }
+            // Call custom onSuccess handler
+            if (customOnSuccess) {
+                customOnSuccess(data, variables, queryClient);
+            }
+        },
+    };
+}
+/**
+ * Creates a generic mutation with optimistic updates
+ */
+function createGenericMutation(config, queryClient) {
+    const { mutationFn, queryKey, optimisticData, errorMessage = 'Operation failed', successMessage, invalidateQueries = [], } = config;
+    return {
+        mutationFn,
+        onMutate: async (variables) => {
+            await queryClient.cancelQueries({ queryKey });
+            const previous = queryClient.getQueryData(queryKey);
+            if (optimisticData) {
+                queryClient.setQueryData(queryKey, optimisticData(previous, variables));
+            }
+            return { previous };
+        },
+        onError: (error, _variables, context) => {
+            if (context?.previous !== undefined) {
+                queryClient.setQueryData(queryKey, context.previous);
+            }
+            sonner_1.toast.error(error instanceof Error ? error.message : errorMessage);
+        },
+        onSuccess: (data) => {
+            queryClient.setQueryData(queryKey, data);
+            for (const key of invalidateQueries) {
+                queryClient.invalidateQueries({ queryKey: key });
+            }
+            if (successMessage) {
+                sonner_1.toast.success(successMessage);
+            }
+        },
+    };
+}

package/src/ui/hooks/mutations/useAccountMutations.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Update user profile with optimistic updates and offline queue support
+ */
+export declare const useUpdateProfile: () => import("@tanstack/react-query").UseMutationResult<any, Error, User, {
+    previousUser: any;
+}>;
+/**
+ * Upload avatar with progress tracking and offline queue support
+ */
+export declare const useUploadAvatar: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
+    uri: string;
+    type?: string;
+    name?: string;
+    size?: number;
+}, {
+    previousUser: any;
+}>;
+/**
+ * Update account settings
+ */
+export declare const useUpdateAccountSettings: () => import("@tanstack/react-query").UseMutationResult<any, Error, Record<string, any>, {
+    previousUser: any;
+}>;
+/**
+ * Update privacy settings with optimistic updates and authentication handling
+ */
+export declare const useUpdatePrivacySettings: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
+    settings: Record<string, any>;
+    userId?: string;
+}, {
+    previousPrivacySettings: unknown;
+    previousUser: any;
+} | undefined>;
+/**
+ * Upload file with authentication handling and progress tracking
+ */
+export declare const useUploadFile: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
+    file: File;
+    visibility?: "private" | "public" | "unlisted";
+    metadata?: Record<string, any>;
+    onProgress?: (progress: number) => void;
+}, unknown>;