@oxyhq/services 6.9.13 → 6.9.15

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

@@ -0,0 +1,42 @@
+/**
+ * Get user profile by session ID
+ */
+export declare const useUserProfile: (sessionId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get multiple user profiles by session IDs (batch query)
+ */
+export declare const useUserProfiles: (sessionIds: string[], options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>[];
+/**
+ * Get current authenticated user
+ */
+export declare const useCurrentUser: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get user by ID
+ */
+export declare const useUserById: (userId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get user profile by username
+ */
+export declare const useUserByUsername: (username: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Batch get users by session IDs (optimized single API call)
+ */
+export declare const useUsersBySessions: (sessionIds: string[], options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get privacy settings for a user
+ */
+export declare const usePrivacySettings: (userId?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;

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

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePrivacySettings = exports.useUsersBySessions = exports.useUserByUsername = exports.useUserById = exports.useCurrentUser = exports.useUserProfiles = exports.useUserProfile = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const core_1 = require("@oxyhq/core");
+const queryKeys_1 = require("./queryKeys");
+const OxyContext_1 = require("../../context/OxyContext");
+/**
+ * Get user profile by session ID
+ */
+const useUserProfile = (sessionId, options) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.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
+    });
+};
+exports.useUserProfile = useUserProfile;
+/**
+ * Get multiple user profiles by session IDs (batch query)
+ */
+const useUserProfiles = (sessionIds, options) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQueries)({
+        queries: sessionIds.map((sessionId) => ({
+            queryKey: queryKeys_1.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,
+        })),
+    });
+};
+exports.useUserProfiles = useUserProfiles;
+/**
+ * Get current authenticated user
+ */
+const useCurrentUser = (options) => {
+    const { oxyServices, activeSessionId, isAuthenticated } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.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,
+    });
+};
+exports.useCurrentUser = useCurrentUser;
+/**
+ * Get user by ID
+ */
+const useUserById = (userId, options) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.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,
+    });
+};
+exports.useUserById = useUserById;
+/**
+ * Get user profile by username
+ */
+const useUserByUsername = (username, options) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: [...queryKeys_1.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,
+    });
+};
+exports.useUserByUsername = useUserByUsername;
+/**
+ * Batch get users by session IDs (optimized single API call)
+ */
+const useUsersBySessions = (sessionIds, options) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.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,
+    });
+};
+exports.useUsersBySessions = useUsersBySessions;
+/**
+ * Get privacy settings for a user
+ */
+const usePrivacySettings = (userId, options) => {
+    const { oxyServices, activeSessionId, user } = (0, OxyContext_1.useOxy)();
+    const targetUserId = userId || user?.id;
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.queryKeys.privacy.settings(targetUserId),
+        queryFn: async () => {
+            if (!targetUserId) {
+                throw new Error('User ID is required');
+            }
+            return (0, core_1.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.getPrivacySettings(targetUserId));
+        },
+        enabled: (options?.enabled !== false) && !!targetUserId,
+        staleTime: 2 * 60 * 1000, // 2 minutes
+        gcTime: 10 * 60 * 1000, // 10 minutes
+    });
+};
+exports.usePrivacySettings = usePrivacySettings;

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

@@ -0,0 +1,14 @@
+import type { SecurityEventType } from '@oxyhq/core';
+/**
+ * Get user's security activity with pagination
+ */
+export declare const useSecurityActivity: (options?: {
+    limit?: number;
+    offset?: number;
+    eventType?: SecurityEventType;
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get recent security activity (convenience hook)
+ */
+export declare const useRecentSecurityActivity: (limit?: number) => import("@tanstack/react-query").UseQueryResult<SecurityActivity[], Error>;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRecentSecurityActivity = exports.useSecurityActivity = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const queryKeys_1 = require("./queryKeys");
+const OxyContext_1 = require("../../context/OxyContext");
+/**
+ * Get user's security activity with pagination
+ */
+const useSecurityActivity = (options) => {
+    const { oxyServices, activeSessionId } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.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
+    });
+};
+exports.useSecurityActivity = useSecurityActivity;
+/**
+ * Get recent security activity (convenience hook)
+ */
+const useRecentSecurityActivity = (limit = 10) => {
+    const { oxyServices, activeSessionId } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.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
+    });
+};
+exports.useRecentSecurityActivity = useRecentSecurityActivity;

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

