@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/utils/storage/helpers.test.ts

@@ -1,7 +1,7 @@
 /**
  * @file Unit Tests for Storage Helpers
  * @package @jmruthers/pace-core
- * @module Utils/Storage/__tests__
+ * @module Utils/Storage
  * @since 1.0.0
  */
 
@@ -224,14 +224,15 @@ describe('[unit] Storage Helpers', () => {
       const options = { appName: 'test-app', orgId: 'org-123' };
       
       const result = await extractFileMetadata(file, options, 'user-123');
-      
-      expect(result.mimeType).toBe('application/pdf');
-      expect(result.size).toBe(file.size); // Use actual file size
-      expect(result.orgId).toBe('org-123');
-      expect(result.appName).toBe('test-app');
-      expect(result.uploadedBy).toBe('user-123');
-      expect(result.uploadedAt).toBeDefined();
-      expect(result.isPublic).toBe(false);
+      expect(result.ok).toBe(true);
+      const data = result.data;
+      expect(data.mimeType).toBe('application/pdf');
+      expect(data.size).toBe(file.size); // Use actual file size
+      expect(data.orgId).toBe('org-123');
+      expect(data.appName).toBe('test-app');
+      expect(data.uploadedBy).toBe('user-123');
+      expect(data.uploadedAt).toBeDefined();
+      expect(data.isPublic).toBe(false);
     }, TEST_TIMEOUT);
 
     it('extracts image dimensions for image files', async () => {
@@ -264,12 +265,13 @@ describe('[unit] Storage Helpers', () => {
 
       const options = { appName: 'test-app', orgId: 'org-123' };
       const result = await extractFileMetadata(file, options, 'user-123');
-      
-      expect(result.mimeType).toBe('image/jpeg');
+      expect(result.ok).toBe(true);
+      const data = result.data;
+      expect(data.mimeType).toBe('image/jpeg');
       // Dimensions may or may not be extracted depending on async timing
-      if (result.width) {
-        expect(result.width).toBe(800);
-        expect(result.height).toBe(600);
+      if (data.width) {
+        expect(data.width).toBe(800);
+        expect(data.height).toBe(600);
       }
     }, TEST_TIMEOUT);
 
@@ -282,9 +284,9 @@ describe('[unit] Storage Helpers', () => {
       (crypto.subtle as any).digest = vi.fn().mockRejectedValue(new Error('Hash generation failed'));
       
       const result = await extractFileMetadata(file, options, 'user-123');
-      
+      expect(result.ok).toBe(true);
       // Hash should be undefined when generation fails
-      expect(result.hash).toBeUndefined();
+      expect(result.data.hash).toBeUndefined();
       
       // Restore original function
       (crypto.subtle as any).digest = originalDigest;
@@ -299,8 +301,8 @@ describe('[unit] Storage Helpers', () => {
       };
       
       const result = await extractFileMetadata(file, options, 'user-123');
-      
-      expect(result.customMetadata).toEqual({ customField: 'customValue' });
+      expect(result.ok).toBe(true);
+      expect(result.data.customMetadata).toEqual({ customField: 'customValue' });
     }, TEST_TIMEOUT);
 
     it('handles user-scoped files with userId', async () => {
@@ -311,9 +313,9 @@ describe('[unit] Storage Helpers', () => {
       };
       
       const result = await extractFileMetadata(file, options, 'user-123');
-      
-      expect(result.userId).toBe('user-123');
-      expect(result.orgId).toBeUndefined();
+      expect(result.ok).toBe(true);
+      expect(result.data.userId).toBe('user-123');
+      expect(result.data.orgId).toBeUndefined();
     }, TEST_TIMEOUT);
 
     it('handles public files', async () => {
@@ -325,8 +327,8 @@ describe('[unit] Storage Helpers', () => {
       };
       
       const result = await extractFileMetadata(file, options, 'user-123');
-      
-      expect(result.isPublic).toBe(true);
+      expect(result.ok).toBe(true);
+      expect(result.data.isPublic).toBe(true);
     }, TEST_TIMEOUT);
 
     it('handles tags when provided', async () => {
@@ -338,8 +340,8 @@ describe('[unit] Storage Helpers', () => {
       };
       
       const result = await extractFileMetadata(file, options, 'user-123');
-      
-      expect(result.tags).toEqual(['tag1', 'tag2']);
+      expect(result.ok).toBe(true);
+      expect(result.data.tags).toEqual(['tag1', 'tag2']);
     }, TEST_TIMEOUT);
 
     it('handles image dimension extraction errors gracefully', async () => {
@@ -372,11 +374,11 @@ describe('[unit] Storage Helpers', () => {
 
       const options = { appName: 'test-app', orgId: 'org-123' };
       const result = await extractFileMetadata(file, options, 'user-123');
-      
+      expect(result.ok).toBe(true);
       // Should still return metadata even if image dimensions fail
-      expect(result.mimeType).toBe('image/jpeg');
-      expect(result.width).toBeUndefined();
-      expect(result.height).toBeUndefined();
+      expect(result.data.mimeType).toBe('image/jpeg');
+      expect(result.data.width).toBeUndefined();
+      expect(result.data.height).toBeUndefined();
     }, TEST_TIMEOUT);
 
     it('handles different image types', async () => {
@@ -386,8 +388,8 @@ describe('[unit] Storage Helpers', () => {
         const file = createTestFile('test.jpg', type, 1024);
         const options = { appName: 'test-app', orgId: 'org-123' };
         const result = await extractFileMetadata(file, options, 'user-123');
-        
-        expect(result.mimeType).toBe(type);
+        expect(result.ok).toBe(true);
+        expect(result.data.mimeType).toBe(type);
       }
     }, TEST_TIMEOUT);
   });
@@ -412,10 +414,9 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await uploadFile(mockClient as SupabaseClient<Database>, testFile, options);
-      
       expect(mockClient.storage.from).toHaveBeenCalledWith('files');
-      expect(result.success).toBe(true);
-      expect(result.path).toMatch(/^test-org-123\//);
+      expect(result.ok).toBe(true);
+      expect(result.data.path).toMatch(/^test-org-123\//);
     }, TEST_TIMEOUT);
 
     it('uploads to public bucket when isPublic is true', async () => {
@@ -460,8 +461,8 @@ describe('[unit] Storage Helpers', () => {
       
       const result = await uploadFile(mockClient as SupabaseClient<Database>, testFile, options);
       
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Upload failed: Upload failed');
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('Upload failed');
     }, TEST_TIMEOUT);
 
     it('validates file size before upload', async () => {
@@ -475,10 +476,7 @@ describe('[unit] Storage Helpers', () => {
       };
       
       const result = await uploadFile(mockClient as SupabaseClient<Database>, largeFile, options);
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-      // Error should indicate size validation failed - check for size-related error
+      expect(result.ok).toBe(false);
       expect(result.error).toBeDefined();
       // The error comes from validateFileSize which returns error message about size
     }, TEST_TIMEOUT);
@@ -528,11 +526,10 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await uploadFile(mockClient as SupabaseClient<Database>, testFile, options);
-      
-      expect(result.success).toBe(true);
-      expect(result.metadata?.mimeType).toBe('image/jpeg');
-      expect(result.metadata?.size).toBe(testFile.size);
-      expect(result.metadata?.orgId).toBe('test-org-123');
+      expect(result.ok).toBe(true);
+      expect(result.data.metadata?.mimeType).toBe('image/jpeg');
+      expect(result.data.metadata?.size).toBe(testFile.size);
+      expect(result.data.metadata?.orgId).toBe('test-org-123');
     }, TEST_TIMEOUT);
 
     it('uses custom path when provided', async () => {
@@ -555,9 +552,8 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await uploadFile(mockClient as SupabaseClient<Database>, testFile, options);
-      
-      expect(result.success).toBe(true);
-      expect(result.path).toContain('custom/path');
+      expect(result.ok).toBe(true);
+      expect(result.data.path).toContain('custom/path');
     }, TEST_TIMEOUT);
   });
 
@@ -572,10 +568,9 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await deleteFile(mockClient as SupabaseClient<Database>, filePath, false);
-      
       expect(mockClient.storage.from).toHaveBeenCalledWith('files');
       expect(mockClient.storage.from().remove).toHaveBeenCalledWith([filePath]);
-      expect(result.success).toBe(true);
+      expect(result.ok).toBe(true);
     }, TEST_TIMEOUT);
 
     it('deletes from public bucket when isPublic is true', async () => {
@@ -602,9 +597,8 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await deleteFile(mockClient as SupabaseClient<Database>, filePath, false);
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Delete failed: File not found');
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('File not found');
     }, TEST_TIMEOUT);
   });
 
@@ -625,11 +619,11 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await downloadFile(mockClient as SupabaseClient<Database>, filePath, false);
-      
       expect(mockClient.storage.from).toHaveBeenCalledWith('files');
       expect(mockClient.storage.from().download).toHaveBeenCalledWith(filePath);
-      expect(result?.blob).toBe(mockBlob);
-      expect(result?.metadata.name).toBe('test.pdf');
+      expect(result.ok).toBe(true);
+      expect(result.data.blob).toBe(mockBlob);
+      expect(result.data.metadata.name).toBe('test.pdf');
     }, TEST_TIMEOUT);
 
     it('downloads from public bucket when isPublic is true', async () => {
@@ -657,8 +651,8 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await downloadFile(mockClient as SupabaseClient<Database>, filePath, false);
-      
-      expect(result).toBe(null);
+      expect(result.ok).toBe(false);
+      expect(result.error).toBeDefined();
     }, TEST_TIMEOUT);
   });
 
