@oxyhq/auth 1.0.0

package/dist/esm/hooks/mutations/useAccountMutations.js

@@ -0,0 +1,267 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../queries/queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+import { toast } from 'sonner';
+import { refreshAvatarInStore } from '../../utils/avatarUtils';
+import { useAuthStore } from '../../stores/authStore';
+import { authenticatedApiCall } from '../../utils/authHelpers';
+/**
+ * Update user profile with optimistic updates and offline queue support
+ */
+export const useUpdateProfile = () => {
+    const { oxyServices, activeSessionId, user } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (updates) => {
+            return authenticatedApiCall(oxyServices, activeSessionId, () => oxyServices.updateProfile(updates));
+        },
+        // Optimistic update
+        onMutate: async (updates) => {
+            // Cancel outgoing refetches
+            await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+            // Snapshot previous value
+            const previousUser = queryClient.getQueryData(queryKeys.accounts.current());
+            // Optimistically update
+            if (previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), {
+                    ...previousUser,
+                    ...updates,
+                });
+                // Also update profile query if sessionId is available
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), {
+                        ...previousUser,
+                        ...updates,
+                    });
+                }
+            }
+            return { previousUser };
+        },
+        // On error, rollback
+        onError: (error, updates, context) => {
+            if (context?.previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+                }
+            }
+            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.accounts.current(), data);
+            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
+            invalidateUserQueries(queryClient);
+            invalidateAccountQueries(queryClient);
+        },
+    });
+};
+/**
+ * Upload avatar with progress tracking and offline queue support
+ */
+export const useUploadAvatar = () => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (file) => {
+            return authenticatedApiCall(oxyServices, activeSessionId, async () => {
+                // Upload file first
+                const uploadResult = await oxyServices.assetUpload(file, 'public');
+                const fileId = uploadResult?.file?.id || uploadResult?.id || uploadResult;
+                if (!fileId || typeof fileId !== 'string') {
+                    throw new Error('Failed to get file ID from upload result');
+                }
+                // Update profile with file ID
+                return await oxyServices.updateProfile({ avatar: fileId });
+            });
+        },
+        onMutate: async (file) => {
+            await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+            const previousUser = queryClient.getQueryData(queryKeys.accounts.current());
+            // 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.accounts.current(), optimisticUser);
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), optimisticUser);
+                }
+            }
+            return { previousUser };
+        },
+        onError: (error, file, context) => {
+            if (context?.previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+                if (activeSessionId) {
+                    queryClient.setQueryData(queryKeys.users.profile(activeSessionId), context.previousUser);
+                }
+            }
+            toast.error(error instanceof Error ? error.message : 'Failed to upload avatar');
+        },
+        onSuccess: (data) => {
+            queryClient.setQueryData(queryKeys.accounts.current(), data);
+            if (activeSessionId) {
+                queryClient.setQueryData(queryKeys.users.profile(activeSessionId), data);
+            }
+            // 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
+            invalidateUserQueries(queryClient);
+            invalidateAccountQueries(queryClient);
+            toast.success('Avatar updated successfully');
+        },
+    });
+};
+/**
+ * Update account settings
+ */
+export const useUpdateAccountSettings = () => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (settings) => {
+            return await oxyServices.updateProfile({ privacySettings: settings });
+        },
+        onMutate: async (settings) => {
+            await queryClient.cancelQueries({ queryKey: queryKeys.accounts.settings() });
+            const previousUser = queryClient.getQueryData(queryKeys.accounts.current());
+            if (previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), {
+                    ...previousUser,
+                    privacySettings: {
+                        ...previousUser.privacySettings,
+                        ...settings,
+                    },
+                });
+            }
+            return { previousUser };
+        },
+        onError: (error, settings, context) => {
+            if (context?.previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+            }
+            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');
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.accounts.settings() });
+        },
+    });
+};
+/**
+ * Update privacy settings with optimistic updates and authentication handling
+ */
+export const useUpdatePrivacySettings = () => {
+    const { oxyServices, activeSessionId, user } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ settings, userId }) => {
+            const targetUserId = userId || user?.id;
+            if (!targetUserId) {
+                throw new Error('User ID is required');
+            }
+            return 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.privacy.settings(targetUserId) });
+            await queryClient.cancelQueries({ queryKey: queryKeys.accounts.current() });
+            // Snapshot previous values
+            const previousPrivacySettings = queryClient.getQueryData(queryKeys.privacy.settings(targetUserId));
+            const previousUser = queryClient.getQueryData(queryKeys.accounts.current());
+            // Optimistically update privacy settings
+            if (previousPrivacySettings) {
+                queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), {
+                    ...previousPrivacySettings,
+                    ...settings,
+                });
+            }
+            // Also update user query if available
+            if (previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), {
+                    ...previousUser,
+                    privacySettings: {
+                        ...previousUser.privacySettings,
+                        ...settings,
+                    },
+                });
+            }
+            return { previousPrivacySettings, previousUser };
+        },
+        // On error, rollback
+        onError: (error, { userId }, context) => {
+            const targetUserId = userId || user?.id;
+            if (context?.previousPrivacySettings && targetUserId) {
+                queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), context.previousPrivacySettings);
+            }
+            if (context?.previousUser) {
+                queryClient.setQueryData(queryKeys.accounts.current(), context.previousUser);
+            }
+            toast.error(error instanceof Error ? error.message : 'Failed to update privacy settings');
+        },
+        // On success, invalidate and refetch
+        onSuccess: (data, { userId }) => {
+            const targetUserId = userId || user?.id;
+            if (targetUserId) {
+                queryClient.setQueryData(queryKeys.privacy.settings(targetUserId), data);
+            }
+            // Also update account query if it contains privacy settings
+            const currentUser = queryClient.getQueryData(queryKeys.accounts.current());
+            if (currentUser) {
+                const updatedUser = {
+                    ...currentUser,
+                    privacySettings: data,
+                };
+                queryClient.setQueryData(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() });
+        },
+    });
+};
+/**
+ * Upload file with authentication handling and progress tracking
+ */
+export const useUploadFile = () => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    return useMutation({
+        mutationFn: async ({ file, visibility, metadata, onProgress }) => {
+            return authenticatedApiCall(oxyServices, activeSessionId, () => oxyServices.assetUpload(file, visibility, metadata, onProgress));
+        },
+    });
+};

