@jmruthers/pace-core 0.6.4 → 0.6.6

package/src/services/InactivityService.ts

@@ -205,6 +205,14 @@ export class InactivityService extends BaseService implements IInactivityService
       logger.error('InactivityService', 'Error during idle logout:', error);
     }
     
+    // Clear sessionStorage on logout
+    try {
+      sessionStorage.clear();
+    } catch (storageError) {
+      // Ignore storage errors (e.g., in private browsing mode)
+      logger.warn('InactivityService', 'Failed to clear sessionStorage', { error: storageError });
+    }
+    
     // Call app callback for navigation/redirect
     this.onIdleLogout?.('inactivity');
     this.notify();
@@ -231,6 +239,14 @@ export class InactivityService extends BaseService implements IInactivityService
       logger.error('InactivityService', 'Error during manual sign out:', error);
     }
     
+    // Clear sessionStorage on logout
+    try {
+      sessionStorage.clear();
+    } catch (storageError) {
+      // Ignore storage errors (e.g., in private browsing mode)
+      logger.warn('InactivityService', 'Failed to clear sessionStorage', { error: storageError });
+    }
+    
     // Call app callback for navigation/redirect
     this.onIdleLogout?.('inactivity');
     this.notify();
@@ -291,10 +307,10 @@ export class InactivityService extends BaseService implements IInactivityService
   private setupEventHandlers(): void {
     if (typeof window === 'undefined') return;
 
-    let idleTimer: NodeJS.Timeout | null = null;
     let warningTimer: NodeJS.Timeout | null = null;
+    let logoutTimer: NodeJS.Timeout | null = null;
+    let countdownInterval: NodeJS.Timeout | null = null;
     let lastActivity = Date.now();
-    let pollInterval: NodeJS.Timeout | null = null;
     
     // Store previous state for comparison
     let prevIsIdle = false;
@@ -303,19 +319,29 @@ export class InactivityService extends BaseService implements IInactivityService
     let prevInactivityTimeRemaining = 0;
     let prevTimeRemaining = this.idleTimeoutMs;
 
-    // Poll every 10 seconds to check for state changes
-    const pollInactivityState = () => {
+    // Calculate time until warning and logout
+    const getTimeUntilWarning = () => {
+      const timeSinceActivity = Date.now() - lastActivity;
+      return Math.max(0, (this.idleTimeoutMs - this.warnBeforeMs) - timeSinceActivity);
+    };
+
+    const getTimeUntilLogout = () => {
+      const timeSinceActivity = Date.now() - lastActivity;
+      return Math.max(0, this.idleTimeoutMs - timeSinceActivity);
+    };
+
+    // Update state and notify if changed
+    const updateState = (forceNotify = false) => {
       const now = Date.now();
       const timeSinceActivity = now - lastActivity;
       const timeUntilIdle = this.idleTimeoutMs - timeSinceActivity;
-      const timeUntilWarning = (this.idleTimeoutMs - this.warnBeforeMs) - timeSinceActivity;
       
-      // Calculate new state values based on time since last activity
-      const newIsIdle = timeSinceActivity >= (this.idleTimeoutMs - this.warnBeforeMs);
-      const newShowWarning = newIsIdle && timeSinceActivity < this.idleTimeoutMs;
+      // Calculate new state values
+      const newIsIdle = timeSinceActivity >= this.idleTimeoutMs;
+      const newShowWarning = timeSinceActivity >= (this.idleTimeoutMs - this.warnBeforeMs) && !newIsIdle;
       const newShowInactivityWarning = newShowWarning;
       const newInactivityTimeRemaining = newShowWarning 
-        ? Math.ceil((this.idleTimeoutMs - timeSinceActivity) / 1000)
+        ? Math.ceil(timeUntilIdle / 1000)
         : 0;
       const newTimeRemaining = Math.max(0, timeUntilIdle);
       
@@ -324,11 +350,11 @@ export class InactivityService extends BaseService implements IInactivityService
         prevIsIdle !== newIsIdle ||
         prevShowWarning !== newShowWarning ||
         prevShowInactivityWarning !== newShowInactivityWarning ||
-        prevInactivityTimeRemaining !== newInactivityTimeRemaining ||
+        (newShowWarning && prevInactivityTimeRemaining !== newInactivityTimeRemaining) ||
         prevTimeRemaining !== newTimeRemaining;
       
-      // Only update and notify if state changed
-      if (stateChanged) {
+      // Only update and notify if state changed or forced
+      if (stateChanged || forceNotify) {
         this._isIdle = newIsIdle;
         this._showWarning = newShowWarning;
         this._showInactivityWarning = newShowInactivityWarning;
@@ -342,76 +368,147 @@ export class InactivityService extends BaseService implements IInactivityService
         prevInactivityTimeRemaining = newInactivityTimeRemaining;
         prevTimeRemaining = newTimeRemaining;
         
-        this.notify();
+        if (stateChanged) {
+          this.notify();
+        }
         
         // Handle idle logout if needed
-        if (newIsIdle && timeSinceActivity >= this.idleTimeoutMs) {
+        if (newIsIdle) {
           this.handleIdleLogout();
         }
       }
-      
-      // Update timers based on current state
-      if (idleTimer) {
-        clearTimeout(idleTimer);
-        idleTimer = null;
-      }
-      
+    };
+
+    // Schedule next state check based on current state
+    const scheduleNextCheck = () => {
+      // Clear existing timers
       if (warningTimer) {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
       
-      // Set up timers for next state transitions
-      if (!newIsIdle && timeUntilIdle > 0) {
-        idleTimer = setTimeout(() => {
-          pollInactivityState();
-        }, Math.min(10000, timeUntilIdle));
+      if (logoutTimer) {
+        clearTimeout(logoutTimer);
+        logoutTimer = null;
       }
       
-      if (newShowWarning && timeUntilIdle > 0) {
-        warningTimer = setTimeout(() => {
+      if (countdownInterval) {
+        clearInterval(countdownInterval);
+        countdownInterval = null;
+      }
+
+      const timeUntilWarning = getTimeUntilWarning();
+      const timeUntilLogout = getTimeUntilLogout();
+      const timeSinceActivity = Date.now() - lastActivity;
+      
+      // If already idle, nothing to schedule
+      if (timeSinceActivity >= this.idleTimeoutMs) {
+        return;
+      }
+      
+      // If warning should be shown, start countdown interval
+      if (timeSinceActivity >= (this.idleTimeoutMs - this.warnBeforeMs)) {
+        // Update state to show warning
+        updateState();
+        
+        // Start countdown interval to update remaining time every second
+        countdownInterval = setInterval(() => {
+          updateState();
+          
+          // Check if we've reached logout time
+          if (Date.now() - lastActivity >= this.idleTimeoutMs) {
+            if (countdownInterval) {
+              clearInterval(countdownInterval);
+              countdownInterval = null;
+            }
+            this.handleIdleLogout();
+          }
+        }, 1000); // Update every second during warning period
+        
+        // Schedule logout
+        logoutTimer = setTimeout(() => {
+          if (countdownInterval) {
+            clearInterval(countdownInterval);
+            countdownInterval = null;
+          }
           this.handleIdleLogout();
-        }, timeUntilIdle);
+        }, timeUntilLogout);
+      } else {
+        // User is still active - schedule warning timer
+        // Use adaptive interval: check more frequently as we approach warning time
+        // Check every 60 seconds when far from warning, every 10 seconds when close
+        const timeUntilWarningMs = timeUntilWarning;
+        const adaptiveInterval = timeUntilWarningMs > 5 * 60 * 1000 
+          ? 60 * 1000  // Check every 60 seconds when > 5 minutes away
+          : timeUntilWarningMs > 60 * 1000
+          ? 10 * 1000  // Check every 10 seconds when < 5 minutes but > 1 minute away
+          : 1000;      // Check every second when < 1 minute away
+        
+        warningTimer = setTimeout(() => {
+          updateState();
+          scheduleNextCheck(); // Reschedule for next check
+        }, Math.min(adaptiveInterval, timeUntilWarningMs));
       }
     };
 
     const resetTimers = () => {
-      // Only update lastActivity - don't notify yet
+      // Update last activity time
       lastActivity = Date.now();
       
-      // Clear timers
-      if (idleTimer) {
-        clearTimeout(idleTimer);
-        idleTimer = null;
-      }
-      
+      // Clear all timers
       if (warningTimer) {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
       
-      // Reset state values (will be checked on next poll)
+      if (logoutTimer) {
+        clearTimeout(logoutTimer);
+        logoutTimer = null;
+      }
+      
+      if (countdownInterval) {
+        clearInterval(countdownInterval);
+        countdownInterval = null;
+      }
+      
+      // Reset state values
+      const hadWarning = this._showWarning || this._showInactivityWarning;
       this._showInactivityWarning = false;
       this._inactivityTimeRemaining = 0;
       this._isIdle = false;
       this._showWarning = false;
+      this._timeRemaining = this.idleTimeoutMs;
       
-      // Update previous state to match
+      // Update previous state
       prevIsIdle = false;
       prevShowWarning = false;
       prevShowInactivityWarning = false;
       prevInactivityTimeRemaining = 0;
       prevTimeRemaining = this.idleTimeoutMs;
       
-      // Poll will check and notify if needed
+      // Notify if we were showing a warning (state changed)
+      if (hadWarning) {
+        this.notify();
+      }
+      
+      // Reschedule next check
+      scheduleNextCheck();
     };
 
-    // Activity detection - only updates lastActivity, doesn't notify
+    // Activity detection - throttled to avoid excessive calls
     const activityEvents = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'];
+    let activityThrottleTimer: NodeJS.Timeout | null = null;
     
     const handleActivity = () => {
-      resetTimers();
-      // Don't call notify - polling will handle state updates
+      // Throttle activity detection to once per second max
+      if (activityThrottleTimer) {
+        return;
+      }
+      
+      activityThrottleTimer = setTimeout(() => {
+        activityThrottleTimer = null;
+        resetTimers();
+      }, 1000);
     };
 
     // Add event listeners
@@ -419,29 +516,30 @@ export class InactivityService extends BaseService implements IInactivityService
       document.addEventListener(event, handleActivity, true);
     });
 
-    // Start polling every 10 seconds
-    pollInterval = setInterval(() => {
-      pollInactivityState();
-    }, 10000); // 10 seconds
-
-    // Initial poll
-    pollInactivityState();
+    // Initial state update and schedule first check
+    updateState(true); // Force initial notification
+    scheduleNextCheck();
 
     // Store cleanup function
     this.cleanupHandlers = () => {
-      if (idleTimer) {
-        clearTimeout(idleTimer);
-        idleTimer = null;
-      }
-      
       if (warningTimer) {
         clearTimeout(warningTimer);
         warningTimer = null;
       }
       
-      if (pollInterval) {
-        clearInterval(pollInterval);
-        pollInterval = null;
+      if (logoutTimer) {
+        clearTimeout(logoutTimer);
+        logoutTimer = null;
+      }
+      
+      if (countdownInterval) {
+        clearInterval(countdownInterval);
+        countdownInterval = null;
+      }
+      
+      if (activityThrottleTimer) {
+        clearTimeout(activityThrottleTimer);
+        activityThrottleTimer = null;
       }
 
       activityEvents.forEach(event => {
@@ -457,6 +555,5 @@ export class InactivityService extends BaseService implements IInactivityService
     };
 
     this._isTracking = true;
-    this.notify(); // Initial notification only
   }
 }

package/src/services/OrganisationService.ts

@@ -70,10 +70,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
-    logger.debug('OrganisationService', `Instance created [ID:${this.instanceId}]`, {
-      hasUser: !!user,
-      userId: user?.id
-    });
   }
 
   getInstanceId(): number {
@@ -164,10 +160,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
     if (userChanged || needsRetry || isEmpty) {
       if (userChanged) {
-        logger.debug('OrganisationService', `User changed [ID:${this.instanceId}], resetting initialization`, {
-          previousUserId,
-          newUserId
-        });
       } else if (needsRetry) {
         logger.debug('OrganisationService', `Previous error detected [ID:${this.instanceId}], retrying initialization`);
       } else if (isEmpty) {
@@ -293,7 +285,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     // SECURITY: Only initialize if we have an authenticated user
     // This prevents premature initialization during early auth states
     if (!this.user) {
-      logger.debug('OrganisationService', 'Skipping initialization - no user');
       return;
     }
 
@@ -337,34 +328,13 @@ export class OrganisationService extends BaseService implements IOrganisationSer
   }
 
   private async setDatabaseOrganisationContext(organisation: Organisation): Promise<void> {
-    if (!this.supabaseClient || !this.session) {
-      logger.warn('OrganisationService', 'No Supabase client or session available for setting organisation context');
-      this._isContextReady = false;
-      this.notify();
-      return;
-    }
-
-    try {
-      // Add timeout to prevent hanging
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error('Context setting timeout after 5 seconds')), 5000);
-      });
-      
-      const contextPromise = setOrganisationContext(this.supabaseClient, organisation.id);
-      
-      await Promise.race([contextPromise, timeoutPromise]);
-      
-      // Database organisation context set successfully
-      this._isContextReady = true;
-      this.notify();
-    } catch (error) {
-      logger.error('OrganisationService', 'Failed to set database organisation context:', error);
-      // Set context ready to true anyway - this is a non-critical operation
-      // The app should still work without database context
-      this._isContextReady = true;
-      this.notify();
-      // Don't throw - this is a non-critical operation
-    }
+    // Organisation context is now handled via secure client and explicit parameters
+    // This function is kept for backward compatibility but is effectively a no-op
+    // The setOrganisationContext function has been deprecated and no longer sets database context
+    
+    // Mark context as ready immediately since context is handled elsewhere
+    this._isContextReady = true;
+    this.notify();
   }
 
   private async loadUserOrganisations(): Promise<void> {
@@ -416,9 +386,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this._error = null;
     this.notify();
 
-    logger.debug('OrganisationService', 'Loading organisations for user', {
-      userId: this.user.id
-    });
       
     try {
       // Get user's organisation roles directly from rbac_organisation_roles table
@@ -500,10 +467,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         
         organisations = Array.from(organisationsMap.values());
         
-        logger.debug('OrganisationService', 'Query results', {
-          membershipsCount: memberships.length,
-          organisationsCount: organisations.length
-        });
         
         // Extract organisations from join results
       } catch (queryError) {

package/src/services/__tests__/OrganisationService.test.ts

@@ -866,10 +866,19 @@ describe('OrganisationService', () => {
         mockSession
       );
 
-      serviceWithoutClient.setSelectedOrganisation(mockOrganisation);
-
-      // Should handle gracefully
-      await new Promise(resolve => setTimeout(resolve, 100));
+      // Initially context is not ready
+      expect(serviceWithoutClient.isContextReady()).toBe(false);
+      
+      // setSelectedOrganisation requires a valid organisation in the organisations list
+      // Since we don't have a client, we can't load organisations, so this will throw
+      // or the organisation won't be in the list. The context ready state should remain false.
+      try {
+        await serviceWithoutClient.switchOrganisation(mockOrganisation.id);
+      } catch {
+        // Expected to fail
+      }
+      
+      // Context should still be false since organisation switch failed
       expect(serviceWithoutClient.isContextReady()).toBe(false);
     });
 
@@ -880,10 +889,19 @@ describe('OrganisationService', () => {
         null
       );
 
-      serviceWithoutSession.setSelectedOrganisation(mockOrganisation);
-
-      // Should handle gracefully
-      await new Promise(resolve => setTimeout(resolve, 100));
+      // Initially context is not ready
+      expect(serviceWithoutSession.isContextReady()).toBe(false);
+      
+      // Without a session, loadUserOrganisations will return early and not load organisations
+      // So setSelectedOrganisation will fail because the organisation isn't in the list
+      // The context ready state should remain false
+      try {
+        await serviceWithoutSession.switchOrganisation(mockOrganisation.id);
+      } catch {
+        // Expected to fail
+      }
+      
+      // Context should still be false since organisation switch failed
       expect(serviceWithoutSession.isContextReady()).toBe(false);
     });
   });

package/src/services/base/BaseService.ts

@@ -38,9 +38,6 @@ export abstract class BaseService {
    * This triggers React re-renders
    */
   protected notify(): void {
-    const serviceName = this.constructor.name;
-    const instanceId = (this as any).instanceId || 'unknown';
-    logger.debug('BaseService', `[${serviceName} ID:${instanceId}] Notifying ${this.subscribers.length} subscribers`);
     this.subscribers.forEach(callback => {
       try {
         callback();

package/src/styles/core.css

@@ -202,6 +202,10 @@
     font-size: 0.875em;
     color: var(--color-main-600);
   }
+
+  dialog::backdrop {
+    background-color: oklch(from var(--color-main-700) l c h / 0.5);
+  }
   
   .appGradient {
     background: linear-gradient(145deg, var(--color-main-100) 10%, var(--color-main-200) 30%, var(--color-main-200) 70%, var(--color-main-300) 90%);