@oxyhq/services 30.0.0 → 30.0.1

package/lib/commonjs/ui/hooks/mutations/useAccountMutations.js

@@ -0,0 +1,675 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useUploadFile = exports.useUploadAvatar = exports.useUpdateUserPreferences = exports.useUpdateProfile = exports.useUpdatePrivacySettings = exports.useUpdateNotificationPreferences = exports.useUpdateAccountSettings = exports.useRevokeConnectedApp = void 0;
+var _reactQuery = require("@tanstack/react-query");
+var _core = require("@oxyhq/core");
+var _queryKeys = require("../queries/queryKeys.js");
+var _mutationKeys = require("./mutationKeys.js");
+var _OxyContext = require("../../context/OxyContext.js");
+var _toast = require("@oxyhq/bloom/toast");
+var _authStore = require("../../stores/authStore.js");
+var _userCache = require("../queries/userCache.js");
+/**
+ * Update user profile with optimistic updates and offline queue support
+ */
+const useUpdateProfile = () => {
+  const {
+    oxyServices,
+    activeSessionId,
+    user
+  } = (0, _OxyContext.useOxy)();
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  return (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.account.updateProfile],
+    mutationFn: async updates => {
+      return (0, _core.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.updateProfile(updates));
+    },
+    // Optimistic update
+    onMutate: async updates => {
+      // Cancel outgoing refetches
+      await queryClient.cancelQueries({
+        queryKey: _queryKeys.queryKeys.accounts.current(activeSessionId)
+      });
+
+      // Snapshot previous value
+      const previousUser = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+
+      // Optimistically update
+      if (previousUser) {
+        const optimisticUser = {
+          ...previousUser,
+          ...updates,
+          name: updates.name ? {
+            ...previousUser.name,
+            ...updates.name
+          } : previousUser.name
+        };
+        queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), optimisticUser);
+
+        // Also update profile query if sessionId is available
+        if (activeSessionId) {
+          queryClient.setQueryData(_queryKeys.queryKeys.users.profile(activeSessionId), optimisticUser);
+        }
+      }
+      return {
+        previousUser
+      };
+    },
+    // On error, rollback ONLY the keys this mutation tried to change
+    onError: (error, updates, context) => {
+      if (context?.previousUser && updates) {
+        const previousUser = context.previousUser;
+        const changedKeys = Object.keys(updates);
+        const partialRollback = changedKeys.reduce((acc, key) => {
+          acc[key] = previousUser[key];
+          return acc;
+        }, {});
+        const current = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+        if (current) {
+          queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+            ...current,
+            ...partialRollback
+          });
+        }
+        if (activeSessionId) {
+          const currentProfile = queryClient.getQueryData(_queryKeys.queryKeys.users.profile(activeSessionId));
+          if (currentProfile) {
+            queryClient.setQueryData(_queryKeys.queryKeys.users.profile(activeSessionId), {
+              ...currentProfile,
+              ...partialRollback
+            });
+          }
+        }
+      }
+      _toast.toast.error(error instanceof Error ? error.message : 'Failed to update profile');
+    },
+    // On success, invalidate and refetch
+    onSuccess: (data, updates) => {
+      // Update cache with server response
+      queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), data);
+      if (activeSessionId) {
+        queryClient.setQueryData(_queryKeys.queryKeys.users.profile(activeSessionId), data);
+      }
+
+      // Update authStore so frontend components see the changes immediately
+      _authStore.useAuthStore.getState().setUser(data);
+      const cleared = (0, _userCache.clearedFieldsFromProfileUpdate)(updates);
+      (0, _userCache.upsertCachedUser)(queryClient, data, data.id, {
+        cleared: cleared.length > 0 ? cleared : undefined
+      });
+
+      // Invalidate all related queries so every consumer (the account dialog,
+      // 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.
+      (0, _queryKeys.invalidateUserQueries)(queryClient);
+      (0, _queryKeys.invalidateAccountQueries)(queryClient);
+      (0, _queryKeys.invalidateSessionQueries)(queryClient);
+    }
+  });
+};
+
+/**
+ * Upload avatar with progress tracking and offline queue support
+ */
+exports.useUpdateProfile = useUpdateProfile;
+const useUploadAvatar = () => {
+  const {
+    oxyServices,
+    activeSessionId
+  } = (0, _OxyContext.useOxy)();
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  return (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.account.uploadAvatar],
+    mutationFn: async file => {
+      return (0, _core.authenticatedApiCall)(oxyServices, activeSessionId, async () => {
+        const uploadResult = await oxyServices.assetUpload(file, 'public');
+        const fileId = uploadResult?.file?.id;
+        if (!fileId || typeof fileId !== 'string') {
+          throw new Error('Upload succeeded but response did not contain a file ID');
+        }
+
+        // Update profile with file ID
+        return await oxyServices.updateProfile({
+          avatar: fileId
+        });
+      });
+    },
+    onMutate: async file => {
+      await queryClient.cancelQueries({
+        queryKey: _queryKeys.queryKeys.accounts.current(activeSessionId)
+      });
+      const previousUser = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+
+      // Optimistically set a temporary avatar (using file URI as placeholder)
+      if (previousUser) {
+        const optimisticUser = {
+          ...previousUser,
+          avatar: file.uri // Temporary, will be replaced with fileId
+        };
+        queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), optimisticUser);
+        if (activeSessionId) {
+          queryClient.setQueryData(_queryKeys.queryKeys.users.profile(activeSessionId), optimisticUser);
+        }
+      }
+      return {
+        previousUser
+      };
+    },
+    onError: (error, _file, context) => {
+      // Avatar upload only mutates the `avatar` field — restore only that key
+      if (context?.previousUser) {
+        const previousAvatar = context.previousUser.avatar;
+        const current = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+        if (current) {
+          queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+            ...current,
+            avatar: previousAvatar
+          });
+        }
+        if (activeSessionId) {
+          const currentProfile = queryClient.getQueryData(_queryKeys.queryKeys.users.profile(activeSessionId));
+          if (currentProfile) {
+            queryClient.setQueryData(_queryKeys.queryKeys.users.profile(activeSessionId), {
+              ...currentProfile,
+              avatar: previousAvatar
+            });
+          }
+        }
+      }
+      _toast.toast.error(error instanceof Error ? error.message : 'Failed to upload avatar');
+    },
+    onSuccess: data => {
+      queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), data);
+      if (activeSessionId) {
+        queryClient.setQueryData(_queryKeys.queryKeys.users.profile(activeSessionId), data);
+      }
+
+      // Update authStore so frontend components see the changes immediately
+      _authStore.useAuthStore.getState().setUser(data);
+
+      // Invalidate all related queries to refresh everywhere, including the
+      // sessions cache so other-account avatars update too.
+      (0, _queryKeys.invalidateUserQueries)(queryClient);
+      (0, _queryKeys.invalidateAccountQueries)(queryClient);
+      (0, _queryKeys.invalidateSessionQueries)(queryClient);
+      _toast.toast.success('Avatar updated successfully');
+    }
+  });
+};
+
+/**
+ * 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.
+ */
+exports.useUploadAvatar = useUploadAvatar;
+/**
+ * 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`.
+ */
+const useUpdateAccountSettings = () => {
+  const {
+    oxyServices,
+    activeSessionId,
+    user
+  } = (0, _OxyContext.useOxy)();
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  const mutation = (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.account.updateSettings],
+    mutationFn: async ({
+      updates,
+      currentUser
+    }) => {
+      const userId = currentUser.id;
+      if (!userId) {
+        throw new Error('User ID is required to update account settings');
+      }
+      const updatedPrivacy = await (0, _core.authenticatedApiCall)(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 ({
+      updates
+    }) => {
+      await queryClient.cancelQueries({
+        queryKey: _queryKeys.queryKeys.accounts.settings()
+      });
+      const previousUser = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+      if (previousUser) {
+        queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+          ...previousUser,
+          privacySettings: {
+            ...previousUser.privacySettings,
+            ...updates
+          }
+        });
+      }
+      return {
+        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);
+        const partialPrivacyRollback = changedKeys.reduce((acc, key) => {
+          acc[key] = previousPrivacy[key];
+          return acc;
+        }, {});
+        const current = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+        if (current) {
+          queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+            ...current,
+            privacySettings: {
+              ...(current.privacySettings ?? {}),
+              ...partialPrivacyRollback
+            }
+          });
+        }
+      }
+      _toast.toast.error(error instanceof Error ? error.message : 'Failed to update settings');
+    },
+    onSuccess: data => {
+      queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), data);
+
+      // Update authStore so frontend components see the changes immediately
+      _authStore.useAuthStore.getState().setUser(data);
+      (0, _queryKeys.invalidateAccountQueries)(queryClient);
+      _toast.toast.success('Settings updated successfully');
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({
+        queryKey: _queryKeys.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 => {
+      const currentUser = user ?? queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+      if (!currentUser) {
+        _toast.toast.error('Cannot update account settings: no current user');
+        return;
+      }
+      mutation.mutate({
+        updates,
+        currentUser
+      });
+    },
+    mutateAsync: async updates => {
+      const currentUser = user ?? queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+      if (!currentUser) {
+        throw new Error('Cannot update account settings: no current user');
+      }
+      return mutation.mutateAsync({
+        updates,
+        currentUser
+      });
+    }
+  };
+};
+
+/**
+ * Update privacy settings with optimistic updates and authentication handling
+ */
+exports.useUpdateAccountSettings = useUpdateAccountSettings;
+const useUpdatePrivacySettings = () => {
+  const {
+    oxyServices,
+    activeSessionId,
+    user
+  } = (0, _OxyContext.useOxy)();
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  return (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.account.updatePrivacySettings],
+    mutationFn: async ({
+      settings,
+      userId
+    }) => {
+      const targetUserId = userId || user?.id;
+      if (!targetUserId) {
+        throw new Error('User ID is required');
+      }
+      return (0, _core.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.updatePrivacySettings(settings, targetUserId));
+    },
+    // Optimistic update
+    onMutate: async ({
+      settings,
+      userId
+    }) => {
+      const targetUserId = userId || user?.id;
+      if (!targetUserId) return;
+
+      // Cancel outgoing refetches
+      await queryClient.cancelQueries({
+        queryKey: _queryKeys.queryKeys.privacy.settings(targetUserId)
+      });
+      await queryClient.cancelQueries({
+        queryKey: _queryKeys.queryKeys.accounts.current(activeSessionId)
+      });
+
+      // Snapshot previous values
+      const previousPrivacySettings = queryClient.getQueryData(_queryKeys.queryKeys.privacy.settings(targetUserId));
+      const previousUser = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+
+      // Optimistically update privacy settings
+      if (previousPrivacySettings) {
+        queryClient.setQueryData(_queryKeys.queryKeys.privacy.settings(targetUserId), {
+          ...previousPrivacySettings,
+          ...settings
+        });
+      }
+
+      // Also update user query if available
+      if (previousUser) {
+        queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+          ...previousUser,
+          privacySettings: {
+            ...previousUser.privacySettings,
+            ...settings
+          }
+        });
+      }
+      return {
+        previousPrivacySettings,
+        previousUser
+      };
+    },
+    // 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;
+      const changedKeys = settings ? Object.keys(settings) : [];
+
+      // Rollback the privacy.settings query (partial)
+      if (context?.previousPrivacySettings && targetUserId && changedKeys.length > 0) {
+        const previousPrivacy = context.previousPrivacySettings;
+        const partialPrivacyRollback = changedKeys.reduce((acc, key) => {
+          acc[key] = previousPrivacy[key];
+          return acc;
+        }, {});
+        const currentPrivacy = queryClient.getQueryData(_queryKeys.queryKeys.privacy.settings(targetUserId));
+        if (currentPrivacy) {
+          queryClient.setQueryData(_queryKeys.queryKeys.privacy.settings(targetUserId), {
+            ...currentPrivacy,
+            ...partialPrivacyRollback
+          });
+        }
+      }
+
+      // Rollback the accounts.current() user.privacySettings (partial)
+      if (context?.previousUser && changedKeys.length > 0) {
+        const previousPrivacy = context.previousUser.privacySettings ?? {};
+        const partialPrivacyRollback = changedKeys.reduce((acc, key) => {
+          acc[key] = previousPrivacy[key];
+          return acc;
+        }, {});
+        const current = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+        if (current) {
+          queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+            ...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.queryKeys.privacy.settings(targetUserId)
+        });
+      }
+      _toast.toast.error(error instanceof Error ? error.message : 'Failed to update privacy settings');
+    },
+    // 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) return;
+      const incoming = data ?? {};
+      const requested = settings ?? {};
+      queryClient.setQueryData(_queryKeys.queryKeys.privacy.settings(targetUserId), previous => ({
+        ...(previous ?? {}),
+        ...requested,
+        ...incoming // server wins for fields it explicitly returned
+      }));
+      const currentUser = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+      if (currentUser) {
+        const updatedUser = {
+          ...currentUser,
+          privacySettings: {
+            ...(currentUser.privacySettings ?? {}),
+            ...requested,
+            ...incoming
+          }
+        };
+        queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), updatedUser);
+        _authStore.useAuthStore.getState().setUser(updatedUser);
+      }
+      // 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.
+    }
+  });
+};
+
+/** Uploaded file data structure from API */
+
+/** Upload result type that supports both single file and batch responses */
+exports.useUpdatePrivacySettings = useUpdatePrivacySettings;
+/**
+ * Update the authenticated user's notification preferences with optimistic
+ * updates. Persisted on the User document via `PUT /users/me` — same cache-
+ * invalidation behaviour as `useUpdateProfile`.
+ */
+const useUpdateNotificationPreferences = () => {
+  const {
+    oxyServices,
+    activeSessionId
+  } = (0, _OxyContext.useOxy)();
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  return (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.account.updateNotificationPreferences],
+    mutationFn: async preferences => {
+      return (0, _core.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.updateNotificationPreferences(preferences));
+    },
+    onMutate: async preferences => {
+      await queryClient.cancelQueries({
+        queryKey: _queryKeys.queryKeys.accounts.current(activeSessionId)
+      });
+      const previousUser = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+      if (previousUser) {
+        queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+          ...previousUser,
+          notificationPreferences: {
+            ...previousUser.notificationPreferences,
+            ...preferences
+          }
+        });
+      }
+      return {
+        previousUser
+      };
+    },
+    onError: (error, _preferences, context) => {
+      if (context?.previousUser) {
+        const current = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+        if (current) {
+          queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+            ...current,
+            notificationPreferences: context.previousUser.notificationPreferences
+          });
+        }
+      }
+      _toast.toast.error(error instanceof Error ? error.message : 'Failed to update notification preferences');
+    },
+    onSuccess: data => {
+      queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), data);
+      _authStore.useAuthStore.getState().setUser(data);
+      (0, _queryKeys.invalidateAccountQueries)(queryClient);
+    }
+  });
+};
+
+/**
+ * Update the authenticated user's general preferences (language, theme,
+ * reduce-motion, timezone). Persisted on the User document via
+ * `PUT /users/me`.
+ */
+exports.useUpdateNotificationPreferences = useUpdateNotificationPreferences;
+const useUpdateUserPreferences = () => {
+  const {
+    oxyServices,
+    activeSessionId
+  } = (0, _OxyContext.useOxy)();
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  return (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.account.updateUserPreferences],
+    mutationFn: async preferences => {
+      return (0, _core.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.updateUserPreferences(preferences));
+    },
+    onMutate: async preferences => {
+      await queryClient.cancelQueries({
+        queryKey: _queryKeys.queryKeys.accounts.current(activeSessionId)
+      });
+      const previousUser = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+      if (previousUser) {
+        queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+          ...previousUser,
+          userPreferences: {
+            ...previousUser.userPreferences,
+            ...preferences
+          }
+        });
+      }
+      return {
+        previousUser
+      };
+    },
+    onError: (error, _preferences, context) => {
+      if (context?.previousUser) {
+        const current = queryClient.getQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId));
+        if (current) {
+          queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), {
+            ...current,
+            userPreferences: context.previousUser.userPreferences
+          });
+        }
+      }
+      _toast.toast.error(error instanceof Error ? error.message : 'Failed to update preferences');
+    },
+    onSuccess: data => {
+      queryClient.setQueryData(_queryKeys.queryKeys.accounts.current(activeSessionId), data);
+      _authStore.useAuthStore.getState().setUser(data);
+      (0, _queryKeys.invalidateAccountQueries)(queryClient);
+    }
+  });
+};
+
+/**
+ * Revoke the current user's grant for a connected application (by its
+ * `applicationId`). Removes the grant so the app no longer appears in the user's
+ * "Connected apps" list — next sign-in for that app will require explicit
+ * re-consent.
+ */
+exports.useUpdateUserPreferences = useUpdateUserPreferences;
+const useRevokeConnectedApp = () => {
+  const {
+    oxyServices,
+    activeSessionId
+  } = (0, _OxyContext.useOxy)();
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  return (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.connectedApps.revoke],
+    mutationFn: async applicationId => {
+      return (0, _core.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.revokeAppGrant(applicationId));
+    },
+    onSuccess: () => {
+      (0, _queryKeys.invalidateConnectedAppsQueries)(queryClient);
+    },
+    onError: error => {
+      _toast.toast.error(error instanceof Error ? error.message : 'Failed to revoke connected app');
+    }
+  });
+};
+
+/**
+ * Upload file with authentication handling and progress tracking
+ */
+exports.useRevokeConnectedApp = useRevokeConnectedApp;
+const useUploadFile = () => {
+  const {
+    oxyServices,
+    activeSessionId
+  } = (0, _OxyContext.useOxy)();
+  return (0, _reactQuery.useMutation)({
+    mutationKey: [..._mutationKeys.mutationKeys.account.uploadFile],
+    mutationFn: async ({
+      file,
+      visibility,
+      metadata,
+      onProgress
+    }) => {
+      return (0, _core.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.assetUpload(file, visibility, metadata, onProgress));
+    }
+  });
+};
+exports.useUploadFile = useUploadFile;
+//# sourceMappingURL=useAccountMutations.js.map