@@ -0,0 +1,30 @@
+/**
+ * Get all active sessions for the current user
+ */
+export declare const useSessions: (userId?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<ClientSession[], Error>;
+/**
+ * Get specific session by ID
+ */
+export declare const useSession: (sessionId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<ClientSession, Error>;
+/**
+ * Get device sessions for the current active session
+ */
+export declare const useDeviceSessions: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get user devices
+ */
+export declare const useUserDevices: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+/**
+ * Get security information
+ */
+export declare const useSecurityInfo: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<any, Error>;

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSecurityInfo = exports.useUserDevices = exports.useDeviceSessions = exports.useSession = exports.useSessions = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const core_1 = require("@oxyhq/core");
+const queryKeys_1 = require("./queryKeys");
+const OxyContext_1 = require("../../context/OxyContext");
+const sessionHelpers_1 = require("../../utils/sessionHelpers");
+/**
+ * Get all active sessions for the current user
+ */
+const useSessions = (userId, options) => {
+    const { oxyServices, activeSessionId } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.queryKeys.sessions.list(userId),
+        queryFn: async () => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            const sessions = await (0, sessionHelpers_1.fetchSessionsWithFallback)(oxyServices, activeSessionId, {
+                fallbackDeviceId: undefined,
+                fallbackUserId: userId,
+            });
+            return (0, sessionHelpers_1.mapSessionsToClient)(sessions, activeSessionId);
+        },
+        enabled: (options?.enabled !== false) && !!activeSessionId,
+        staleTime: 2 * 60 * 1000, // 2 minutes (sessions change frequently)
+        gcTime: 10 * 60 * 1000, // 10 minutes
+    });
+};
+exports.useSessions = useSessions;
+/**
+ * Get specific session by ID
+ */
+const useSession = (sessionId, options) => {
+    const { oxyServices } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.queryKeys.sessions.detail(sessionId || ''),
+        queryFn: async () => {
+            if (!sessionId) {
+                throw new Error('Session ID is required');
+            }
+            const validation = await oxyServices.validateSession(sessionId, { useHeaderValidation: true });
+            if (!validation?.valid || !validation.user) {
+                throw new Error('Session not found or invalid');
+            }
+            const now = new Date();
+            return {
+                sessionId,
+                deviceId: '', // Device ID not available from validation response
+                expiresAt: validation.expiresAt || new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000).toISOString(),
+                lastActive: validation.lastActivity || now.toISOString(),
+                userId: validation.user.id?.toString() ?? '',
+                isCurrent: false,
+            };
+        },
+        enabled: (options?.enabled !== false) && !!sessionId,
+        staleTime: 2 * 60 * 1000,
+        gcTime: 10 * 60 * 1000,
+    });
+};
+exports.useSession = useSession;
+/**
+ * Get device sessions for the current active session
+ */
+const useDeviceSessions = (options) => {
+    const { oxyServices, activeSessionId } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.queryKeys.sessions.active(),
+        queryFn: async () => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            return await oxyServices.getDeviceSessions(activeSessionId);
+        },
+        enabled: (options?.enabled !== false) && !!activeSessionId,
+        staleTime: 2 * 60 * 1000,
+        gcTime: 10 * 60 * 1000,
+    });
+};
+exports.useDeviceSessions = useDeviceSessions;
+/**
+ * Get user devices
+ */
+const useUserDevices = (options) => {
+    const { oxyServices, isAuthenticated, activeSessionId } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.queryKeys.devices.list(),
+        queryFn: async () => {
+            return (0, core_1.authenticatedApiCall)(oxyServices, activeSessionId, () => oxyServices.getUserDevices());
+        },
+        enabled: (options?.enabled !== false) && isAuthenticated,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+};
+exports.useUserDevices = useUserDevices;
+/**
+ * Get security information
+ */
+const useSecurityInfo = (options) => {
+    const { oxyServices, isAuthenticated } = (0, OxyContext_1.useOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: [...queryKeys_1.queryKeys.devices.all, 'security'],
+        queryFn: async () => {
+            return await oxyServices.getSecurityInfo();
+        },
+        enabled: (options?.enabled !== false) && isAuthenticated,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+};
+exports.useSecurityInfo = useSecurityInfo;

package/src/ui/hooks/queryClient.d.ts

@@ -0,0 +1,18 @@
+import { QueryClient } from '@tanstack/react-query';
+import type { StorageInterface } from '../utils/storageHelpers';
+/**
+ * Custom persistence adapter for TanStack Query using our StorageInterface
+ */
+export declare const createPersistenceAdapter: (storage: StorageInterface) => {
+    persistClient: (client: any) => Promise<void>;
+    restoreClient: () => Promise<any>;
+    removeClient: () => Promise<void>;
+};
+/**
+ * Create a QueryClient with offline-first configuration
+ */
+export declare const createQueryClient: (storage?: StorageInterface | null) => QueryClient;
+/**
+ * Clear persisted query cache
+ */
+export declare const clearQueryCache: (storage: StorageInterface) => Promise<void>;

package/src/ui/hooks/queryClient.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearQueryCache = exports.createQueryClient = exports.createPersistenceAdapter = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const core_1 = require("@oxyhq/core");
+const QUERY_CACHE_KEY = 'oxy_query_cache';
+const QUERY_CACHE_VERSION = '1';
+/**
+ * Custom persistence adapter for TanStack Query using our StorageInterface
+ */
+const createPersistenceAdapter = (storage) => {
+    return {
+        persistClient: async (client) => {
+            try {
+                const serialized = JSON.stringify({
+                    clientState: client,
+                    timestamp: Date.now(),
+                    version: QUERY_CACHE_VERSION,
+                });
+                await storage.setItem(QUERY_CACHE_KEY, serialized);
+            }
+            catch (error) {
+                if ((0, core_1.isDev)()) {
+                    console.warn('[QueryClient] Failed to persist cache:', error);
+                }
+            }
+        },
+        restoreClient: async () => {
+            try {
+                const cached = await storage.getItem(QUERY_CACHE_KEY);
+                if (!cached)
+                    return undefined;
+                const parsed = JSON.parse(cached);
+                // Check version compatibility
+                if (parsed.version !== QUERY_CACHE_VERSION) {
+                    // Clear old cache on version mismatch
+                    await storage.removeItem(QUERY_CACHE_KEY);
+                    return undefined;
+                }
+                // Check if cache is too old (30 days)
+                const maxAge = 30 * 24 * 60 * 60 * 1000;
+                if (parsed.timestamp && Date.now() - parsed.timestamp > maxAge) {
+                    await storage.removeItem(QUERY_CACHE_KEY);
+                    return undefined;
+                }
+                return parsed.clientState;
+            }
+            catch (error) {
+                if ((0, core_1.isDev)()) {
+                    console.warn('[QueryClient] Failed to restore cache:', error);
+                }
+                return undefined;
+            }
+        },
+        removeClient: async () => {
+            try {
+                await storage.removeItem(QUERY_CACHE_KEY);
+            }
+            catch (error) {
+                if ((0, core_1.isDev)()) {
+                    console.warn('[QueryClient] Failed to remove cache:', error);
+                }
+            }
+        },
+    };
+};
+exports.createPersistenceAdapter = createPersistenceAdapter;
+/**
+ * Create a QueryClient with offline-first configuration
+ */
+const createQueryClient = (storage) => {
+    const client = new react_query_1.QueryClient({
+        defaultOptions: {
+            queries: {
+                // Data is fresh for 5 minutes
+                staleTime: 5 * 60 * 1000,
+                // Keep unused data in cache for 30 minutes
+                gcTime: 30 * 60 * 1000,
+                // Retry 3 times with exponential backoff
+                retry: 3,
+                retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
+                // Refetch on reconnect
+                refetchOnReconnect: true,
+                // Don't refetch on window focus (better for mobile)
+                refetchOnWindowFocus: false,
+                // Offline-first: use cache when offline
+                networkMode: 'offlineFirst',
+            },
+            mutations: {
+                // Retry once for mutations
+                retry: 1,
+                // Offline-first: queue mutations when offline
+                networkMode: 'offlineFirst',
+            },
+        },
+    });
+    // Note: Persistence is handled by TanStack Query's built-in persistence
+    // For now, we rely on the query client's default behavior with networkMode: 'offlineFirst'
+    // The cache will be available in memory and queries will use cached data when offline
+    // Full persistence to AsyncStorage can be added later with @tanstack/react-query-persist-client if needed
+    return client;
+};
+exports.createQueryClient = createQueryClient;
+/**
+ * Clear persisted query cache
+ */
+const clearQueryCache = async (storage) => {
+    const adapter = (0, exports.createPersistenceAdapter)(storage);
+    await adapter.removeClient();
+};
+exports.clearQueryCache = clearQueryCache;

package/src/ui/hooks/useAssets.d.ts

@@ -0,0 +1,34 @@
+import type { OxyServices } from '@oxyhq/core';
+import { type Asset } from '@oxyhq/core';
+export declare const setOxyAssetInstance: (instance: OxyServices) => void;
+/**
+ * Hook for managing assets with Zustand store integration
+ */
+export declare const useAssets: () => {
+    assets: Asset[];
+    uploadProgress: Record<string, AssetUploadProgress>;
+    loading: {
+        uploading: boolean;
+        linking: boolean;
+        deleting: boolean;
+    };
+    errors: {
+        upload?: string;
+        link?: string;
+        delete?: string;
+    };
+    upload: (file: File, metadata?: Record<string, any>) => Promise<Asset | null>;
+    link: (assetId: string, app: string, entityType: string, entityId: string) => Promise<void>;
+    unlink: (assetId: string, app: string, entityType: string, entityId: string) => Promise<void>;
+    getUrl: (assetId: string, variant?: string, expiresIn?: number) => Promise<string>;
+    getAsset: (assetId: string) => Promise<Asset>;
+    deleteAsset: (assetId: string, force?: boolean) => Promise<void>;
+    restore: (assetId: string) => Promise<void>;
+    getVariants: (assetId: string) => Promise<any>;
+    getAssetsByApp: (app: string) => Asset[];
+    getAssetsByEntity: (app: string, entityType: string, entityId: string) => Asset[];
+    getAssetUsageCount: (assetId: string) => number;
+    isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => boolean;
+    clearErrors: () => void;
+    reset: () => void;
+};