@oxyhq/services 6.9.46 → 6.10.2

package/src/ui/hooks/index.ts

@@ -1,6 +1,13 @@
 export { useFollow, useFollowerCounts } from './useFollow';
-export { useFileDownloadUrl, setOxyFileUrlInstance } from './useFileDownloadUrl';
-export { useThemeStyles } from './useThemeStyles';
-export { useThemeColors } from './useThemeColors';
+export { useFileDownloadUrl } from './useFileDownloadUrl';
 export { useAsyncAction, executeWithToast } from './useAsyncAction';
-export { useSettingToggle, useSettingToggles } from './useSettingToggle';
+export { useSettingToggle, useSettingToggles } from './useSettingToggle';
+export { useMutationStatus, type MutationStatus } from './useMutationStatus';
+export { useOnlineStatus } from './useOnlineStatus';
+export { mutationKeys } from './mutations/mutationKeys';
+export {
+  attachQueryPersistence,
+  clearQueryCache,
+  createQueryClient,
+  type AttachPersistenceResult,
+} from './queryClient';

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

@@ -12,7 +12,7 @@
 import type { QueryClient, UseMutationOptions } from '@tanstack/react-query';
 import type { User } from '@oxyhq/core';
 import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
-import { toast } from '../../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 import { useAuthStore } from '../../stores/authStore';
 
 /**
@@ -21,6 +21,11 @@ import { useAuthStore } from '../../stores/authStore';
 export interface ProfileMutationConfig<TData, TVariables> {
   /** The mutation function that makes the API call */
   mutationFn: (variables: TVariables) => Promise<TData>;
+  /**
+   * Stable mutation key for the offline queue. Required so TanStack Query
+   * can correlate paused mutations across refetches/resume cycles.
+   */
+  mutationKey: readonly unknown[];
   /** Query keys to cancel before mutation */
   cancelQueryKeys?: unknown[][];
   /** Function to apply optimistic update to the user data */
