@jmruthers/pace-core 0.5.135 → 0.5.136

package/src/hooks/useOrganisationSecurity.ts

@@ -14,6 +14,7 @@ import { useOrganisations } from './useOrganisations';
 // Legacy useRBAC hook removed - use new RBAC system instead
 import type { OrganisationSecurityError, SuperAdminContext } from '../types/organisation';
 import type { Permission } from '../rbac/types';
+import { logger } from '../utils/core/logger';
 
 export interface OrganisationSecurityHook {
   // Super admin context
@@ -66,7 +67,7 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
 
         setIsSuperAdmin(!error && data && data.length > 0);
       } catch (error) {
-        console.error('[useOrganisationSecurity] Error checking super admin status:', error);
+        logger.error('useOrganisationSecurity', 'Error checking super admin status:', error);
         setIsSuperAdmin(false);
       } finally {
         setIsCheckingSuperAdmin(false);
@@ -107,13 +108,13 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
         .single();
 
       if (error) {
-        console.error('[useOrganisationSecurity] Error validating organisation access:', error);
+        logger.error('useOrganisationSecurity', 'Error validating organisation access:', error);
         return false;
       }
 
       return !!data;
     } catch (error) {
-      console.error('[useOrganisationSecurity] Exception validating organisation access:', error);
+      logger.error('useOrganisationSecurity', 'Exception validating organisation access:', error);
       return false;
     }
   }, [user, session, supabase, superAdminContext.isSuperAdmin]);
@@ -177,7 +178,7 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
         permission: permission as Permission
       });
     } catch (error) {
-      console.error('[useOrganisationSecurity] Exception checking permission:', error);
+      logger.error('useOrganisationSecurity', 'Exception checking permission:', error);
       return false;
     }
   }, [selectedOrganisation, user, superAdminContext.isSuperAdmin]);
@@ -213,7 +214,7 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
         .map(([permission]) => permission);
       return [...new Set(allPermissions)]; // Remove duplicates
     } catch (error) {
-      console.error('[useOrganisationSecurity] Exception getting user permissions:', error);
+      logger.error('useOrganisationSecurity', 'Exception getting user permissions:', error);
       return [];
     }
   }, [selectedOrganisation, user, getUserRole, superAdminContext.isSuperAdmin]);
@@ -239,7 +240,7 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
         });
       }
     } catch (error) {
-      console.error('[useOrganisationSecurity] Error logging organisation access:', error);
+      logger.error('useOrganisationSecurity', 'Error logging organisation access:', error);
     }
   }, [user, selectedOrganisation]);
 
@@ -274,7 +275,7 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
 
       return await validateOrganisationAccess(orgId);
     } catch (error) {
-      console.error('[useOrganisationSecurity] Exception validating user access:', error);
+      logger.error('useOrganisationSecurity', 'Exception validating user access:', error);
       return false;
     }
   }, [supabase, superAdminContext.isSuperAdmin, user, validateOrganisationAccess]);

package/src/hooks/usePerformanceMonitor.ts

@@ -1,6 +1,9 @@
 
 import { useEffect, useRef, useCallback } from 'react';
