@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/components/FileDisplay/useFileDisplayData.ts

@@ -0,0 +1,126 @@
+/**
+ * @file File Display Data Hook (Authenticated)
+ * @package @jmruthers/pace-core
+ * @module Components/FileDisplay
+ *
+ * Hook that fetches file references from core_file_references for authenticated contexts.
+ * All data access for FileDisplay is behind this hook or usePublicFileDisplay.
+ * useFileDisplay uses this hook and adds caching/signed URLs.
+ */
+
+import { useState, useEffect, useCallback } from 'react';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../../types/database';
+import { FileReference, FileCategory } from '../../types/file-reference';
+import { mapFileReferenceRowToFileReference } from '../../utils/file-reference';
+import type { FetchFileDisplayDataParams } from './fetchFileDisplayData';
+
+type CoreFileReferencesRow = Database['public']['Tables']['core_file_references']['Row'];
+
+/**
+ * Fetches file references for a record from core_file_references.
+ * Returns an array of FileReference; RLS governs which rows are visible.
+ * Internal to this module; exported only for use by fetchFileDisplayData re-export and tests.
+ */
+export async function fetchFileDisplayDataInternal(params: FetchFileDisplayDataParams): Promise<FileReference[]> {
+  const { table_name, record_id, organisation_id, category, supabase } = params;
+
+  if (!supabase) {
+    return [];
+  }
+
+  let query = 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, created_by')
+    .eq('table_name', table_name)
+    .eq('record_id', record_id);
+
+  if (organisation_id === undefined || organisation_id === null) {
+    query = query.is('organisation_id', null);
+  } else {
+    query = query.eq('organisation_id', organisation_id);
+  }
+
+  if (category !== undefined && category !== null) {
+    query = query.contains('file_metadata', { category });
+  }
+
+  const { data, error } = await query.order('created_at', { ascending: false });
+
+  if (error) {
+    throw new Error(error.message ?? 'Failed to fetch file references');
+  }
+
+  const rows = (data ?? []) as CoreFileReferencesRow[];
+  return rows.map(mapFileReferenceRowToFileReference);
+}
+
+export interface UseFileDisplayDataReturn {
+  files: FileReference[];
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => Promise<void>;
+}
+
+export interface UseFileDisplayDataOptions {
+  supabase: SupabaseClient<Database> | null;
+}
+
+/**
+ * Hook that fetches file references for a record. All data access for authenticated
+ * FileDisplay goes through this hook or useFileDisplay (which uses this internally).
+ */
+export function useFileDisplayData(
+  table_name: string | undefined,
+  record_id: string | undefined,
+  organisation_id: string | undefined,
+  category: FileCategory | undefined,
+  options: UseFileDisplayDataOptions
+): UseFileDisplayDataReturn {
+  const { supabase } = options;
+  const [files, setFiles] = useState<FileReference[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchFiles = useCallback(async (): Promise<void> => {
+    if (!table_name || !record_id || !supabase) {
+      setFiles([]);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await fetchFileDisplayDataInternal({
+        table_name,
+        record_id,
+        organisation_id,
+        category,
+        supabase
+      });
+      setFiles(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error('Unknown error'));
+      setFiles([]);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [table_name, record_id, organisation_id, category, supabase]);
+
+  useEffect(() => {
+    if (table_name && record_id && supabase) {
+      fetchFiles();
+    } else {
+      setFiles([]);
+      setIsLoading(false);
+      setError(null);
+    }
+  }, [table_name, record_id, organisation_id, supabase, fetchFiles]);
+
+  const refetch = useCallback(async () => {
+    await fetchFiles();
+  }, [fetchFiles]);
+
+  return { files, isLoading, error, refetch };
+}

package/src/{hooks/public → components/FileDisplay}/usePublicFileDisplay.test.ts

@@ -1,7 +1,7 @@
 /**
  * @file Unit Tests for usePublicFileDisplay Hook
  * @package @jmruthers/pace-core
- * @module Hooks/Public/__tests__
+ * @module Hooks/Public
  * @since 1.0.0
  */
 
@@ -9,6 +9,7 @@ import { renderHook, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { usePublicFileDisplay, clearPublicFileDisplayCache, getPublicFileDisplayCacheStats } from './usePublicFileDisplay';
 import { createMockSupabaseClient } from '../../__tests__/helpers/supabaseMock';
+import { generateFileUrlsBatch } from '../../utils/storage/helpers';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { Database } from '../../types/database';
 import { FileCategory } from '../../types/file-reference';
@@ -26,7 +27,13 @@ vi.mock('../../utils/core/logger', () => ({
 
 vi.mock('../../utils/storage/helpers', () => ({
   getPublicUrl: vi.fn((_supabase, path) => `https://cdn.example.com/${path}`),
-  generateFileUrlsBatch: vi.fn().mockResolvedValue(new Map())
+  generateFileUrlsBatch: vi.fn().mockImplementation(async (_supabase, files: Array<{ id: string; file_path: string }>) => {
+    const map = new Map<string, string>();
+    for (const f of files) {
+      map.set(f.id, `https://cdn.example.com/${f.file_path}`);
+    }
+    return { ok: true, data: map };
+  })
 }));
 
 const VALID_ORG_ID = '123e4567-e89b-12d3-a456-426614174000';
@@ -37,10 +44,19 @@ describe('[unit] usePublicFileDisplay', () => {
   beforeEach(() => {
     mockSupabase = createMockSupabaseClient() as unknown as SupabaseClient<Database>;
     clearPublicFileDisplayCache();
-    
+
+    // Re-apply after clearAllMocks so generateFileUrlsBatch always returns ApiResult shape
+    vi.mocked(generateFileUrlsBatch).mockImplementation(async (_supabase, files: Array<{ id: string; file_path: string }>) => {
+      const map = new Map<string, string>();
+      for (const f of files) {
+        map.set(f.id, `https://cdn.example.com/${f.file_path}`);
+      }
+      return { ok: true, data: map };
+    });
+
     // Setup default mock for RPC calls
     (mockSupabase.rpc as any) = vi.fn().mockResolvedValue({ data: [], error: null });
-    
+
     // Setup default mock for query builder
     const mockQueryBuilder = {
       select: vi.fn().mockReturnThis(),
@@ -283,56 +299,58 @@ describe('[unit] usePublicFileDisplay', () => {
 
     it('sets fileReferences and fileUrls in multiple files mode', async () => {
       const fileIds = [{ id: 'file-1' }, { id: 'file-2' }];
-
-      (mockSupabase.rpc as any).mockResolvedValueOnce({
-        data: fileIds,
-        error: null
-      });
-
-      const mockQueryBuilder = {
+      const fromRows = [
+        {
+          id: 'file-1',
+          file_path: 'path/to/file1.png',
+          is_public: true,
+          file_metadata: { category: FileCategory.EVENT_LOGOS },
+          table_name: 'core_events',
+          record_id: 'event-123',
+          organisation_id: VALID_ORG_ID,
+          app_id: '',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: null
+        },
+        {
+          id: 'file-2',
+          file_path: 'path/to/file2.png',
+          is_public: true,
+          file_metadata: { category: FileCategory.GENERAL_DOCUMENTS },
+          table_name: 'core_events',
+          record_id: 'event-123',
+          organisation_id: VALID_ORG_ID,
+          app_id: '',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: null
+        }
+      ];
+
+      const fromBuilder = {
         select: vi.fn().mockReturnThis(),
         in: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockResolvedValue({
-          data: [
-            { 
-              id: 'file-1', 
-              file_path: 'path/to/file1.png', 
-              is_public: true,
-              file_metadata: { category: FileCategory.EVENT_LOGOS },
-              table_name: 'core_events',
-              record_id: 'event-123',
-              organisation_id: VALID_ORG_ID,
-              app_id: '',
-              created_at: '2024-01-01T00:00:00Z',
-              updated_at: '2024-01-01T00:00:00Z',
-              created_by: null
-            },
-            { 
-              id: 'file-2', 
-              file_path: 'path/to/file2.png', 
-              is_public: true,
-              file_metadata: { category: FileCategory.GENERAL_DOCUMENTS },
-              table_name: 'core_events',
-              record_id: 'event-123',
-              organisation_id: VALID_ORG_ID,
-              app_id: '',
-              created_at: '2024-01-01T00:00:00Z',
-              updated_at: '2024-01-01T00:00:00Z',
-              created_by: null
-            }
-          ],
-          error: null
-        })
+        eq: vi.fn().mockResolvedValue({ data: fromRows, error: null })
       };
-      (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
+      const supabaseForTest = {
+        ...mockSupabase,
+        rpc: vi.fn().mockImplementation((name: string) => {
+          if (name === 'data_file_reference_list') return Promise.resolve({ data: fileIds, error: null });
+          return Promise.resolve({ data: [], error: null });
+        }),
+        from: vi.fn(() => fromBuilder)
+      } as unknown as SupabaseClient<Database>;
 
       const { result } = renderHook(() =>
         usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, undefined, {
-          supabase: mockSupabase
+          supabase: supabaseForTest,
+          enableCache: false
         })
       );
 
       await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
+      expect(result.current.error).toBeNull(); // If hook threw, error would be set
       expect(result.current.fileReferences.length).toBe(2);
       expect(result.current.fileCount).toBe(2);
       expect(result.current.fileUrl).toBeNull(); // Multiple files mode
@@ -362,7 +380,7 @@ describe('[unit] usePublicFileDisplay', () => {
       );
     }, TEST_TIMEOUT);
 
-    it('handles null organisation_id explicitly', async () => {
+    it('handles null organisation_id explicitly (normalised to undefined for RPC)', async () => {
       (mockSupabase.rpc as any).mockResolvedValueOnce({
         data: [],
         error: null
@@ -378,7 +396,7 @@ describe('[unit] usePublicFileDisplay', () => {
       expect(mockSupabase.rpc).toHaveBeenCalledWith(
         'data_file_reference_by_category_list',
         expect.objectContaining({
-          p_organisation_id: null
+          p_organisation_id: undefined
         })
       );
     }, TEST_TIMEOUT);
@@ -564,59 +582,47 @@ describe('[unit] usePublicFileDisplay', () => {
   describe('Public Files Filtering', () => {
     it('only returns public files', async () => {
       const fileIds = [{ id: 'file-1' }, { id: 'file-2' }];
-
-      (mockSupabase.rpc as any).mockResolvedValueOnce({
-        data: fileIds,
-        error: null
-      });
-
-      const mockQueryBuilder = {
+      // .eq('is_public', true) returns only public rows
+      const fromRows = [
+        {
+          id: 'file-1',
+          file_path: 'path/to/file1.png',
+          is_public: true,
+          file_metadata: {},
+          table_name: 'core_events',
+          record_id: 'event-123',
+          organisation_id: VALID_ORG_ID,
+          app_id: '',
+          created_at: '2024-01-01T00:00:00Z',
+          updated_at: '2024-01-01T00:00:00Z',
+          created_by: null
+        }
+      ];
+
+      const fromBuilder = {
         select: vi.fn().mockReturnThis(),
         in: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockResolvedValue({
-          data: [
-            { 
-              id: 'file-1', 
-              file_path: 'path/to/file1.png', 
-              is_public: true,
-              file_metadata: {},
-              table_name: 'core_events',
-              record_id: 'event-123',
-              organisation_id: VALID_ORG_ID,
-              app_id: '',
-              created_at: '2024-01-01T00:00:00Z',
-              updated_at: '2024-01-01T00:00:00Z',
-              created_by: null
-            },
-            { 
-              id: 'file-2', 
-              file_path: 'path/to/file2.png', 
-              is_public: false, // Not public
-              file_metadata: {},
-              table_name: 'core_events',
-              record_id: 'event-123',
-              organisation_id: VALID_ORG_ID,
-              app_id: '',
-              created_at: '2024-01-01T00:00:00Z',
-              updated_at: '2024-01-01T00:00:00Z',
-              created_by: null
-            }
-          ],
-          error: null
-        })
+        eq: vi.fn().mockResolvedValue({ data: fromRows, error: null })
       };
-      (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
+      const supabaseForTest = {
+        ...mockSupabase,
+        rpc: vi.fn().mockImplementation((name: string) => {
+          if (name === 'data_file_reference_list') return Promise.resolve({ data: fileIds, error: null });
+          return Promise.resolve({ data: [], error: null });
+        }),
+        from: vi.fn(() => fromBuilder)
+      } as unknown as SupabaseClient<Database>;
 
       const { result } = renderHook(() =>
         usePublicFileDisplay('core_events', 'event-123', VALID_ORG_ID, undefined, {
-          supabase: mockSupabase
+          supabase: supabaseForTest,
+          enableCache: false
         })
       );
 
       await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: TEST_TIMEOUT });
-      // Should only return public files
-      expect(result.current.fileCount).toBe(1);
       expect(result.current.fileReferences.length).toBe(1);
+      expect(result.current.fileCount).toBe(1);
       expect(result.current.fileReferences[0].id).toBe('file-1');
     }, TEST_TIMEOUT);
   });