@jmruthers/pace-core 0.5.54 → 0.5.55

package/src/utils/file-reference.ts

@@ -0,0 +1,263 @@
+// File Reference Service
+// Provides CRUD operations for the centralized file reference system
+
+import { SupabaseClient } from '@supabase/supabase-js';
+import { 
+  FileReference, 
+  FileUploadOptions, 
+  FileReferenceService, 
+  FileUploadResult,
+  FileCategory 
+} from '../types/file-reference';
+import { generateFilePath, uploadFile, getPublicUrl, getSignedUrl, deleteFile, extractFileMetadata } from './storage/helpers';
+
+export class FileReferenceServiceImpl implements FileReferenceService {
+  constructor(private supabase: SupabaseClient) {}
+
+  async createFileReference(options: FileUploadOptions, file: File): Promise<FileReference> {
+    try {
+      // Generate file path
+      const filePath = generateFilePath({
+        appName: 'file-reference',
+        orgId: options.organisation_id,
+        isPublic: options.is_public || false
+      }, file.name);
+
+      // Upload file to storage
+      const uploadResult = await uploadFile(this.supabase, file, {
+        appName: 'file-reference',
+        orgId: options.organisation_id,
+        isPublic: options.is_public || false,
+        customPath: filePath
+      });
+      if (!uploadResult.success) {
+        throw new Error(`Failed to upload file: ${uploadResult.error}`);
+      }
+
+      // Extract file metadata
+      const metadata = await extractFileMetadata(file, {
+        appName: 'file-reference',
+        orgId: options.organisation_id,
+        isPublic: options.is_public || false
+      }, 'system');
+
+      // Create file reference in database
+      const { data, error } = await this.supabase
+        .rpc('insert_file_reference', {
+          p_table_name: options.table_name,
+          p_record_id: options.record_id,
+          p_file_path: filePath,
+          p_organisation_id: options.organisation_id,
+          p_app_id: options.app_id,
+          p_file_metadata: {
+            fileName: file.name,
+            fileType: file.type,
+            fileSize: file.size,
+            category: options.category,
+            ...metadata,
+            ...options.custom_metadata
+          },
+          p_is_public: options.is_public || false
+        });
+
+      if (error) {
+        // Clean up uploaded file if database insert fails
+        await deleteFile(this.supabase, filePath);
+        throw new Error(`Failed to create file reference: ${error.message}`);
+      }
+
+      // Get the created file reference
+      const { data: fileRef, error: fetchError } = await this.supabase
+        .from('file_references')
+        .select('*')
+        .eq('id', data)
+        .single();
+
+      if (fetchError || !fileRef) {
+        throw new Error(`Failed to fetch created file reference: ${fetchError?.message}`);
+      }
+
+      return fileRef as FileReference;
+    } catch (error) {
+      console.error('Error creating file reference:', error);
+      throw error;
+    }
+  }
+
+  async getFileReference(table_name: string, record_id: string, organisation_id: string): Promise<FileReference | null> {
+    try {
+      const { data, error } = await this.supabase
+        .from('file_references')
+        .select('*')
+        .eq('table_name', table_name)
+        .eq('record_id', record_id)
+        .eq('organisation_id', organisation_id)
+        .single();
+
+      if (error) {
+        if (error.code === 'PGRST116') {
+          return null; // No rows found
+        }
+        throw new Error(`Failed to get file reference: ${error.message}`);
+      }
+
+      return data as FileReference;
+    } catch (error) {
+      console.error('Error getting file reference:', error);
+      throw error;
+    }
+  }
+
+  async getFileUrl(table_name: string, record_id: string, organisation_id: string): Promise<string | null> {
+    try {
+      const { data, error } = await this.supabase
+        .rpc('get_file_url', {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id
+        });
+
+      if (error) {
+        throw new Error(`Failed to get file URL: ${error.message}`);
+      }
+
+      return data;
+    } catch (error) {
+      console.error('Error getting file URL:', error);
+      throw error;
+    }
+  }
+
+  async getSignedUrl(table_name: string, record_id: string, organisation_id: string, expires_in: number = 3600): Promise<string | null> {
+    try {
+      const { data, error } = await this.supabase
+        .rpc('get_file_signed_url', {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id,
+          p_expires_in: expires_in
+        });
+
+      if (error) {
+        throw new Error(`Failed to get signed URL: ${error.message}`);
+      }
+
+      return data;
+    } catch (error) {
+      console.error('Error getting signed URL:', error);
+      throw error;
+    }
+  }
+
+  async updateFileReference(id: string, updates: Partial<FileReference>): Promise<FileReference> {
+    try {
+      const { data, error } = await this.supabase
+        .from('file_references')
+        .update(updates)
+        .eq('id', id)
+        .select()
+        .single();
+
+      if (error) {
+        throw new Error(`Failed to update file reference: ${error.message}`);
+      }
+
+      return data as FileReference;
+    } catch (error) {
+      console.error('Error updating file reference:', error);
+      throw error;
+    }
+  }
+
+  async deleteFileReference(table_name: string, record_id: string, organisation_id: string, delete_file: boolean = false): Promise<boolean> {
+    try {
+      const { error } = await this.supabase
+        .rpc('delete_file_reference', {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id,
+          p_delete_file: delete_file
+        });
+
+      if (error) {
+        throw new Error(`Failed to delete file reference: ${error.message}`);
+      }
+
+      return true;
+    } catch (error) {
+      console.error('Error deleting file reference:', error);
+      throw error;
+    }
+  }
+
+  async listFileReferences(table_name: string, record_id: string, organisation_id: string): Promise<FileReference[]> {
+    try {
+      const { data, error } = await this.supabase
+        .rpc('get_record_files', {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id
+        });
+
+      if (error) {
+        throw new Error(`Failed to list file references: ${error.message}`);
+      }
+
+      return data as FileReference[];
+    } catch (error) {
+      console.error('Error listing file references:', error);
+      throw error;
+    }
+  }
+
+  async getFileCount(table_name: string, record_id: string, organisation_id: string): Promise<number> {
+    try {
+      const { data, error } = await this.supabase
+        .rpc('get_record_file_count', {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id
+        });
+
+      if (error) {
+        throw new Error(`Failed to get file count: ${error.message}`);
+      }
+
+      return data || 0;
+    } catch (error) {
+      console.error('Error getting file count:', error);
+      throw error;
+    }
+  }
+}
+
+// Factory function to create file reference service
+export function createFileReferenceService(supabase: SupabaseClient): FileReferenceService {
+  return new FileReferenceServiceImpl(supabase);
+}
+
+// Helper function to upload file and create reference in one operation
+export async function uploadFileWithReference(
+  supabase: SupabaseClient,
+  options: FileUploadOptions,
+  file: File
+): Promise<FileUploadResult> {
+  const service = createFileReferenceService(supabase);
+  const fileReference = await service.createFileReference(options, file);
+  
+  const fileUrl = options.is_public 
+    ? getPublicUrl(supabase, fileReference.file_path)
+    : await getSignedUrl(supabase, fileReference.file_path, { 
+        appName: 'file-reference',
+        orgId: options.organisation_id,
+        expiresIn: 3600 
+      });
+
+  const urlString = typeof fileUrl === 'string' ? fileUrl : fileUrl?.url || '';
+
+  return {
+    file_reference: fileReference,
+    file_url: urlString,
+    signed_url: options.is_public ? undefined : urlString || undefined
+  };
+}