@@ -802,10 +796,10 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await getSignedUrl(mockClient as SupabaseClient<Database>, filePath, options);
-      
       expect(mockClient.storage.from).toHaveBeenCalledWith('files');
       expect(mockClient.storage.from().createSignedUrl).toHaveBeenCalledWith(filePath, 3600);
-      expect(result?.url).toBe('https://example.com/signed/test.pdf?token=abc123');
+      expect(result.ok).toBe(true);
+      expect(result.data.url).toBe('https://example.com/signed/test.pdf?token=abc123');
     }, TEST_TIMEOUT);
 
     it('generates signed URL with custom expiration', async () => {
@@ -841,8 +835,8 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await getSignedUrl(mockClient as SupabaseClient<Database>, filePath, options);
-      
-      expect(result).toBe(null);
+      expect(result.ok).toBe(false);
+      expect(result.error).toBeDefined();
     }, TEST_TIMEOUT);
 
     it('includes expiration metadata in result', async () => {
@@ -860,10 +854,10 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await getSignedUrl(mockClient as SupabaseClient<Database>, filePath, options);
-      
-      expect(result?.url).toContain('signed');
-      expect(typeof result?.expiresAt).toBe('string');
-      expect(new Date(result!.expiresAt).getTime()).toBeGreaterThan(Date.now());
+      expect(result.ok).toBe(true);
+      expect(result.data.url).toContain('signed');
+      expect(typeof result.data.expiresAt).toBe('string');
+      expect(new Date(result.data.expiresAt).getTime()).toBeGreaterThan(Date.now());
     }, TEST_TIMEOUT);
   });
 
