@jmruthers/pace-core 0.5.134 → 0.5.136

package/src/utils/__tests__/logger.unit.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { Logger, LogLevel, logger, createLogger, type LoggerConfig } from '../logger';
+import { Logger, LogLevel, logger, createLogger, type LoggerConfig } from '../core/logger';
 
 describe('Logger Utility', () => {
   let consoleDebugSpy: ReturnType<typeof vi.spyOn>;

package/src/utils/__tests__/organisationContext.unit.test.ts

@@ -5,7 +5,7 @@ import {
   clearOrganisationContext,
   getOrganisationContext,
   isOrganisationContextAvailable
-} from '../organisationContext';
+} from '../context/organisationContext';
 
 describe('organisationContext', () => {
   let mockSupabase: SupabaseClient;

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

@@ -12,7 +12,7 @@ import {
   createPerformanceBenchmark, 
   measureRenderPerformance,
   type PerformanceMetrics 
-} from '../performanceBenchmark';
+} from '../performance/performanceBenchmark';
 
 describe('Performance Benchmark', () => {
   beforeEach(() => {

package/src/utils/__tests__/performanceBudgets.unit.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { performanceBudgetMonitor, PERFORMANCE_BUDGETS } from '../performanceBudgets';
+import { performanceBudgetMonitor, PERFORMANCE_BUDGETS } from '../performance/performanceBudgets';
 
 describe('performanceBudgets', () => {
   let consoleSpy: {

package/src/utils/__tests__/permissionTypes.unit.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { PermissionType, parsePermission } from '../permissionTypes';
+import { PermissionType, parsePermission } from '../permissions/permissionTypes';
 
 describe('permissionTypes', () => {
   describe('PermissionType enum', () => {

package/src/utils/__tests__/permissionUtils.unit.test.ts

@@ -4,7 +4,7 @@ import {
   hasPermission,
   hasAnyPermission,
   hasAllPermissions
-} from '../permissionUtils';
+} from '../permissions/permissionUtils';
 
 describe('permissionUtils', () => {
   describe('transformPermissionMapToBoolean', () => {

package/src/utils/__tests__/sanitization.unit.test.ts

@@ -16,7 +16,7 @@ import {
   sanitizeFormData,
   generateCSPHeader,
   RateLimiter
-} from '../sanitization';
+} from '../validation/sanitization';
 import { z } from 'zod';
 
 describe('Sanitization Utilities', () => {

package/src/utils/__tests__/schemaUtils.unit.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { z } from 'zod';
-import { pickSchema, combineSchemas } from '../schemaUtils';
+import { pickSchema, combineSchemas } from '../validation/schema';
 
 describe('schemaUtils', () => {
   describe('pickSchema', () => {

package/src/utils/__tests__/secureDataAccess.unit.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createSecureDataAccess } from '../secureDataAccess';
+import { createSecureDataAccess } from '../security/secureDataAccess';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import { testDataGenerators } from '../../__tests__/helpers/test-utils';
 

package/src/utils/__tests__/secureErrors.unit.test.ts

@@ -14,9 +14,23 @@ import {
   sanitizeError, 
   generateRequestId, 
   logSecurityEvent 
-} from '../secureErrors';
+} from '../security/secureErrors';
 import { AuthErrorCode } from '../../types/unified';
 
+// Mock the Logger module
+vi.mock('../core/logger', () => {
+  const mockLoggerInstance = {
+    warn: vi.fn(),
+  };
+  return {
+    createLogger: vi.fn(() => mockLoggerInstance),
+  };
+});
+
+// Get the mock instance after mock is set up
+import { createLogger } from '../core/logger';
+const getMockLogger = () => createLogger('test');
+
 describe('Secure Errors', () => {
     describe('SecureError', () => {
     it('should create a SecureError with all properties', () => {
@@ -288,50 +302,54 @@ describe('Secure Errors', () => {
 
   describe('logSecurityEvent', () => {
     it('should log security events', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
+      vi.clearAllMocks();
 
       logSecurityEvent('Test security event');
 
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Test security event',
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(
+        'Security event: Test security event',
         undefined
       );
     });
 
     it('should log security events with details', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
+      vi.clearAllMocks();
       const details = { userId: 'user-123', action: 'login_attempt' };
 
       logSecurityEvent('Test security event', details);
 
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Test security event',
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(
+        'Security event: Test security event',
         details
       );
     });
 
     it('should handle multiple security events', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
+      vi.clearAllMocks();
 
       logSecurityEvent('Event 1');
       logSecurityEvent('Event 2', { detail: 'test' });
 
-      expect(consoleSpy).toHaveBeenCalledTimes(2);
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledTimes(2);
     });
 
     it('should handle null and undefined details', () => {
-      const consoleSpy = vi.spyOn(console, 'warn');
+      vi.clearAllMocks();
 
       logSecurityEvent('Event with null details', null);
       logSecurityEvent('Event with undefined details', undefined);
 
-      expect(consoleSpy).toHaveBeenCalledTimes(2);
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Event with null details',
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledTimes(2);
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(
+        'Security event: Event with null details',
         null
       );
-      expect(consoleSpy).toHaveBeenCalledWith(
-        '[SECURITY] Event with undefined details',
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(
+        'Security event: Event with undefined details',
         undefined
       );
     });

package/src/utils/__tests__/secureStorage.unit.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { secureStorage } from '../secureStorage';
+import { secureStorage } from '../security/secureStorage';
 
 // Mock localStorage
 const mockLocalStorage = {

package/src/utils/__tests__/security.unit.test.ts

@@ -8,32 +8,49 @@ import {
   validateSecurityHeaders,
   generateDeviceFingerprint,
   validateDeviceFingerprint
-} from '../security';
+} from '../security/security';
+
+// Mock the Logger module
+vi.mock('../core/logger', () => {
+  const mockLoggerInstance = {
+    warn: vi.fn(),
+  };
+  return {
+    createLogger: vi.fn(() => mockLoggerInstance),
+  };
+});
+
+// Get the mock instance after mock is set up
+import { createLogger } from '../core/logger';
+const getMockLogger = () => createLogger('test');
 
 describe('Security Utils', () => {
   beforeEach(() => {
     vi.restoreAllMocks();
   });
 
-  it('logSecurityEvent logs to console.warn', () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+  it('logSecurityEvent logs to Logger', () => {
+    vi.clearAllMocks();
     const event = { type: 'test', timestamp: new Date(), details: { foo: 1 } };
     logSecurityEvent(event);
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'test', details: { foo: 1 }, timestamp: event.timestamp.toISOString() }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'test', details: { foo: 1 }, timestamp: event.timestamp.toISOString() }));
   });
 
   it('validateUserSession returns false and logs for invalid userId', async () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.clearAllMocks();
     const result = await validateUserSession('', 'sometoken');
     expect(result).toBe(false);
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'invalid_session_validation' }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'invalid_session_validation' }));
   });
 
   it('validateUserSession returns false and logs for short sessionToken', async () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.clearAllMocks();
     const result = await validateUserSession('user1', 'short');
     expect(result).toBe(false);
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'suspicious_session_token' }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'suspicious_session_token' }));
   });
 
   it('validateUserSession returns true for valid input', async () => {
@@ -42,19 +59,21 @@ describe('Security Utils', () => {
   });
 
   it('createSecureSession returns a session ID and logs', async () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.clearAllMocks();
     const fakeClient = {} as any;
     const sessionId = await createSecureSession(fakeClient, { userId: 'user1', deviceFingerprint: 'abc' });
     expect(typeof sessionId).toBe('string');
     expect(sessionId).toMatch(/^sess_/);
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'session_created' }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'session_created' }));
   });
 
   it('invalidateSession logs and resolves', async () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.clearAllMocks();
     const fakeClient = {} as any;
     await expect(invalidateSession(fakeClient, 'sess_123')).resolves.toBeUndefined();
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'session_invalidated' }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'session_invalidated' }));
   });
 
   it('getSecurityHeaders returns required headers', () => {
@@ -72,10 +91,11 @@ describe('Security Utils', () => {
   });
 
   it('validateSecurityHeaders returns false and logs for missing headers', () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.clearAllMocks();
     const headers = { 'X-Content-Type-Options': 'nosniff' };
     expect(validateSecurityHeaders(headers)).toBe(false);
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'missing_security_headers' }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'missing_security_headers' }));
   });
 
   it('generateDeviceFingerprint returns a string', () => {
@@ -114,14 +134,16 @@ describe('Security Utils', () => {
   });
 
   it('validateDeviceFingerprint returns false and logs for invalid input', () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.clearAllMocks();
     expect(validateDeviceFingerprint('', 'abc')).toBe(false);
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'invalid_device_fingerprint' }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'invalid_device_fingerprint' }));
   });
 
   it('validateDeviceFingerprint returns false and logs for mismatch', () => {
-    const spy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    vi.clearAllMocks();
     expect(validateDeviceFingerprint('abc', 'def')).toBe(false);
-    expect(spy).toHaveBeenCalledWith('[SECURITY EVENT]', expect.objectContaining({ type: 'device_fingerprint_mismatch' }));
+    const logger = getMockLogger();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('Security event:', expect.objectContaining({ type: 'device_fingerprint_mismatch' }));
   });
 }); 