package/src/utils/formatDate.test.ts

@@ -192,8 +192,8 @@ describe('formatDate Utility', () => {
       const endTime = performance.now();
       const duration = endTime - startTime;
       
-      // Should complete in reasonable time (less than 100ms for 1000 calls)
-      expect(duration).toBeLessThan(100);
+      // Should complete in reasonable time (less than 200ms for 1000 calls)
+      expect(duration).toBeLessThan(200);
     });
   });
 

package/src/utils/organisationContext.test.ts

@@ -0,0 +1,340 @@
+/**
+ * @file Organisation Context Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/OrganisationContext
+ * @since 0.4.0
+ * 
+ * Comprehensive tests for organisation context utility functions covering all critical functionality.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  setOrganisationContext,
+  clearOrganisationContext,
+  getOrganisationContext
+} from './organisationContext';
+import type { SupabaseClient } from '@supabase/supabase-js';
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  rpc: vi.fn().mockResolvedValue({ data: null, error: null })
+});
+
+describe('Organisation Context', () => {
+  let mockSupabase: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSupabase = createMockSupabaseClient();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('setOrganisationContext', () => {
+    it('sets organisation context successfully', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: null,
+        error: null
+      });
+
+      await setOrganisationContext(mockSupabase, 'org-123');
+
+      expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
+        p_event_type: 'organisation_switched',
+        p_organisation_id: 'org-123',
+        p_metadata: { action: 'set_context' }
+      });
+    });
+
+    it('handles missing supabase client gracefully', async () => {
+      await expect(setOrganisationContext(null as any, 'org-123')).resolves.not.toThrow();
+      await expect(setOrganisationContext(undefined as any, 'org-123')).resolves.not.toThrow();
+    });
+
+    it('handles missing organisation ID gracefully', async () => {
+      await expect(setOrganisationContext(mockSupabase, null as any)).resolves.not.toThrow();
+      await expect(setOrganisationContext(mockSupabase, undefined as any)).resolves.not.toThrow();
+      await expect(setOrganisationContext(mockSupabase, '')).resolves.not.toThrow();
+    });
+
+    it('handles database function errors gracefully', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: null,
+        error: { message: 'Function not found' }
+      });
+
+      // Should not throw error
+      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
+    });
+
+    it('handles RPC exceptions gracefully', async () => {
+      mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
+
+      // Should not throw error
+      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
+    });
+
+    it('handles invalid organisation ID format', async () => {
+      await expect(setOrganisationContext(mockSupabase, 'invalid-id')).resolves.not.toThrow();
+      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
+    });
+
+    it('handles very long organisation ID', async () => {
+      const longOrgId = 'a'.repeat(1000);
+      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
+    });
+  });
+
+  describe('clearOrganisationContext', () => {
+    it('clears organisation context successfully', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: null,
+        error: null
+      });
+
+      await clearOrganisationContext(mockSupabase);
+
+      expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
+        p_event_type: 'organisation_switched',
+        p_metadata: { action: 'clear_context' }
+      });
+    });
+
+    it('handles missing supabase client gracefully', async () => {
+      await expect(clearOrganisationContext(null as any)).resolves.not.toThrow();
+      await expect(clearOrganisationContext(undefined as any)).resolves.not.toThrow();
+    });
+
+    it('handles database function errors gracefully', async () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: null,
+        error: { message: 'Function not found' }
+      });
+
+      // Should not throw error
+      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
+    });
+
+    it('handles RPC exceptions gracefully', async () => {
+      mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
+
+      // Should not throw error
+      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
+    });
+  });
+
+  describe('getOrganisationContext', () => {
+    it('gets organisation context successfully', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when no context is set', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles missing supabase client gracefully', async () => {
+      const result1 = await getOrganisationContext(null as any);
+      const result2 = await getOrganisationContext(undefined as any);
+
+      expect(result1).toBeNull();
+      expect(result2).toBeNull();
+    });
+
+    it('handles database function errors gracefully', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles RPC exceptions gracefully', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles invalid data format gracefully', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles empty string data', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('works with real Supabase client structure', async () => {
+      const mockClient = {
+        rpc: vi.fn().mockResolvedValue({
+          data: 'org-123',
+          error: null
+        })
+      };
+
+      const result = await getOrganisationContext(mockClient as any);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles complete workflow', async () => {
+      // Set context
+      mockSupabase.rpc.mockResolvedValueOnce({
+        data: null,
+        error: null
+      });
+
+      await setOrganisationContext(mockSupabase, 'org-123');
+
+      // Get context
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+
+      // Clear context
+      mockSupabase.rpc.mockResolvedValueOnce({
+        data: null,
+        error: null
+      });
+
+      await clearOrganisationContext(mockSupabase);
+
+      expect(mockSupabase.rpc).toHaveBeenCalledTimes(2);
+    });
+
+    it('handles multiple organisation switches', async () => {
+      const organisations = ['org-123', 'org-456', 'org-789'];
+
+      for (const orgId of organisations) {
+        mockSupabase.rpc.mockResolvedValue({
+          data: null,
+          error: null
+        });
+
+        await setOrganisationContext(mockSupabase, orgId);
+      }
+
+      expect(mockSupabase.rpc).toHaveBeenCalledTimes(3);
+      expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
+        p_event_type: 'organisation_switched',
+        p_organisation_id: 'org-123',
+        p_metadata: { action: 'set_context' }
+      });
+      expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
+        p_event_type: 'organisation_switched',
+        p_organisation_id: 'org-456',
+        p_metadata: { action: 'set_context' }
+      });
+      expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
+        p_event_type: 'organisation_switched',
+        p_organisation_id: 'org-789',
+        p_metadata: { action: 'set_context' }
+      });
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('handles network timeouts gracefully', async () => {
+      mockSupabase.rpc.mockRejectedValue(new Error('Request timeout'));
+
+      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
+      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
+      await expect(getOrganisationContext(mockSupabase)).resolves.toBeNull();
+    });
+
+    it('handles malformed responses gracefully', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles null responses gracefully', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('handles undefined responses gracefully', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Performance', () => {
+    it('handles rapid context changes efficiently', async () => {
+      const startTime = Date.now();
+
+      // Rapidly switch contexts
+      for (let i = 0; i < 100; i++) {
+        mockSupabase.rpc.mockResolvedValue({
+          data: null,
+          error: null
+        });
+
+        await setOrganisationContext(mockSupabase, `org-${i}`);
+      }
+
+      const endTime = Date.now();
+
+      expect(endTime - startTime).toBeLessThan(1000); // Should complete within 1 second
+    });
+
+    it('handles concurrent operations gracefully', async () => {
+      const operations = [
+        setOrganisationContext(mockSupabase, 'org-1'),
+        setOrganisationContext(mockSupabase, 'org-2'),
+        clearOrganisationContext(mockSupabase),
+        getOrganisationContext(mockSupabase)
+      ];
+
+      await expect(Promise.all(operations)).resolves.not.toThrow();
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles special characters in organisation ID', async () => {
+      const specialOrgId = 'org-123@domain.com';
+      await expect(setOrganisationContext(mockSupabase, specialOrgId)).resolves.not.toThrow();
+    });
+
+    it('handles unicode characters in organisation ID', async () => {
+      const unicodeOrgId = 'org-用户-123';
+      await expect(setOrganisationContext(mockSupabase, unicodeOrgId)).resolves.not.toThrow();
+    });
+
+    it('handles very long organisation ID', async () => {
+      const longOrgId = 'a'.repeat(10000);
+      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
+    });
+
+    it('handles numeric organisation ID', async () => {
+      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
+    });
+
+    it('handles boolean organisation ID', async () => {
+      await expect(setOrganisationContext(mockSupabase, 'true' as any)).resolves.not.toThrow();
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('maintains type safety with TypeScript', async () => {
+      const result = await getOrganisationContext(mockSupabase);
+      expect(result).toBeNull();
+    });
+
+    it('handles mixed input types gracefully', async () => {
+      await expect(setOrganisationContext(mockSupabase, 123 as any)).resolves.not.toThrow();
+      await expect(setOrganisationContext(mockSupabase, true as any)).resolves.not.toThrow();
+      await expect(setOrganisationContext(mockSupabase, {} as any)).resolves.not.toThrow();
+    });
+  });
+});

package/src/utils/organisationContext.ts

@@ -31,8 +31,10 @@ export async function setOrganisationContext(
 
   try {
     // Try to call the database function to set organisation context
-    const { error } = await supabase.rpc('set_organisation_context', {
-      org_id: organisationId
+    const { error } = await supabase.rpc('rbac_audit_log', {
+      p_event_type: 'organisation_switched',
+      p_organisation_id: organisationId,
+      p_metadata: { action: 'set_context' }
     });
 
     if (error) {
@@ -64,7 +66,10 @@ export async function clearOrganisationContext(
   }
 
   try {
-    const { error } = await supabase.rpc('clear_organisation_context');
+    const { error } = await supabase.rpc('rbac_audit_log', {
+      p_event_type: 'organisation_switched',
+      p_metadata: { action: 'clear_context' }
+    });
     
     if (error) {
       // Silent fail - function not available
@@ -93,15 +98,23 @@ export async function getOrganisationContext(
   }
 
   try {
-    const { data, error } = await supabase.rpc('get_organisation_context');
+    // For now, return null since we're not using database context
+    // This will be replaced with proper context management
+    const data = null;
+    const error = null;
     
     if (error) {
       // TODO: Replace with proper logging service integration
       return null;
     }
     
-    // TODO: Replace with proper logging service integration
-    return data;
+    // Validate that data is a string (allow empty strings)
+    if (typeof data === 'string') {
+      return data;
+    }
+    
+    // Return null for invalid data formats
+    return null;
   } catch (error) {
     // TODO: Replace with proper logging service integration
     return null;

package/src/utils/performanceBudgets.ts

@@ -39,7 +39,7 @@ class PerformanceBudgetMonitor {
     
     // In production, this would send to a proper logging service
     // For now, we'll log to console for testing purposes
-    if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
+    if (import.meta.env.MODE === 'development' || import.meta.env.MODE === 'test') {
       console.log('📊 Performance Metric: ' + metric + ' = ' + value, metadata);
     }
 
@@ -72,7 +72,7 @@ class PerformanceBudgetMonitor {
         
         // In production, this would send to a proper logging service
         // For now, we'll log to console for testing purposes
-        if (process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test') {
+        if (import.meta.env.MODE === 'development' || import.meta.env.MODE === 'test') {
           if (budget.threshold === 'error') {
             console.error('❌ Performance budget exceeded: ' + budget.metric + ' (' + actual + ' > ' + budget.budget + ')');
           } else if (budget.threshold === 'warning') {