-import { performanceBudgetMonitor, PERFORMANCE_BUDGETS } from '../utils/performanceBudgets';
+import { performanceBudgetMonitor, PERFORMANCE_BUDGETS } from '../utils/performance/performanceBudgets';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('usePerformanceMonitor');
 
 export interface PerformanceMetrics {
   renderTime: number;
@@ -54,8 +57,8 @@ export function usePerformanceMonitor(
     
     // Log slow renders in development
     if (!measurement.passed) {
-      console.warn(
-        `🐌 Performance budget exceeded in ${componentName}: ${renderTime.toFixed(2)}ms ` +
+      log.warn(
+        `Performance budget exceeded in ${componentName}: ${renderTime.toFixed(2)}ms ` +
         `(budget: ${PERFORMANCE_BUDGETS[budgetName]?.threshold}ms)`
       );
     }

package/src/hooks/usePermissionCache.ts

@@ -59,6 +59,7 @@ import { useUnifiedAuth } from '../providers/UnifiedAuthProvider';
 import { useOrganisations } from './useOrganisations';
 import { useEvents } from './useEvents';
 import { isPermittedCached } from '../rbac/api';
+import { logger } from '../utils/core/logger';
 import type { Operation, Permission, Scope, UUID } from '../rbac/types';
 
 // Cache entry interface
@@ -213,12 +214,15 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
   ): Promise<boolean> => {
     // Validate parameters
     if (!operation || !pageId) {
-      console.warn('[PermissionCache] Invalid parameters: operation and pageId are required');
+      logger.warn('PermissionCache', 'Invalid parameters: operation and pageId are required', { operation, pageId });
       return false;
     }
 
     if (!user?.id || !scope.organisationId) {
-      console.warn('[PermissionCache] User or organisation context not available - permission check failed');
+      logger.warn('PermissionCache', 'User or organisation context not available - permission check failed', { 
+        hasUserId: !!user?.id, 
+        hasOrganisationId: !!scope.organisationId 
+      });
       return false;
     }
 
@@ -278,7 +282,7 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
         logPermissionCheck(operation, pageId, result, false, responseTime);
         return result;
       } catch (error) {
-        console.error(`[PermissionCache] Error checking permission ${operation}:${pageId}:`, error);
+        logger.error('PermissionCache', `Error checking permission ${operation}:${pageId}`, { operation, pageId, error });
         return false;
       } finally {
         // Remove the promise from cache after completion
@@ -299,12 +303,15 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
   ): Promise<PermissionResult[]> => {
     // Validate parameters
     if (!permissions || !Array.isArray(permissions) || permissions.length === 0) {
-      console.warn('[PermissionCache] Invalid permissions array');
+      logger.warn('PermissionCache', 'Invalid permissions array', { permissions });
       return [];
     }
 
     if (!user?.id || !scope.organisationId) {
-      console.warn('[PermissionCache] User or organisation context not available - permission checks failed');
+      logger.warn('PermissionCache', 'User or organisation context not available - permission checks failed', {
+        hasUserId: !!user?.id,
+        hasOrganisationId: !!scope.organisationId
+      });
       return permissions.map(([operation, pageId]) => ({
         operation,
         pageId,
@@ -388,7 +395,7 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
           
           stats.current.cacheMisses++;
         } catch (error) {
-          console.error(`[PermissionCache] Error checking permission ${operation}:${pageId}:`, error);
+          logger.error('PermissionCache', `Error checking permission ${operation}:${pageId}`, { operation, pageId, error });
           results[originalIndex] = {
             operation,
             pageId,

package/src/hooks/useSecureDataAccess.test.ts

@@ -12,7 +12,7 @@ import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { useSecureDataAccess } from './useSecureDataAccess';
 import { useUnifiedAuth } from '../providers';
 import { useOrganisations } from './useOrganisations';
-import { setOrganisationContext } from '../utils/organisationContext';
+import { setOrganisationContext } from '../utils/context/organisationContext';
 import { createMockSupabaseClient, createMockQueryBuilderWithData } from '../__tests__/helpers/supabaseMock';
 
 // Mock the providers
@@ -25,7 +25,7 @@ vi.mock('./useOrganisations', () => ({
 }));
 
 // Mock the organisation context utility
-vi.mock('../utils/organisationContext', () => ({
+vi.mock('../utils/context/organisationContext', () => ({
   setOrganisationContext: vi.fn()
 }));
 

package/src/hooks/useSecureDataAccess.ts

@@ -55,7 +55,8 @@ import { useCallback, useState, useContext } from 'react';
 import { useUnifiedAuth } from '../providers';
 import { useOrganisations } from './useOrganisations';
 import { EventServiceContext } from '../providers/services/EventServiceProvider';
-import { setOrganisationContext } from '../utils/organisationContext';
+import { setOrganisationContext } from '../utils/context/organisationContext';
+import { logger } from '../utils/core/logger';
 import type { Permission } from '../rbac/types';
 import type { OrganisationSecurityError } from '../types/organisation';
 
@@ -261,7 +262,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
     const { data, error } = await query;
     
     if (error) {
-      console.error('[useSecureDataAccess] Query failed:', error);
+      logger.error('useSecureDataAccess', 'Query failed', { table, columns, filters, error });
       // NEW: Phase 1 - Record failed data access attempt
       recordDataAccess(table, 'read', false, `SELECT ${columns} FROM ${table}`, filters);
       throw error;
@@ -296,7 +297,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
       .single();
 
     if (error) {
-      console.error('[useSecureDataAccess] Insert failed:', error);
+      logger.error('useSecureDataAccess', 'Insert failed', { table, data: secureData, error });
       throw error;
     }
 
@@ -346,7 +347,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
     const { data: updateData, error } = await query.select();
 
     if (error) {
-      console.error('[useSecureDataAccess] Update failed:', error);
+      logger.error('useSecureDataAccess', 'Update failed', { table, data: secureData, filters, error });
       throw error;
     }
 
@@ -402,7 +403,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
     const { error } = await query;
 
     if (error) {
-      console.error('[useSecureDataAccess] Delete failed:', error);
+      logger.error('useSecureDataAccess', 'Delete failed', { table, filters, error });
       throw error;
     }
   }, [validateContext, getCurrentOrganisationId, setOrganisationContextInSession, supabase]);
@@ -499,7 +500,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
     const { data, error } = await supabase!.rpc(functionName, secureParams);
 
     if (error) {
-      console.error('[useSecureDataAccess] RPC failed:', error);
+      logger.error('useSecureDataAccess', 'RPC failed', { functionName, params: secureParams, error });
       throw error;
     }
 
@@ -553,7 +554,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
     try {
       validateContext();
     } catch (error) {
-      console.error(`[useSecureDataAccess] Organisation context validation failed:`, error);
+      logger.error('useSecureDataAccess', 'Organisation context validation failed', { table, operation, error });
       return false;
     }
     
@@ -587,7 +588,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
     });
     
     if (isStrictMode && !allowed) {
-      console.error(`[useSecureDataAccess] STRICT MODE VIOLATION: User attempted data access without permission`, {
+      logger.error('useSecureDataAccess', 'STRICT MODE VIOLATION: User attempted data access without permission', {
         table,
         operation,
         userId: user.id,

package/src/hooks/useSessionRestoration.ts

@@ -12,6 +12,9 @@
 import { useContext, useMemo, useEffect, useState } from 'react';
 import { AuthServiceContext } from '../providers/services/AuthServiceProvider';
 import type { SessionRestorationState } from '../types/auth';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useSessionRestoration');
 
 const SESSION_RESTORATION_TIMEOUT_MS = 5000;
 
@@ -38,7 +41,7 @@ export function useSessionRestoration(): UseSessionRestorationResult {
     if (sessionRestoration.isRestoring && !sessionRestoration.restorationComplete && !sessionRestoration.restorationError) {
       setHasTimedOut(false);
       timeoutHandle = setTimeout(() => {
-        console.warn('[useSessionRestoration] Session restoration timed out');
+        log.warn('Session restoration timed out');
         setHasTimedOut(true);
       }, SESSION_RESTORATION_TIMEOUT_MS);
     } else {

package/src/hooks/useStorage.ts

@@ -17,6 +17,9 @@ import {
   listFiles,
   archiveFile
 } from '../utils/storage';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useStorage');
 
 export interface UseStorageOptions {
   supabase: SupabaseClient;
@@ -117,7 +120,7 @@ export function useStorage({ supabase, appName, orgId }: UseStorageOptions): Use
       });
       return result?.url || null;
     } catch (error) {
-      console.error('Failed to get signed URL:', error);
+      log.error('Failed to get signed URL:', error);
       return null;
     }
   }, [supabase, appName, orgId]);

package/src/index.ts

@@ -21,7 +21,7 @@ export { UnifiedAuthProvider, useUnifiedAuth } from './providers/UnifiedAuthProv
 export type { UnifiedAuthProviderProps, UnifiedAuthContextType, UserEventAccess } from './providers/UnifiedAuthProvider';
 
 // Session tracking utility (for manual use if needed)
-export { useSessionTracking } from './utils/sessionTracking';
+export { useSessionTracking } from './utils/context/sessionTracking';
 
 // Provider components (using service architecture)
 export { EventProvider } from './providers/EventProvider';
@@ -155,6 +155,15 @@ export {
   type ExportColumn
 } from './components/DataTable/utils/exportUtils';
 
+// Export DataTable aggregation utilities
+export {
+  sum,
+  average,
+  count,
+  min,
+  max
+} from './components/DataTable/utils/aggregationUtils';
+
 // FORM COMPONENTS
 export { Form } from './components/Form/Form';
 export { LoginForm } from './components/LoginForm/LoginForm';
@@ -183,7 +192,8 @@ export type { ProtectedRouteProps } from './components/ProtectedRoute/ProtectedR
 // UTILITY COMPONENTS
 export { ErrorBoundary } from './components/ErrorBoundary/ErrorBoundary';
 export { LoadingSpinner } from './components/LoadingSpinner/LoadingSpinner';
-export { SessionRestorationLoader } from './components/SessionRestorationLoader';
+export { SessionRestorationLoader } from './components/SessionRestorationLoader/SessionRestorationLoader';
+export type { SessionRestorationLoaderProps } from './components/SessionRestorationLoader/SessionRestorationLoader';
 
 // EVENT MANAGEMENT
 export { EventSelector } from './components/EventSelector/EventSelector';
@@ -192,20 +202,19 @@ export { EventSelector } from './components/EventSelector/EventSelector';
 export { OrganisationSelector } from './components/OrganisationSelector/OrganisationSelector';
 export { useOrganisationPermissions } from './hooks/useOrganisationPermissions';
 export { useOrganisationSecurity } from './hooks/useOrganisationSecurity';
-export { createSecureDataAccess } from './utils/secureDataAccess';
+export { createSecureDataAccess } from './utils/security/secureDataAccess';
 
 // TYPES
 export type { UserProfile } from './types/organisation';
 
 // AUTHENTICATION FORMS
-export { PasswordResetForm } from './components/PasswordReset/PasswordResetForm';
 export { PasswordChangeForm } from './components/PasswordReset/PasswordChangeForm';
 
 // UTILS & HOOKS
 export { useAppConfig } from './hooks/useAppConfig';
 export { useEventTheme } from './hooks/useEventTheme';
-export { cn } from './utils/cn';
-export { setAppConfig, getAppConfig, getCurrentAppName, getCurrentAppId } from './utils/appConfig';
+export { cn } from './utils/core/cn';
+export { setAppConfig, getAppConfig, getCurrentAppName, getCurrentAppId } from './utils/app/appConfig';
 
 // FORMATTING UTILITIES
 export { 
@@ -215,7 +224,7 @@ export {
   formatPercent,
   formatCompactNumber,
   formatFileSize
-} from './utils/formatting';
+} from './utils/formatting/formatting';
 
 // STORAGE UTILITIES
 export { FileUpload } from './components/FileUpload';

package/src/providers/services/AuthServiceProvider.tsx

@@ -12,6 +12,7 @@ import React, { createContext, useContext, useMemo, useEffect, useState } from '
 import { type SupabaseClient } from '@supabase/supabase-js';
 import { AuthService } from '../../services/AuthService';
 import type { SessionRestorationState } from '../../types/auth';
+import { logger } from '../../utils/core/logger';
 
 // Context type
 export interface AuthServiceContextType {
@@ -46,7 +47,7 @@ export function AuthServiceProvider({ children, supabaseClient, appName }: AuthS
 
       const isDev = typeof import.meta !== 'undefined' && (import.meta.env.DEV || import.meta.env.MODE === 'development');
       if (isDev) {
-        console.debug('[AuthServiceProvider] Session restoration state updated', restorationState);
+        logger.debug('AuthServiceProvider', 'Session restoration state updated', restorationState);
       }
     });
 
@@ -58,7 +59,7 @@ export function AuthServiceProvider({ children, supabaseClient, appName }: AuthS
   // Initialize service on mount
   useEffect(() => {
     authService.initialize().catch(error => {
-      console.error('[AuthServiceProvider] Failed to initialize auth service:', error);
+      logger.error('AuthServiceProvider', 'Failed to initialize auth service:', error);
     });
 
     // Cleanup on unmount

package/src/providers/services/EventServiceProvider.tsx

@@ -11,6 +11,7 @@
 import React, { createContext, useContext, useMemo, useEffect, useRef } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { EventService } from '../../services/EventService';
+import { logger } from '../../utils/core/logger';
 
 // Context type
 export interface EventServiceContextType {
@@ -63,7 +64,7 @@ export function EventServiceProvider({
       // Re-initialize service when dependencies change
       await eventService.initialize().catch(error => {
         if (isMounted) {
-          console.error('[EventServiceProvider] Failed to initialize event service:', error);
+          logger.error('EventServiceProvider', 'Failed to initialize event service:', error);
         }
       });
     };

package/src/providers/services/InactivityServiceProvider.tsx

@@ -11,6 +11,7 @@
 import React, { createContext, useContext, useMemo, useEffect, useRef } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { InactivityService } from '../../services/InactivityService';
+import { logger } from '../../utils/core/logger';
 
 // Context type
 export interface InactivityServiceContextType {
@@ -56,7 +57,7 @@ export function InactivityServiceProvider({
     
     inactivityService.initialize().catch(error => {
       if (isMounted) {
-        console.error('[InactivityServiceProvider] Failed to initialize inactivity service:', error);
+        logger.error('InactivityServiceProvider', 'Failed to initialize inactivity service:', error);
       }
     });
 

package/src/providers/services/OrganisationServiceProvider.tsx

@@ -11,6 +11,7 @@
 import React, { createContext, useContext, useMemo, useEffect, useRef } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { OrganisationService } from '../../services/OrganisationService';
+import { logger } from '../../utils/core/logger';
 
 // Context type
 export interface OrganisationServiceContextType {
@@ -50,7 +51,7 @@ export function OrganisationServiceProvider({
     
     organisationService.initialize().catch(error => {
       if (isMounted) {
-        console.error('[OrganisationServiceProvider] Failed to initialize organisation service:', error);
+        logger.error('OrganisationServiceProvider', 'Failed to initialize organisation service:', error);
       }
     });
 

package/src/providers/services/UnifiedAuthProvider.tsx

@@ -23,6 +23,7 @@ import type { Organisation, OrganisationMembership } from '../../types/organisat
 import type { Event } from '../../types/unified';
 import type { AuthError } from '@supabase/supabase-js';
 import type { SessionRestorationState } from '../../types/auth';
+import { logger } from '../../utils/core/logger';
 
 // Re-export UserEventAccess type
 export interface UserEventAccess {
@@ -116,8 +117,8 @@ const UnifiedAuthContext = createContext<UnifiedAuthContextType | undefined>(und
 export const useUnifiedAuth = () => {
   const context = useContext(UnifiedAuthContext);
   if (!context) {
-    // Provide a helpful console error in addition to throwing for testability and DX
-    console.error('useUnifiedAuth must be used within a UnifiedAuthProvider');
+    // Provide a helpful error log in addition to throwing for testability and DX
+    logger.error('useUnifiedAuth', 'useUnifiedAuth must be used within a UnifiedAuthProvider');
     throw new Error('useUnifiedAuth must be used within a UnifiedAuthProvider');
   }
   return context;
@@ -265,7 +266,7 @@ function UnifiedAuthContextProvider({
         prevState.isAuthenticated !== currentState.isAuthenticated ||
         prevState.userEmail !== currentState.userEmail ||
         prevState.totalLoading !== currentState.totalLoading) {
-      console.log('[UnifiedAuthContext] Auth state changed:', {
+      logger.debug('UnifiedAuthContext', 'Auth state changed:', {
         isAuthenticated: isAuth,
         user: currentUser?.email,
         session: currentSession ? 'exists' : 'null',

package/src/providers/services/__tests__/AuthServiceProvider.integration.test.tsx

@@ -13,6 +13,7 @@ import { render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
 import { AuthServiceProvider, useAuthService } from '../AuthServiceProvider';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
+import { Logger, LogLevel } from '../../../utils/core/logger';
 
 // Mock Supabase client
 const createMockSupabaseClient = (): SupabaseClient => ({
@@ -76,12 +77,28 @@ function TestComponent() {
 
 describe('AuthServiceProvider Integration', () => {
   let mockSupabase: SupabaseClient;
+  let originalMode: string | undefined;
 
   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,
+    });
+    
     mockSupabase = createMockSupabaseClient();
   });
 
   afterEach(() => {
+    // Restore original mode
+    if (originalMode !== undefined) {
+      (import.meta.env as any).MODE = originalMode;
+    }
     vi.clearAllMocks();
   });
 
@@ -201,8 +218,11 @@ describe('AuthServiceProvider Integration', () => {
 
       // Error is logged during initialization
       await waitFor(() => {
-        expect(consoleSpy).toHaveBeenCalled();
-      }, { interval: 10 });
+        expect(consoleSpy).toHaveBeenCalledWith(
+          expect.stringContaining('[ERROR] [AuthServiceProvider] Failed to initialize auth service'),
+          expect.any(Error)
+        );
+      }, { interval: 10, timeout: 2000 });
 
       consoleSpy.mockRestore();
     });

package/src/providers/services/__tests__/UnifiedAuthProvider.integration.test.tsx

@@ -12,6 +12,7 @@ import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { render, screen, waitFor } from '@testing-library/react';
 import { UnifiedAuthProvider, useUnifiedAuth } from '../UnifiedAuthProvider';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
+import { Logger, LogLevel } from '../../../utils/core/logger';
 
 // Mock Supabase client
 const createMockSupabaseClient = (): SupabaseClient => ({
@@ -72,12 +73,28 @@ function TestComponent() {
 
 describe('UnifiedAuthProvider Integration', () => {
   let mockSupabase: SupabaseClient;
+  let originalMode: string | undefined;
 
   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,
+    });
+    
     mockSupabase = createMockSupabaseClient();
   });
 
   afterEach(() => {
+    // Restore original mode
+    if (originalMode !== undefined) {
+      (import.meta.env as any).MODE = originalMode;
+    }
     vi.clearAllMocks();
   });
 
@@ -162,8 +179,13 @@ describe('UnifiedAuthProvider Integration', () => {
       );
 
       await waitFor(() => {
-        expect(consoleSpy).toHaveBeenCalled();
-      });
+        // Check that logger.error was called (which uses console.error internally)
+        // The error could be from any of the service providers (Auth, Organisation, Event, Inactivity)
+        expect(consoleSpy).toHaveBeenCalledWith(
+          expect.stringMatching(/\[ERROR\] \[(AuthServiceProvider|OrganisationServiceProvider|EventServiceProvider|InactivityServiceProvider)\]/),
+          expect.any(Error)
+        );
+      }, { timeout: 2000 });
 
       consoleSpy.mockRestore();
     });

package/src/rbac/__tests__/cache-invalidation.test.ts

@@ -20,6 +20,22 @@ import {
 import { rbacCache, CACHE_PATTERNS } from '../cache';
 import { emitAuditEvent } from '../audit';
 
+// Mock the Logger module
+vi.mock('../../utils/core/logger', () => {
+  const mockLoggerInstance = {
+    warn: vi.fn(),
+    debug: vi.fn(),
+    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 the cache module
 vi.mock('../cache', () => ({
   rbacCache: {
@@ -365,20 +381,18 @@ describe('RBAC Cache Invalidation', () => {
 
   describe('Error Handling', () => {
     it('handles audit event errors gracefully', async () => {
+      vi.clearAllMocks();
       vi.mocked(emitAuditEvent).mockRejectedValue(new Error('Audit error'));
       
-      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-      
       manager.invalidateUser('user-123' as const, 'test');
       
       await vi.waitFor(() => {
-        expect(consoleWarnSpy).toHaveBeenCalledWith(
-          expect.stringContaining('[RBAC Cache] Failed to log cache invalidation audit event'),
+        const logger = getMockLogger();
+        expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(
+          'Failed to log cache invalidation audit event:',
           expect.any(Error)
         );
       });
-      
-      consoleWarnSpy.mockRestore();
     });
   });
 });

package/src/rbac/api.ts

@@ -26,6 +26,9 @@ import { createAuditManager, setGlobalAuditManager } from './audit';
 import { rbacCache, RBACCache, CACHE_PATTERNS } from './cache';
 import { createRBACConfig, RBACConfig, getRBACLogger } from './config';
 import { SecurityContext } from './security';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('RBACAPI');
 
 // Global engine instance
 let globalEngine: RBACEngine | null = null;
@@ -292,7 +295,7 @@ export async function isSuperAdmin(userId: UUID): Promise<boolean> {
 export async function getAppConfig(appId: UUID): Promise<{ requires_event: boolean } | null> {
   // This function requires a Supabase client to be provided
   // Callers should pass the client as a parameter
-  console.warn('[RBAC] getAppConfig called without Supabase client - returning null');
+  log.warn('getAppConfig called without Supabase client - returning null');
   return null;
 }
 
@@ -311,7 +314,7 @@ export async function getAppConfigWithClient(client: SupabaseClient, appId: UUID
 
     return { requires_event: data.requires_event };
   } catch (err) {
-    console.error('[RBAC] Error fetching app config:', err);
+    log.error('Error fetching app config:', err);
     return null;
   }
 }