@oxyhq/auth 1.0.0

package/src/hooks/useAssets.ts

@@ -0,0 +1,291 @@
+import { useCallback } from 'react';
+import { useAssetStore } from '../stores/assetStore';
+import { OxyServices } from '@oxyhq/core';
+import { 
+  Asset, 
+  AssetLinkRequest, 
+  AssetUnlinkRequest, 
+  AssetUploadProgress 
+} from '@oxyhq/core';
+
+// Create a singleton instance for the hook
+let oxyInstance: OxyServices | null = null;
+
+export const setOxyAssetInstance = (instance: OxyServices) => {
+  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: File, 
+    metadata?: Record<string, any>
+  ): Promise<Asset | null> => {
+    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 as any, 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: any) {
+      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: string, 
+    app: string, 
+    entityType: string, 
+    entityId: string
+  ): Promise<void> => {
+    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' as const
+        : 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: any) {
+      setLinkError(error.message || 'Link failed');
+      throw error;
+    } finally {
+      setLinking(false);
+    }
+  }, [clearErrors, setLinking, setAsset, addLink, setLinkError]);
+
+  // Unlink asset from entity
+  const unlink = useCallback(async (
+    assetId: string, 
+    app: string, 
+    entityType: string, 
+    entityId: string
+  ): Promise<void> => {
+    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: any) {
+      setLinkError(error.message || 'Unlink failed');
+      throw error;
+    } finally {
+      setLinking(false);
+    }
+  }, [clearErrors, setLinking, setAsset, removeLink, setLinkError]);
+
+  // Get asset URL
+  const getUrl = useCallback(async (
+    assetId: string, 
+    variant?: string, 
+    expiresIn?: number
+  ): Promise<string> => {
+    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: any) {
+      throw error;
+    }
+  }, []);
+
+  // Get asset metadata
+  const getAsset = useCallback(async (assetId: string): Promise<Asset> => {
+    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: any) {
+      throw error;
+    }
+  }, [setAsset]);
+
+  // Delete asset
+  const deleteAsset = useCallback(async (
+    assetId: string, 
+    force: boolean = false
+  ): Promise<void> => {
+    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: any) {
+      setDeleteError(error.message || 'Delete failed');
+      throw error;
+    } finally {
+      setDeleting(false);
+    }
+  }, [clearErrors, setDeleting, removeAsset, setDeleteError]);
+
+  // Restore asset from trash
+  const restore = useCallback(async (assetId: string): Promise<void> => {
+    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: any) {
+      throw error;
+    }
+  }, [setAsset]);
+
+  // Get variants
+  const getVariants = useCallback(async (assetId: string) => {
+    if (!oxyInstance) {
+      throw new Error('OxyServices instance not configured. Call setOxyAssetInstance first.');
+    }
+
+    try {
+      return await oxyInstance.assetGetVariants(assetId);
+    } catch (error: any) {
+      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/src/hooks/useFileDownloadUrl.ts

@@ -0,0 +1,118 @@
+import { useEffect, useState } from 'react';
+import { OxyServices } from '@oxyhq/core';
+
+let oxyInstance: OxyServices | null = null;
+
+export const setOxyFileUrlInstance = (instance: OxyServices) => {
+  oxyInstance = instance;
+};
+
+export interface UseFileDownloadUrlOptions {
+  variant?: string;
+  expiresIn?: number;
+}
+
+export interface UseFileDownloadUrlResult {
+  url: string | null;
+  loading: boolean;
+  error: Error | null;
+}
+
+/**
+ * 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?: string | null,
+  options?: UseFileDownloadUrlOptions
+): UseFileDownloadUrlResult => {
+  const [url, setUrl] = useState<string | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(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: string | null = 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: any) {
+        // 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/src/hooks/useFileFiltering.ts

@@ -0,0 +1,115 @@
+import { useMemo, useState, useCallback } from 'react';
+import type { FileMetadata } from '@oxyhq/core';
+
+export type ViewMode = 'all' | 'photos' | 'videos' | 'documents' | 'audio';
+export type SortBy = 'date' | 'size' | 'name' | 'type';
+export type SortOrder = 'asc' | 'desc';
+
+interface UseFileFilteringOptions {
+  files: FileMetadata[];
+  initialViewMode?: ViewMode;
+  initialSortBy?: SortBy;
+  initialSortOrder?: SortOrder;
+}
+
+interface UseFileFilteringReturn {
+  filteredFiles: FileMetadata[];
+  viewMode: ViewMode;
+  setViewMode: (mode: ViewMode) => void;
+  searchQuery: string;
+  setSearchQuery: (query: string) => void;
+  sortBy: SortBy;
+  setSortBy: (sort: SortBy) => void;
+  sortOrder: SortOrder;
+  setSortOrder: (order: SortOrder) => void;
+  toggleSortOrder: () => void;
+}
+
+/**
+ * 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',
+}: UseFileFilteringOptions): UseFileFilteringReturn {
+  const [viewMode, setViewMode] = useState<ViewMode>(initialViewMode);
+  const [searchQuery, setSearchQuery] = useState('');
+  const [sortBy, setSortBy] = useState<SortBy>(initialSortBy);
+  const [sortOrder, setSortOrder] = useState<SortOrder>(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,
+  };
+}

package/src/hooks/useFollow.ts

@@ -0,0 +1,175 @@
+import { useCallback, useMemo, useEffect } from 'react';
+import { useFollowStore } from '../stores/followStore';
+import { useWebOxy } from '../WebOxyProvider';
+
+export const useFollow = (userId?: string | string[]) => {
+  const { oxyServices } = useWebOxy();
+  const userIds = useMemo(() => (Array.isArray(userId) ? userId : userId ? [userId] : []), [userId]);
+  const isSingleUser = typeof userId === 'string';
+
+  // Zustand selectors
+  const followState = useFollowStore();
+
+  // Single user helpers
+  const isFollowing = isSingleUser && userId ? followState.followingUsers[userId] ?? false : false;
+  const isLoading = isSingleUser && userId ? followState.loadingUsers[userId] ?? false : false;
+  const error = isSingleUser && userId ? followState.errors[userId] ?? null : null;
+  
+  // Follower count helpers
+  const followerCount = isSingleUser && userId ? followState.followerCounts[userId] ?? null : null;
+  const followingCount = isSingleUser && userId ? followState.followingCounts[userId] ?? null : null;
+  const isLoadingCounts = isSingleUser && userId ? followState.loadingCounts[userId] ?? false : false;
+
+  const toggleFollow = useCallback(async () => {
+    if (!isSingleUser || !userId) throw new Error('toggleFollow is only available for single user mode');
+    await followState.toggleFollowUser(userId, oxyServices, isFollowing);
+  }, [isSingleUser, userId, followState, oxyServices, isFollowing]);
+
+  const setFollowStatus = useCallback((following: boolean) => {
+    if (!isSingleUser || !userId) throw new Error('setFollowStatus is only available for single user mode');
+    followState.setFollowingStatus(userId, following);
+  }, [isSingleUser, userId, followState]);
+
+  const fetchStatus = useCallback(async () => {
+    if (!isSingleUser || !userId) throw new Error('fetchStatus is only available for single user mode');
+    await followState.fetchFollowStatus(userId, oxyServices);
+  }, [isSingleUser, userId, followState, oxyServices]);
+
+  const clearError = useCallback(() => {
+    if (!isSingleUser || !userId) throw new Error('clearError is only available for single user mode');
+    followState.clearFollowError(userId);
+  }, [isSingleUser, userId, followState]);
+
+  const fetchUserCounts = useCallback(async () => {
+    if (!isSingleUser || !userId) throw new Error('fetchUserCounts is only available for single user mode');
+    await followState.fetchUserCounts(userId, oxyServices);
+  }, [isSingleUser, userId, followState, oxyServices]);
+
+  const setFollowerCount = useCallback((count: number) => {
+    if (!isSingleUser || !userId) throw new Error('setFollowerCount is only available for single user mode');
+    followState.setFollowerCount(userId, count);
+  }, [isSingleUser, userId, followState]);
+
+  const setFollowingCount = useCallback((count: number) => {
+    if (!isSingleUser || !userId) throw new Error('setFollowingCount is only available for single user mode');
+    followState.setFollowingCount(userId, count);
+  }, [isSingleUser, userId, followState]);
+
+  // Auto-fetch counts when hook is used for a single user and counts are missing.
+  useEffect(() => {
+    if (!isSingleUser || !userId) return;
+
+    // If either count is not set and we're not already loading counts, trigger a fetch.
+    if ((followerCount === null || followingCount === null) && !isLoadingCounts) {
+      fetchUserCounts().catch((err: any) => console.warn('useFollow: fetchUserCounts failed', err));
+    }
+  }, [isSingleUser, userId, followerCount, followingCount, isLoadingCounts, fetchUserCounts]);
+
+  // Multiple user helpers
+  const followData = useMemo(() => {
+    const data: Record<string, { isFollowing: boolean; isLoading: boolean; error: string | null }> = {};
+    userIds.forEach(uid => {
+      data[uid] = {
+        isFollowing: followState.followingUsers[uid] ?? false,
+        isLoading: followState.loadingUsers[uid] ?? false,
+        error: followState.errors[uid] ?? null,
+      };
+    });
+    return data;
+  }, [userIds, followState.followingUsers, followState.loadingUsers, followState.errors]);
+
+  const toggleFollowForUser = useCallback(async (targetUserId: string) => {
+    const currentState = followState.followingUsers[targetUserId] ?? false;
+    await followState.toggleFollowUser(targetUserId, oxyServices, currentState);
+  }, [followState, oxyServices]);
+
+  const setFollowStatusForUser = useCallback((targetUserId: string, following: boolean) => {
+    followState.setFollowingStatus(targetUserId, following);
+  }, [followState]);
+
+  const fetchStatusForUser = useCallback(async (targetUserId: string) => {
+    await followState.fetchFollowStatus(targetUserId, oxyServices);
+  }, [followState, oxyServices]);
+
+  const fetchAllStatuses = useCallback(async () => {
+    await Promise.all(userIds.map(uid => followState.fetchFollowStatus(uid, oxyServices)));
+  }, [userIds, followState, oxyServices]);
+
+  const clearErrorForUser = useCallback((targetUserId: string) => {
+    followState.clearFollowError(targetUserId);
+  }, [followState]);
+
+  const updateCountsFromFollowAction = useCallback((targetUserId: string, action: 'follow' | 'unfollow', counts: { followers: number; following: number }) => {
+    const currentUserId = oxyServices.getCurrentUserId() || undefined;
+    followState.updateCountsFromFollowAction(targetUserId, action, counts, currentUserId);
+  }, [followState, oxyServices]);
+
+  // Aggregate helpers for multiple users
+  const isAnyLoading = userIds.some(uid => followState.loadingUsers[uid]);
+  const hasAnyError = userIds.some(uid => !!followState.errors[uid]);
+  const allFollowing = userIds.every(uid => followState.followingUsers[uid]);
+  const allNotFollowing = userIds.every(uid => !followState.followingUsers[uid]);
+
+  if (isSingleUser && userId) {
+    return {
+      isFollowing,
+      isLoading,
+      error,
+      toggleFollow,
+      setFollowStatus,
+      fetchStatus,
+      clearError,
+      // Follower count methods
+      followerCount,
+      followingCount,
+      isLoadingCounts,
+      fetchUserCounts,
+      setFollowerCount,
+      setFollowingCount,
+    };
+  }
+
+  return {
+    followData,
+    toggleFollowForUser,
+    setFollowStatusForUser,
+    fetchStatusForUser,
+    fetchAllStatuses,
+    clearErrorForUser,
+    isAnyLoading,
+    hasAnyError,
+    allFollowing,
+    allNotFollowing,
+  };
+};
+
+// Convenience hook for just follower counts
+export const useFollowerCounts = (userId: string) => {
+  const { oxyServices } = useWebOxy();
+  const followState = useFollowStore();
+
+  const followerCount = followState.followerCounts[userId] ?? null;
+  const followingCount = followState.followingCounts[userId] ?? null;
+  const isLoadingCounts = followState.loadingCounts[userId] ?? false;
+
+  const fetchUserCounts = useCallback(async () => {
+    await followState.fetchUserCounts(userId, oxyServices);
+  }, [userId, followState, oxyServices]);
+
+  const setFollowerCount = useCallback((count: number) => {
+    followState.setFollowerCount(userId, count);
+  }, [userId, followState]);
+
+  const setFollowingCount = useCallback((count: number) => {
+    followState.setFollowingCount(userId, count);
+  }, [userId, followState]);
+
+  return {
+    followerCount,
+    followingCount,
+    isLoadingCounts,
+    fetchUserCounts,
+    setFollowerCount,
+    setFollowingCount,
+  };
+};