@oxyhq/services 5.16.13 → 5.16.15

package/src/core/mixins/OxyServices.security.ts

@@ -0,0 +1,59 @@
+/**
+ * Security Methods Mixin
+ */
+import type { OxyServicesBase } from '../OxyServices.base';
+import type { SecurityActivity, SecurityActivityResponse, SecurityEventType } from '../../models/interfaces';
+
+export function OxyServicesSecurityMixin<T extends typeof OxyServicesBase>(Base: T) {
+  return class extends Base {
+    constructor(...args: any[]) {
+      super(...(args as [any]));
+    }
+
+    /**
+     * Get user's security activity with pagination
+     * @param limit - Number of results (default: 50, max: 100)
+     * @param offset - Pagination offset (default: 0)
+     * @param eventType - Optional filter by event type
+     * @returns Security activity response with pagination
+     */
+    async getSecurityActivity(
+      limit?: number,
+      offset?: number,
+      eventType?: SecurityEventType
+    ): Promise<SecurityActivityResponse> {
+      try {
+        const params: any = {};
+        if (limit !== undefined) params.limit = limit;
+        if (offset !== undefined) params.offset = offset;
+        if (eventType) params.eventType = eventType;
+
+        const response = await this.makeRequest<SecurityActivityResponse>(
+          'GET',
+          '/api/security/activity',
+          params,
+          { cache: false }
+        );
+
+        return response;
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+
+    /**
+     * Get recent security activity (convenience method)
+     * @param limit - Number of recent events to fetch (default: 10)
+     * @returns Array of recent security activities
+     */
+    async getRecentSecurityActivity(limit: number = 10): Promise<SecurityActivity[]> {
+      try {
+        const response = await this.getSecurityActivity(limit, 0);
+        return response.data || [];
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+  };
+}
+

package/src/core/mixins/index.ts

@@ -17,6 +17,7 @@ import { OxyServicesDeveloperMixin } from './OxyServices.developer';
 import { OxyServicesLocationMixin } from './OxyServices.location';
 import { OxyServicesAnalyticsMixin } from './OxyServices.analytics';
 import { OxyServicesDevicesMixin } from './OxyServices.devices';
+import { OxyServicesSecurityMixin } from './OxyServices.security';
 import { OxyServicesUtilityMixin } from './OxyServices.utility';
 
 /**
@@ -29,17 +30,19 @@ import { OxyServicesUtilityMixin } from './OxyServices.utility';
  */
 export function composeOxyServices() {
   return OxyServicesUtilityMixin(
-    OxyServicesDevicesMixin(
-      OxyServicesAnalyticsMixin(
-        OxyServicesLocationMixin(
-          OxyServicesDeveloperMixin(
-            OxyServicesAssetsMixin(
-              OxyServicesKarmaMixin(
-                OxyServicesPaymentMixin(
-                  OxyServicesLanguageMixin(
-                    OxyServicesPrivacyMixin(
-                      OxyServicesUserMixin(
-                        OxyServicesAuthMixin(OxyServicesBase)
+    OxyServicesSecurityMixin(
+      OxyServicesDevicesMixin(
+        OxyServicesAnalyticsMixin(
+          OxyServicesLocationMixin(
+            OxyServicesDeveloperMixin(
+              OxyServicesAssetsMixin(
+                OxyServicesKarmaMixin(
+                  OxyServicesPaymentMixin(
+                    OxyServicesLanguageMixin(
+                      OxyServicesPrivacyMixin(
+                        OxyServicesUserMixin(
+                          OxyServicesAuthMixin(OxyServicesBase)
+                        )
                       )
                     )
                   )

package/src/index.ts

@@ -103,7 +103,12 @@ export type {
   AssetUpdateVisibilityResponse,
   // Account storage usage
   AccountStorageCategoryUsage,
-  AccountStorageUsageResponse
+  AccountStorageUsageResponse,
+  // Security activity
+  SecurityEventType,
+  SecurityEventSeverity,
+  SecurityActivity,
+  SecurityActivityResponse
 } from './models/interfaces';
 
 export type {
@@ -148,6 +153,9 @@ export {
   useDeviceSessions,
   useUserDevices,
   useSecurityInfo,
+  // Security activity queries
+  useSecurityActivity,
+  useRecentSecurityActivity,
 } from './ui/hooks/queries';
 
 // UI hooks - Mutation hooks (TanStack Query)

package/src/models/interfaces.ts

@@ -403,6 +403,53 @@ export interface AccountStorageUsageResponse {
   updatedAt: string;
 }
 
+/**
+ * Security activity event types
+ */
+export type SecurityEventType = 
+  | 'sign_in'
+  | 'sign_out'
+  | 'email_changed'
+  | 'profile_updated'
+  | 'device_added'
+  | 'device_removed'
+  | 'account_recovery'
+  | 'security_settings_changed'
+  | 'suspicious_activity';
+
+/**
+ * Security event severity levels
+ */
+export type SecurityEventSeverity = 'low' | 'medium' | 'high' | 'critical';
+
+/**
+ * Security activity event
+ */
+export interface SecurityActivity {
+  id: string;
+  userId: string;
+  eventType: SecurityEventType;
+  eventDescription: string;
+  metadata?: Record<string, any>;
+  ipAddress?: string;
+  userAgent?: string;
+  deviceId?: string;
+  timestamp: string;
+  severity: SecurityEventSeverity;
+  createdAt: string;
+}
+
+/**
+ * Security activity response with pagination
+ */
+export interface SecurityActivityResponse {
+  data: SecurityActivity[];
+  total: number;
+  limit: number;
+  offset: number;
+  hasMore: boolean;
+}
+
 export interface AssetUploadProgress {
   fileId: string;
   uploaded: number;

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

@@ -4,6 +4,7 @@ import { queryKeys, invalidateAccountQueries, invalidateUserQueries } from '../q
 import { useOxy } from '../../context/OxyContext';
 import { toast } from '../../../lib/sonner';
 import { refreshAvatarInStore } from '../../utils/avatarUtils';
+import { useAuthStore } from '../../stores/authStore';
 
 /**
  * Update user profile with optimistic updates and offline queue support
@@ -107,6 +108,9 @@ export const useUpdateProfile = () => {
         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);
@@ -220,6 +224,9 @@ export const useUploadAvatar = () => {
         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);
@@ -268,6 +275,10 @@ 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');
     },
@@ -394,10 +405,14 @@ export const useUpdatePrivacySettings = () => {
       // Also update account query if it contains privacy settings
       const currentUser = queryClient.getQueryData<User>(queryKeys.accounts.current());
       if (currentUser) {
-        queryClient.setQueryData<User>(queryKeys.accounts.current(), {
+        const updatedUser = {
           ...currentUser,
           privacySettings: data,
-        });
+        };
+        queryClient.setQueryData<User>(queryKeys.accounts.current(), updatedUser);
+        
+        // Update authStore so frontend components see the changes immediately
+        useAuthStore.getState().setUser(updatedUser);
       }
       invalidateAccountQueries(queryClient);
     },

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

@@ -25,6 +25,12 @@ export {
   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/src/ui/hooks/queries/queryKeys.ts

@@ -54,6 +54,15 @@ export const queryKeys = {
     all: ['privacy'] as const,
     settings: (userId?: string) => [...queryKeys.privacy.all, 'settings', userId || 'current'] as const,
   },
+
+  // Security activity queries
+  security: {
+    all: ['security'] as const,
+    activity: (limit?: number, offset?: number, eventType?: string) => 
+      [...queryKeys.security.all, 'activity', limit, offset, eventType] as const,
+    recent: (limit: number) => 
+      [...queryKeys.security.all, 'recent', limit] as const,
+  },
 } as const;
 
 /**

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

@@ -0,0 +1,64 @@
+import { useQuery } from '@tanstack/react-query';
+import { queryKeys } from './queryKeys';
+import { useOxy } from '../../context/OxyContext';
+import type { SecurityActivity, SecurityEventType } from '../../../models/interfaces';
+
+/**
+ * Get user's security activity with pagination
+ */
+export const useSecurityActivity = (
+  options?: {
+    limit?: number;
+    offset?: number;
+    eventType?: SecurityEventType;
+    enabled?: boolean;
+  }
+) => {
+  const { oxyServices, activeSessionId } = useOxy();
+
+  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: number = 10) => {
+  const { oxyServices, activeSessionId } = useOxy();
+
+  return useQuery<SecurityActivity[]>({
+    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
+  });
+};
+

package/src/ui/utils/avatarUtils.ts

@@ -1,6 +1,7 @@
 import type { OxyServices } from '../../core';
 import type { User } from '../../models/interfaces';
 import { useAccountStore } from '../stores/accountStore';
+import { useAuthStore } from '../stores/authStore';
 import { QueryClient } from '@tanstack/react-query';
 import { queryKeys, invalidateUserQueries, invalidateAccountQueries } from '../hooks/queries/queryKeys';
 
@@ -103,6 +104,9 @@ export async function updateProfileWithAvatar(
       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) {
       refreshAvatarInStore(activeSessionId, updates.avatar, oxyServices);