@oxyhq/services 5.17.17 → 5.18.0

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

@@ -1,20 +1,16 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import type { User } from '../../../models/interfaces';
-import type { ClientSession } from '../../../models/session';
 import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
 import { useOxy } from '../../context/OxyContext';
 import { toast } from '../../../lib/sonner';
-import { refreshAccountInStore } from '../../utils/avatarUtils';
-import { logger } from '../../../utils/loggerUtils';
-
-const getDeviceIdForSession = (sessions: ClientSession[] = [], sessionId: string | null) =>
-  sessionId ? sessions.find((s) => s.sessionId === sessionId)?.deviceId : undefined;
+import { refreshAvatarInStore } from '../../utils/avatarUtils';
+import { useAuthStore } from '../../stores/authStore';
 
 /**
  * Update user profile with optimistic updates and offline queue support
  */
 export const useUpdateProfile = () => {
-  const { oxyServices, activeSessionId, user, sessions } = useOxy();
+  const { oxyServices, activeSessionId, user } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -23,9 +19,16 @@ export const useUpdateProfile = () => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
+          await oxyServices.getTokenBySession(activeSessionId);
         } catch (tokenError) {
-          throw 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;
+          }
         }
       }
 
@@ -37,7 +40,8 @@ export const useUpdateProfile = () => {
         
         // Handle authentication errors
         if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          throw error;
+          // 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
@@ -80,39 +84,25 @@ export const useUpdateProfile = () => {
       }
       toast.error(error instanceof Error ? error.message : 'Failed to update profile');
     },
-    // On success, update cache and sync to store
-    onSuccess: async (data, updates) => {
-      logger.debug('Profile update successful', {
-        component: 'useUpdateProfile',
-        username: data.username,
-        updatedFields: Object.keys(updates)
-      });
-
+    // On success, invalidate and refetch
+    onSuccess: (data, updates) => {
       // Update cache with server response
       queryClient.setQueryData(queryKeys.accounts.current(), data);
       if (activeSessionId) {
         queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
       }
-
-      // Refresh accountStore with all updated profile data (synchronizes immediately)
-      if (activeSessionId && oxyServices) {
-        refreshAccountInStore(activeSessionId, data, oxyServices);
+      
+      // Update authStore so frontend components see the changes immediately
+      useAuthStore.getState().setUser(data);
+      
+      // If avatar was updated, refresh accountStore with cache-busted URL
+      if (updates.avatar && activeSessionId && oxyServices) {
+        refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);
       }
-
-      // Force refetch of all active queries to ensure UI updates immediately
-      // Using refetchQueries instead of invalidateQueries to bypass staleTime
-      await Promise.all([
-        queryClient.refetchQueries({
-          queryKey: queryKeys.accounts.all,
-          type: 'active'
-        }),
-        queryClient.refetchQueries({
-          queryKey: queryKeys.users.all,
-          type: 'active'
-        })
-      ]);
-
-      logger.debug('Profile update complete', { component: 'useUpdateProfile' });
+      
+      // Invalidate all related queries to refresh everywhere
+      invalidateUserQueries(queryClient);
+      invalidateAccountQueries(queryClient);
     },
   });
 };
@@ -121,7 +111,7 @@ export const useUpdateProfile = () => {
  * Upload avatar with progress tracking and offline queue support
  */
 export const useUploadAvatar = () => {
-  const { oxyServices, activeSessionId, sessions } = useOxy();
+  const { oxyServices, activeSessionId } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
@@ -129,9 +119,15 @@ export const useUploadAvatar = () => {
       // Ensure we have a valid token before making the request
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
-          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
+          await oxyServices.getTokenBySession(activeSessionId);
         } catch (tokenError) {
-          throw tokenError;
+          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;
+          }
         }
       }
 
@@ -152,7 +148,8 @@ export const useUploadAvatar = () => {
         
         // Handle authentication errors
         if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          throw error;
+          // 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
@@ -186,35 +183,24 @@ export const useUploadAvatar = () => {
       }
       toast.error(error instanceof Error ? error.message : 'Failed to upload avatar');
     },
