@jmruthers/pace-core 0.5.135 → 0.5.136

package/src/hooks/public/usePublicFileDisplay.ts

@@ -36,11 +36,12 @@
  * ```
  */
 
-import { useState, useEffect, useCallback, useMemo } from 'react';
+import { useState, useEffect, useCallback } from 'react';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { Database } from '../../types/database';
 import { FileReference, FileCategory } from '../../types/file-reference';
 import { getPublicUrl } from '../../utils/storage/helpers';
+import { logger } from '../../utils/core/logger';
 
 // Simple in-memory cache for public file data
 const publicFileCache = new Map<string, { data: any; timestamp: number; ttl: number }>();
@@ -121,7 +122,7 @@ export function usePublicFileDisplay(
     // Validate UUID format for organisationId to prevent database errors
     const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     if (!uuidRegex.test(organisation_id)) {
-      console.warn('[usePublicFileDisplay] Invalid organisationId format (not a valid UUID):', organisation_id);
+      logger.warn('usePublicFileDisplay', 'Invalid organisationId format (not a valid UUID)', { organisation_id });
     }
 
     // Check cache first
@@ -158,53 +159,11 @@ export function usePublicFileDisplay(
           p_organisation_id: organisation_id
         };
         
-        // Step 1: Log RPC call parameters with full context
-        console.log('[usePublicFileDisplay] RPC Call Parameters:', {
-          function: 'data_file_reference_by_category_list',
-          parameters: rpcParams,
-          supabaseClient: {
-            available: !!supabase,
-            hasAuth: !!supabase?.auth
-          },
-          context: 'public_page_anonymous_user',
-          note: 'Public pages use anonymous Supabase client (no user session)'
-        });
-        
-        console.log('[usePublicFileDisplay] Using RPC function for category filtering:', {
-          table_name,
-          record_id,
-          category,
-          organisation_id
-        });
-        
         const { data, error: rpcError } = await (supabase as any)
           .rpc('data_file_reference_by_category_list', rpcParams);
 
-        // Step 2: Log RPC response immediately after call
-        console.log('[usePublicFileDisplay] RPC Response:', {
-          function: 'data_file_reference_by_category_list',
-          dataType: Array.isArray(data) ? 'array' : typeof data,
-          dataLength: Array.isArray(data) ? data.length : (data ? 1 : 0),
-          dataIsNull: data === null,
-          dataIsUndefined: data === undefined,
-          dataIsEmpty: Array.isArray(data) ? data.length === 0 : !data,
-          firstItem: Array.isArray(data) && data.length > 0 ? {
-            id: data[0].id,
-            file_path: data[0].file_path,
-            is_public: data[0].is_public,
-            has_metadata: !!data[0].file_metadata,
-            category_in_metadata: data[0].file_metadata?.category
-          } : null,
-          error: rpcError ? {
-            message: rpcError.message,
-            code: rpcError.code,
-            details: rpcError.details,
-            hint: rpcError.hint
-          } : null
-        });
-
         if (rpcError) {
-          console.error('[usePublicFileDisplay] RPC function error:', {
+          logger.error('usePublicFileDisplay', 'RPC function error', {
             function: 'data_file_reference_by_category_list',
             table_name,
             record_id,
@@ -224,28 +183,6 @@ export function usePublicFileDisplay(
         if (!data || data.length === 0) {
           files = [];
         } else {
-          // Step 3: Log data transformation - analyze files before filtering
-          const totalFilesFromRPC = data.length;
-          const filesWithIsPublic = data.filter((item: any) => item.is_public === true).length;
-          const filesWithIsPublicFalse = data.filter((item: any) => item.is_public === false).length;
-          const filesWithIsPublicNull = data.filter((item: any) => item.is_public === null || item.is_public === undefined).length;
-          const filesWithValidStructure = data.filter((item: any) => item.id && item.file_path && item.file_metadata).length;
-          
-          console.log('[usePublicFileDisplay] RPC Data Analysis (before filtering):', {
-            totalFilesFromRPC,
-            filesWithIsPublicTrue: filesWithIsPublic,
-            filesWithIsPublicFalse,
-            filesWithIsPublicNull,
-            filesWithValidStructure,
-            sampleItems: data.slice(0, 2).map((item: any) => ({
-              id: item.id,
-              is_public: item.is_public,
-              has_id: !!item.id,
-              has_file_path: !!item.file_path,
-              has_metadata: !!item.file_metadata
-            }))
-          });
-          
           // Construct file reference objects from RPC response
           // This avoids RLS issues - the RPC already validated permissions and filtered public files
           files = data
@@ -268,18 +205,6 @@ export function usePublicFileDisplay(
                 updated_at: item.created_at || new Date().toISOString()
               };
             });
-          
-          // Step 3: Log after filtering
-          console.log('[usePublicFileDisplay] Data Transformation (after filtering):', {
-            filesBeforeFilter: totalFilesFromRPC,
-            filesAfterFilter: files.length,
-            constructedFileReferences: files.map(f => ({
-              id: f.id,
-              file_path: f.file_path,
-              organisation_id: f.organisation_id,
-              is_public: f.is_public
-            }))
-          });
         }
       } else {
         // Multiple files mode - use RPC to get all files
@@ -291,7 +216,7 @@ export function usePublicFileDisplay(
           });
 
         if (rpcError) {
-          console.error('[usePublicFileDisplay] RPC function error:', {
+          logger.error('usePublicFileDisplay', 'RPC function error', {
             function: 'data_file_reference_list',
             table_name,
             record_id,
@@ -327,75 +252,6 @@ export function usePublicFileDisplay(
       const publicFiles = files.filter((f: any) => f.is_public === true);
 
       if (publicFiles.length === 0) {
-        console.log('[usePublicFileDisplay] No public files found:', {
-          table_name,
-          record_id,
-          category,
-          organisation_id,
-          totalFilesFound: files.length,
-          note: 'This is expected if no public files exist. Fallback UI will be shown if showFallback is enabled.'
-        });
-        
-        // Step 5: Add database query verification (for debugging only)
-        // This helps determine if files exist but RPC is filtering them out
-        try {
-          console.log('[usePublicFileDisplay] Database Query Verification (debugging):', {
-            note: 'Performing direct query to verify if files exist in database',
-            table_name,
-            record_id,
-            organisation_id,
-            category
-          });
-          
-          // Direct query to check if any files exist (regardless of is_public)
-          const { data: directQueryData, error: directQueryError } = await supabase
-            .from('file_references')
-            .select('id, file_path, file_metadata, is_public, organisation_id')
-            .eq('table_name', table_name)
-            .eq('record_id', record_id)
-            .eq('organisation_id', organisation_id);
-          
-          if (directQueryError) {
-            console.warn('[usePublicFileDisplay] Direct query error (RLS may be blocking):', {
-              error: directQueryError.message,
-              code: directQueryError.code,
-              hint: 'This is expected if RLS policies block anonymous access to file_references table'
-            });
-          } else {
-            const totalFilesInDB = directQueryData?.length || 0;
-            const publicFilesInDB = directQueryData?.filter((f: any) => f.is_public === true).length || 0;
-            const privateFilesInDB = directQueryData?.filter((f: any) => f.is_public === false).length || 0;
-            const filesWithCategory = category ? directQueryData?.filter((f: any) => 
-              f.file_metadata?.category === category
-            ).length || 0 : totalFilesInDB;
-            
-            console.log('[usePublicFileDisplay] Database Query Results:', {
-              totalFilesInDB,
-              publicFilesInDB,
-              privateFilesInDB,
-              filesWithCategory: category ? filesWithCategory : 'N/A (no category filter)',
-              filesWithMatchingCategoryAndPublic: category ? directQueryData?.filter((f: any) => 
-                f.is_public === true && f.file_metadata?.category === category
-              ).length || 0 : 'N/A',
-              sampleFiles: directQueryData?.slice(0, 2).map((f: any) => ({
-                id: f.id,
-                is_public: f.is_public,
-                category: f.file_metadata?.category,
-                organisation_id: f.organisation_id
-              })) || [],
-              conclusion: totalFilesInDB === 0 
-                ? 'No files exist in database for this record'
-                : publicFilesInDB === 0
-                ? 'Files exist but none are marked as public (is_public = true)'
-                : filesWithCategory === 0 && category
-                ? `Files exist but none match category "${category}"`
-                : 'Files exist and should be accessible - RPC function may be filtering them out'
-            });
-          }
-        } catch (debugError) {
-          console.warn('[usePublicFileDisplay] Database verification query failed:', debugError);
-        }
-        
         setFileUrl(null);
         setFileReference(null);
         setFileReferences([]);
@@ -477,7 +333,7 @@ export function usePublicFileDisplay(
       }
 
     } catch (err) {
-      console.error('[usePublicFileDisplay] Error fetching files:', {
+      logger.error('usePublicFileDisplay', 'Error fetching files', {
         table_name,
         record_id,
         organisation_id,

package/src/hooks/useComponentPerformance.ts

@@ -1,5 +1,8 @@
 
 import { useEffect, useRef } from 'react';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useComponentPerformance');
 
 interface PerformanceConfig {
   componentName: string;
@@ -23,7 +26,7 @@ export function useComponentPerformance({
     renderCount.current += 1;
 
     if (renderCount.current > 1 && renderTime > threshold) {
-      console.warn(
+      log.warn(
         `Performance warning: ${componentName} rendered in ${renderTime.toFixed(2)}ms ` +
         `(render #${renderCount.current}). Consider optimizing.`
       );