@@ -45,6 +50,7 @@ export interface ProfileMutationConfig<TData, TVariables> {
  * @example
  * ```ts
  * const updateProfile = createProfileMutation({
+ *   mutationKey: mutationKeys.account.updateProfile,
  *   mutationFn: (updates) => oxyServices.updateProfile(updates),
  *   optimisticUpdate: (user, updates) => updates,
  *   errorMessage: 'Failed to update profile',
@@ -58,6 +64,7 @@ export function createProfileMutation<TVariables>(
 ): UseMutationOptions<User, Error, TVariables, { previousUser?: User }> {
   const {
     mutationFn,
+    mutationKey,
     cancelQueryKeys = [],
     optimisticUpdate,
     errorMessage = 'Operation failed',
@@ -69,6 +76,7 @@ export function createProfileMutation<TVariables>(
   } = config;
 
   return {
+    mutationKey: [...mutationKey],
     mutationFn,
 
     onMutate: async (variables) => {
@@ -151,6 +159,11 @@ export function createProfileMutation<TVariables>(
 export interface GenericMutationConfig<TData, TVariables, TContext> {
   /** The mutation function */
   mutationFn: (variables: TVariables) => Promise<TData>;
+  /**
+   * Stable mutation key for the offline queue. Required so TanStack Query
+   * can correlate paused mutations across refetches/resume cycles.
+   */
+  mutationKey: readonly unknown[];
   /** Query key for optimistic data */
   queryKey: unknown[];
   /** Function to create optimistic data */
@@ -172,6 +185,7 @@ export function createGenericMutation<TData, TVariables>(
 ): UseMutationOptions<TData, Error, TVariables, { previous?: TData }> {
   const {
     mutationFn,
+    mutationKey,
     queryKey,
     optimisticData,
     errorMessage = 'Operation failed',
@@ -180,6 +194,7 @@ export function createGenericMutation<TData, TVariables>(
   } = config;
 
   return {
+    mutationKey: [...mutationKey],
     mutationFn,
 
     onMutate: async (variables) => {

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

@@ -0,0 +1,28 @@
+/**
+ * Stable mutation key factories.
+ *
+ * Mutations that may be queued while offline MUST declare a stable
+ * `mutationKey`. When the network comes back, TanStack Query resumes
+ * paused mutations grouped by key — so the keys here should be stable
+ * across renders and across reloads when persistence is enabled.
+ */
+
+export const mutationKeys = {
+  // Account-related writes
+  account: {
+    updateProfile: ['mutation', 'account', 'updateProfile'] as const,
+    uploadAvatar: ['mutation', 'account', 'uploadAvatar'] as const,
+    updateSettings: ['mutation', 'account', 'updateSettings'] as const,
+    updatePrivacySettings: ['mutation', 'account', 'updatePrivacySettings'] as const,
+    uploadFile: ['mutation', 'account', 'uploadFile'] as const,
+  },
+
+  // Session / device writes
+  session: {
+    switch: ['mutation', 'session', 'switch'] as const,
+    logout: ['mutation', 'session', 'logout'] as const,
+    logoutAll: ['mutation', 'session', 'logoutAll'] as const,
+    updateDeviceName: ['mutation', 'session', 'updateDeviceName'] as const,
+    removeDevice: ['mutation', 'session', 'removeDevice'] as const,
+  },
+} as const;

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

@@ -1,9 +1,10 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { authenticatedApiCall } from '@oxyhq/core';
-import type { User } from '@oxyhq/core';
-import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
+import type { AssetUploadInput, PrivacySettings, User } from '@oxyhq/core';
+import { queryKeys, invalidateAccountQueries, invalidateUserQueries, invalidateSessionQueries } from '../queries/queryKeys';
+import { mutationKeys } from './mutationKeys';
 import { useOxy } from '../../context/OxyContext';
-import { toast } from '../../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 import { refreshAvatarInStore } from '../../utils/avatarUtils';
 import { useAuthStore } from '../../stores/authStore';
 
@@ -15,6 +16,7 @@ export const useUpdateProfile = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
+    mutationKey: [...mutationKeys.account.updateProfile],
     mutationFn: async (updates: Partial<User>) => {
       return authenticatedApiCall<User>(
         oxyServices,
@@ -48,12 +50,31 @@ export const useUpdateProfile = () => {
 
       return { previousUser };
     },
-    // On error, rollback
+    // On error, rollback ONLY the keys this mutation tried to change
     onError: (error, updates, context) => {
-      if (context?.previousUser) {
-        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+      if (context?.previousUser && updates) {
+        const previousUser = context.previousUser;
+        const changedKeys = Object.keys(updates) as Array<keyof User>;
+        const partialRollback = changedKeys.reduce<Partial<User>>((acc, key) => {
+          (acc as Record<string, unknown>)[key as string] = previousUser[key];
+          return acc;
+        }, {});
+
+        const current = queryClient.getQueryData<User>(queryKeys.accounts.current());
+        if (current) {
+          queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+            ...current,
+            ...partialRollback,
+          });
+        }
         if (activeSessionId) {
-          queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+          const currentProfile = queryClient.getQueryData<User>(queryKeys.users.profile(activeSessionId));
+          if (currentProfile) {
+            queryClient.setQueryData<User>(queryKeys.users.profile(activeSessionId), {
+              ...currentProfile,
+              ...partialRollback,
+            });
+          }
         }
       }
       toast.error(error instanceof Error ? error.message : 'Failed to update profile');
@@ -65,18 +86,22 @@ export const useUpdateProfile = () => {
       if (activeSessionId) {
         queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
       }
-      
+
       // 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);
       }
-      
-      // Invalidate all related queries to refresh everywhere
+
+      // Invalidate all related queries so every consumer (AccountSwitcher,
+      // session lists, managed accounts, etc.) refetches the fresh profile.
+      // This is critical right after `username` is set the first time, when
+      // every cached "session profile" still reports the user as unnamed.
       invalidateUserQueries(queryClient);
       invalidateAccountQueries(queryClient);
+      invalidateSessionQueries(queryClient);
     },
   });
 };
@@ -89,6 +114,7 @@ export const useUploadAvatar = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
+    mutationKey: [...mutationKeys.account.uploadAvatar],
     mutationFn: async (file: { uri: string; type?: string; name?: string; size?: number }) => {
       return authenticatedApiCall<User>(oxyServices, activeSessionId, async () => {
         const uploadResult = await oxyServices.assetUpload(file, 'public');
@@ -120,11 +146,25 @@ export const useUploadAvatar = () => {
 
       return { previousUser };
     },
-    onError: (error, file, context) => {
+    onError: (error, _file, context) => {
+      // Avatar upload only mutates the `avatar` field — restore only that key
       if (context?.previousUser) {
-        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+        const previousAvatar = context.previousUser.avatar;
+        const current = queryClient.getQueryData<User>(queryKeys.accounts.current());
+        if (current) {
+          queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+            ...current,
+            avatar: previousAvatar,
+          });
+        }
         if (activeSessionId) {
-          queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+          const currentProfile = queryClient.getQueryData<User>(queryKeys.users.profile(activeSessionId));
+          if (currentProfile) {
+            queryClient.setQueryData<User>(queryKeys.users.profile(activeSessionId), {
+              ...currentProfile,
+              avatar: previousAvatar,
+            });
+          }
         }
       }
       toast.error(error instanceof Error ? error.message : 'Failed to upload avatar');
@@ -142,27 +182,79 @@ export const useUploadAvatar = () => {
       if (data?.avatar && activeSessionId && oxyServices) {
         refreshAvatarInStore(activeSessionId, data.avatar, oxyServices);
       }
-      
-      // Invalidate all related queries to refresh everywhere
+
+      // Invalidate all related queries to refresh everywhere, including the
+      // sessions cache so other-account avatars update too.
       invalidateUserQueries(queryClient);
       invalidateAccountQueries(queryClient);
+      invalidateSessionQueries(queryClient);
       toast.success('Avatar updated successfully');
     },
   });
 };
 
 /**
- * Update account settings
+ * Variables accepted by the `useUpdateAccountSettings` mutation.
+ *
+ * `currentUser` is captured at dispatch time so the rebuilt user object the
+ * mutation returns is computed against a stable snapshot — NOT the cache
+ * value at the moment the API call settles. Reading from the cache inside
+ * `mutationFn` would race with sibling optimistic updates: a concurrent
+ * write could already have overwritten the cache by the time the privacy
+ * update returns, causing the rebuilt user to clobber the sibling's
+ * optimistic value.
+ */
+interface UpdateAccountSettingsVariables {
+  /** Subset of privacy fields to write. */
+  updates: Partial<PrivacySettings>;
+  /**
+   * The User snapshot captured at mutation dispatch time. The mutation
+   * rebuilds this user with the updated `privacySettings` and returns it
+   * to `onSuccess`. Required to avoid the race described above.
+   */
+  currentUser: User;
+}
+
+/**
+ * Update account settings (privacy preferences).
+ *
+ * Privacy settings are not part of the `PUT /users/me` allow-list; the API
+ * would silently drop them. Route through `updatePrivacySettings` so the
+ * dedicated `PATCH /privacy/:id/privacy` endpoint performs a dot-path merge
+ * and returns the updated `privacySettings` object.
+ *
+ * The returned object exposes the standard mutation surface PLUS a
+ * convenience `mutate(updates)` / `mutateAsync(updates)` that snapshots
+ * the current user from `useOxy()` at dispatch time. Callers that need to
+ * supply their own user snapshot (testing, server-side) can call the
+ * underlying `.mutate({ updates, currentUser })` form via `.mutation`.
  */
 export const useUpdateAccountSettings = () => {
-  const { oxyServices, activeSessionId } = useOxy();
+  const { oxyServices, activeSessionId, user } = useOxy();
   const queryClient = useQueryClient();
 
-  return useMutation({
-    mutationFn: async (settings: Record<string, any>) => {
-      return await oxyServices.updateProfile({ privacySettings: settings });
+  const mutation = useMutation({
+    mutationKey: [...mutationKeys.account.updateSettings],
+    mutationFn: async ({ updates, currentUser }: UpdateAccountSettingsVariables) => {
+      const userId = currentUser.id;
+      if (!userId) {
+        throw new Error('User ID is required to update account settings');
+      }
+      const updatedPrivacy = await authenticatedApiCall<PrivacySettings>(
+        oxyServices,
+        activeSessionId,
+        () => oxyServices.updatePrivacySettings(updates, userId)
+      );
+      // Rebuild against the dispatch-time snapshot, NOT the live cache.
+      // The cache may have been mutated by a sibling write between
+      // dispatch and settle; using `currentUser` keeps this mutation
+      // hermetic.
+      return {
+        ...currentUser,
+        privacySettings: updatedPrivacy,
+      };
     },
-    onMutate: async (settings) => {
+    onMutate: async ({ updates }) => {
       await queryClient.cancelQueries({ queryKey: queryKeys.accounts.settings() });
       const previousUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
 
@@ -171,25 +263,42 @@ export const useUpdateAccountSettings = () => {
           ...previousUser,
           privacySettings: {
             ...previousUser.privacySettings,
-            ...settings,
+            ...updates,
           },
         });
       }
 
       return { previousUser };
     },
-    onError: (error, settings, context) => {
-      if (context?.previousUser) {
-        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+    onError: (error, { updates }, context) => {
+      // Restore only the privacySettings keys this mutation tried to change
+      if (context?.previousUser && updates) {
+        const previousPrivacy = context.previousUser.privacySettings ?? {};
+        const changedKeys = Object.keys(updates) as Array<keyof PrivacySettings>;
+        const partialPrivacyRollback = changedKeys.reduce<Partial<PrivacySettings>>((acc, key) => {
+          (acc as Record<string, unknown>)[key as string] = (previousPrivacy as Record<string, unknown>)[key as string];
+          return acc;
+        }, {});
+
+        const current = queryClient.getQueryData<User>(queryKeys.accounts.current());
+        if (current) {
+          queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+            ...current,
+            privacySettings: {
+              ...(current.privacySettings ?? {}),
+              ...partialPrivacyRollback,
+            },
+          });
+        }
       }
       toast.error(error instanceof Error ? error.message : 'Failed to update settings');
     },
     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');
     },
@@ -197,6 +306,29 @@ export const useUpdateAccountSettings = () => {
       queryClient.invalidateQueries({ queryKey: queryKeys.accounts.settings() });
     },
   });
+
+  // Snapshot the current user at dispatch time. Reading `user` here (from
+  // the `useOxy()` closure of the call to `useUpdateAccountSettings`) is
+  // the dispatch-time value, captured the moment `mutate()` runs — exactly
+  // what the race fix needs.
+  return {
+    ...mutation,
+    mutate: (updates: Partial<PrivacySettings>): void => {
+      const currentUser = user ?? queryClient.getQueryData<User>(queryKeys.accounts.current());
+      if (!currentUser) {
+        toast.error('Cannot update account settings: no current user');
+        return;
+      }
+      mutation.mutate({ updates, currentUser });
+    },
+    mutateAsync: async (updates: Partial<PrivacySettings>): Promise<User> => {
+      const currentUser = user ?? queryClient.getQueryData<User>(queryKeys.accounts.current());
+      if (!currentUser) {
+        throw new Error('Cannot update account settings: no current user');
+      }
+      return mutation.mutateAsync({ updates, currentUser });
+    },
+  };
 };
 
 /**
@@ -207,13 +339,14 @@ export const useUpdatePrivacySettings = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async ({ settings, userId }: { settings: Record<string, any>; userId?: string }) => {
+    mutationKey: [...mutationKeys.account.updatePrivacySettings],
+    mutationFn: async ({ settings, userId }: { settings: Partial<PrivacySettings>; userId?: string }) => {
       const targetUserId = userId || user?.id;
       if (!targetUserId) {
         throw new Error('User ID is required');
       }
 
-      return authenticatedApiCall<Record<string, unknown>>(
+      return authenticatedApiCall<PrivacySettings>(
         oxyServices,
         activeSessionId,
         () => oxyServices.updatePrivacySettings(settings, targetUserId)
@@ -234,8 +367,8 @@ export const useUpdatePrivacySettings = () => {
 
       // Optimistically update privacy settings
       if (previousPrivacySettings) {
-        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), {
-          ...previousPrivacySettings,
+        queryClient.setQueryData<PrivacySettings>(queryKeys.privacy.settings(targetUserId), {
+          ...(previousPrivacySettings as PrivacySettings),
           ...settings,
         });
       }
@@ -253,44 +386,102 @@ export const useUpdatePrivacySettings = () => {
 
       return { previousPrivacySettings, previousUser };
     },
-    // On error, rollback
-    onError: (error, { userId }, context) => {
+    // On error, rollback ONLY the privacy keys this mutation tried to change.
+    // Restoring the entire previous object would wipe out other concurrent
+    // optimistic updates (e.g. user toggles two privacy switches in quick
+    // succession; failure on one must not revert the other).
+    onError: (error, { settings, userId }, context) => {
       const targetUserId = userId || user?.id;
-      if (context?.previousPrivacySettings && targetUserId) {
-        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), context.previousPrivacySettings);
+      const changedKeys = settings ? (Object.keys(settings) as Array<keyof PrivacySettings>) : [];
+
+      // Rollback the privacy.settings query (partial)
+      if (context?.previousPrivacySettings && targetUserId && changedKeys.length > 0) {
+        const previousPrivacy = context.previousPrivacySettings as Record<string, unknown>;
+        const partialPrivacyRollback = changedKeys.reduce<Partial<PrivacySettings>>((acc, key) => {
+          (acc as Record<string, unknown>)[key as string] = previousPrivacy[key as string];
+          return acc;
+        }, {});
+        const currentPrivacy = queryClient.getQueryData<PrivacySettings>(queryKeys.privacy.settings(targetUserId));
+        if (currentPrivacy) {
+          queryClient.setQueryData<PrivacySettings>(queryKeys.privacy.settings(targetUserId), {
+            ...currentPrivacy,
+            ...partialPrivacyRollback,
+          });
+        }
       }
-      if (context?.previousUser) {
-        queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+
+      // Rollback the accounts.current() user.privacySettings (partial)
+      if (context?.previousUser && changedKeys.length > 0) {
+        const previousPrivacy = (context.previousUser.privacySettings ?? {}) as Record<string, unknown>;
+        const partialPrivacyRollback = changedKeys.reduce<Partial<PrivacySettings>>((acc, key) => {
+          (acc as Record<string, unknown>)[key as string] = previousPrivacy[key as string];
+          return acc;
+        }, {});
+        const current = queryClient.getQueryData<User>(queryKeys.accounts.current());
+        if (current) {
+          queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+            ...current,
+            privacySettings: {
+              ...(current.privacySettings ?? {}),
+              ...partialPrivacyRollback,
+            },
+          });
+        }
+      }
+
+      // After partial rollback, force a fresh fetch from the server so any
+      // concurrent-mutation state we may have failed to restore correctly
+      // gets reconciled with the source of truth. Targeted at privacy.settings
+      // only — NOT onSettled, which would defeat the merge fix on success.
+      if (targetUserId) {
+        queryClient.invalidateQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
       }
+
       toast.error(error instanceof Error ? error.message : 'Failed to update privacy settings');
     },
-    // On success, invalidate and refetch
-    onSuccess: (data, { userId }) => {
+    // On success, MERGE the server response into the cached state. Older
+    // API builds returned only the changed field (or wiped the privacySettings
+    // subdocument when handed a partial update), which would clobber every
+    // other toggle if we blindly replaced. Defensive merge means the UI stays
+    // consistent regardless of server behaviour.
+    //
+    // BOTH the privacy.settings query AND the accounts.current() user are
+    // gated on `targetUserId`. If it's missing (no userId param, no logged-in
+    // user) the optimistic update in onMutate would have early-returned too,
+    // so neither cache was ever touched — there's nothing to reconcile here.
+    onSuccess: (data, { userId, settings }) => {
       const targetUserId = userId || user?.id;
-      if (targetUserId) {
-        queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), data);
-      }
-      // Also update account query if it contains privacy settings
+      if (!targetUserId) return;
+
+      const incoming = (data ?? {}) as PrivacySettings;
+      const requested = (settings ?? {}) as Partial<PrivacySettings>;
+
+      queryClient.setQueryData<PrivacySettings>(
+        queryKeys.privacy.settings(targetUserId),
+        (previous) => ({
+          ...(previous ?? {}),
+          ...requested,
+          ...incoming, // server wins for fields it explicitly returned
+        }),
+      );
+
       const currentUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
       if (currentUser) {
         const updatedUser: User = {
           ...currentUser,
-          privacySettings: data as { [key: string]: unknown },
+          privacySettings: {
+            ...(currentUser.privacySettings ?? {}),
+            ...requested,
+            ...incoming,
+          },
         };
         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 || user?.id;
-      if (targetUserId) {
-        queryClient.invalidateQueries({ queryKey: queryKeys.privacy.settings(targetUserId) });
-      }
-      queryClient.invalidateQueries({ queryKey: queryKeys.accounts.current() });
+      // Deliberately NOT invalidating any queries here. invalidateAccountQueries
+      // invalidates accounts.all which is the prefix for accounts.current(),
+      // triggering a background refetch of useCurrentUser that would overwrite
+      // the merged state above. The onSuccess merge is the source of truth.
     },
   });
 };
@@ -321,15 +512,16 @@ export const useUploadFile = () => {
   const { oxyServices, activeSessionId } = useOxy();
 
   return useMutation({
+    mutationKey: [...mutationKeys.account.uploadFile],
     mutationFn: async ({
       file,
       visibility,
       metadata,
-      onProgress
+      onProgress,
     }: {
-      file: File;
+      file: AssetUploadInput;
       visibility?: 'private' | 'public' | 'unlisted';
-      metadata?: Record<string, any>;
+      metadata?: Record<string, unknown>;
       onProgress?: (progress: number) => void;
     }) => {
       return authenticatedApiCall<UploadResult>(

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

@@ -1,17 +1,19 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
-import type { User, ClientSession } from '@oxyhq/core';
+import type { ClientSession } from '@oxyhq/core';
 import { queryKeys, invalidateSessionQueries } from '../queries/queryKeys';
+import { mutationKeys } from './mutationKeys';
 import { useOxy } from '../../context/OxyContext';
-import { toast } from '../../../lib/sonner';
+import { toast } from '@oxyhq/bloom';
 
 /**
  * Switch active session
  */
 export const useSwitchSession = () => {
-  const { switchSession, activeSessionId } = useOxy();
+  const { switchSession } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
+    mutationKey: [...mutationKeys.session.switch],
     mutationFn: async (sessionId: string) => {
       return await switchSession(sessionId);
     },
@@ -35,10 +37,11 @@ export const useSwitchSession = () => {
  * Logout from a session
  */
 export const useLogoutSession = () => {
-  const { oxyServices, activeSessionId, sessions } = useOxy();
+  const { oxyServices, activeSessionId } = useOxy();
   const queryClient = useQueryClient();
 
   return useMutation({
+    mutationKey: [...mutationKeys.session.logout],
     mutationFn: async (targetSessionId?: string) => {
       if (!activeSessionId) {
         throw new Error('No active session');
@@ -92,6 +95,7 @@ export const useLogoutAll = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
+    mutationKey: [...mutationKeys.session.logoutAll],
     mutationFn: async () => {
       if (!activeSessionId) {
         throw new Error('No active session');
@@ -119,6 +123,7 @@ export const useUpdateDeviceName = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
+    mutationKey: [...mutationKeys.session.updateDeviceName],
     mutationFn: async (deviceName: string) => {
       if (!activeSessionId) {
         throw new Error('No active session');
@@ -146,6 +151,7 @@ export const useRemoveDevice = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
+    mutationKey: [...mutationKeys.session.removeDevice],
     mutationFn: async (deviceId: string) => {
       await oxyServices.removeDevice(deviceId);
       return deviceId;

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

@@ -29,6 +29,7 @@ export {
 export {
   useSecurityActivity,
   useRecentSecurityActivity,
+  useInfiniteSecurityActivity,
 } from './useSecurityQueries';
 
 // Query keys and invalidation helpers (for advanced usage)

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

@@ -62,6 +62,8 @@ export const queryKeys = {
       [...queryKeys.security.all, 'activity', limit, offset, eventType] as const,
     recent: (limit: number) =>
       [...queryKeys.security.all, 'recent', limit] as const,
+    infinite: (limit: number, eventType?: string) =>
+      [...queryKeys.security.all, 'infinite', limit, eventType] as const,
   },
 } as const;