-    onSuccess: async (data) => {
-      logger.debug(
-        'Avatar upload successful',
-        { component: 'useUploadAvatar', method: 'onSuccess', data }
-      );
-      
+    onSuccess: (data) => {
       queryClient.setQueryData(queryKeys.accounts.current(), data);
       if (activeSessionId) {
         queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
       }
       
-      // Refresh accountStore with all updated profile data (including avatar)
-      if (activeSessionId && oxyServices) {
-        refreshAccountInStore(activeSessionId, data, oxyServices);
+      // Update authStore so frontend components see the changes immediately
+      useAuthStore.getState().setUser(data);
+      
+      // Refresh accountStore with cache-busted URL if avatar was updated
+      if (data?.avatar && activeSessionId && oxyServices) {
+        refreshAvatarInStore(activeSessionId, data.avatar, oxyServices);
       }
       
       // Invalidate all related queries to refresh everywhere
-      await invalidateUserQueries(queryClient);
-      await invalidateAccountQueries(queryClient);
-      
-      // Explicitly refetch to ensure UI updates
-      await queryClient.refetchQueries({ queryKey: queryKeys.accounts.current() });
-      
+      invalidateUserQueries(queryClient);
+      invalidateAccountQueries(queryClient);
       toast.success('Avatar updated successfully');
-      
-      logger.debug(
-        'Avatar update complete - cache invalidated and refetched',
-        { component: 'useUploadAvatar', method: 'onSuccess' }
-      );
     },
   });
 };