package/src/hooks/useDataTablePerformance.ts

@@ -34,6 +34,7 @@ import {
   DEFAULT_FALLBACK_CONFIG,
   type FallbackConfig
 } from '../components/DataTable/utils/errorHandling';
+import { logger } from '../utils/core/logger';
 
 export interface UseDataTablePerformanceOptions<TData extends DataRecord> {
   data: TData[];
@@ -236,7 +237,7 @@ export function useDataTablePerformance<TData extends DataRecord>({
       const response = await serverSide.fetchData(params);
       setServerData(response);
     } catch (error) {
-      console.error('Failed to fetch server data:', error);
+      logger.error('useDataTablePerformance', 'Failed to fetch server data:', error);
     } finally {
       setIsLoading(false);
     }
@@ -310,7 +311,7 @@ export function useDataTablePerformance<TData extends DataRecord>({
         onError?.(error);
         return recovery;
       } catch (recoveryError) {
-        console.error('Error recovery failed:', recoveryError);
+        logger.error('useDataTablePerformance', 'Error recovery failed:', recoveryError);
       }
     }
     throw error;
@@ -323,7 +324,7 @@ export function useDataTablePerformance<TData extends DataRecord>({
         setLastFailedOperation(null);
         setErrorState(prev => ({ ...prev, hasErrors: false }));
       } catch (error) {
-        console.error('Retry failed:', error);
+        logger.error('useDataTablePerformance', 'Retry failed:', error);
       }
     }
   }, [lastFailedOperation]);