@@ -889,10 +883,10 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await listFiles(mockClient as SupabaseClient<Database>, options);
-      
-      expect(result.files).toHaveLength(1);
-      expect(result.files[0].name).toBe('file1.jpg');
-      expect(result.totalCount).toBe(1);
+      expect(result.ok).toBe(true);
+      expect(result.data.files).toHaveLength(1);
+      expect(result.data.files[0].name).toBe('file1.jpg');
+      expect(result.data.totalCount).toBe(1);
     }, TEST_TIMEOUT);
 
     it('lists files with userId', async () => {
@@ -909,8 +903,8 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await listFiles(mockClient as SupabaseClient<Database>, options);
-      
-      expect(result.files).toEqual([]);
+      expect(result.ok).toBe(true);
+      expect(result.data.files).toEqual([]);
       expect(mockClient.storage.from().list).toHaveBeenCalledWith(
         'users/user-123/',
         expect.any(Object)
@@ -924,13 +918,10 @@ describe('[unit] Storage Helpers', () => {
         isPublic: false
       };
       
-      // listFiles throws an error when neither orgId nor userId is provided
-      // The error is caught and returns empty result
+      // listFiles returns err when neither orgId nor userId is provided
       const result = await listFiles(mockClient as SupabaseClient<Database>, options as any);
-      
-      expect(result.files).toEqual([]);
-      expect(result.totalCount).toBe(0);
-      expect(result.hasMore).toBe(false);
+      expect(result.ok).toBe(false);
+      expect(result.error.code).toBe('LIST_FILES_INVALID_OPTIONS');
     }, TEST_TIMEOUT);
 
     it('handles list errors gracefully', async () => {
@@ -947,9 +938,8 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await listFiles(mockClient as SupabaseClient<Database>, options);
-      
-      expect(result.files).toEqual([]);
-      expect(result.totalCount).toBe(0);
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('List failed');
     }, TEST_TIMEOUT);
   });
 
