@jmruthers/pace-core 0.6.10 → 0.6.12

package/src/hooks/useFileDisplay.ts

@@ -1,748 +0,0 @@
-/**
- * @file File Display Hook (Authenticated)
- * @package @jmruthers/pace-core
- * @module Hooks
- *
- * A React hook for accessing file references in authenticated contexts.
- * Can handle both public and private files using the core_file_references system.
- *
- * Features:
- * - Works in authenticated contexts
- * - Supports both public and private files
- * - Automatic signed URL generation for private files
- * - Caching for performance
- * - Error handling and loading states
- * - Supports both single file (category) and multiple files
- *
- * @example
- * ```tsx
- * import { useFileDisplay } from '@jmruthers/pace-core';
- *
- * function FileView() {
- *   const { fileUrl, fileReference, isLoading, error } = useFileDisplay(
- *     'core_events',
- *     eventId,
- *     organisationId,
- *     FileCategory.EVENT_LOGOS
- *   );
- *
- *   if (isLoading) return <p>Loading...</p>;
- *   if (error) return <p>Error: {error.message}</p>;
- *
- *   return fileUrl ? <img src={fileUrl} alt="File" /> : null;
- * }
- * ```
- */
-
-import { useState, useEffect, useCallback, useRef } from 'react';
-import type { SupabaseClient } from '@supabase/supabase-js';
-import type { Database } from '../types/database';
-import { FileReference, FileCategory } from '../types/file-reference';
-import { getPublicUrl, getSignedUrl, generateFileUrlsBatch } from '../utils/storage/helpers';
-import { createFileReferenceService } from '../utils/file-reference';
-import { logger } from '../utils/core/logger';
-
-// Cache data structure
-interface CacheData {
-  fileUrl: string | null;
-  fileReference: FileReference | null;
-  fileReferences: FileReference[];
-  fileUrls: Map<string, string>;
-  fileCount: number;
-}
-
-// Simple in-memory cache for authenticated file data
-const authenticatedFileCache = new Map<string, { data: CacheData; timestamp: number; ttl: number }>();
-
-// Cache size limit to prevent memory leaks
-const MAX_CACHE_SIZE = 100;
-
-// Helper function to clean up expired entries and enforce size limit
-function cleanupCache() {
-  const now = Date.now();
-  const entries = Array.from(authenticatedFileCache.entries());
-  
-  // Remove expired entries
-  const expiredKeys: string[] = [];
-  entries.forEach(([key, value]) => {
-    if (now - value.timestamp >= value.ttl) {
-      expiredKeys.push(key);
-    }
-  });
-  expiredKeys.forEach(key => authenticatedFileCache.delete(key));
-  
-  // If still over limit, remove oldest entries
-  if (authenticatedFileCache.size > MAX_CACHE_SIZE) {
-    const sorted = entries
-      .filter(([key]) => !expiredKeys.includes(key))
-      .sort((a, b) => a[1].timestamp - b[1].timestamp);
-    const toRemove = sorted.slice(0, authenticatedFileCache.size - MAX_CACHE_SIZE);
-    toRemove.forEach(([key]) => authenticatedFileCache.delete(key));
-  }
-}
-
-/**
- * Return value of the useFileDisplay hook.
- * Provides file URLs, references, loading state, error, and refetch function.
- */
-export interface UseFileDisplayReturn {
-  /** Single file URL if category is provided and file found, null otherwise */
-  fileUrl: string | null;
-  /** Single file reference if category is provided and file found, null otherwise */
-  fileReference: FileReference | null;
-  /** Array of all file references for the record (when category not provided or for multiple files) */
-  fileReferences: FileReference[];
-  /** Map of file IDs to URLs for multiple files */
-  fileUrls: Map<string, string>;
-  /** Total count of files for the record */
-  fileCount: number;
-  /** Whether the data is currently loading */
-  isLoading: boolean;
-  /** Any error that occurred during loading */
-  error: Error | null;
-  /** Function to manually refetch the data */
-  refetch: () => Promise<void>;
-}
-
-export interface UseFileDisplayOptions {
-  /** Cache TTL in milliseconds (default: 30 minutes) */
-  cacheTtl?: number;
-  /** Whether to enable caching (default: true) */
-  enableCache?: boolean;
-  /** Supabase client instance (required) */
-  supabase: SupabaseClient | null;
-}
-
-/**
- * Hook for accessing file references in authenticated contexts
- * 
- * This hook provides access to file references for authenticated users.
- * It supports both public and private files, generating appropriate URLs
- * (public URLs for public files, signed URLs for private files).
- * 
- * @param table_name - The table name containing the file reference
- * @param record_id - The record ID that owns the file(s)
- * @param organisation_id - The organisation ID for storage path
- * @param category - Optional file category to filter by (for single file mode)
- * @param options - Configuration options for caching and behavior
- * @returns Object containing file data, loading state, error, and refetch function
- */
-export function useFileDisplay(
-  table_name: string | undefined,
-  record_id: string | undefined,
-  organisation_id: string | undefined,
-  category: FileCategory | undefined,
-  options: UseFileDisplayOptions
-): UseFileDisplayReturn {
-  const {
-    cacheTtl = 30 * 60 * 1000, // 30 minutes
-    enableCache = true,
-    supabase
-  } = options;
-
-  const [fileUrl, setFileUrl] = useState<string | null>(null);
-  const [fileReference, setFileReference] = useState<FileReference | null>(null);
-  const [fileReferences, setFileReferences] = useState<FileReference[]>([]);
-  const [fileUrls, setFileUrls] = useState<Map<string, string>>(new Map());
-  const [fileCount, setFileCount] = useState<number>(0);
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  // Ref to track if component is mounted and effect is active
-  // This prevents state updates from stale async operations
-  const isMountedRef = useRef(true);
-
-  // Helper to safely set state only if component is still mounted
-  const safeSetState = <T,>(setter: (value: T) => void, value: T) => {
-    if (isMountedRef.current) {
-      setter(value);
-    }
-  };
-
-  const fetchFiles = useCallback(async (): Promise<void> => {
-    if (!table_name || !record_id || !supabase) {
-      safeSetState(setFileUrl, null);
-      safeSetState(setFileReference, null);
-      safeSetState(setFileReferences, []);
-      safeSetState(setFileUrls, new Map());
-      safeSetState(setFileCount, 0);
-      safeSetState(setIsLoading, false);
-      return;
-    }
-
-    // Validate UUID format for organisationId to prevent database errors (only if provided)
-    if (organisation_id) {
-      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-      if (!uuidRegex.test(organisation_id)) {
-        logger.warn('useFileDisplay', 'Invalid organisationId format (not a valid UUID):', organisation_id);
-      }
-    }
-
-    // Check cache first
-    // When organisation_id is undefined, use 'undefined' in cache key to distinguish from explicit null
-    const cacheKey = `file_${table_name}_${record_id}_${organisation_id === undefined ? 'undefined' : (organisation_id ?? 'null')}_${category || 'all'}`;
-    if (enableCache) {
-      const cached = authenticatedFileCache.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < cached.ttl) {
-        const cachedData = cached.data;
-        
-        // FIX: Regenerate signed URL for private files if missing
-        if (cachedData.fileReference && !cachedData.fileUrl && 
-            cachedData.fileReference.is_public === false && supabase) {
-          // Regenerate signed URL without fetching from database
-          try {
-            const signedUrlResult = await getSignedUrl(supabase, cachedData.fileReference.file_path, {
-              appName: 'pace-core',
-              orgId: organisation_id,
-              userId: organisation_id ? undefined : record_id,
-              expiresIn: 3600
-            });
-            const regeneratedUrl = signedUrlResult?.url || null;
-            safeSetState(setFileUrl, regeneratedUrl);
-            safeSetState(setFileReference, cachedData.fileReference);
-            safeSetState(setFileReferences, cachedData.fileReferences || []);
-            safeSetState(setFileUrls, cachedData.fileUrls || new Map());
-            safeSetState(setFileCount, cachedData.fileCount || 0);
-            safeSetState(setIsLoading, false);
-            safeSetState(setError, null);
-            return;
-          } catch (err) {
-            // If signed URL regeneration fails, fall through to normal fetch
-            logger.warn('useFileDisplay', 'Failed to regenerate signed URL from cache, falling back to fetch:', err);
-          }
-        }
-        
-        // Normal cache hit for public files or files with URLs
-        safeSetState(setFileUrl, cachedData.fileUrl || null);
-        safeSetState(setFileReference, cachedData.fileReference || null);
-        safeSetState(setFileReferences, cachedData.fileReferences || []);
-        safeSetState(setFileUrls, cachedData.fileUrls || new Map());
-        safeSetState(setFileCount, cachedData.fileCount || 0);
-        safeSetState(setIsLoading, false);
-        safeSetState(setError, null);
-        return;
-      }
-    }
-
-    try {
-      safeSetState(setIsLoading, true);
-      safeSetState(setError, null);
-
-      const service = createFileReferenceService(supabase);
-      let files: FileReference[] = [];
-
-      // When organisation_id is undefined (not provided), search both user-scoped (null) and organisation-scoped files
-      // This allows FileDisplay to work without requiring the organisation_id prop
-      // Note: Explicitly passing null or empty string should only search user-scoped files
-      const shouldSearchBothScopes = organisation_id === undefined;
-      
-      if (shouldSearchBothScopes) {
-        // First, try user-scoped files (organisation_id = null)
-        let userScopedFiles: FileReference[] = [];
-        let orgScopedFiles: FileReference[] = [];
-
-        try {
-          if (category) {
-            userScopedFiles = await service.getFilesByCategory(
-              table_name,
-              record_id,
-              category,
-              undefined // Explicitly pass undefined for user-scoped files (service converts to null for RPC)
-            );
-          } else {
-            userScopedFiles = await service.listFileReferences(
-              table_name,
-              record_id,
-              undefined // Explicitly pass undefined for user-scoped files (service converts to null for RPC)
-            );
-          }
-        } catch (err) {
-          logger.warn('useFileDisplay', 'Error querying user-scoped files:', err);
-          userScopedFiles = [];
-        }
-
-        // For organisation-scoped files, we need to query the user's organisations
-        // Get user's organisations from the authenticated session
-        try {
-          const { data: { user }, error: userError } = await supabase.auth.getUser();
-          if (userError) {
-            logger.warn('useFileDisplay', 'Error getting user:', userError);
-          }
-          
-          if (user) {
-            // Query user's active organisation memberships
-            const { data: memberships, error: membershipError } = await supabase
-              .from('core_organisation_memberships')
-              .select('organisation_id')
-              .eq('user_id', user.id);
-
-            if (membershipError) {
-              logger.warn('useFileDisplay', 'Error querying organisation memberships:', membershipError);
-            }
-
-            if (memberships && memberships.length > 0) {
-              // Try each organisation the user belongs to
-              const orgIds = memberships.map(m => m.organisation_id).filter(Boolean) as string[];
-              
-              // Query each organisation in parallel
-              const orgQueries = orgIds.map(async (orgId) => {
-                try {
-                  if (category) {
-                    return await service.getFilesByCategory(
-                      table_name,
-                      record_id,
-                      category,
-                      orgId
-                    );
-                  } else {
-                    return await service.listFileReferences(
-                      table_name,
-                      record_id,
-                      orgId
-                    );
-                  }
-                } catch (_err) {
-                  // Silently fail for individual org queries - user might not have access
-                  return [];
-                }
-              });
-
-              const orgResults = await Promise.all(orgQueries);
-              orgScopedFiles = orgResults.flat();
-            } else {
-              // When user has no organisation memberships, try querying files with any organisation_id
-              // as a fallback - the file might be organisation-scoped but accessible via RLS
-              // This handles edge cases where RLS allows access but we can't enumerate organisations
-              try {
-                // Try querying without organisation_id filter - let RLS handle security
-                let fallbackQuery = supabase
-                  .from('core_file_references')
-                  .select('id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at')
-                  .eq('table_name', table_name)
-                  .eq('record_id', record_id)
-                  .order('created_at', { ascending: false });
-
-                if (category) {
-                  fallbackQuery = fallbackQuery.eq('file_metadata->>category', category);
-                }
-
-                const { data: fallbackFiles } = await fallbackQuery;
-                
-                if (fallbackFiles && fallbackFiles.length > 0) {
-                  // Convert to FileReference format
-                  orgScopedFiles = (fallbackFiles as Database['public']['Tables']['core_file_references']['Row'][]).map((f) => {
-                    const fileName = f.file_path.split('/').pop() || 'unknown';
-                    const fileType = fileName.split('.').pop() || 'unknown';
-                    const metadata = f.file_metadata as { fileName?: string; fileType?: string; category?: FileCategory; [key: string]: unknown } | null;
-                    
-                    return {
-                      id: f.id,
-                      table_name: f.table_name,
-                      record_id: f.record_id,
-                      file_path: f.file_path,
-                      file_metadata: {
-                        fileName: metadata?.fileName || fileName,
-                        fileType: metadata?.fileType || fileType,
-                        category: metadata?.category || FileCategory.GENERAL_DOCUMENTS,
-                        ...(metadata || {})
-                      } as FileReference['file_metadata'],
-                      organisation_id: f.organisation_id,
-                      app_id: f.app_id as FileReference['app_id'],
-                      is_public: f.is_public ?? false,
-                      created_at: f.created_at || new Date().toISOString(),
-                      updated_at: f.updated_at || new Date().toISOString()
-                    };
-                  });
-                }
-              } catch (_err) {
-                // Silently fail - RLS may block or other error
-              }
-            }
-          }
-        } catch (err) {
-          logger.warn('useFileDisplay', 'Error querying organisation-scoped files:', err);
-          orgScopedFiles = [];
-        }
-
-        // Merge results: prefer organisation-scoped files if both exist, otherwise use user-scoped
-        // Sort by created_at DESC to get most recent first
-        const allFiles = [...userScopedFiles, ...orgScopedFiles];
-        allFiles.sort((a, b) => {
-          const aTime = new Date(a.created_at).getTime();
-          const bTime = new Date(b.created_at).getTime();
-          return bTime - aTime;
-        });
-
-        // If we have both types, prefer organisation-scoped (non-null organisation_id)
-        // Otherwise, use whatever we found
-        if (orgScopedFiles.length > 0 && userScopedFiles.length > 0) {
-          // Prefer organisation-scoped files - filter to only those with organisation_id
-          files = allFiles.filter(f => f.organisation_id !== null);
-        } else {
-          // Use all files found (either user-scoped or org-scoped, but not both)
-          files = allFiles;
-        }
-
-        // If no files found through RPC, try a direct query as fallback
-        // This handles cases where RLS policy allows access but RPC security check is too strict
-        // (e.g., core_person files where user owns the person record but record_id != user_id)
-        if (files.length === 0) {
-          try {
-            let directQuery = supabase
-              .from('core_file_references')
-              .select('id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at')
-              .eq('table_name', table_name)
-              .eq('record_id', record_id)
-              .order('created_at', { ascending: false });
-
-            // If category is provided, filter by category in metadata
-            if (category) {
-              directQuery = directQuery.eq('file_metadata->>category', category);
-            }
-
-            const { data: directFiles } = await directQuery;
-
-            if (directFiles && directFiles.length > 0) {
-              // Convert to FileReference format
-              files = (directFiles as Database['public']['Tables']['core_file_references']['Row'][]).map((f) => {
-                const fileName = f.file_path.split('/').pop() || 'unknown';
-                const fileType = fileName.split('.').pop() || 'unknown';
-                const metadata = f.file_metadata as { fileName?: string; fileType?: string; category?: FileCategory; [key: string]: unknown } | null;
-                
-                return {
-                  id: f.id,
-                  table_name: f.table_name,
-                  record_id: f.record_id,
-                  file_path: f.file_path,
-                  file_metadata: {
-                    fileName: metadata?.fileName || fileName,
-                    fileType: metadata?.fileType || fileType,
-                    category: metadata?.category || FileCategory.GENERAL_DOCUMENTS,
-                    ...(metadata || {})
-                  } as FileReference['file_metadata'],
-                  organisation_id: f.organisation_id,
-                  app_id: f.app_id as FileReference['app_id'],
-                  is_public: f.is_public ?? false,
-                  created_at: f.created_at || new Date().toISOString(),
-                  updated_at: f.updated_at || new Date().toISOString()
-                };
-              });
-            }
-          } catch (_err) {
-            // Silently fail - RLS may block or other error
-          }
-        }
-      } else {
-        // organisation_id is provided (or explicitly null) - use normal query
-        // CRITICAL: When category is provided, MUST use RPC function, not direct queries
-        // Category is stored in file_metadata JSONB field, not a direct column
-        if (category) {
-          // Single file mode - get files by category using RPC
-          // Removed verbose debug log - only log on errors
-          files = await service.getFilesByCategory(
-            table_name,
-            record_id,
-            category,
-            organisation_id
-          );
-        } else {
-          // Multiple files mode - get all files using RPC
-          files = await service.listFileReferences(
-            table_name,
-            record_id,
-            organisation_id
-          );
-        }
-
-        // Fallback: If no files found and organisation_id is falsy (undefined, null, empty string),
-        // try searching both scopes as a fallback
-        // This handles cases where the prop might be passed as empty string or the check above didn't catch it
-        if (files.length === 0 && (!organisation_id || organisation_id === '')) {
-          // Try the dual-scope search logic
-          let userScopedFiles: FileReference[] = [];
-          let orgScopedFiles: FileReference[] = [];
-
-          try {
-            if (category) {
-              userScopedFiles = await service.getFilesByCategory(
-                table_name,
-                record_id,
-                category,
-                undefined
-              );
-            } else {
-              userScopedFiles = await service.listFileReferences(
-                table_name,
-                record_id,
-                undefined
-              );
-            }
-          } catch (_err) {
-            // Silently fail
-          }
-
-          try {
-            const { data: { user } } = await supabase.auth.getUser();
-            if (user) {
-              const { data: memberships } = await supabase
-                .from('core_organisation_memberships')
-                .select('organisation_id')
-                .eq('user_id', user.id)
-                .or('status.is.null,status.eq.active');
-
-              if (memberships && memberships.length > 0) {
-                const orgIds = memberships.map(m => m.organisation_id).filter(Boolean) as string[];
-                const orgQueries = orgIds.map(async (orgId) => {
-                  try {
-                    if (category) {
-                      return await service.getFilesByCategory(table_name, record_id, category, orgId);
-                    } else {
-                      return await service.listFileReferences(table_name, record_id, orgId);
-                    }
-                  } catch (_err) {
-                    return [];
-                  }
-                });
-                const orgResults = await Promise.all(orgQueries);
-                orgScopedFiles = orgResults.flat();
-              }
-            }
-          } catch (_err) {
-            // Silently fail
-          }
-
-          // Merge results
-          const allFiles = [...userScopedFiles, ...orgScopedFiles];
-          allFiles.sort((a, b) => {
-            const aTime = new Date(a.created_at).getTime();
-            const bTime = new Date(b.created_at).getTime();
-            return bTime - aTime;
-          });
-
-          if (orgScopedFiles.length > 0 && userScopedFiles.length > 0) {
-            files = allFiles.filter(f => f.organisation_id !== null);
-          } else {
-            files = allFiles;
-          }
-        }
-      }
-
-      if (files.length === 0) {
-        safeSetState(setFileUrl, null);
-        safeSetState(setFileReference, null);
-        safeSetState(setFileReferences, []);
-        safeSetState(setFileUrls, new Map());
-        safeSetState(setFileCount, 0);
-        
-        // Cache empty result
-        if (enableCache) {
-          authenticatedFileCache.set(cacheKey, {
-            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: new Map(), fileCount: 0 },
-            timestamp: Date.now(),
-            ttl: cacheTtl
-          });
-          cleanupCache();
-        }
-        return;
-      }
-
-      safeSetState(setFileReferences, files);
-      safeSetState(setFileCount, files.length);
-
-      if (category && files.length > 0) {
-        // Single file mode - get first file
-        const firstFile = files[0];
-        // Removed verbose debug logs - only log on errors
-        safeSetState(setFileReference, firstFile);
-        
-        // Generate URL based on file visibility
-        let url: string | null = null;
-        if (firstFile.is_public) {
-          url = getPublicUrl(supabase, firstFile.file_path, true);
-        } else {
-          const signedUrlResult = await getSignedUrl(supabase, firstFile.file_path, {
-            appName: 'pace-core',
-            orgId: organisation_id,
-            userId: organisation_id ? undefined : record_id,
-            expiresIn: 3600
-          });
-          url = signedUrlResult?.url || null;
-          // Only log if URL generation fails
-          if (!url) {
-            logger.warn('useFileDisplay', 'Failed to generate signed URL for file:', {
-              file_path: firstFile.file_path,
-              record_id,
-              table_name
-            });
-          }
-        }
-        safeSetState(setFileUrl, url);
-      } else {
-        // Multiple files mode - generate URLs for all files in batch
-        const urlMap = await generateFileUrlsBatch(supabase, files, {
-              appName: 'pace-core',
-              orgId: organisation_id,
-              userId: organisation_id ? undefined : record_id,
-              expiresIn: 3600
-            });
-        safeSetState(setFileUrls, urlMap);
-        safeSetState(setFileReference, null);
-        safeSetState(setFileUrl, null);
-      }
-
-      // Cache the result
-      if (enableCache) {
-        // Prepare cache data - fileUrl will be set below if category mode
-        const cacheData: CacheData = {
-          fileUrl: null,
-          fileReference: category && files.length > 0 ? files[0] : null,
-          fileReferences: files,
-          fileUrls: new Map(),
-          fileCount: files.length
-        };
-
-        if (category && files.length > 0) {
-          const firstFile = files[0];
-          let url: string | null = null;
-          if (firstFile.is_public) {
-            url = getPublicUrl(supabase, firstFile.file_path, true);
-          }
-          cacheData.fileUrl = url;
-        } else {
-          const urlMap = new Map<string, string>();
-          for (const fileRef of files) {
-            if (fileRef.is_public) {
-              const url = getPublicUrl(supabase, fileRef.file_path, true);
-              if (url) {
-                urlMap.set(fileRef.id, url);
-              }
-            }
-          }
-          cacheData.fileUrls = urlMap;
-        }
-
-        authenticatedFileCache.set(cacheKey, {
-          data: cacheData,
-          timestamp: Date.now(),
-          ttl: cacheTtl
-        });
-        cleanupCache();
-      }
-
-    } catch (err) {
-      logger.error('useFileDisplay', 'Error fetching files:', err);
-      const error = err instanceof Error ? err : new Error('Unknown error occurred');
-      safeSetState(setError, error);
-      safeSetState(setFileUrl, null);
-      safeSetState(setFileReference, null);
-      safeSetState(setFileReferences, []);
-      safeSetState(setFileUrls, new Map());
-      safeSetState(setFileCount, 0);
-    } finally {
-      safeSetState(setIsLoading, false);
-    }
-  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-
-  // Fetch files when parameters change
-  useEffect(() => {
-    // Mark as mounted when effect runs
-    isMountedRef.current = true;
-
-    if (table_name && record_id && supabase) {
-      // Call fetchFiles - it will check isMountedRef before setting state
-      fetchFiles().catch((err) => {
-        // Only set error if component is still mounted
-        if (isMountedRef.current) {
-          safeSetState(setError, err instanceof Error ? err : new Error('Unknown error'));
-        }
-      });
-    } else {
-      // Only update state if component is still mounted
-      safeSetState(setFileUrl, null);
-      safeSetState(setFileReference, null);
-      safeSetState(setFileReferences, []);
-      safeSetState(setFileUrls, new Map());
-      safeSetState(setFileCount, 0);
-      safeSetState(setIsLoading, false);
-      safeSetState(setError, null);
-    }
-
-    // Cleanup: mark as unmounted when dependencies change or component unmounts
-    // This prevents state updates from stale requests
-    return () => {
-      isMountedRef.current = false;
-    };
-    // fetchFiles is memoized; we only need to re-run when parameters change
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [table_name, record_id, organisation_id, supabase]);
-
-  const refetch = useCallback(async (): Promise<void> => {
-    if (!table_name || !record_id || !supabase) return;
-    
-    // Clear cache for this file
-    if (enableCache) {
-      const cacheKey = `file_${table_name}_${record_id}_${organisation_id === undefined ? 'undefined' : (organisation_id ?? 'null')}_${category || 'all'}`;
-      authenticatedFileCache.delete(cacheKey);
-    }
-    await fetchFiles();
-  }, [fetchFiles, table_name, record_id, organisation_id, category, supabase, enableCache]);
-
-  return {
-    fileUrl,
-    fileReference,
-    fileReferences,
-    fileUrls,
-    fileCount,
-    isLoading,
-    error,
-    refetch
-  };
-}
-
-/**
- * Clear all cached authenticated file data
- * Useful for testing or when you need to force refresh all data
- */
-export function clearFileDisplayCache(): void {
-  for (const [key] of authenticatedFileCache) {
-    if (key.startsWith('file_')) {
-      authenticatedFileCache.delete(key);
-    }
-  }
-}
-
-/**
- * Get cache statistics for debugging
- */
-export function getFileDisplayCacheStats(): { size: number; keys: string[] } {
-  const keys = Array.from(authenticatedFileCache.keys()).filter(key => key.startsWith('file_'));
-  return {
-    size: keys.length,
-    keys
-  };
-}
-
-/**
- * Invalidate cache for a specific file display entry
- * Useful for clearing cache after file uploads or updates
- * 
- * @param table_name - The table name containing the file reference
- * @param record_id - The record ID that owns the file(s)
- * @param organisation_id - The organisation ID for storage path
- * @param category - Optional file category to invalidate (if provided, also invalidates 'all' category)
- */
-export function invalidateFileDisplayCache(
-  table_name: string,
-  record_id: string,
-  organisation_id: string | null | undefined,
-  category?: FileCategory
-): void {
-  const cacheKey = `file_${table_name}_${record_id}_${organisation_id === undefined ? 'undefined' : (organisation_id ?? 'null')}_${category || 'all'}`;
-  authenticatedFileCache.delete(cacheKey);
-  // Also invalidate 'all' category if specific category invalidated
-  if (category) {
-    const allCategoryKey = `file_${table_name}_${record_id}_${organisation_id === undefined ? 'undefined' : (organisation_id ?? 'null')}_all`;
-    authenticatedFileCache.delete(allCategoryKey);
-  }
-}
-