package/dist/esm/hooks/mutations/useServicesMutations.js

@@ -0,0 +1,141 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { queryKeys, invalidateSessionQueries } from '../queries/queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+import { toast } from 'sonner';
+/**
+ * Switch active session
+ */
+export const useSwitchSession = () => {
+    const { switchSession, activeSessionId } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (sessionId) => {
+            return await switchSession(sessionId);
+        },
+        onSuccess: (user) => {
+            // Invalidate all session queries
+            invalidateSessionQueries(queryClient);
+            // Update current user query
+            queryClient.setQueryData(queryKeys.accounts.current(), user);
+            // Invalidate account queries
+            queryClient.invalidateQueries({ queryKey: queryKeys.accounts.all });
+        },
+        onError: (error) => {
+            toast.error(error instanceof Error ? error.message : 'Failed to switch session');
+        },
+    });
+};
+/**
+ * Logout from a session
+ */
+export const useLogoutSession = () => {
+    const { oxyServices, activeSessionId, sessions } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (targetSessionId) => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            const sessionToLogout = targetSessionId || activeSessionId;
+            await oxyServices.logoutSession(activeSessionId, sessionToLogout);
+            return sessionToLogout;
+        },
+        onMutate: async (targetSessionId) => {
+            // Cancel outgoing queries
+            await queryClient.cancelQueries({ queryKey: queryKeys.sessions.all });
+            // Snapshot previous sessions
+            const previousSessions = queryClient.getQueryData(queryKeys.sessions.list());
+            // Optimistically remove session
+            if (previousSessions) {
+                const sessionToLogout = targetSessionId || activeSessionId;
+                const updatedSessions = previousSessions.filter((s) => s.sessionId !== sessionToLogout);
+                queryClient.setQueryData(queryKeys.sessions.list(), updatedSessions);
+            }
+            return { previousSessions };
+        },
+        onError: (error, targetSessionId, context) => {
+            // Rollback on error
+            if (context?.previousSessions) {
+                queryClient.setQueryData(queryKeys.sessions.list(), context.previousSessions);
+            }
+            toast.error(error instanceof Error ? error.message : 'Failed to logout');
+        },
+        onSuccess: () => {
+            // Invalidate all session queries
+            invalidateSessionQueries(queryClient);
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+        },
+    });
+};
+/**
+ * Logout from all sessions
+ */
+export const useLogoutAll = () => {
+    const { oxyServices, activeSessionId, clearSessionState } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async () => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            await oxyServices.logoutAllSessions(activeSessionId);
+            await clearSessionState();
+        },
+        onSuccess: () => {
+            // Clear all queries
+            queryClient.clear();
+            toast.success('Logged out from all sessions');
+        },
+        onError: (error) => {
+            toast.error(error instanceof Error ? error.message : 'Failed to logout from all sessions');
+        },
+    });
+};
+/**
+ * Update device name
+ */
+export const useUpdateDeviceName = () => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (deviceName) => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            return await oxyServices.updateDeviceName(activeSessionId, deviceName);
+        },
+        onSuccess: () => {
+            // Invalidate device and session queries
+            queryClient.invalidateQueries({ queryKey: queryKeys.devices.all });
+            queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+            toast.success('Device name updated');
+        },
+        onError: (error) => {
+            toast.error(error instanceof Error ? error.message : 'Failed to update device name');
+        },
+    });
+};
+/**
+ * Remove a device
+ */
+export const useRemoveDevice = () => {
+    const { oxyServices } = useWebOxy();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (deviceId) => {
+            await oxyServices.removeDevice(deviceId);
+            return deviceId;
+        },
+        onSuccess: () => {
+            // Invalidate device queries
+            queryClient.invalidateQueries({ queryKey: queryKeys.devices.all });
+            queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+            toast.success('Device removed');
+        },
+        onError: (error) => {
+            toast.error(error instanceof Error ? error.message : 'Failed to remove device');
+        },
+    });
+};