@@ -967,8 +957,7 @@ describe('[unit] Storage Helpers', () => {
       (mockClient.storage.from().remove as any).mockResolvedValue({ error: null });
       
       const result = await archiveFile(mockClient as SupabaseClient<Database>, filePath, options);
-      
-      expect(result.success).toBe(true);
+      expect(result.ok).toBe(true);
       expect(mockClient.storage.from().copy).toHaveBeenCalledWith(
         filePath,
         'archived/org-123/documents/test.pdf'
@@ -988,8 +977,7 @@ describe('[unit] Storage Helpers', () => {
       (mockClient.storage.from().remove as any).mockResolvedValue({ error: null });
       
       const result = await archiveFile(mockClient as SupabaseClient<Database>, filePath, options);
-      
-      expect(result.success).toBe(true);
+      expect(result.ok).toBe(true);
       expect(mockClient.storage.from().copy).toHaveBeenCalledWith(
         filePath,
         'archived/users/user-123/documents/test.pdf'
@@ -1005,9 +993,8 @@ describe('[unit] Storage Helpers', () => {
       };
       
       const result = await archiveFile(mockClient as SupabaseClient<Database>, filePath, options as any);
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Either orgId or userId is required');
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toContain('Either orgId or userId is required');
     }, TEST_TIMEOUT);
 
     it('handles archive errors gracefully', async () => {
@@ -1024,9 +1011,8 @@ describe('[unit] Storage Helpers', () => {
       });
       
       const result = await archiveFile(mockClient as SupabaseClient<Database>, filePath, options);
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Copy failed');
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toContain('Copy failed');
     }, TEST_TIMEOUT);
   });
 
@@ -1052,10 +1038,10 @@ describe('[unit] Storage Helpers', () => {
         fileReferences,
         options
       );
-      
-      expect(result.size).toBe(2);
-      expect(result.get('file-1')).toBeDefined();
-      expect(result.get('file-2')).toBeDefined();
+      expect(result.ok).toBe(true);
+      expect(result.data.size).toBe(2);
+      expect(result.data.get('file-1')).toBeDefined();
+      expect(result.data.get('file-2')).toBeDefined();
     }, TEST_TIMEOUT);
 
     it('generates signed URLs for private files', async () => {
@@ -1080,9 +1066,9 @@ describe('[unit] Storage Helpers', () => {
         fileReferences,
         options
       );
-      
-      expect(result.size).toBe(2);
-      expect(result.get('file-1')).toContain('signed');
+      expect(result.ok).toBe(true);
+      expect(result.data.size).toBe(2);
+      expect(result.data.get('file-1')).toContain('signed');
     }, TEST_TIMEOUT);
 
     it('handles mixed public and private files', async () => {
@@ -1110,8 +1096,8 @@ describe('[unit] Storage Helpers', () => {
         fileReferences,
         options
       );
-      
-      expect(result.size).toBe(2);
+      expect(result.ok).toBe(true);
+      expect(result.data.size).toBe(2);
     }, TEST_TIMEOUT);
 
     it('returns empty map for empty file references', async () => {
@@ -1121,8 +1107,8 @@ describe('[unit] Storage Helpers', () => {
         [],
         { appName: 'test-app', orgId: 'org-123' }
       );
-      
-      expect(result.size).toBe(0);
+      expect(result.ok).toBe(true);
+      expect(result.data.size).toBe(0);
     }, TEST_TIMEOUT);
   });
 });