@oxyhq/auth 1.0.0

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

@@ -0,0 +1,105 @@
+import { useQuery } from '@tanstack/react-query';
+import { queryKeys } from './queryKeys';
+import { useWebOxy } from '../../WebOxyProvider';
+import { fetchSessionsWithFallback, mapSessionsToClient } from '../../utils/sessionHelpers';
+import { authenticatedApiCall } from '../../utils/authHelpers';
+/**
+ * Get all active sessions for the current user
+ */
+export const useSessions = (userId, options) => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.sessions.list(userId),
+        queryFn: async () => {
+            if (!activeSessionId) {
+                throw new Error('No active session');
+            }
+            const sessions = await fetchSessionsWithFallback(oxyServices, activeSessionId, {
+                fallbackDeviceId: undefined,
+                fallbackUserId: userId,
+            });
+            return mapSessionsToClient(sessions, activeSessionId);
+        },
+        enabled: (options?.enabled !== false) && !!activeSessionId,
+        staleTime: 2 * 60 * 1000, // 2 minutes (sessions change frequently)
+        gcTime: 10 * 60 * 1000, // 10 minutes
+    });
+};
+/**
+ * Get specific session by ID
+ */
+export const useSession = (sessionId, options) => {
+    const { oxyServices } = useWebOxy();
+    return useQuery({
+        queryKey: 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,
+    });
+};
+/**
+ * Get device sessions for the current active session
+ */
+export const useDeviceSessions = (options) => {
+    const { oxyServices, activeSessionId } = useWebOxy();
+    return useQuery({
+        queryKey: 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,
+    });
+};
+/**
+ * Get user devices
+ */
+export const useUserDevices = (options) => {
+    const { oxyServices, isAuthenticated, activeSessionId } = useWebOxy();
+    return useQuery({
+        queryKey: queryKeys.devices.list(),
+        queryFn: async () => {
+            return authenticatedApiCall(oxyServices, activeSessionId, () => oxyServices.getUserDevices());
+        },
+        enabled: (options?.enabled !== false) && isAuthenticated,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+};
+/**
+ * Get security information
+ */
+export const useSecurityInfo = (options) => {
+    const { oxyServices, isAuthenticated } = useWebOxy();
+    return useQuery({
+        queryKey: [...queryKeys.devices.all, 'security'],
+        queryFn: async () => {
+            return await oxyServices.getSecurityInfo();
+        },
+        enabled: (options?.enabled !== false) && isAuthenticated,
+        staleTime: 5 * 60 * 1000,
+        gcTime: 30 * 60 * 1000,
+    });
+};

package/dist/esm/hooks/queryClient.js

@@ -0,0 +1,104 @@
+import { QueryClient } from '@tanstack/react-query';
+const QUERY_CACHE_KEY = 'oxy_query_cache';
+const QUERY_CACHE_VERSION = '1';
+/**
+ * Custom persistence adapter for TanStack Query using our StorageInterface
+ */
+export 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);
+                }
+            }
+        },
+    };
+};
+/**
+ * Create a QueryClient with offline-first configuration
+ */
+export const createQueryClient = (storage) => {
+    const client = new 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;
+};
+/**
+ * Clear persisted query cache
+ */
+export const clearQueryCache = async (storage) => {
+    const adapter = createPersistenceAdapter(storage);
+    await adapter.removeClient();
+};

package/dist/esm/hooks/useAssets.js

@@ -0,0 +1,220 @@
+import { useCallback } from 'react';
+import { useAssetStore } from '../stores/assetStore';
+// Create a singleton instance for the hook
+let oxyInstance = null;
+export const setOxyAssetInstance = (instance) => {
+    oxyInstance = instance;
+};
+/**
+ * Hook for managing assets with Zustand store integration
+ */
+export 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 } = useAssetStore();
+    // Upload asset with progress tracking
+    const upload = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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
+    };
+};

package/dist/esm/hooks/useFileDownloadUrl.js

