@jmruthers/pace-core 0.5.184 → 0.5.186

package/src/styles/core.css

@@ -240,14 +240,14 @@
   /* Custom utility styles go here */
   
   
-  /* Hide spinner arrows on number inputs in DataTable */
-  .datatable-number-no-spinners::-webkit-inner-spin-button,
-  .datatable-number-no-spinners::-webkit-outer-spin-button {
+  /* Hide spinner arrows on all number inputs (modern UX convention) */
+  input[type="number"]::-webkit-inner-spin-button,
+  input[type="number"]::-webkit-outer-spin-button {
     -webkit-appearance: none;
     margin: 0;
   }
-  
-  .datatable-number-no-spinners {
+
+  input[type="number"] {
     -moz-appearance: textfield;
   }
 }

package/src/types/database.generated.ts

@@ -3320,13 +3320,13 @@ export type Database = {
           },
         ]
       }
-      pace_id_documents: {
+      pace_identification: {
         Row: {
           created_at: string | null
           document_number: string | null
-          document_type: string
           expiry_date: string | null
           id: string
+          identification_type_id: number | null
           issue_city: string | null
           issue_country: string | null
           issue_date: string | null
@@ -3339,9 +3339,9 @@ export type Database = {
         Insert: {
           created_at?: string | null
           document_number?: string | null
-          document_type: string
           expiry_date?: string | null
           id?: string
+          identification_type_id?: number | null
           issue_city?: string | null
           issue_country?: string | null
           issue_date?: string | null
@@ -3354,9 +3354,9 @@ export type Database = {
         Update: {
           created_at?: string | null
           document_number?: string | null
-          document_type?: string
           expiry_date?: string | null
           id?: string
+          identification_type_id?: number | null
           issue_city?: string | null
           issue_country?: string | null
           issue_date?: string | null
@@ -3368,14 +3368,21 @@ export type Database = {
         }
         Relationships: [
           {
-            foreignKeyName: "fk_pace_id_documents_organisation_id"
+            foreignKeyName: "fk_pace_identification_organisation_id"
             columns: ["organisation_id"]
             isOneToOne: false
             referencedRelation: "organisations"
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "identification_documents_member_id_fkey"
+            foreignKeyName: "fk_pace_identification_type_id"
+            columns: ["identification_type_id"]
+            isOneToOne: false
+            referencedRelation: "pace_identification_type"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "pace_identification_member_id_fkey"
             columns: ["member_id"]
             isOneToOne: false
             referencedRelation: "pace_member"
@@ -3383,6 +3390,53 @@ export type Database = {
           },
         ]
       }
+      pace_identification_type: {
+        Row: {
+          created_at: string | null
+          created_by: string | null
+          description: string | null
+          id: number
+          is_active: boolean | null
+          name: string
+          organisation_id: string
+          sort_order: number | null
+          updated_at: string | null
+          updated_by: string | null
+        }
+        Insert: {
+          created_at?: string | null
+          created_by?: string | null
+          description?: string | null
+          id?: never
+          is_active?: boolean | null
+          name: string
+          organisation_id: string
+          sort_order?: number | null
+          updated_at?: string | null
+          updated_by?: string | null
+        }
+        Update: {
+          created_at?: string | null
+          created_by?: string | null
+          description?: string | null
+          id?: never
+          is_active?: boolean | null
+          name?: string
+          organisation_id?: string
+          sort_order?: number | null
+          updated_at?: string | null
+          updated_by?: string | null
+        }
+        Relationships: [
+          {
+            foreignKeyName: "pace_identification_type_organisation_id_fkey"
+            columns: ["organisation_id"]
+            isOneToOne: false
+            referencedRelation: "organisations"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       pace_member: {
         Row: {
           address_id: string | null
@@ -3858,7 +3912,7 @@ export type Database = {
           },
         ]
       }
-      pace_qualifications: {
+      pace_qualification: {
         Row: {
           created_at: string | null
           credential_id: string | null
@@ -3900,14 +3954,14 @@ export type Database = {
         }
         Relationships: [
           {
-            foreignKeyName: "fk_pace_qualifications_organisation_id"
+            foreignKeyName: "fk_pace_qualification_organisation_id"
             columns: ["organisation_id"]
             isOneToOne: false
             referencedRelation: "organisations"
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "qualifications_member_id_fkey"
+            foreignKeyName: "pace_qualification_member_id_fkey"
             columns: ["member_id"]
             isOneToOne: false
             referencedRelation: "pace_member"

package/src/types/file-reference.ts

@@ -51,12 +51,21 @@ export enum FileCategory {
   TRAC_TRANSPORT = 'trac_transport'
 }
 
+/**
+ * Options for uploading a file with a file reference
+ * @property pageContext - The page context where the file upload occurs (e.g., 'configuration', 'forms', 'applications')
+ *                          Used for context-aware permission checks. Required to check appropriate page-level permissions.
+ * @property event_id - Optional event ID for event-scoped permission checks. Required for event-based apps.
+ */
 export interface FileUploadOptions {
   table_name: string;
   record_id: string;
   organisation_id: string;
   app_id: AppId;
   category: FileCategory;
+  folder: string; // Folder name in storage bucket (e.g., 'profile_photos', 'documents')
+  pageContext: string;
+  event_id?: string;
   is_public?: boolean;
   custom_metadata?: Record<string, unknown>;
 }

package/src/utils/__tests__/timezone.test.ts

@@ -0,0 +1,345 @@
+/**
+ * @file Timezone Utilities Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/__tests__/Timezone
+ * @since 0.1.0
+ * 
+ * Comprehensive tests for timezone utility functions covering all critical functionality,
+ * edge cases, and error handling.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  formatInTimeZone,
+  getTimezoneAbbreviation,
+  formatTimeInTimeZone,
+  getUserTimeZone,
+  toZonedTime,
+  fromZonedTime,
+  roundToNearestMinutes,
+  getTimeZoneDifference
+} from '../timezone';
+
+describe('Timezone Utilities', () => {
+  describe('formatInTimeZone', () => {
+    it('should format date in specific timezone', () => {
+      const utcDate = new Date('2024-01-15T10:00:00Z');
+      const result = formatInTimeZone(utcDate, 'America/New_York', 'MMM dd, yyyy HH:mm');
+      
+      // EST is UTC-5, so 10:00 UTC = 05:00 EST
+      expect(result).toContain('Jan 15, 2024');
+      expect(result).toContain('05:00');
+    });
+
+    it('should handle ISO string input', () => {
+      const result = formatInTimeZone('2024-01-15T10:00:00Z', 'America/New_York', 'MMM dd, yyyy');
+      expect(result).toContain('Jan 15, 2024');
+    });
+
+    it('should handle timestamp input', () => {
+      const timestamp = new Date('2024-01-15T10:00:00Z').getTime();
+      const result = formatInTimeZone(timestamp, 'America/New_York', 'MMM dd, yyyy');
+      expect(result).toContain('Jan 15, 2024');
+    });
+
+    it('should handle different format strings', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const result = formatInTimeZone(date, 'America/New_York', 'yyyy-MM-dd');
+      expect(result).toBe('2024-01-15');
+    });
+
+    it('should return "Invalid date" for invalid date input', () => {
+      const result = formatInTimeZone(new Date('invalid'), 'America/New_York', 'MMM dd, yyyy');
+      expect(result).toBe('Invalid date');
+    });
+
+    it('should return "Invalid date" for invalid timezone', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const result = formatInTimeZone(date, '', 'MMM dd, yyyy');
+      expect(result).toBe('Invalid date');
+    });
+
+    it('should handle DST transitions', () => {
+      // Summer date (DST)
+      const summerDate = new Date('2024-07-15T10:00:00Z');
+      const summerResult = formatInTimeZone(summerDate, 'America/New_York', 'HH:mm');
+      
+      // Winter date (no DST)
+      const winterDate = new Date('2024-01-15T10:00:00Z');
+      const winterResult = formatInTimeZone(winterDate, 'America/New_York', 'HH:mm');
+      
+      // Summer should be UTC-4 (EDT), winter should be UTC-5 (EST)
+      expect(summerResult).not.toBe(winterResult);
+    });
+  });
+
+  describe('getTimezoneAbbreviation', () => {
+    it('should get timezone abbreviation', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const result = getTimezoneAbbreviation(date, 'America/New_York');
+      
+      // Should return EST or EDT depending on DST
+      expect(result).toMatch(/EST|EDT|America\/New_York/);
+    });
+
+    it('should handle different timezones', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const pst = getTimezoneAbbreviation(date, 'America/Los_Angeles');
+      const est = getTimezoneAbbreviation(date, 'America/New_York');
+      
+      expect(pst).toBeTruthy();
+      expect(est).toBeTruthy();
+    });
+
+    it('should return timezone name on error', () => {
+      const date = new Date('invalid');
+      const result = getTimezoneAbbreviation(date, 'America/New_York');
+      expect(result).toBeTruthy();
+    });
+
+    it('should handle invalid timezone gracefully', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const result = getTimezoneAbbreviation(date, '');
+      // Empty string returns 'UTC' as fallback per implementation
+      expect(result).toBe('UTC');
+    });
+  });
+
+  describe('formatTimeInTimeZone', () => {
+    it('should format time only in timezone', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const result = formatTimeInTimeZone(date, 'America/New_York');
+      
+      // Should be in HH:mm format
+      expect(result).toMatch(/^\d{2}:\d{2}$/);
+    });
+
+    it('should handle string date input', () => {
+      const result = formatTimeInTimeZone('2024-01-15T10:00:00Z', 'America/New_York');
+      expect(result).toMatch(/^\d{2}:\d{2}$/);
+    });
+  });
+
+  describe('getUserTimeZone', () => {
+    it('should return user timezone', () => {
+      const result = getUserTimeZone();
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('should return UTC as fallback', () => {
+      // Mock Intl to be undefined
+      const originalIntl = global.Intl;
+      // @ts-expect-error - Testing error case
+      global.Intl = undefined;
+      
+      const result = getUserTimeZone();
+      expect(result).toBe('UTC');
+      
+      global.Intl = originalIntl;
+    });
+
+    it('should handle Intl.DateTimeFormat errors gracefully', () => {
+      const originalIntl = global.Intl;
+      // @ts-expect-error - Testing error case
+      global.Intl = {
+        DateTimeFormat: () => {
+          throw new Error('Test error');
+        }
+      };
+      
+      const result = getUserTimeZone();
+      expect(result).toBe('UTC');
+      
+      global.Intl = originalIntl;
+    });
+  });
+
+  describe('toZonedTime', () => {
+    it('should convert UTC to timezone local time', () => {
+      const utcDate = new Date('2024-01-15T10:00:00Z');
+      const result = toZonedTime(utcDate, 'America/New_York');
+      
+      expect(result).toBeInstanceOf(Date);
+      expect(isNaN(result.getTime())).toBe(false);
+    });
+
+    it('should handle invalid date input', () => {
+      const result = toZonedTime(new Date('invalid'), 'America/New_York');
+      expect(isNaN(result.getTime())).toBe(true);
+    });
+
+    it('should handle invalid timezone', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const result = toZonedTime(date, '');
+      // Empty timezone returns original date per implementation
+      expect(result).toBe(date);
+      expect(result.getTime()).toBe(date.getTime());
+    });
+
+    it('should handle DST correctly', () => {
+      const summerDate = new Date('2024-07-15T10:00:00Z');
+      const winterDate = new Date('2024-01-15T10:00:00Z');
+      
+      const summerResult = toZonedTime(summerDate, 'America/New_York');
+      const winterResult = toZonedTime(winterDate, 'America/New_York');
+      
+      // Results should be different due to DST
+      expect(summerResult.getHours()).not.toBe(winterResult.getHours());
+    });
+  });
+
+  describe('fromZonedTime', () => {
+    it('should convert local time to UTC', () => {
+      const localDate = new Date(2024, 0, 15, 10, 0); // Jan 15, 2024 10:00 AM (local)
+      const result = fromZonedTime(localDate, 'America/New_York');
+      
+      expect(result).toBeInstanceOf(Date);
+      expect(isNaN(result.getTime())).toBe(false);
+    });
+
+    it('should handle invalid date input', () => {
+      const result = fromZonedTime(new Date('invalid'), 'America/New_York');
+      expect(isNaN(result.getTime())).toBe(true);
+    });
+
+    it('should handle invalid timezone', () => {
+      const date = new Date(2024, 0, 15, 10, 0);
+      const result = fromZonedTime(date, '');
+      // Empty timezone returns original date per implementation
+      expect(result).toBe(date);
+      expect(result.getTime()).toBe(date.getTime());
+    });
+
+    it('should correctly convert to UTC', () => {
+      // 10:00 AM EST (UTC-5) should be 15:00 UTC
+      // Using a specific date in January (no DST) for predictable results
+      const localDate = new Date(2024, 0, 15, 10, 0, 0, 0);
+      const utcResult = fromZonedTime(localDate, 'America/New_York');
+      
+      // Check that it's approximately 5 hours ahead (EST is UTC-5)
+      // The actual difference depends on how fromZonedTime interprets the local date
+      // We just verify it's a valid date and the conversion happened
+      expect(isNaN(utcResult.getTime())).toBe(false);
+      expect(utcResult).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('roundToNearestMinutes', () => {
+    it('should round to nearest 5 minutes by default', () => {
+      const date = new Date('2024-01-15T10:23:00Z');
+      const result = roundToNearestMinutes(date);
+      
+      expect(result).toBeInstanceOf(Date);
+      const minutes = result.getMinutes();
+      expect([0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55]).toContain(minutes);
+    });
+
+    it('should round to specified minutes step', () => {
+      const date = new Date('2024-01-15T10:23:00Z');
+      const result = roundToNearestMinutes(date, 15);
+      
+      const minutes = result.getMinutes();
+      expect([0, 15, 30, 45]).toContain(minutes);
+    });
+
+    it('should handle invalid date input', () => {
+      const result = roundToNearestMinutes(new Date('invalid'));
+      expect(isNaN(result.getTime())).toBe(true);
+    });
+
+    it('should return original date for invalid minutesStep', () => {
+      const date = new Date('2024-01-15T10:23:00Z');
+      const result = roundToNearestMinutes(date, -5);
+      expect(result.getTime()).toBe(date.getTime());
+    });
+
+    it('should return original date for non-integer minutesStep', () => {
+      const date = new Date('2024-01-15T10:23:00Z');
+      const result = roundToNearestMinutes(date, 5.5);
+      expect(result.getTime()).toBe(date.getTime());
+    });
+
+    it('should round up correctly', () => {
+      const date = new Date('2024-01-15T10:23:00Z');
+      const result = roundToNearestMinutes(date, 5);
+      // Should round to 25 (closer to 25 than 20)
+      expect(result.getMinutes()).toBe(25);
+    });
+  });
+
+  describe('getTimeZoneDifference', () => {
+    it('should calculate timezone difference in hours', () => {
+      const result = getTimeZoneDifference('America/New_York', 'America/Los_Angeles');
+      // EST is 3 hours ahead of PST
+      expect(result).toBe(-3);
+    });
+
+    it('should handle UTC timezone', () => {
+      const result = getTimeZoneDifference('UTC', 'America/New_York');
+      // UTC to EST is -5 hours (or -4 during DST)
+      expect([-5, -4]).toContain(result);
+    });
+
+    it('should return 0 for same timezone', () => {
+      const result = getTimeZoneDifference('America/New_York', 'America/New_York');
+      expect(result).toBe(0);
+    });
+
+    it('should handle invalid timezones gracefully', () => {
+      const result = getTimeZoneDifference('', 'America/New_York');
+      expect(result).toBe(0);
+    });
+
+    it('should handle reversed timezones', () => {
+      const forward = getTimeZoneDifference('America/New_York', 'America/Los_Angeles');
+      const backward = getTimeZoneDifference('America/Los_Angeles', 'America/New_York');
+      
+      expect(forward).toBe(-backward);
+    });
+
+    it('should account for DST in calculations', () => {
+      // Test with a summer date (DST active)
+      const summerDiff = getTimeZoneDifference('UTC', 'America/New_York');
+      // Should be -4 (EDT) or -5 (EST) depending on current date
+      expect([-4, -5]).toContain(summerDiff);
+    });
+  });
+
+  describe('Edge cases and error handling', () => {
+    it('should handle null and undefined gracefully', () => {
+      // @ts-expect-error - Testing error case
+      expect(formatInTimeZone(null, 'America/New_York', 'MMM dd, yyyy')).toBe('Invalid date');
+      // @ts-expect-error - Testing error case
+      expect(formatInTimeZone(undefined, 'America/New_York', 'MMM dd, yyyy')).toBe('Invalid date');
+    });
+
+    it('should handle various timezone formats', () => {
+      const date = new Date('2024-01-15T10:00:00Z');
+      const timezones = [
+        'America/New_York',
+        'Europe/London',
+        'Asia/Tokyo',
+        'Australia/Sydney',
+        'UTC'
+      ];
+      
+      timezones.forEach(tz => {
+        const result = formatInTimeZone(date, tz, 'MMM dd, yyyy');
+        expect(result).not.toBe('Invalid date');
+      });
+    });
+
+    it('should handle extreme dates', () => {
+      const farFuture = new Date('2099-12-31T23:59:59Z');
+      // Use a date that won't have timezone boundary issues
+      const farPast = new Date('1900-01-01T12:00:00Z');
+      
+      expect(formatInTimeZone(farFuture, 'America/New_York', 'yyyy')).toContain('2099');
+      // The year might be 1899 or 1900 depending on timezone conversion, so just check it's valid
+      const pastResult = formatInTimeZone(farPast, 'America/New_York', 'yyyy');
+      expect(pastResult).not.toBe('Invalid date');
+      expect(pastResult.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/utils/file-reference/__tests__/file-reference.test.ts

@@ -50,6 +50,8 @@ const mockFileUploadOptions = {
   organisation_id: 'test-org-123',
   app_id: 'test-app-123',
   category: FileCategory.GENERAL_DOCUMENTS,
+  folder: 'documents',
+  pageContext: 'configuration',
   is_public: false
 };
 
@@ -104,7 +106,7 @@ describe('[service] FileReferenceServiceImpl', () => {
         testFile,
         expect.objectContaining({
           orgId: mockFileUploadOptions.organisation_id,
-          customPath: mockFileUploadOptions.category,
+          customPath: mockFileUploadOptions.folder,
           isPublic: mockFileUploadOptions.is_public
         })
       );
@@ -116,6 +118,7 @@ describe('[service] FileReferenceServiceImpl', () => {
           p_record_id: mockFileUploadOptions.record_id,
           p_organisation_id: mockFileUploadOptions.organisation_id,
           p_app_id: mockFileUploadOptions.app_id,
+          p_page_context: mockFileUploadOptions.pageContext,
           p_file_metadata: expect.objectContaining({
             fileName: testFile.name,
             fileType: testFile.type,
@@ -755,22 +758,75 @@ describe('[utility] createFileReferenceService', () => {
 describe('[utility] uploadFileWithReference', () => {
   it('uploads file and creates reference successfully', async () => {
     const testFile = createTestFile();
+    
+    // Mock successful RPC call that returns file reference ID
+    mockSupabase.rpc.mockResolvedValue({
+      data: 'file-ref-123',
+      error: null
+    });
+
+    // Mock successful file reference fetch - using the same pattern as other tests
+    (mockSupabase.from() as any).select().eq().eq().eq().single.mockResolvedValue({
+      data: mockFileReference,
+      error: null
+    });
+
+    // Mock storage signed URL generation
+    mockSupabase.storage = {
+      from: vi.fn().mockReturnValue({
+        createSignedUrl: vi.fn().mockResolvedValue({
+          data: { signedUrl: 'https://example.com/signed-url' },
+          error: null
+        })
+      })
+    } as any;
+
     const result = await uploadFileWithReference(mockSupabase, mockFileUploadOptions, testFile);
     expect(result).toHaveProperty('file_reference');
     expect('file_url' in result).toBe(true);
   });
 
   it('handles upload failures gracefully', async () => {
-    // This path is covered by service tests; here just ensure function returns structured result on success path
+    // Mock upload failure
+    mockUploadFile.mockResolvedValue({
+      success: false,
+      error: 'Upload failed'
+    });
+
     const testFile = createTestFile();
-    const result = await uploadFileWithReference(mockSupabase, mockFileUploadOptions, testFile);
-    expect(result).toHaveProperty('file_reference');
+    await expect(uploadFileWithReference(mockSupabase, mockFileUploadOptions, testFile))
+      .rejects.toThrow('Upload failed');
   });
 
   it('handles URL generation failures gracefully', async () => {
     const testFile = createTestFile();
+    
+    // Mock successful RPC call
+    mockSupabase.rpc.mockResolvedValue({
+      data: 'file-ref-123',
+      error: null
+    });
+
+    // Mock successful file reference fetch
+    (mockSupabase.from() as any).select().eq().eq().eq().single.mockResolvedValue({
+      data: mockFileReference,
+      error: null
+    });
+    
+    // Mock storage to fail on signed URL generation
+    mockSupabase.storage = {
+      from: vi.fn().mockReturnValue({
+        createSignedUrl: vi.fn().mockResolvedValue({
+          data: null,
+          error: { message: 'URL generation failed' }
+        })
+      })
+    } as any;
+
     const result = await uploadFileWithReference(mockSupabase, mockFileUploadOptions, testFile);
     expect(result).toHaveProperty('file_reference');
+    // URL should be empty string when generation fails
+    expect(result.file_url).toBe('');
   });
 
   it('validates required parameters', async () => {

package/src/utils/file-reference/index.ts

@@ -50,13 +50,13 @@ export class FileReferenceServiceImpl implements FileReferenceService {
       }
 
       // Step 1: Upload file to storage bucket first
-      // This generates a unique path: {orgId}/{category}/{timestamp-uuid-filename}
+      // This generates a unique path: {orgId}/{folder}/{timestamp-uuid-filename}
       // Bucket is automatically selected based on is_public flag
       const uploadResult = await uploadFile(this.supabase, file, {
         appName: 'file-reference',
         orgId: options.organisation_id,
         isPublic: options.is_public || false,
-        customPath: options.category // Use category as the custom path segment
+        customPath: options.folder // Use folder prop as the custom path segment
       });
       if (!uploadResult.success) {
         throw new Error(`Failed to upload file: ${uploadResult.error}`);
@@ -88,6 +88,8 @@ export class FileReferenceServiceImpl implements FileReferenceService {
           p_file_path: filePath, // Storage path from step 1
           p_organisation_id: options.organisation_id,
           p_app_id: options.app_id,
+          p_page_context: options.pageContext,
+          p_event_id: options.event_id || null, // Pass event_id for event-based apps
           p_file_metadata: {
             fileName: file.name,
             fileType: file.type,
@@ -105,6 +107,13 @@ export class FileReferenceServiceImpl implements FileReferenceService {
         throw new Error(`Failed to create file reference: ${error.message}`);
       }
 
+      // Check if RPC returned null (permission denied or other failure)
+      if (!data || data === null) {
+        // Clean up the uploaded file since DB insert failed
+        await deleteFile(this.supabase, filePath, options.is_public || false);
+        throw new Error(`File upload denied: insufficient permissions. You need 'create:page.${options.pageContext}' or 'update:page.${options.pageContext}' permission for the '${options.pageContext}' page. Make sure the page exists in rbac_app_pages table.`);
+      }
+
       // Get the created file reference
       const { data: fileRef, error: fetchError } = await this.supabase
         .from('file_references')
@@ -113,6 +122,8 @@ export class FileReferenceServiceImpl implements FileReferenceService {
         .single();
 
       if (fetchError || !fileRef) {
+        // Clean up uploaded file if we can't fetch the reference
+        await deleteFile(this.supabase, filePath, options.is_public || false);
         throw new Error(`Failed to fetch created file reference: ${fetchError?.message}`);
       }