@@ -255,6 +241,9 @@ export const useUpdateAccountSettings = () => {
     onSuccess: (data) => {
       queryClient.setQueryData(queryKeys.accounts.current(), data);
       
+      // Update authStore so frontend components see the changes immediately
+      useAuthStore.getState().setUser(data);
+      
       invalidateAccountQueries(queryClient);
       toast.success('Settings updated successfully');
     },
@@ -268,14 +257,12 @@ export const useUpdateAccountSettings = () => {
  * Update privacy settings with optimistic updates and authentication handling
  */
 export const useUpdatePrivacySettings = () => {
-  const { oxyServices, activeSessionId, sessions } = useOxy();
+  const { oxyServices, activeSessionId, user } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: async ({ settings, userId }: { settings: Record<string, any>; userId?: string }) => {
-      // Use getCurrentUserId() which returns MongoDB ObjectId from JWT token
-      // Never use user?.id as it may be set to publicKey
-      const targetUserId = userId || oxyServices.getCurrentUserId();
+      const targetUserId = userId || user?.id;
       if (!targetUserId) {
         throw new Error('User ID is required');
       }
@@ -284,9 +271,16 @@ export const useUpdatePrivacySettings = () => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
+          await oxyServices.getTokenBySession(activeSessionId);
         } catch (tokenError) {
-          throw 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;
+          }
         }
       }
 
@@ -298,7 +292,8 @@ export const useUpdatePrivacySettings = () => {
         
         // Handle authentication errors
         if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          throw error;
+          // 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
@@ -307,7 +302,7 @@ export const useUpdatePrivacySettings = () => {
     },
     // Optimistic update
     onMutate: async ({ settings, userId }) => {
-      const targetUserId = userId || oxyServices.getCurrentUserId();
+      const targetUserId = userId || user?.id;
       if (!targetUserId) return;
 
       // Cancel outgoing refetches
@@ -341,7 +336,7 @@ export const useUpdatePrivacySettings = () => {
     },
     // On error, rollback
     onError: (error, { userId }, context) => {
-      const targetUserId = userId || oxyServices.getCurrentUserId();
+      const targetUserId = userId || user?.id;
       if (context?.previousPrivacySettings && targetUserId) {
         queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), context.previousPrivacySettings);
       }
@@ -352,7 +347,7 @@ export const useUpdatePrivacySettings = () => {
     },
     // On success, invalidate and refetch
     onSuccess: (data, { userId }) => {
-      const targetUserId = userId || oxyServices.getCurrentUserId();
+      const targetUserId = userId || user?.id;
       if (targetUserId) {
         queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), data);
       }
@@ -364,12 +359,15 @@ export const useUpdatePrivacySettings = () => {
           privacySettings: data,
         };
         queryClient.setQueryData<User>(queryKeys.accounts.current(), updatedUser);
+        
+        // Update authStore so frontend components see the changes immediately
+        useAuthStore.getState().setUser(updatedUser);
       }
       invalidateAccountQueries(queryClient);
     },
     // Always refetch after error or success
     onSettled: (data, error, { userId }) => {
-      const targetUserId = userId || oxyServices.getCurrentUserId();
+      const targetUserId = userId || user?.id;
       if (targetUserId) {
         queryClient.invalidateQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
       }
@@ -382,7 +380,7 @@ export const useUpdatePrivacySettings = () => {
  * Upload file with authentication handling and progress tracking
  */
 export const useUploadFile = () => {
-  const { oxyServices, activeSessionId, sessions } = useOxy();
+  const { oxyServices, activeSessionId } = useOxy();
 
   return useMutation({
     mutationFn: async ({ 
@@ -400,9 +398,16 @@ export const useUploadFile = () => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId, getDeviceIdForSession(sessions, activeSessionId));
+          await oxyServices.getTokenBySession(activeSessionId);
         } catch (tokenError) {
-          throw 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;
+          }
         }
       }
 
@@ -414,7 +419,8 @@ export const useUploadFile = () => {
         
         // Handle authentication errors
         if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          throw error;
+          // 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
@@ -423,3 +429,4 @@ export const useUploadFile = () => {
     },
   });
 };
+

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

@@ -2,8 +2,7 @@ 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/OxyContextBase';
-import { logger } from '../../../utils/loggerUtils';
+import { useOxy } from '../../context/OxyContext';
 
 /**
  * Get user profile by session ID
@@ -20,8 +19,8 @@ export const useUserProfile = (sessionId: string | null, options?: { enabled?: b
       return await oxyServices.getUserBySession(sessionId);
     },
     enabled: (options?.enabled !== false) && !!sessionId,
-    staleTime: 30000, // 30 seconds - reasonable freshness without constant refetching
-    gcTime: 5 * 60 * 1000, // 5 minutes - keep in cache for quick access
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 30 * 60 * 1000, // 30 minutes
   });
 };
 
@@ -39,8 +38,8 @@ export const useUserProfiles = (sessionIds: string[], options?: { enabled?: bool
         return results[0]?.user || null;
       },
       enabled: (options?.enabled !== false) && !!sessionId,
-      staleTime: 30000, // 30 seconds
-      gcTime: 5 * 60 * 1000, // 5 minutes
+      staleTime: 5 * 60 * 1000,
+      gcTime: 30 * 60 * 1000,
     })),
   });
 };
@@ -54,25 +53,14 @@ export const useCurrentUser = (options?: { enabled?: boolean }) => {
   return useQuery({
     queryKey: queryKeys.accounts.current(),
     queryFn: async () => {
-      logger.debug('Fetching current user', {
-        component: 'useCurrentUser',
-        sessionId: activeSessionId ?? undefined
-      });
       if (!activeSessionId) {
         throw new Error('No active session');
       }
-      const userData = await oxyServices.getUserBySession(activeSessionId);
-      logger.debug('Current user fetched', {
-        component: 'useCurrentUser',
-        username: userData.username
-      });
-      return userData;
+      return await oxyServices.getUserBySession(activeSessionId);
     },
     enabled: (options?.enabled !== false) && isAuthenticated && !!activeSessionId,
-    staleTime: 30000, // 30 seconds - balances freshness with performance
-    gcTime: 5 * 60 * 1000, // 5 minutes
-    refetchOnMount: 'always', // Always refetch on mount
-    refetchOnWindowFocus: false,
+    staleTime: 1 * 60 * 1000, // 1 minute for current user
+    gcTime: 30 * 60 * 1000,
   });
 };
 
@@ -91,8 +79,8 @@ export const useUserById = (userId: string | null, options?: { enabled?: boolean
       return await oxyServices.getUserById(userId);
     },
     enabled: (options?.enabled !== false) && !!userId,
-    staleTime: 60000, // 1 minute - other users' profiles change less frequently
-    gcTime: 10 * 60 * 1000, // 10 minutes
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
   });
 };
 
@@ -111,8 +99,8 @@ export const useUserByUsername = (username: string | null, options?: { enabled?:
       return await oxyServices.getProfileByUsername(username);
     },
     enabled: (options?.enabled !== false) && !!username,
-    staleTime: 60000, // 1 minute
-    gcTime: 10 * 60 * 1000, // 10 minutes
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
   });
 };
 
@@ -131,8 +119,8 @@ export const useUsersBySessions = (sessionIds: string[], options?: { enabled?: b
       return await oxyServices.getUsersBySessions(sessionIds);
     },
     enabled: (options?.enabled !== false) && sessionIds.length > 0,
-    staleTime: 30000, // 30 seconds
-    gcTime: 5 * 60 * 1000, // 5 minutes
+    staleTime: 5 * 60 * 1000,
+    gcTime: 30 * 60 * 1000,
   });
 };
 
@@ -140,11 +128,8 @@ export const useUsersBySessions = (sessionIds: string[], options?: { enabled?: b
  * Get privacy settings for a user
  */
 export const usePrivacySettings = (userId?: string, options?: { enabled?: boolean }) => {
-  const { oxyServices, activeSessionId, sessions } = useOxy();
-  // Use getCurrentUserId() which returns MongoDB ObjectId from JWT token
-  // Never use user?.id as it may be set to publicKey
-  const targetUserId = userId || oxyServices.getCurrentUserId() || undefined;
-  const deviceId = activeSessionId ? sessions.find((s) => s.sessionId === activeSessionId)?.deviceId : undefined;
+  const { oxyServices, activeSessionId, user } = useOxy();
+  const targetUserId = userId || user?.id;
 
   return useQuery({
     queryKey: queryKeys.privacy.settings(targetUserId),
@@ -157,9 +142,16 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId, deviceId);
+          await oxyServices.getTokenBySession(activeSessionId);
         } catch (tokenError) {
-          throw 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;
+          }
         }
       }
 