package/src/hooks/useEventTheme.test.ts

@@ -23,6 +23,20 @@ vi.mock('../theming/runtime', () => ({
   clearPalette: vi.fn()
 }));
 
+// Mock the Logger module
+vi.mock('../utils/core/logger', () => {
+  const mockLoggerInstance = {
+    error: vi.fn(),
+  };
+  return {
+    createLogger: vi.fn(() => mockLoggerInstance),
+  };
+});
+
+// Get the mock instance after mock is set up
+import { createLogger } from '../utils/core/logger';
+const getMockLogger = () => createLogger('test');
+
 // Mock react-router-dom useLocation
 vi.mock('react-router-dom', () => ({
   useLocation: vi.fn(() => ({
@@ -254,7 +268,7 @@ describe('useEventTheme', () => {
 
   describe('Error handling', () => {
     it('handles errors when applying palette', () => {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.clearAllMocks();
       
       mockUseEvents.mockReturnValue({
         selectedEvent: {
@@ -276,12 +290,11 @@ describe('useEventTheme', () => {
 
       renderHook(() => useEventTheme());
 
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[useEventTheme] Failed to apply event palette:',
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+        'Failed to apply event palette:',
         expect.any(Error)
       );
-
-      consoleSpy.mockRestore();
     });
   });
 

package/src/hooks/useEventTheme.ts

@@ -44,6 +44,9 @@ import { useEvents } from './useEvents';
 import { applyPalette, clearPalette } from '../theming/runtime';
 import { parseAndNormalizeEventColours } from '../theming/parseEventColours';
 import type { Event } from '../types/unified';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useEventTheme');
 
 /**
  * Hook that automatically applies event-specific theming
@@ -147,7 +150,7 @@ export function useEventTheme(event?: Event | null): void {
     try {
       applyPalette(normalized);
     } catch (error) {
-      console.error('[useEventTheme] Failed to apply event palette:', error);
+      log.error('Failed to apply event palette:', error);
     }
 
     // Cleanup function to clear palette when component unmounts or event changes

package/src/hooks/useEvents.ts

@@ -21,6 +21,7 @@ export interface EventContextType {
   error: Error | null;
   setSelectedEvent: (event: Event | null) => void;
   refreshEvents: () => Promise<void>;
+  clearEventSelection: () => Promise<void>;
 }
 
 /**
@@ -58,6 +59,7 @@ export function useEvents(): EventContextType {
     error: eventService.getError(),
     setSelectedEvent: (event: Event | null) => eventService.setSelectedEvent(event),
     refreshEvents: () => eventService.refreshEvents(),
+    clearEventSelection: () => eventService.clearEventSelection(),
   };
 }
 

package/src/hooks/useFileDisplay.ts

@@ -39,6 +39,7 @@ import type { SupabaseClient } from '@supabase/supabase-js';
 import { FileReference, FileCategory } from '../types/file-reference';
 import { getPublicUrl, getSignedUrl } from '../utils/storage/helpers';
 import { createFileReferenceService } from '../utils/file-reference';
+import { logger } from '../utils/core/logger';
 
 // Simple in-memory cache for authenticated file data
 const authenticatedFileCache = new Map<string, { data: any; timestamp: number; ttl: number }>();
@@ -147,7 +148,7 @@ export function useFileDisplay(
     // Validate UUID format for organisationId to prevent database errors
     const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     if (!uuidRegex.test(organisation_id)) {
-      console.warn('[useFileDisplay] Invalid organisationId format (not a valid UUID):', organisation_id);
+      logger.warn('useFileDisplay', 'Invalid organisationId format (not a valid UUID):', organisation_id);
     }
 
     // Check cache first
@@ -178,7 +179,7 @@ export function useFileDisplay(
             return;
           } catch (err) {
             // If signed URL regeneration fails, fall through to normal fetch
-            console.warn('[useFileDisplay] Failed to regenerate signed URL from cache, falling back to fetch:', err);
+            logger.warn('useFileDisplay', 'Failed to regenerate signed URL from cache, falling back to fetch:', err);
           }
         }
         
@@ -205,7 +206,7 @@ export function useFileDisplay(
       // Category is stored in file_metadata JSONB field, not a direct column
       if (category) {
         // Single file mode - get files by category using RPC
-        console.log('[useFileDisplay] Using RPC function for category filtering:', {
+        logger.debug('useFileDisplay', 'Using RPC function for category filtering:', {
           table_name,
           record_id,
           category,
@@ -251,7 +252,7 @@ export function useFileDisplay(
       if (category && files.length > 0) {
         // Single file mode - get first file
         const firstFile = files[0];
-        console.log('[useFileDisplay] Processing category files, first file:', {
+        logger.debug('useFileDisplay', 'Processing category files, first file:', {
           id: firstFile.id,
           file_path: firstFile.file_path,
           is_public: firstFile.is_public,
@@ -265,7 +266,7 @@ export function useFileDisplay(
         let url: string | null = null;
         if (firstFile.is_public) {
           url = getPublicUrl(supabase, firstFile.file_path, true);
-          console.log('[useFileDisplay] Generated public URL:', url);
+          logger.debug('useFileDisplay', 'Generated public URL:', url);
         } else {
           const signedUrlResult = await getSignedUrl(supabase, firstFile.file_path, {
             appName: 'pace-core',
@@ -273,9 +274,9 @@ export function useFileDisplay(
             expiresIn: 3600
           });
           url = signedUrlResult?.url || null;
-          console.log('[useFileDisplay] Generated signed URL:', url ? 'URL generated' : 'URL generation failed');
+          logger.debug('useFileDisplay', 'Generated signed URL:', url ? 'URL generated' : 'URL generation failed');
         }
-        console.log('[useFileDisplay] Setting file URL:', url ? 'URL set' : 'URL is null');
+        logger.debug('useFileDisplay', 'Setting file URL:', url ? 'URL set' : 'URL is null');
         setFileUrl(url);
       } else {
         // Multiple files mode - generate URLs for all files
@@ -340,7 +341,7 @@ export function useFileDisplay(
       }
 
     } catch (err) {
-      console.error('[useFileDisplay] Error fetching files:', err);
+      logger.error('useFileDisplay', 'Error fetching files:', err);
       const error = err instanceof Error ? err : new Error('Unknown error occurred');
       setError(error);
       setFileUrl(null);

package/src/hooks/useFileReference.ts

@@ -12,6 +12,9 @@ import {
 } from '../types/file-reference';
 import { createFileReferenceService, uploadFileWithReference } from '../utils/file-reference';
 import { getPublicUrl, getSignedUrl } from '../utils/storage/helpers';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useFileReference');
 
 export function useFileReference(supabase: SupabaseClient) {
   const [isLoading, setIsLoading] = useState(false);
@@ -422,7 +425,7 @@ export function useFilesByCategory(
           urlMap.set(fileRef.id, url);
         }
       } catch (err) {
-        console.error(`Failed to load URL for file ${fileRef.id}:`, err);
+        log.error(`Failed to load URL for file ${fileRef.id}:`, err);
       }
     }
     

package/src/hooks/useFileUrl.ts

@@ -11,6 +11,9 @@ import { useState, useEffect, useCallback, useRef } from 'react';
 import { SupabaseClient } from '@supabase/supabase-js';
 import { FileReference } from '../types/file-reference';
 import { getPublicUrl, getSignedUrl } from '../utils/storage/helpers';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useFileUrl');
 
 export interface UseFileUrlOptions {
   /** Organisation ID for signed URL generation */
@@ -91,7 +94,7 @@ export function useFileUrl(
       const error = err instanceof Error ? err : new Error('Failed to generate file URL');
       setError(error);
       setUrl(null);
-      console.error('[useFileUrl] Error generating URL:', error);
+      log.error('Error generating URL:', error);
     } finally {
       setIsLoading(false);
     }

package/src/hooks/useInactivityTracker.ts

@@ -53,6 +53,7 @@
  */
 
 import { useState, useEffect, useCallback, useRef } from 'react';
+import { logger } from '../utils/core/logger';
 
 export interface UseInactivityTrackerOptions {
   /** Timeout in milliseconds before user is considered idle (default: 30 minutes) */
@@ -221,7 +222,7 @@ export function useInactivityTracker({
     try {
       localStorage.setItem(storageKey, now.toString());
     } catch (error) {
-      console.warn('[useInactivityTracker] Failed to persist activity time:', error);
+      logger.warn('useInactivityTracker', 'Failed to persist activity time:', error);
     }
 
     // Broadcast activity to other tabs
@@ -230,7 +231,7 @@ export function useInactivityTracker({
         channelRef.current.postMessage({ type: 'activity', timestamp: now });
       }
     } catch (error) {
-      console.warn('[useInactivityTracker] Failed to broadcast activity:', error);
+      logger.warn('useInactivityTracker', 'Failed to broadcast activity:', error);
     }
   }, [enabled, idleTimeoutMs, warnBeforeMs, onIdle, onWarning, onActivity, storageKey, clearTimers]);
 
@@ -261,7 +262,7 @@ export function useInactivityTracker({
         };
       }
     } catch (error) {
-      console.warn('[useInactivityTracker] Failed to set up cross-tab communication:', error);
+      logger.warn('useInactivityTracker', 'Failed to set up cross-tab communication:', error);
     }
 
     // Check for persisted activity time
@@ -290,7 +291,7 @@ export function useInactivityTracker({
         }
       }
     } catch (error) {
-      console.warn('[useInactivityTracker] Failed to check persisted activity time:', error);
+      logger.warn('useInactivityTracker', 'Failed to check persisted activity time:', error);
     }
 
     // Set up throttled activity handler

package/src/hooks/useOrganisationSecurity.test.ts

@@ -12,6 +12,7 @@ import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { useOrganisationSecurity } from './useOrganisationSecurity';
 import { useUnifiedAuth } from '../providers';
 import { useOrganisations } from './useOrganisations';
+import { Logger, LogLevel } from '../utils/core/logger';
 
 // Mock the providers
 vi.mock('../providers', () => ({
@@ -44,6 +45,7 @@ describe('useOrganisationSecurity', () => {
   const mockIsSuperAdmin = vi.mocked(isSuperAdmin);
   const mockGetPermissionMap = vi.mocked(getPermissionMap);
   const mockEmitAuditEvent = vi.mocked(emitAuditEvent);
+  let originalMode: string | undefined;
 
   const mockUser = {
     id: 'user-123',
@@ -82,6 +84,17 @@ describe('useOrganisationSecurity', () => {
   };
 
   beforeEach(() => {
+    // Ensure logger is enabled by setting MODE to development
+    originalMode = import.meta.env.MODE;
+    (import.meta.env as any).MODE = 'development';
+    
+    // Configure logger to ensure it logs in test environment
+    Logger.configure({
+      level: LogLevel.DEBUG,
+      includeTimestamp: false,
+      includeComponent: true,
+    });
+    
     // Clear all mocks but preserve the structure
     mockUseUnifiedAuth.mockClear();
     mockUseOrganisations.mockClear();
@@ -535,18 +548,18 @@ describe('useOrganisationSecurity', () => {
       mockIsSuperAdmin.mockResolvedValue(false);
       mockIsPermitted.mockRejectedValue(new Error('Permission check failed'));
 
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
       const { result } = renderHook(() => useOrganisationSecurity());
 
       const hasPermission = await result.current.hasPermission('read:users');
       expect(hasPermission).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Exception checking permission'),
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[ERROR] [useOrganisationSecurity] Exception checking permission'),
         expect.any(Error)
       );
 
-      consoleSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
     });
   });
 
@@ -611,18 +624,18 @@ describe('useOrganisationSecurity', () => {
       mockIsSuperAdmin.mockResolvedValue(false);
       mockIsPermitted.mockRejectedValue(new Error('Permission retrieval failed'));
 
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
       const { result } = renderHook(() => useOrganisationSecurity());
 
       const permissions = await result.current.getUserPermissions();
       expect(permissions).toEqual([]);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Exception getting user permissions'),
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[ERROR] [useOrganisationSecurity] Exception getting user permissions'),
         expect.any(Error)
       );
 
-      consoleSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
     });
   });
 
@@ -719,18 +732,18 @@ describe('useOrganisationSecurity', () => {
 
       mockSingle.mockRejectedValue(new Error('Validation failed'));
 
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
       const { result } = renderHook(() => useOrganisationSecurity());
 
       const isValid = await result.current.validateUserAccess('user-123', 'org-123');
       expect(isValid).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Exception validating organisation access'),
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[ERROR] [useOrganisationSecurity] Exception validating organisation access'),
         expect.any(Error)
       );
 
-      consoleSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
     });
   });
 
@@ -768,4 +781,12 @@ describe('useOrganisationSecurity', () => {
       expect(result.current.hasMinimumRole('member')).toBe(false);
     });
   });
+
+  afterEach(() => {
+    // Restore original mode
+    if (originalMode !== undefined) {
+      (import.meta.env as any).MODE = originalMode;
+    }
+    vi.clearAllMocks();
+  });
 });