@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/hooks/useFileReference.test.ts

@@ -33,22 +33,25 @@ beforeEach(() => {
     updateFileReference: vi.fn(),
     deleteFileReference: vi.fn(),
     listFileReferences: vi.fn(),
-    getFilesByCategory: vi.fn().mockResolvedValue([]),
+    getFilesByCategory: vi.fn().mockResolvedValue({ ok: true, data: [] }),
     getFileCount: vi.fn(),
     uploadMultipleFiles: vi.fn()
   };
   
   mockCreateFileReferenceService.mockReturnValue(serviceMock);
   mockUploadFileWithReference.mockResolvedValue({
-    file_reference: { id: 'test-file-ref' },
-    file_url: 'test-url'
+    ok: true,
+    data: {
+      file_reference: { id: 'test-file-ref' },
+      file_url: 'test-url'
+    }
   });
   mockGetPublicUrl.mockReturnValue('https://example.com/public-file.jpg');
   mockGetSignedUrl.mockResolvedValue({ 
     url: 'https://example.com/signed-file.jpg', 
     expiresAt: new Date(Date.now() + 3600 * 1000).toISOString() 
   });
-  // Mock batch URL generation to return URLs for all files
+  // Mock batch URL generation to return ApiResult with URLs for all files
   mockGenerateFileUrlsBatch.mockImplementation(async (supabase, files) => {
     const urlMap = new Map<string, string>();
     for (const file of files) {
@@ -58,7 +61,7 @@ beforeEach(() => {
         urlMap.set(file.id, `https://example.com/signed/${file.file_path}`);
       }
     }
-    return urlMap;
+    return { ok: true, data: urlMap };
   });
   
   // Apply mocks
@@ -137,7 +140,7 @@ describe('[hook] useFileReference', () => {
         file_url: 'test-url'
       };
       
-      mockUploadFileWithReference.mockResolvedValue(expectedResult);
+      mockUploadFileWithReference.mockResolvedValue({ ok: true, data: expectedResult });
       
       let uploadResult;
       await act(async () => {
@@ -232,8 +235,8 @@ describe('[hook] useFileReference', () => {
       
       // Second upload succeeds
       mockUploadFileWithReference.mockResolvedValueOnce({
-        file_reference: { id: 'test-file-ref' },
-        file_url: 'test-url'
+        ok: true,
+        data: { file_reference: { id: 'test-file-ref' }, file_url: 'test-url' }
       });
       
       await act(async () => {
@@ -249,7 +252,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileReference.mockResolvedValue(mockFileReference);
+      mockService.getFileReference.mockResolvedValue({ ok: true, data: mockFileReference });
       
       let fileRef;
       await act(async () => {
@@ -273,7 +276,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileReference.mockRejectedValue(new Error('Not found'));
+      mockService.getFileReference.mockResolvedValue({ ok: false, error: { code: 'NOT_FOUND', message: 'Not found' } });
       
       let fileRef;
       await act(async () => {
@@ -294,7 +297,7 @@ describe('[hook] useFileReference', () => {
       const mockService = mockCreateFileReferenceService();
       const updatedReference = { ...mockFileReference, file_metadata: { ...mockFileReference.file_metadata, fileName: 'updated.pdf' } };
       
-      mockService.updateFileReference.mockResolvedValue(updatedReference);
+      mockService.updateFileReference.mockResolvedValue({ ok: true, data: updatedReference });
       
       let updateResult;
       await act(async () => {
@@ -314,7 +317,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.deleteFileReference.mockResolvedValue(true);
+      mockService.deleteFileReference.mockResolvedValue({ ok: true, data: true });
       
       let deleteResult;
       await act(async () => {
@@ -339,7 +342,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.deleteFileReference.mockRejectedValue(new Error('Delete failed'));
+      mockService.deleteFileReference.mockResolvedValue({ ok: false, error: { code: 'DELETE_FAILED', message: 'Delete failed' } });
       
       let deleteResult;
       await act(async () => {
@@ -359,7 +362,7 @@ describe('[hook] useFileReference', () => {
       const mockService = mockCreateFileReferenceService();
       const mockFiles = [mockFileReference];
       
-      mockService.listFileReferences.mockResolvedValue(mockFiles);
+      mockService.listFileReferences.mockResolvedValue({ ok: true, data: mockFiles });
       
       let files;
       await act(async () => {
@@ -377,7 +380,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.listFileReferences.mockRejectedValue(new Error('List failed'));
+      mockService.listFileReferences.mockResolvedValue({ ok: false, error: { code: 'LIST_FAILED', message: 'List failed' } });
       
       let files;
       await act(async () => {
@@ -398,7 +401,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileUrl.mockResolvedValue('https://example.com/file.pdf');
+      mockService.getFileUrl.mockResolvedValue({ ok: true, data: 'https://example.com/file.pdf' });
       
       let fileUrl;
       await act(async () => {
@@ -416,7 +419,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getSignedUrl.mockResolvedValue('https://example.com/signed-file.pdf');
+      mockService.getSignedUrl.mockResolvedValue({ ok: true, data: 'https://example.com/signed-file.pdf' });
       
       let signedUrl;
       await act(async () => {
@@ -441,7 +444,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileUrl.mockRejectedValue(new Error('URL generation failed'));
+      mockService.getFileUrl.mockResolvedValue({ ok: false, error: { code: 'URL_FAILED', message: 'URL generation failed' } });
       
       let fileUrl;
       await act(async () => {
@@ -463,7 +466,7 @@ describe('[hook] useFileReference', () => {
       const mockService = mockCreateFileReferenceService();
       const mockFiles = [mockFileReference];
       
-      mockService.getFilesByCategory.mockResolvedValue(mockFiles);
+      mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: mockFiles });
       
       let files;
       await act(async () => {
@@ -488,7 +491,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFilesByCategory.mockRejectedValue(new Error('Category query failed'));
+      mockService.getFilesByCategory.mockResolvedValue({ ok: false, error: { code: 'LIST_FAILED', message: 'Category query failed' } });
       
       let files;
       await act(async () => {
@@ -508,7 +511,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileCount.mockResolvedValue(5);
+      mockService.getFileCount.mockResolvedValue({ ok: true, data: 5 });
       
       let count;
       await act(async () => {
@@ -526,7 +529,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileCount.mockRejectedValue(new Error('Count query failed'));
+      mockService.getFileCount.mockResolvedValue({ ok: false, error: { code: 'COUNT_FAILED', message: 'Count query failed' } });
       
       let count;
       await act(async () => {
@@ -547,7 +550,7 @@ describe('[hook] useFileReference', () => {
       const { result } = renderHook(() => useFileReference(mockSupabase));
       const mockService = mockCreateFileReferenceService();
       
-      mockService.getFileReference.mockRejectedValue(new Error('Test error'));
+      mockService.getFileReference.mockResolvedValue({ ok: false, error: { code: 'ERR', message: 'Test error' } });
       
       await act(async () => {
         await result.current.getFileReference('test_table', 'test-record-123', 'test-org-123');
@@ -567,7 +570,7 @@ describe('[hook] useFileReference', () => {
 describe('[hook] useFileReferenceById', () => {
   it('loads file reference on mount when ID is provided', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReferenceById.mockResolvedValue(mockFileReference);
+    mockService.getFileReferenceById.mockResolvedValue({ ok: true, data: mockFileReference });
     
     const { result } = renderHook(() => 
       useFileReferenceById(mockSupabase, 'file-ref-123', 'test-org-123')
@@ -603,8 +606,8 @@ describe('[hook] useFileReferenceById', () => {
 
   it('generates file URL when file reference is loaded', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReferenceById.mockResolvedValue(mockFileReference);
-    mockService.getFileUrl.mockResolvedValue('https://example.com/file.pdf');
+    mockService.getFileReferenceById.mockResolvedValue({ ok: true, data: mockFileReference });
+    mockService.getFileUrl.mockResolvedValue({ ok: true, data: 'https://example.com/file.pdf' });
     
     const { result } = renderHook(() => 
       useFileReferenceById(mockSupabase, 'file-ref-123', 'test-org-123')
@@ -621,7 +624,7 @@ describe('[hook] useFileReferenceById', () => {
 
   it('handles errors gracefully', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReferenceById.mockRejectedValue(new Error('Not found'));
+    mockService.getFileReferenceById.mockResolvedValue({ ok: false, error: { code: 'NOT_FOUND', message: 'Not found' } });
     
     const { result } = renderHook(() => 
       useFileReferenceById(mockSupabase, 'file-ref-123', 'test-org-123')
@@ -639,8 +642,8 @@ describe('[hook] useFileReferenceById', () => {
     const secondRef = { ...mockFileReference, id: 'file-ref-2' };
     
     mockService.getFileReferenceById
-      .mockResolvedValueOnce(firstRef)
-      .mockResolvedValueOnce(secondRef);
+      .mockResolvedValueOnce({ ok: true, data: firstRef })
+      .mockResolvedValueOnce({ ok: true, data: secondRef });
     
     const { result, rerender } = renderHook(
       ({ id, orgId }) => useFileReferenceById(mockSupabase, id, orgId),
@@ -664,7 +667,7 @@ describe('[hook] useFilesByCategory', () => {
 
   it('loads files by category on mount', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFilesByCategory.mockResolvedValue(mockFiles);
+    mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: mockFiles });
     
     const { result } = renderHook(() => 
       useFilesByCategory(
@@ -717,7 +720,7 @@ describe('[hook] useFilesByCategory', () => {
 
   it('generates URLs for loaded files', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFilesByCategory.mockResolvedValue(mockFiles);
+    mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: mockFiles });
     
     const { result } = renderHook(() => 
       useFilesByCategory(
@@ -740,7 +743,7 @@ describe('[hook] useFilesByCategory', () => {
     const privateFile = { ...mockFileReference, id: 'private-file', is_public: false };
     
     const mockService = mockCreateFileReferenceService();
-    mockService.getFilesByCategory.mockResolvedValue([publicFile, privateFile]);
+    mockService.getFilesByCategory.mockResolvedValue({ ok: true, data: [publicFile, privateFile] });
     
     const { result } = renderHook(() => 
       useFilesByCategory(
@@ -773,8 +776,8 @@ describe('[hook] useFilesByCategory', () => {
     const imageFiles = [{ ...mockFileReference, id: 'image-ref', file_metadata: { ...mockFileReference.file_metadata, category: FileCategory.IMAGES } }];
     
     mockService.getFilesByCategory
-      .mockResolvedValueOnce(generalFiles)
-      .mockResolvedValueOnce(imageFiles);
+      .mockResolvedValueOnce({ ok: true, data: generalFiles })
+      .mockResolvedValueOnce({ ok: true, data: imageFiles });
     
     const { result, rerender } = renderHook(
       ({ category, orgId }) => useFilesByCategory(
@@ -820,7 +823,7 @@ describe('[hook] useFileReferenceForRecord', () => {
 
   it('loads file reference successfully', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReference.mockResolvedValue(mockFileReference);
+    mockService.getFileReference.mockResolvedValue({ ok: true, data: mockFileReference });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
@@ -840,7 +843,7 @@ describe('[hook] useFileReferenceForRecord', () => {
 
   it('loads file URL successfully', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileUrl.mockResolvedValue('https://example.com/file.pdf');
+    mockService.getFileUrl.mockResolvedValue({ ok: true, data: 'https://example.com/file.pdf' });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
@@ -860,7 +863,7 @@ describe('[hook] useFileReferenceForRecord', () => {
 
   it('loads file count successfully', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileCount.mockResolvedValue(5);
+    mockService.getFileCount.mockResolvedValue({ ok: true, data: 5 });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
@@ -880,8 +883,8 @@ describe('[hook] useFileReferenceForRecord', () => {
 
   it('deletes file and updates count', async () => {
     const mockService = mockCreateFileReferenceService();
-    mockService.deleteFileReference.mockResolvedValue(true);
-    mockService.getFileCount.mockResolvedValue(0);
+    mockService.deleteFileReference.mockResolvedValue({ ok: true, data: true });
+    mockService.getFileCount.mockResolvedValue({ ok: true, data: 0 });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(
@@ -916,7 +919,7 @@ describe('[hook] useFileReferenceForRecord', () => {
     
     // Simulate an error
     const mockService = mockCreateFileReferenceService();
-    mockService.getFileReference.mockRejectedValue(new Error('Test error'));
+    mockService.getFileReference.mockResolvedValue({ ok: false, error: { code: 'ERR', message: 'Test error' } });
     
     await act(async () => {
       await result.current.loadFileReference();
@@ -933,7 +936,7 @@ describe('[hook] useFileReferenceForRecord', () => {
 
   it('does not refresh URLs for public files', async () => {
     const publicFileRef = { ...mockFileReference, is_public: true };
-    serviceMock.getFileReference.mockResolvedValue(publicFileRef);
+    serviceMock.getFileReference.mockResolvedValue({ ok: true, data: publicFileRef });
     
     const { result } = renderHook(() => 
       useFileReferenceForRecord(