package/dist/esm/hooks/queries/index.js

@@ -0,0 +1,14 @@
+/**
+ * Query Hooks
+ *
+ * TanStack Query hooks for fetching Oxy services data.
+ * All hooks follow the same pattern with optional `enabled` parameter.
+ */
+// Account and user query hooks
+export { useUserProfile, useUserProfiles, useCurrentUser, useUserById, useUserByUsername, useUsersBySessions, usePrivacySettings, } from './useAccountQueries';
+// Service query hooks (sessions, devices, security)
+export { useSessions, useSession, useDeviceSessions, useUserDevices, useSecurityInfo, } from './useServicesQueries';
+// Security activity query hooks
+export { useSecurityActivity, useRecentSecurityActivity, } from './useSecurityQueries';
+// Query keys and invalidation helpers (for advanced usage)
+export { queryKeys, invalidateAccountQueries, invalidateUserQueries, invalidateSessionQueries } from './queryKeys';

package/dist/esm/hooks/queries/queryKeys.js

@@ -0,0 +1,76 @@
+/**
+ * Centralized query keys for TanStack Query
+ *
+ * Following best practices:
+ * - Use arrays for hierarchical keys
+ * - Include all parameters in the key
+ * - Use consistent naming conventions
+ */
+export const queryKeys = {
+    // Account queries
+    accounts: {
+        all: ['accounts'],
+        lists: () => [...queryKeys.accounts.all, 'list'],
+        list: (sessionIds) => [...queryKeys.accounts.lists(), sessionIds],
+        details: () => [...queryKeys.accounts.all, 'detail'],
+        detail: (sessionId) => [...queryKeys.accounts.details(), sessionId],
+        current: () => [...queryKeys.accounts.all, 'current'],
+        settings: () => [...queryKeys.accounts.all, 'settings'],
+    },
+    // User queries
+    users: {
+        all: ['users'],
+        lists: () => [...queryKeys.users.all, 'list'],
+        list: (userIds) => [...queryKeys.users.lists(), userIds],
+        details: () => [...queryKeys.users.all, 'detail'],
+        detail: (userId) => [...queryKeys.users.details(), userId],
+        profile: (sessionId) => [...queryKeys.users.details(), sessionId, 'profile'],
+    },
+    // Session queries
+    sessions: {
+        all: ['sessions'],
+        lists: () => [...queryKeys.sessions.all, 'list'],
+        list: (userId) => [...queryKeys.sessions.lists(), userId],
+        details: () => [...queryKeys.sessions.all, 'detail'],
+        detail: (sessionId) => [...queryKeys.sessions.details(), sessionId],
+        active: () => [...queryKeys.sessions.all, 'active'],
+        device: (deviceId) => [...queryKeys.sessions.all, 'device', deviceId],
+    },
+    // Device queries
+    devices: {
+        all: ['devices'],
+        lists: () => [...queryKeys.devices.all, 'list'],
+        list: (userId) => [...queryKeys.devices.lists(), userId],
+        details: () => [...queryKeys.devices.all, 'detail'],
+        detail: (deviceId) => [...queryKeys.devices.details(), deviceId],
+    },
+    // Privacy settings queries
+    privacy: {
+        all: ['privacy'],
+        settings: (userId) => [...queryKeys.privacy.all, 'settings', userId || 'current'],
+    },
+    // Security activity queries
+    security: {
+        all: ['security'],
+        activity: (limit, offset, eventType) => [...queryKeys.security.all, 'activity', limit, offset, eventType],
+        recent: (limit) => [...queryKeys.security.all, 'recent', limit],
+    },
+};
+/**
+ * Helper to invalidate all account-related queries
+ */
+export const invalidateAccountQueries = (queryClient) => {
+    queryClient.invalidateQueries({ queryKey: queryKeys.accounts.all });
+};
+/**
+ * Helper to invalidate all user-related queries
+ */
+export const invalidateUserQueries = (queryClient) => {
+    queryClient.invalidateQueries({ queryKey: queryKeys.users.all });
+};
+/**
+ * Helper to invalidate all session-related queries
+ */
+export const invalidateSessionQueries = (queryClient) => {
+    queryClient.invalidateQueries({ queryKey: queryKeys.sessions.all });
+};

