@oxyhq/auth 1.0.0

package/dist/cjs/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 queryKeys_1 = require("./queryKeys");
+const WebOxyProvider_1 = require("../../WebOxyProvider");
+const authHelpers_1 = require("../../utils/authHelpers");
+/**
+ * Get user profile by session ID
+ */
+const useUserProfile = (sessionId, options) => {
+    const { oxyServices } = (0, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, authHelpers_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/dist/cjs/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 WebOxyProvider_1 = require("../../WebOxyProvider");
+/**
+ * Get user's security activity with pagination
+ */
+const useSecurityActivity = (options) => {
+    const { oxyServices, activeSessionId } = (0, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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/dist/cjs/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 queryKeys_1 = require("./queryKeys");
+const WebOxyProvider_1 = require("../../WebOxyProvider");
+const sessionHelpers_1 = require("../../utils/sessionHelpers");
+const authHelpers_1 = require("../../utils/authHelpers");
+/**
+ * Get all active sessions for the current user
+ */
+const useSessions = (userId, options) => {
+    const { oxyServices, activeSessionId } = (0, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    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, WebOxyProvider_1.useWebOxy)();
+    return (0, react_query_1.useQuery)({
+        queryKey: queryKeys_1.queryKeys.devices.list(),
+        queryFn: async () => {
+            return (0, authHelpers_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, WebOxyProvider_1.useWebOxy)();
+    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/dist/cjs/hooks/queryClient.js

@@ -0,0 +1,110 @@
+"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 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 (__DEV__) {
+                    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 (__DEV__) {
+                    console.warn('[QueryClient] Failed to restore cache:', error);
+                }
+                return undefined;
+            }
+        },
+        removeClient: async () => {
+            try {
+                await storage.removeItem(QUERY_CACHE_KEY);
+            }
+            catch (error) {
+                if (__DEV__) {
+                    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/dist/cjs/hooks/useAssets.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAssets = exports.setOxyAssetInstance = void 0;
+const react_1 = require("react");
+const assetStore_1 = require("../stores/assetStore");
+// Create a singleton instance for the hook
+let oxyInstance = null;
+const setOxyAssetInstance = (instance) => {
+    oxyInstance = instance;
+};
+exports.setOxyAssetInstance = setOxyAssetInstance;
+/**
+ * Hook for managing assets with Zustand store integration
+ */
+const useAssets = () => {
+    const { assets, uploadProgress, loading, errors, setAsset, setAssets, removeAsset, setUploadProgress, removeUploadProgress, addLink, removeLink, setUploading, setLinking, setDeleting, setUploadError, setLinkError, setDeleteError, clearErrors, getAssetsByApp, getAssetsByEntity, getAssetUsageCount, isAssetLinked, reset } = (0, assetStore_1.useAssetStore)();
+    // Upload asset with progress tracking
+    const upload = (0, react_1.useCallback)(async (file, metadata) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setUploading(true);
+            // Upload file (progress tracking simplified for now)
+            const result = await oxyInstance.assetUpload(file, undefined, metadata);
+            // Update progress with final status
+            if (result?.file) {
+                const fileId = result.file.id;
+                setUploadProgress(fileId, {
+                    fileId,
+                    uploaded: file.size,
+                    total: file.size,
+                    percentage: 100,
+                    status: 'complete'
+                });
+                // Remove progress after a short delay
+                setTimeout(() => {
+                    removeUploadProgress(fileId);
+                }, 2000);
+            }
+            // Add asset to store
+            if (result.file) {
+                setAsset(result.file);
+                return result.file;
+            }
+            return null;
+        }
+        catch (error) {
+            setUploadError(error.message || 'Upload failed');
+            throw error;
+        }
+        finally {
+            setUploading(false);
+        }
+    }, [
+        clearErrors,
+        setUploading,
+        setUploadProgress,
+        removeUploadProgress,
+        setAsset,
+        setUploadError
+    ]);
+    // Link asset to entity
+    const link = (0, react_1.useCallback)(async (assetId, app, entityType, entityId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setLinking(true);
+            // Auto-detect visibility for avatars and profile banners
+            const visibility = (entityType === 'avatar' || entityType === 'profile-banner')
+                ? 'public'
+                : undefined;
+            const result = await oxyInstance.assetLink(assetId, app, entityType, entityId, visibility);
+            if (result.file) {
+                setAsset(result.file);
+            }
+            else {
+                // If API doesn't return full file, update store optimistically
+                addLink(assetId, {
+                    app,
+                    entityType,
+                    entityId,
+                    createdBy: '', // Will be filled by server
+                    createdAt: new Date().toISOString()
+                });
+            }
+        }
+        catch (error) {
+            setLinkError(error.message || 'Link failed');
+            throw error;
+        }
+        finally {
+            setLinking(false);
+        }
+    }, [clearErrors, setLinking, setAsset, addLink, setLinkError]);
+    // Unlink asset from entity
+    const unlink = (0, react_1.useCallback)(async (assetId, app, entityType, entityId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setLinking(true);
+            const result = await oxyInstance.assetUnlink(assetId, app, entityType, entityId);
+            if (result.file) {
+                setAsset(result.file);
+            }
+            else {
+                // Update store optimistically
+                removeLink(assetId, app, entityType, entityId);
+            }
+        }
+        catch (error) {
+            setLinkError(error.message || 'Unlink failed');
+            throw error;
+        }
+        finally {
+            setLinking(false);
+        }
+    }, [clearErrors, setLinking, setAsset, removeLink, setLinkError]);
+    // Get asset URL
+    const getUrl = (0, react_1.useCallback)(async (assetId, variant, expiresIn) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            const result = await oxyInstance.assetGetUrl(assetId, variant, expiresIn);
+            return result.url;
+        }
+        catch (error) {
+            throw error;
+        }
+    }, []);
+    // Get asset metadata
+    const getAsset = (0, react_1.useCallback)(async (assetId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            const result = await oxyInstance.assetGet(assetId);
+            if (result.file) {
+                setAsset(result.file);
+                return result.file;
+            }
+            throw new Error('Asset not found');
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [setAsset]);
+    // Delete asset
+    const deleteAsset = (0, react_1.useCallback)(async (assetId, force = false) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            clearErrors();
+            setDeleting(true);
+            await oxyInstance.assetDelete(assetId, force);
+            removeAsset(assetId);
+        }
+        catch (error) {
+            setDeleteError(error.message || 'Delete failed');
+            throw error;
+        }
+        finally {
+            setDeleting(false);
+        }
+    }, [clearErrors, setDeleting, removeAsset, setDeleteError]);
+    // Restore asset from trash
+    const restore = (0, react_1.useCallback)(async (assetId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            const result = await oxyInstance.assetRestore(assetId);
+            if (result.file) {
+                setAsset(result.file);
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }, [setAsset]);
+    // Get variants
+    const getVariants = (0, react_1.useCallback)(async (assetId) => {
+        if (!oxyInstance) {
+            throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+        }
+        try {
+            return await oxyInstance.assetGetVariants(assetId);
+        }
+        catch (error) {
+            throw error;
+        }
+    }, []);
+    return {
+        // State
+        assets: Object.values(assets),
+        uploadProgress,
+        loading,
+        errors,
+        // Actions
+        upload,
+        link,
+        unlink,
+        getUrl,
+        getAsset,
+        deleteAsset,
+        restore,
+        getVariants,
+        // Utility methods
+        getAssetsByApp,
+        getAssetsByEntity,
+        getAssetUsageCount,
+        isAssetLinked,
+        // Store management
+        clearErrors,
+        reset
+    };
+};
+exports.useAssets = useAssets;