package/src/utils/__tests__/securityMonitor.unit.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { securityMonitor } from '../securityMonitor';
+import { securityMonitor } from '../security/securityMonitor';
 
 describe('securityMonitor', () => {
   beforeEach(() => {

package/src/utils/__tests__/sessionTracking.unit.test.ts

@@ -1,22 +1,27 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import type { SupabaseClient } from '@supabase/supabase-js';
 
-describe('sessionTracking', () => {
-  let consoleSpy: {
-    log: ReturnType<typeof vi.spyOn>;
-    warn: ReturnType<typeof vi.spyOn>;
-    error: ReturnType<typeof vi.spyOn>;
+// Mock the Logger module
+vi.mock('../core/logger', () => {
+  const mockLoggerInstance = {
+    warn: vi.fn(),
+    error: vi.fn(),
+  };
+  return {
+    createLogger: vi.fn(() => mockLoggerInstance),
   };
+});
+
+// Get the mock instance after mock is set up
+import { createLogger } from '../core/logger';
+const getMockLogger = () => createLogger('test');
+
+describe('sessionTracking', () => {
   let mockSupabase: SupabaseClient;
   let trackingFunctions: any;
 
   beforeEach(() => {
-    // Mock console methods before each test
-    consoleSpy = {
-      log: vi.spyOn(console, 'log').mockImplementation(() => {}),
-      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
-      error: vi.spyOn(console, 'error').mockImplementation(() => {})
-    };
+    vi.clearAllMocks();
     
     // Create a mock Supabase client
     mockSupabase = {
@@ -37,7 +42,7 @@ describe('sessionTracking', () => {
       mockSupabase.rpc = mockRpc;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackEventSwitch('event-456');
@@ -50,7 +55,7 @@ describe('sessionTracking', () => {
         p_ip_address: undefined,
         p_user_agent: undefined
       });
-      expect(consoleSpy.log).toHaveBeenCalledWith('Event switch session tracked successfully');
+      // Success messages were removed - no logging needed for successful operations
     });
 
     it('should handle no authenticated user', async () => {
@@ -58,12 +63,13 @@ describe('sessionTracking', () => {
       mockSupabase.auth.getUser = mockGetUser;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackEventSwitch('event-456');
 
-      expect(consoleSpy.warn).toHaveBeenCalledWith('No authenticated user found for session tracking');
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('No authenticated user found for session tracking');
     });
 
     it('should handle tracking error', async () => {
@@ -75,12 +81,13 @@ describe('sessionTracking', () => {
       mockSupabase.rpc = mockRpc;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackEventSwitch('event-456');
 
-      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track event switch session:', { message: 'Database error' });
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith('Failed to track event switch session:', { message: 'Database error' });
     });
 
     it('should handle unexpected errors', async () => {
@@ -88,12 +95,13 @@ describe('sessionTracking', () => {
       mockSupabase.auth.getUser = mockGetUser;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackEventSwitch('event-456');
 
-      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track event switch:', expect.any(Error));
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith('Failed to track event switch:', expect.any(Error));
     });
   });
 
@@ -107,7 +115,7 @@ describe('sessionTracking', () => {
       mockSupabase.rpc = mockRpc;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackSessionExpired();
@@ -120,7 +128,7 @@ describe('sessionTracking', () => {
         p_ip_address: undefined,
         p_user_agent: undefined
       });
-      expect(consoleSpy.log).toHaveBeenCalledWith('Session expiration tracked successfully');
+      // Success messages were removed - no logging needed for successful operations
     });
 
     it('should handle no authenticated user', async () => {
@@ -128,12 +136,13 @@ describe('sessionTracking', () => {
       mockSupabase.auth.getUser = mockGetUser;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackSessionExpired();
 
-      expect(consoleSpy.warn).toHaveBeenCalledWith('No authenticated user found for session tracking');
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledWith('No authenticated user found for session tracking');
     });
 
     it('should handle tracking error', async () => {
@@ -145,12 +154,13 @@ describe('sessionTracking', () => {
       mockSupabase.rpc = mockRpc;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackSessionExpired();
 
-      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track session expiration:', { message: 'Database error' });
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith('Failed to track session expiration:', { message: 'Database error' });
     });
 
     it('should handle unexpected errors', async () => {
@@ -158,19 +168,20 @@ describe('sessionTracking', () => {
       mockSupabase.auth.getUser = mockGetUser;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       trackingFunctions = useSessionTracking(mockSupabase, 'test-app');
 
       await trackingFunctions.trackSessionExpired();
 
-      expect(consoleSpy.error).toHaveBeenCalledWith('Failed to track session expiration:', expect.any(Error));
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.error)).toHaveBeenCalledWith('Failed to track session expiration:', expect.any(Error));
     });
   });
 
   describe('useSessionTracking without app name', () => {
     it('should work without app name parameter', async () => {
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       const trackingWithoutApp = useSessionTracking(mockSupabase);
       
       expect(trackingWithoutApp).toHaveProperty('trackEventSwitch');
@@ -189,7 +200,7 @@ describe('sessionTracking', () => {
       mockSupabase.rpc = mockRpc;
 
       vi.resetModules();
-      const { useSessionTracking } = await import('../sessionTracking');
+      const { useSessionTracking } = await import('../context/sessionTracking');
       const trackingWithoutApp = useSessionTracking(mockSupabase);
 
       await trackingWithoutApp.trackEventSwitch('event-123');

package/src/utils/__tests__/validationUtils.unit.test.ts

@@ -9,10 +9,24 @@ import {
   nameSchema,
   phoneSchema,
   urlSchema
-} from '../validationUtils';
+} from '../validation/validationUtils';
+
+// Mock the Logger module
+vi.mock('../core/logger', () => {
+  const mockLoggerInstance = {
+    warn: vi.fn(),
+  };
+  return {
+    createLogger: vi.fn(() => mockLoggerInstance),
+  };
+});
+
+// Get the mock instance after mock is set up
+import { createLogger } from '../core/logger';
+const getMockLogger = () => createLogger('test');
 
 // Mock sanitization functions
-vi.mock('../sanitization', () => ({
+vi.mock('../validation/sanitization', () => ({
   sanitizeUserInput: vi.fn((input: string) => `sanitized_${input}`),
   sanitizeFormData: vi.fn((data: unknown, schema: z.ZodSchema, rules?: Record<string, any>) => {
     // Try to parse with the schema to determine success
@@ -80,16 +94,15 @@ describe('validationUtils', () => {
 
   describe('sanitizeUserInput_deprecated', () => {
     it('should call sanitizeUserInput and log deprecation warning', () => {
-      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      vi.clearAllMocks();
       
       const result = sanitizeUserInput_deprecated('test input');
 
       expect(result).toBe('sanitized_test input');
-      expect(consoleSpy).toHaveBeenCalledWith(
+      const logger = getMockLogger();
+      expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(
         'sanitizeUserInput is deprecated. Use sanitizeUserInput from lib/sanitization instead.'
       );
-
-      consoleSpy.mockRestore();
     });
   });