package/dist/esm/hooks/queries/useAccountQueries.js

@@ -0,0 +1,131 @@
+import { useQuery, useQueries } from '@tanstack/react-query';
+import { queryKeys } from './queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+import { authenticatedApiCall } from '../../utils/authHelpers';
+/**
+ * Get user profile by session ID
+ */
+export const useUserProfile = (sessionId, options) => {
+    const { oxyServices } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.users.profile(sessionId || ''),
+        queryFn: async () => {
+            if (!sessionId) {
+                throw new Error('Session ID is required');
+            }
+            return await oxyServices.getUserBySession(sessionId);
+        },
+        enabled: (options?.enabled !== false) && !!sessionId,
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        gcTime: 30 * 60 * 1000, // 30 minutes
+    });
+};
+/**
+ * Get multiple user profiles by session IDs (batch query)
+ */
+export const useUserProfiles = (sessionIds, options) => {
+    const { oxyServices } = useWebOxy();
+    return useQueries({
+        queries: sessionIds.map((sessionId) => ({
+            queryKey: queryKeys.users.profile(sessionId),
+            queryFn: async () => {
+                const results = await oxyServices.getUsersBySessions([sessionId]);
+                return results[0]?.user || null;
+            },
+            enabled: (options?.enabled !== false) && !!sessionId,
+            staleTime: 5 * 60 * 1000,
+            gcTime: 30 * 60 * 1000,
+        })),
+    });
+};
+/**
+ * Get current authenticated user
+ */
+export const useCurrentUser = (options) => {
+    const { oxyServices, activeSessionId, isAuthenticated } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.accounts.current(),
+        queryFn: async () => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            return await oxyServices.getUserBySession(activeSessionId);
+        },
+        enabled: (options?.enabled !== false) && isAuthenticated && !!activeSessionId,
+        staleTime: 1 * 60 * 1000, // 1 minute for current user
+        gcTime: 30 * 60 * 1000,
+    });
+};
+/**
+ * Get user by ID
+ */
+export const useUserById = (userId, options) => {
+    const { oxyServices } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.users.detail(userId || ''),
+        queryFn: async () => {
+            if (!userId) {
+                throw new Error('User ID is required');
+            }
+            return await oxyServices.getUserById(userId);
+        },
+        enabled: (options?.enabled !== false) && !!userId,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+};
+/**
+ * Get user profile by username
+ */
+export const useUserByUsername = (username, options) => {
+    const { oxyServices } = useWebOxy();
+    return useQuery({
+        queryKey: [...queryKeys.users.details(), 'username', username || ''],
+        queryFn: async () => {
+            if (!username) {
+                throw new Error('Username is required');
+            }
+            return await oxyServices.getProfileByUsername(username);
+        },
+        enabled: (options?.enabled !== false) && !!username,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+};
+/**
+ * Batch get users by session IDs (optimized single API call)
+ */
+export const useUsersBySessions = (sessionIds, options) => {
+    const { oxyServices } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.accounts.list(sessionIds),
+        queryFn: async () => {
+            if (sessionIds.length === 0) {
+                return [];
+            }
+            return await oxyServices.getUsersBySessions(sessionIds);
+        },
+        enabled: (options?.enabled !== false) && sessionIds.length > 0,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+};
+/**
+ * Get privacy settings for a user
+ */
+export const usePrivacySettings = (userId, options) => {
+    const { oxyServices, activeSessionId, user } = useWebOxy();
+    const targetUserId = userId || user?.id;
+    return useQuery({
+        queryKey: queryKeys.privacy.settings(targetUserId),
+        queryFn: async () => {
+            if (!targetUserId) {
+                throw new Error('User ID is required');
+            }
+            return authenticatedApiCall(oxyServices, activeSessionId, () => oxyServices.getPrivacySettings(targetUserId));
+        },
+        enabled: (options?.enabled !== false) && !!targetUserId,
+        staleTime: 2 * 60 * 1000, // 2 minutes
+        gcTime: 10 * 60 * 1000, // 10 minutes
+    });
+};

package/dist/esm/hooks/queries/useSecurityQueries.js

@@ -0,0 +1,40 @@
+import { useQuery } from '@tanstack/react-query';
+import { queryKeys } from './queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+/**
+ * Get user's security activity with pagination
+ */
+export const useSecurityActivity = (options) => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.security.activity(options?.limit, options?.offset, options?.eventType),
+        queryFn: async () => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            const response = await oxyServices.getSecurityActivity(options?.limit, options?.offset, options?.eventType);
+            return response;
+        },
+        enabled: (options?.enabled !== false) && !!activeSessionId,
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        gcTime: 10 * 60 * 1000, // 10 minutes
+    });
+};
+/**
+ * Get recent security activity (convenience hook)
+ */
+export const useRecentSecurityActivity = (limit = 10) => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.security.recent(limit),
+        queryFn: async () => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            return await oxyServices.getRecentSecurityActivity(limit);
+        },
+        enabled: !!activeSessionId,
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        gcTime: 10 * 60 * 1000, // 10 minutes
+    });
+};