@@ -0,0 +1,86 @@
+import { useEffect, useState } from 'react';
+let oxyInstance = null;
+export const setOxyFileUrlInstance = (instance) => {
+    oxyInstance = instance;
+};
+/**
+ * Hook to resolve a file's download URL asynchronously.
+ *
+ * Prefers `getFileDownloadUrlAsync` and falls back to the synchronous
+ * `getFileDownloadUrl` helper if the async call fails.
+ */
+export const useFileDownloadUrl = (fileId, options) => {
+    const [url, setUrl] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!fileId) {
+            setUrl(null);
+            setLoading(false);
+            setError(null);
+            return;
+        }
+        if (!oxyInstance) {
+            // Fail silently but don't crash the UI – caller can decide what to do with null URL.
+            setUrl(null);
+            setLoading(false);
+            setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
+            return;
+        }
+        let cancelled = false;
+        const load = async () => {
+            setLoading(true);
+            setError(null);
+            // Store instance in local variable for TypeScript null checking
+            const instance = oxyInstance;
+            if (!instance) {
+                setLoading(false);
+                setError(new Error('OxyServices instance not configured for useFileDownloadUrl'));
+                return;
+            }
+            try {
+                const { variant, expiresIn } = options || {};
+                let resolvedUrl = null;
+                if (typeof instance.getFileDownloadUrlAsync === 'function') {
+                    resolvedUrl = await instance.getFileDownloadUrlAsync(fileId, variant, expiresIn);
+                }
+                if (!resolvedUrl && typeof instance.getFileDownloadUrl === 'function') {
+                    resolvedUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+                }
+                if (!cancelled) {
+                    setUrl(resolvedUrl || null);
+                }
+            }
+            catch (err) {
+                // Fallback to sync URL on error where possible
+                try {
+                    if (typeof instance.getFileDownloadUrl === 'function') {
+                        const { variant, expiresIn } = options || {};
+                        const fallbackUrl = instance.getFileDownloadUrl(fileId, variant, expiresIn);
+                        if (!cancelled) {
+                            setUrl(fallbackUrl || null);
+                            setError(err instanceof Error ? err : new Error(String(err)));
+                        }
+                        return;
+                    }
+                }
+                catch {
+                    // ignore secondary failure, we'll surface the original error below
+                }
+                if (!cancelled) {
+                    setError(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        };
+        load();
+        return () => {
+            cancelled = true;
+        };
+    }, [fileId, options?.variant, options?.expiresIn]);
+    return { url, loading, error };
+};

package/dist/esm/hooks/useFileFiltering.js

@@ -0,0 +1,78 @@
+import { useMemo, useState, useCallback } from 'react';
+/**
+ * Hook for file filtering, sorting, and search functionality
+ * Extracts common file management logic for reuse across components
+ */
+export function useFileFiltering({ files, initialViewMode = 'all', initialSortBy = 'date', initialSortOrder = 'desc', }) {
+    const [viewMode, setViewMode] = useState(initialViewMode);
+    const [searchQuery, setSearchQuery] = useState('');
+    const [sortBy, setSortBy] = useState(initialSortBy);
+    const [sortOrder, setSortOrder] = useState(initialSortOrder);
+    const toggleSortOrder = useCallback(() => {
+        setSortOrder((prev) => (prev === 'asc' ? 'desc' : 'asc'));
+    }, []);
+    const filteredFiles = useMemo(() => {
+        // Filter by view mode
+        let filteredByMode = files;
+        if (viewMode === 'photos') {
+            filteredByMode = files.filter((file) => file.contentType.startsWith('image/'));
+        }
+        else if (viewMode === 'videos') {
+            filteredByMode = files.filter((file) => file.contentType.startsWith('video/'));
+        }
+        else if (viewMode === 'documents') {
+            filteredByMode = files.filter((file) => file.contentType.includes('pdf') ||
+                file.contentType.includes('document') ||
+                file.contentType.includes('text') ||
+                file.contentType.includes('msword') ||
+                file.contentType.includes('excel') ||
+                file.contentType.includes('spreadsheet') ||
+                file.contentType.includes('presentation') ||
+                file.contentType.includes('powerpoint'));
+        }
+        else if (viewMode === 'audio') {
+            filteredByMode = files.filter((file) => file.contentType.startsWith('audio/'));
+        }
+        // Filter by search query
+        let filtered = filteredByMode;
+        if (searchQuery.trim()) {
+            const query = searchQuery.toLowerCase();
+            filtered = filteredByMode.filter((file) => file.filename.toLowerCase().includes(query) ||
+                file.contentType.toLowerCase().includes(query) ||
+                (file.metadata?.description &&
+                    file.metadata.description.toLowerCase().includes(query)));
+        }
+        // Sort files
+        const sorted = [...filtered].sort((a, b) => {
+            let comparison = 0;
+            if (sortBy === 'date') {
+                const dateA = new Date(a.uploadDate || 0).getTime();
+                const dateB = new Date(b.uploadDate || 0).getTime();
+                comparison = dateA - dateB;
+            }
+            else if (sortBy === 'size') {
+                comparison = (a.length || 0) - (b.length || 0);
+            }
+            else if (sortBy === 'name') {
+                comparison = (a.filename || '').localeCompare(b.filename || '');
+            }
+            else if (sortBy === 'type') {
+                comparison = (a.contentType || '').localeCompare(b.contentType || '');
+            }
+            return sortOrder === 'asc' ? comparison : -comparison;
+        });
+        return sorted;
+    }, [files, searchQuery, viewMode, sortBy, sortOrder]);
+    return {
+        filteredFiles,
+        viewMode,
+        setViewMode,
+        searchQuery,
+        setSearchQuery,
+        sortBy,
+        setSortBy,
+        sortOrder,
+        setSortOrder,
+        toggleSortOrder,
+    };
+}