@jmruthers/pace-core 0.5.121 → 0.5.124

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

@@ -0,0 +1,447 @@
+/**
+ * @file File Reference Type Tests
+ * @package @jmruthers/pace-core
+ * @module Types/__tests__
+ * @since 1.0.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import type {
+  FileReference,
+  FileUploadOptions,
+  FileUploadResult,
+  FileValidationError,
+  FileMetadata,
+  FileStorageConfig,
+  FileAccessLevel
+} from '../file-reference';
+
+describe('[types] File Reference Types', () => {
+  describe('FileReference interface', () => {
+    it('validates FileReference type structure', () => {
+      const fileRef: FileReference = {
+        id: 'test-file-id',
+        filename: 'test-file.pdf',
+        originalName: 'Test File.pdf',
+        mimeType: 'application/pdf',
+        size: 1024,
+        url: 'https://example.com/files/test-file.pdf',
+        uploadedAt: '2024-01-01T00:00:00Z',
+        uploadedBy: 'user-123',
+        organisationId: 'org-123',
+        eventId: 'event-123',
+        accessLevel: 'private',
+        metadata: {
+          description: 'Test file description',
+          tags: ['document', 'test']
+        }
+      };
+
+      expect(fileRef).toHaveProperty('id');
+      expect(fileRef).toHaveProperty('filename');
+      expect(fileRef).toHaveProperty('originalName');
+      expect(fileRef).toHaveProperty('mimeType');
+      expect(fileRef).toHaveProperty('size');
+      expect(fileRef).toHaveProperty('url');
+      expect(fileRef).toHaveProperty('uploadedAt');
+      expect(fileRef).toHaveProperty('uploadedBy');
+      expect(fileRef).toHaveProperty('organisationId');
+      expect(fileRef).toHaveProperty('eventId');
+      expect(fileRef).toHaveProperty('accessLevel');
+      expect(fileRef).toHaveProperty('metadata');
+
+      expect(typeof fileRef.id).toBe('string');
+      expect(typeof fileRef.filename).toBe('string');
+      expect(typeof fileRef.originalName).toBe('string');
+      expect(typeof fileRef.mimeType).toBe('string');
+      expect(typeof fileRef.size).toBe('number');
+      expect(typeof fileRef.url).toBe('string');
+      expect(typeof fileRef.uploadedAt).toBe('string');
+      expect(typeof fileRef.uploadedBy).toBe('string');
+      expect(typeof fileRef.organisationId).toBe('string');
+      expect(typeof fileRef.eventId).toBe('string');
+      expect(typeof fileRef.accessLevel).toBe('string');
+      expect(typeof fileRef.metadata).toBe('object');
+    });
+
+    it('validates FileReference with minimal required fields', () => {
+      const fileRef: FileReference = {
+        id: 'test-file-id',
+        filename: 'test-file.pdf',
+        originalName: 'Test File.pdf',
+        mimeType: 'application/pdf',
+        size: 1024,
+        url: 'https://example.com/files/test-file.pdf',
+        uploadedAt: '2024-01-01T00:00:00Z',
+        uploadedBy: 'user-123',
+        organisationId: 'org-123',
+        accessLevel: 'private'
+      };
+
+      expect(fileRef).toHaveProperty('id');
+      expect(fileRef).toHaveProperty('filename');
+      expect(fileRef.eventId).toBeUndefined();
+      expect(fileRef.metadata).toBeUndefined();
+    });
+  });
+
+  describe('FileUploadOptions interface', () => {
+    it('validates FileUploadOptions type structure', () => {
+      const uploadOptions: FileUploadOptions = {
+        maxSize: 5 * 1024 * 1024, // 5MB
+        allowedTypes: ['image/jpeg', 'image/png', 'application/pdf'],
+        allowedExtensions: ['.jpg', '.jpeg', '.png', '.pdf'],
+        generateThumbnail: true,
+        compressImage: true,
+        quality: 0.8,
+        resize: {
+          width: 1920,
+          height: 1080,
+          maintainAspectRatio: true
+        },
+        metadata: {
+          description: 'Uploaded file',
+          tags: ['upload']
+        },
+        accessLevel: 'private',
+        organisationId: 'org-123',
+        eventId: 'event-123'
+      };
+
+      expect(uploadOptions).toHaveProperty('maxSize');
+      expect(uploadOptions).toHaveProperty('allowedTypes');
+      expect(uploadOptions).toHaveProperty('allowedExtensions');
+      expect(uploadOptions).toHaveProperty('generateThumbnail');
+      expect(uploadOptions).toHaveProperty('compressImage');
+      expect(uploadOptions).toHaveProperty('quality');
+      expect(uploadOptions).toHaveProperty('resize');
+      expect(uploadOptions).toHaveProperty('metadata');
+      expect(uploadOptions).toHaveProperty('accessLevel');
+      expect(uploadOptions).toHaveProperty('organisationId');
+      expect(uploadOptions).toHaveProperty('eventId');
+
+      expect(typeof uploadOptions.maxSize).toBe('number');
+      expect(Array.isArray(uploadOptions.allowedTypes)).toBe(true);
+      expect(Array.isArray(uploadOptions.allowedExtensions)).toBe(true);
+      expect(typeof uploadOptions.generateThumbnail).toBe('boolean');
+      expect(typeof uploadOptions.compressImage).toBe('boolean');
+      expect(typeof uploadOptions.quality).toBe('number');
+      expect(typeof uploadOptions.resize).toBe('object');
+      expect(typeof uploadOptions.metadata).toBe('object');
+      expect(typeof uploadOptions.accessLevel).toBe('string');
+      expect(typeof uploadOptions.organisationId).toBe('string');
+      expect(typeof uploadOptions.eventId).toBe('string');
+    });
+
+    it('validates FileUploadOptions with minimal fields', () => {
+      const uploadOptions: FileUploadOptions = {
+        maxSize: 1024 * 1024, // 1MB
+        allowedTypes: ['image/jpeg'],
+        accessLevel: 'public'
+      };
+
+      expect(uploadOptions).toHaveProperty('maxSize');
+      expect(uploadOptions).toHaveProperty('allowedTypes');
+      expect(uploadOptions).toHaveProperty('accessLevel');
+      expect(uploadOptions.allowedExtensions).toBeUndefined();
+      expect(uploadOptions.generateThumbnail).toBeUndefined();
+      expect(uploadOptions.compressImage).toBeUndefined();
+    });
+  });
+
+  describe('FileUploadResult interface', () => {
+    it('validates FileUploadResult success structure', () => {
+      const successResult: FileUploadResult = {
+        success: true,
+        file: {
+          id: 'test-file-id',
+          filename: 'test-file.pdf',
+          originalName: 'Test File.pdf',
+          mimeType: 'application/pdf',
+          size: 1024,
+          url: 'https://example.com/files/test-file.pdf',
+          uploadedAt: '2024-01-01T00:00:00Z',
+          uploadedBy: 'user-123',
+          organisationId: 'org-123',
+          accessLevel: 'private'
+        },
+        thumbnailUrl: 'https://example.com/thumbnails/test-file.jpg',
+        message: 'File uploaded successfully'
+      };
+
+      expect(successResult).toHaveProperty('success');
+      expect(successResult).toHaveProperty('file');
+      expect(successResult).toHaveProperty('thumbnailUrl');
+      expect(successResult).toHaveProperty('message');
+      expect(successResult.success).toBe(true);
+      expect(typeof successResult.file).toBe('object');
+      expect(typeof successResult.thumbnailUrl).toBe('string');
+      expect(typeof successResult.message).toBe('string');
+    });
+
+    it('validates FileUploadResult error structure', () => {
+      const errorResult: FileUploadResult = {
+        success: false,
+        error: 'File size exceeds maximum allowed size',
+        code: 'FILE_TOO_LARGE',
+        details: {
+          maxSize: 5 * 1024 * 1024,
+          actualSize: 10 * 1024 * 1024
+        }
+      };
+
+      expect(errorResult).toHaveProperty('success');
+      expect(errorResult).toHaveProperty('error');
+      expect(errorResult).toHaveProperty('code');
+      expect(errorResult).toHaveProperty('details');
+      expect(errorResult.success).toBe(false);
+      expect(typeof errorResult.error).toBe('string');
+      expect(typeof errorResult.code).toBe('string');
+      expect(typeof errorResult.details).toBe('object');
+      expect(errorResult.file).toBeUndefined();
+    });
+  });
+
+  describe('FileValidationError interface', () => {
+    it('validates FileValidationError type structure', () => {
+      const validationError: FileValidationError = {
+        field: 'file',
+        message: 'File type not allowed',
+        code: 'INVALID_FILE_TYPE',
+        value: 'test.exe',
+        allowedValues: ['image/jpeg', 'image/png', 'application/pdf']
+      };
+
+      expect(validationError).toHaveProperty('field');
+      expect(validationError).toHaveProperty('message');
+      expect(validationError).toHaveProperty('code');
+      expect(validationError).toHaveProperty('value');
+      expect(validationError).toHaveProperty('allowedValues');
+      expect(typeof validationError.field).toBe('string');
+      expect(typeof validationError.message).toBe('string');
+      expect(typeof validationError.code).toBe('string');
+      expect(typeof validationError.value).toBe('string');
+      expect(Array.isArray(validationError.allowedValues)).toBe(true);
+    });
+  });
+
+  describe('FileMetadata interface', () => {
+    it('validates FileMetadata type structure', () => {
+      const metadata: FileMetadata = {
+        description: 'Test file description',
+        tags: ['document', 'test', 'important'],
+        category: 'documents',
+        author: 'John Doe',
+        version: '1.0',
+        customFields: {
+          department: 'IT',
+          project: 'Test Project',
+          priority: 'high'
+        }
+      };
+
+      expect(metadata).toHaveProperty('description');
+      expect(metadata).toHaveProperty('tags');
+      expect(metadata).toHaveProperty('category');
+      expect(metadata).toHaveProperty('author');
+      expect(metadata).toHaveProperty('version');
+      expect(metadata).toHaveProperty('customFields');
+      expect(typeof metadata.description).toBe('string');
+      expect(Array.isArray(metadata.tags)).toBe(true);
+      expect(typeof metadata.category).toBe('string');
+      expect(typeof metadata.author).toBe('string');
+      expect(typeof metadata.version).toBe('string');
+      expect(typeof metadata.customFields).toBe('object');
+    });
+
+    it('validates FileMetadata with minimal fields', () => {
+      const metadata: FileMetadata = {
+        description: 'Test file'
+      };
+
+      expect(metadata).toHaveProperty('description');
+      expect(metadata.tags).toBeUndefined();
+      expect(metadata.category).toBeUndefined();
+      expect(metadata.author).toBeUndefined();
+      expect(metadata.version).toBeUndefined();
+      expect(metadata.customFields).toBeUndefined();
+    });
+  });
+
+  describe('FileStorageConfig interface', () => {
+    it('validates FileStorageConfig type structure', () => {
+      const storageConfig: FileStorageConfig = {
+        provider: 'supabase',
+        bucket: 'pace-files',
+        region: 'us-east-1',
+        cdnUrl: 'https://cdn.example.com',
+        maxFileSize: 10 * 1024 * 1024, // 10MB
+        allowedMimeTypes: ['image/*', 'application/pdf', 'text/*'],
+        compressionEnabled: true,
+        encryptionEnabled: true,
+        retentionPolicy: {
+          days: 365,
+          autoDelete: true
+        }
+      };
+
+      expect(storageConfig).toHaveProperty('provider');
+      expect(storageConfig).toHaveProperty('bucket');
+      expect(storageConfig).toHaveProperty('region');
+      expect(storageConfig).toHaveProperty('cdnUrl');
+      expect(storageConfig).toHaveProperty('maxFileSize');
+      expect(storageConfig).toHaveProperty('allowedMimeTypes');
+      expect(storageConfig).toHaveProperty('compressionEnabled');
+      expect(storageConfig).toHaveProperty('encryptionEnabled');
+      expect(storageConfig).toHaveProperty('retentionPolicy');
+      expect(typeof storageConfig.provider).toBe('string');
+      expect(typeof storageConfig.bucket).toBe('string');
+      expect(typeof storageConfig.region).toBe('string');
+      expect(typeof storageConfig.cdnUrl).toBe('string');
+      expect(typeof storageConfig.maxFileSize).toBe('number');
+      expect(Array.isArray(storageConfig.allowedMimeTypes)).toBe(true);
+      expect(typeof storageConfig.compressionEnabled).toBe('boolean');
+      expect(typeof storageConfig.encryptionEnabled).toBe('boolean');
+      expect(typeof storageConfig.retentionPolicy).toBe('object');
+    });
+  });
+
+  describe('FileAccessLevel type', () => {
+    it('validates FileAccessLevel values', () => {
+      const accessLevels: FileAccessLevel[] = ['public', 'private', 'restricted'];
+      
+      expect(accessLevels).toContain('public');
+      expect(accessLevels).toContain('private');
+      expect(accessLevels).toContain('restricted');
+    });
+
+    it('validates FileAccessLevel type usage', () => {
+      const accessLevel: FileAccessLevel = 'private';
+      expect(typeof accessLevel).toBe('string');
+      expect(['public', 'private', 'restricted']).toContain(accessLevel);
+    });
+  });
+});
+
+describe('[types] File Reference Usage Patterns', () => {
+  describe('File Upload Flow', () => {
+    it('validates complete file upload flow types', () => {
+      interface FileUploadFlow {
+        file: File;
+        options: FileUploadOptions;
+        onProgress: (progress: number) => void;
+        onSuccess: (result: FileUploadResult) => void;
+        onError: (error: FileValidationError) => void;
+      }
+
+      const uploadFlow: FileUploadFlow = {
+        file: new File(['test'], 'test.txt', { type: 'text/plain' }),
+        options: {
+          maxSize: 1024 * 1024,
+          allowedTypes: ['text/plain'],
+          accessLevel: 'private'
+        },
+        onProgress: (progress) => {
+          expect(typeof progress).toBe('number');
+          expect(progress).toBeGreaterThanOrEqual(0);
+          expect(progress).toBeLessThanOrEqual(100);
+        },
+        onSuccess: (result) => {
+          expect(result).toHaveProperty('success');
+          expect(result).toHaveProperty('file');
+        },
+        onError: (error) => {
+          expect(error).toHaveProperty('field');
+          expect(error).toHaveProperty('message');
+          expect(error).toHaveProperty('code');
+        }
+      };
+
+      expect(uploadFlow).toHaveProperty('file');
+      expect(uploadFlow).toHaveProperty('options');
+      expect(uploadFlow).toHaveProperty('onProgress');
+      expect(uploadFlow).toHaveProperty('onSuccess');
+      expect(uploadFlow).toHaveProperty('onError');
+      expect(uploadFlow.file).toBeInstanceOf(File);
+      expect(typeof uploadFlow.options).toBe('object');
+      expect(typeof uploadFlow.onProgress).toBe('function');
+      expect(typeof uploadFlow.onSuccess).toBe('function');
+      expect(typeof uploadFlow.onError).toBe('function');
+    });
+  });
+
+  describe('File Management Operations', () => {
+    it('validates file management operation types', () => {
+      interface FileManagementOperation {
+        operation: 'upload' | 'download' | 'delete' | 'update' | 'list';
+        fileId?: string;
+        options?: FileUploadOptions;
+        metadata?: FileMetadata;
+      }
+
+      const operations: FileManagementOperation[] = [
+        { operation: 'upload', options: { maxSize: 1024, allowedTypes: ['image/*'] } },
+        { operation: 'download', fileId: 'file-123' },
+        { operation: 'delete', fileId: 'file-123' },
+        { operation: 'update', fileId: 'file-123', metadata: { description: 'Updated' } },
+        { operation: 'list' }
+      ];
+
+      operations.forEach(op => {
+        expect(op).toHaveProperty('operation');
+        expect(['upload', 'download', 'delete', 'update', 'list']).toContain(op.operation);
+        if (op.fileId) {
+          expect(typeof op.fileId).toBe('string');
+        }
+        if (op.options) {
+          expect(typeof op.options).toBe('object');
+        }
+        if (op.metadata) {
+          expect(typeof op.metadata).toBe('object');
+        }
+      });
+    });
+  });
+
+  describe('File Validation Rules', () => {
+    it('validates file validation rule types', () => {
+      interface FileValidationRule {
+        field: keyof FileReference;
+        validator: (value: any) => boolean;
+        message: string;
+        required?: boolean;
+      }
+
+      const validationRules: FileValidationRule[] = [
+        {
+          field: 'filename',
+          validator: (value) => typeof value === 'string' && value.length > 0,
+          message: 'Filename is required',
+          required: true
+        },
+        {
+          field: 'size',
+          validator: (value) => typeof value === 'number' && value > 0,
+          message: 'File size must be greater than 0'
+        },
+        {
+          field: 'mimeType',
+          validator: (value) => typeof value === 'string' && value.includes('/'),
+          message: 'Invalid MIME type format'
+        }
+      ];
+
+      validationRules.forEach(rule => {
+        expect(rule).toHaveProperty('field');
+        expect(rule).toHaveProperty('validator');
+        expect(rule).toHaveProperty('message');
+        expect(typeof rule.field).toBe('string');
+        expect(typeof rule.validator).toBe('function');
+        expect(typeof rule.message).toBe('string');
+        if (rule.required !== undefined) {
+          expect(typeof rule.required).toBe('boolean');
+        }
+      });
+    });
+  });
+});

package/src/utils/formatDate.test.ts

@@ -21,7 +21,7 @@ describe('formatDate Utility', () => {
       const date = new Date('2024-01-15T10:30:00.000Z');
       const result = formatDate(date);
       
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
 
     it('formats different Date objects', () => {
@@ -33,7 +33,7 @@ describe('formatDate Utility', () => {
       
       dates.forEach(date => {
         const result = formatDate(date);
-        expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+        expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
       });
     });
   });
@@ -41,12 +41,12 @@ describe('formatDate Utility', () => {
   describe('String Input', () => {
     it('formats ISO date strings correctly', () => {
       const result = formatDate('2024-01-15T10:30:00.000Z');
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
 
     it('formats date-only strings correctly', () => {
       const result = formatDate('2024-01-15');
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
 
     it('formats various date string formats', () => {
@@ -59,7 +59,7 @@ describe('formatDate Utility', () => {
       
       dateStrings.forEach(dateString => {
         const result = formatDate(dateString);
-        expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+        expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
       });
     });
   });
@@ -68,13 +68,13 @@ describe('formatDate Utility', () => {
     it('formats timestamp numbers correctly', () => {
       const timestamp = new Date('2024-01-15T10:30:00.000Z').getTime();
       const result = formatDate(timestamp);
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
 
     it('formats Unix timestamps correctly', () => {
       const unixTimestamp = Math.floor(new Date('2024-01-15T10:30:00.000Z').getTime() / 1000);
       const result = formatDate(unixTimestamp * 1000); // Convert back to milliseconds
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
   });
 
@@ -154,14 +154,14 @@ describe('formatDate Utility', () => {
       const result = formatDate(date);
       
       // Should use the default locale format
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
 
     it('handles different locales correctly', () => {
       const date = new Date('2024-01-15T10:30:00.000Z');
       
       const result = formatDate(date);
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
   });
 
@@ -171,7 +171,7 @@ describe('formatDate Utility', () => {
       const result = formatDate(date);
       
       // Should format consistently regardless of timezone
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
   });
 
@@ -231,7 +231,7 @@ describe('formatDate Utility', () => {
       const result = formatDate(date);
       
       // Should match pattern: "MMM DD, YYYY"
-      expect(result).toMatch(/^[A-Za-z]{3} \d{1,2}, \d{4}$/);
+      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
   });
 });

package/src/utils/formatting.ts

@@ -3,14 +3,15 @@
  */
 
 /**
- * Format a date as a readable string
+ * Format a date as a readable string in "dd mmm yyyy" format (e.g., "15 Jun 2024")
  */
 export function formatDate(date: Date | string | number): string {
   const dateObj = typeof date === 'string' || typeof date === 'number' 
     ? new Date(date) 
     : date;
   
-  return dateObj.toLocaleDateString(undefined, {
+  // Use 'en-GB' locale to ensure "dd mmm yyyy" format (e.g., "15 Jun 2024")
+  return dateObj.toLocaleDateString('en-GB', {
     year: 'numeric',
     month: 'short',
     day: 'numeric'

package/dist/chunk-BDZUMRBD.js 3.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/organisationContext.ts"],"sourcesContent":["/**\n * @file Organisation Context Utility\n * @package @jmruthers/pace-core\n * @module Utils/OrganisationContext\n * @since 0.4.0\n *\n * Utility functions for managing organisation context in database sessions.\n * Provides fallback mechanisms for when database functions are not available.\n */\n\nimport type { SupabaseClient } from '@supabase/supabase-js';\n\n/**\n * Set organisation context in the database session\n * \n * This function attempts to set the organisation context using a database function.\n * If the function is not available, it falls back gracefully without throwing errors.\n * \n * @param supabase - Supabase client instance\n * @param organisationId - The organisation ID to set as context\n * @returns Promise that resolves when context is set (or falls back gracefully)\n */\nexport async function setOrganisationContext(\n  supabase: SupabaseClient,\n  organisationId: string\n): Promise<void> {\n  if (!supabase || !organisationId) {\n    // TODO: Replace with proper logging service integration\n    return;\n  }\n\n  try {\n    // Add timeout to prevent hanging RPC calls\n    const timeoutPromise = new Promise((_, reject) => {\n      setTimeout(() => reject(new Error('RPC timeout after 3 seconds')), 3000);\n    });\n    \n    // Call the database function to set organisation context\n    const rpcPromise = supabase.rpc('set_organisation_context', {\n      org_id: organisationId\n    });\n\n    const { error } = await Promise.race([rpcPromise, timeoutPromise]) as any;\n\n    if (error) {\n      // Function might not exist yet - this is expected during migration\n      // Silent fail - will fall back to client-side filtering\n      console.log('[organisationContext] RPC function not available or failed, continuing without database context');\n    } else {\n      console.log('[organisationContext] Organisation context set in database successfully');\n    }\n  } catch (error) {\n    // Handle any other errors gracefully\n    // Silent fail - will fall back to client-side filtering\n    console.log('[organisationContext] Failed to set database context, continuing without it:', error);\n  }\n}\n\n/**\n * Clear organisation context from the database session\n * \n * @param supabase - Supabase client instance\n * @returns Promise that resolves when context is cleared\n */\nexport async function clearOrganisationContext(\n  supabase: SupabaseClient\n): Promise<void> {\n  if (!supabase) {\n    // TODO: Replace with proper logging service integration\n    return;\n  }\n\n  try {\n    const { error } = await supabase.rpc('rbac_audit_log', {\n      p_event_type: 'organisation_switched',\n      p_metadata: { action: 'clear_context' }\n    });\n    \n    if (error) {\n      // Silent fail - function not available\n      // TODO: Replace with proper logging service integration\n    } else {\n      // TODO: Replace with proper logging service integration\n    }\n  } catch (error) {\n    // Silent fail - error occurred\n    // TODO: Replace with proper logging service integration\n  }\n}\n\n/**\n * Get current organisation context from the database session\n * \n * @param supabase - Supabase client instance\n * @returns Promise that resolves to the current organisation ID or null\n */\nexport async function getOrganisationContext(\n  supabase: SupabaseClient\n): Promise<string | null> {\n  if (!supabase) {\n    // TODO: Replace with proper logging service integration\n    return null;\n  }\n\n  try {\n    // For now, return null since we're not using database context\n    // This will be replaced with proper context management\n    const data = null;\n    const error = null;\n    \n    if (error) {\n      // TODO: Replace with proper logging service integration\n      return null;\n    }\n    \n    // Validate that data is a string (allow empty strings)\n    if (typeof data === 'string') {\n      return data;\n    }\n    \n    // Return null for invalid data formats\n    return null;\n  } catch (error) {\n    // TODO: Replace with proper logging service integration\n    return null;\n  }\n}\n\n/**\n * Check if organisation context functions are available in the database\n * \n * @param supabase - Supabase client instance\n * @returns Promise that resolves to true if functions are available\n */\nexport async function isOrganisationContextAvailable(\n  supabase: SupabaseClient\n): Promise<boolean> {\n  if (!supabase) {\n    return false;\n  }\n\n  try {\n    const { error } = await supabase.rpc('get_organisation_context');\n    \n    if (error) {\n      return false;\n    }\n    \n    return true;\n  } catch (error) {\n    return false;\n  }\n} "],"mappings":";;;;;AAsBA,eAAsB,uBACpB,UACA,gBACe;AACf,MAAI,CAAC,YAAY,CAAC,gBAAgB;AAEhC;AAAA,EACF;AAEA,MAAI;AAEF,UAAM,iBAAiB,IAAI,QAAQ,CAAC,GAAG,WAAW;AAChD,iBAAW,MAAM,OAAO,IAAI,MAAM,6BAA6B,CAAC,GAAG,GAAI;AAAA,IACzE,CAAC;AAGD,UAAM,aAAa,SAAS,IAAI,4BAA4B;AAAA,MAC1D,QAAQ;AAAA,IACV,CAAC;AAED,UAAM,EAAE,MAAM,IAAI,MAAM,QAAQ,KAAK,CAAC,YAAY,cAAc,CAAC;AAEjE,QAAI,OAAO;AAGT,cAAQ,IAAI,iGAAiG;AAAA,IAC/G,OAAO;AACL,cAAQ,IAAI,yEAAyE;AAAA,IACvF;AAAA,EACF,SAAS,OAAO;AAGd,YAAQ,IAAI,gFAAgF,KAAK;AAAA,EACnG;AACF;AAQA,eAAsB,yBACpB,UACe;AACf,MAAI,CAAC,UAAU;AAEb;AAAA,EACF;AAEA,MAAI;AACF,UAAM,EAAE,MAAM,IAAI,MAAM,SAAS,IAAI,kBAAkB;AAAA,MACrD,cAAc;AAAA,MACd,YAAY,EAAE,QAAQ,gBAAgB;AAAA,IACxC,CAAC;AAED,QAAI,OAAO;AAAA,IAGX,OAAO;AAAA,IAEP;AAAA,EACF,SAAS,OAAO;AAAA,EAGhB;AACF;AAQA,eAAsB,uBACpB,UACwB;AACxB,MAAI,CAAC,UAAU;AAEb,WAAO;AAAA,EACT;AAEA,MAAI;AAGF,UAAM,OAAO;AACb,UAAM,QAAQ;AAEd,QAAI,OAAO;AAET,aAAO;AAAA,IACT;AAGA,QAAI,OAAO,SAAS,UAAU;AAC5B,aAAO;AAAA,IACT;AAGA,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,WAAO;AAAA,EACT;AACF;AAQA,eAAsB,+BACpB,UACkB;AAClB,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AAEA,MAAI;AACF,UAAM,EAAE,MAAM,IAAI,MAAM,SAAS,IAAI,0BAA0B;AAE/D,QAAI,OAAO;AACT,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,WAAO;AAAA,EACT;AACF;AAxJA;AAAA;AAAA;AAAA;AAAA;","names":[]}