@@ -171,7 +163,8 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
         
         // Handle authentication errors
         if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          throw error;
+          // 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
@@ -179,7 +172,8 @@ export const usePrivacySettings = (userId?: string, options?: { enabled?: boolea
       }
     },
     enabled: (options?.enabled !== false) && !!targetUserId,
-    staleTime: 60000, // 1 minute - privacy settings don't change frequently
+    staleTime: 2 * 60 * 1000, // 2 minutes
     gcTime: 10 * 60 * 1000, // 10 minutes
   });
 };
+

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

@@ -1,6 +1,6 @@
 import { useQuery } from '@tanstack/react-query';
 import { queryKeys } from './queryKeys';
-import { useOxy } from '../../context/OxyContextBase';
+import { useOxy } from '../../context/OxyContext';
 import type { SecurityActivity, SecurityEventType } from '../../../models/interfaces';
 
 /**

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

@@ -1,7 +1,7 @@
 import { useQuery } from '@tanstack/react-query';
 import type { ClientSession } from '../../../models/session';
 import { queryKeys } from './queryKeys';
-import { useOxy } from '../../context/OxyContextBase';
+import { useOxy } from '../../context/OxyContext';
 import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
 
 /**
@@ -89,8 +89,7 @@ export const useDeviceSessions = (options?: { enabled?: boolean }) => {
  * Get user devices
  */
 export const useUserDevices = (options?: { enabled?: boolean }) => {
-  const { oxyServices, isAuthenticated, activeSessionId, sessions } = useOxy();
-  const deviceId = activeSessionId ? sessions.find((s) => s.sessionId === activeSessionId)?.deviceId : undefined;
+  const { oxyServices, isAuthenticated, activeSessionId } = useOxy();
 
   return useQuery({
     queryKey: queryKeys.devices.list(),
@@ -99,9 +98,16 @@ export const useUserDevices = (options?: { enabled?: boolean }) => {
       if (!oxyServices.hasValidToken() && activeSessionId) {
         try {
           // Try to get token for the session
-          await oxyServices.getTokenBySession(activeSessionId, deviceId);
+          await oxyServices.getTokenBySession(activeSessionId);
         } catch (tokenError) {
-          throw 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;
+          }
         }
       }
 
@@ -113,7 +119,8 @@ export const useUserDevices = (options?: { enabled?: boolean }) => {
         
         // Handle authentication errors
         if (status === 401 || errorMessage.includes('Authentication required') || errorMessage.includes('Invalid or missing authorization header')) {
-          throw error;
+          // 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
@@ -142,3 +149,4 @@ export const useSecurityInfo = (options?: { enabled?: boolean }) => {
     gcTime: 30 * 60 * 1000,
   });
 };
+

package/src/ui/hooks/useAsyncAction.ts

@@ -0,0 +1,129 @@
+import { useState, useCallback } from 'react';
+import { toast } from '../../lib/sonner';
+
+interface UseAsyncActionOptions<T> {
+    /** Function to execute */
+    action: () => Promise<T>;
+    /** Success message to display */
+    successMessage?: string;
+    /** Error message to display (or function to get message from error) */
+    errorMessage?: string | ((error: any) => string);
+    /** Callback on success */
+    onSuccess?: (result: T) => void;
+    /** Callback on error */
+    onError?: (error: any) => void;
+    /** Show loading toast */
+    showLoadingToast?: boolean;
+    /** Loading message */
+    loadingMessage?: string;
+}
+
+interface UseAsyncActionReturn<T> {
+    /** Execute the action */
+    execute: () => Promise<T | undefined>;
+    /** Whether the action is currently executing */
+    isLoading: boolean;
+    /** The last error that occurred */
+    error: Error | null;
+    /** Reset the error state */
+    resetError: () => void;
+}
+
+/**
+ * Hook for handling async actions with loading state, error handling, and toast notifications.
+ * Reduces boilerplate for common patterns like try-catch with toast feedback.
+ *
+ * @example
+ * const { execute, isLoading } = useAsyncAction({
+ *   action: () => api.saveSettings(settings),
+ *   successMessage: 'Settings saved!',
+ *   errorMessage: 'Failed to save settings',
+ * });
+ *
+ * <Button onPress={execute} disabled={isLoading}>Save</Button>
+ */
+export function useAsyncAction<T = void>(
+    options: UseAsyncActionOptions<T>
+): UseAsyncActionReturn<T> {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const execute = useCallback(async (): Promise<T | undefined> => {
+        const {
+            action,
+            successMessage,
+            errorMessage,
+            onSuccess,
+            onError,
+            showLoadingToast,
+            loadingMessage,
+        } = options;
+
+        setIsLoading(true);
+        setError(null);
+
+        if (showLoadingToast && loadingMessage) {
+            toast.loading(loadingMessage);
+        }
+
+        try {
+            const result = await action();
+
+            if (successMessage) {
+                toast.success(successMessage);
+            }
+
+            onSuccess?.(result);
+            return result;
+        } catch (err: any) {
+            const message = typeof errorMessage === 'function'
+                ? errorMessage(err)
+                : errorMessage || err?.message || 'An error occurred';
+
+            toast.error(message);
+            setError(err instanceof Error ? err : new Error(message));
+            onError?.(err);
+            return undefined;
+        } finally {
+            setIsLoading(false);
+        }
+    }, [options]);
+
+    const resetError = useCallback(() => {
+        setError(null);
+    }, []);
+
+    return { execute, isLoading, error, resetError };
+}
+
+/**
+ * Simplified version that just executes an async action with toast feedback.
+ * Useful for one-off actions.
+ */
+export async function executeWithToast<T>(
+    action: () => Promise<T>,
+    options?: {
+        successMessage?: string;
+        errorMessage?: string;
+        loadingMessage?: string;
+    }
+): Promise<T | undefined> {
+    const { successMessage, errorMessage, loadingMessage } = options || {};
+
+    if (loadingMessage) {
+        toast.loading(loadingMessage);
+    }
+
+    try {
+        const result = await action();
+        if (successMessage) {
+            toast.success(successMessage);
+        }
+        return result;
+    } catch (err: any) {
+        toast.error(errorMessage || err?.message || 'An error occurred');
+        return undefined;
+    }
+}
+
+export default useAsyncAction;