@jmruthers/pace-core 0.5.190 → 0.5.193

package/src/rbac/utils/eventContext.ts

@@ -56,7 +56,7 @@ export async function getOrganisationFromEvent(
 
   // Query database
   const { data, error } = await supabase
-    .from('event')
+    .from('core_events')
     .select('organisation_id')
     .eq('event_id', eventId)
     .single() as { data: { organisation_id: string } | null; error: any };
@@ -65,8 +65,11 @@ export async function getOrganisationFromEvent(
 
   if (error || !data) {
     organisationId = null;
-  } else {
+  } else if (data.organisation_id) {
     organisationId = data.organisation_id;
+  } else {
+    // organisation_id is null or undefined
+    organisationId = null;
   }
 
   // Cache the result (with size limit to prevent memory leaks)

package/src/services/AuthService.ts

@@ -299,7 +299,15 @@ export class AuthService extends BaseService implements IAuthService {
   // Lifecycle methods
   async initialize(): Promise<void> {
     await super.initialize();
+    // Set loading to true before starting session restoration
+    // This ensures ProtectedRoute shows loading state while session is being restored
+    this.authLoading = true;
+    this.notify();
+    
+    // Setup auth state listener first - this will receive INITIAL_SESSION event
     await this.setupAuthStateListener();
+    
+    // Then restore session - this will trigger INITIAL_SESSION event if session exists
     await this.restoreSession();
   }
 
@@ -431,17 +439,25 @@ export class AuthService extends BaseService implements IAuthService {
                     this.sessionRestorationState.restorationError ||
                     (hasTimeoutError && session)) {
                   this.finishSessionRestoration();
-                  return;
+                }
+              } else {
+                // No session in INITIAL_SESSION event - user is not authenticated
+                // Finish restoration to clear loading state
+                if (this.sessionRestorationState.isRestoring) {
+                  this.finishSessionRestoration();
                 }
               }
 
-              if (this.sessionRestorationState.isRestoring) {
-                this.finishSessionRestoration();
-                return;
-              }
+              // CRITICAL: Set loading to false AFTER handling INITIAL_SESSION
+              // This ensures ProtectedRoute waits for session restoration to complete
+              // before checking authentication state
+              this.authLoading = false;
+              this.notify();
+              return; // Return early to avoid setting loading to false again below
             }
 
-            // Always set loading to false after any auth state change
+            // For other events (SIGNED_IN, SIGNED_OUT, TOKEN_REFRESHED), set loading to false
+            // INITIAL_SESSION is handled above and returns early
             this.authLoading = false;
             this.notify();
           } catch (error) {
@@ -519,8 +535,21 @@ export class AuthService extends BaseService implements IAuthService {
         this.authError = null;
       }
 
-      // Finish successfully even if earlier calls reported an error, to avoid noisy warnings in benign cases
-      this.finishSessionRestoration();
+      // CRITICAL FIX: Don't finish restoration here - wait for INITIAL_SESSION event
+      // The INITIAL_SESSION event should fire when the auth state listener is set up
+      // However, if it doesn't fire within a short delay (e.g., edge case), we'll finish it
+      // This ensures ProtectedRoute waits for the event before checking auth state
+      
+      // Set a short fallback timeout to finish restoration if INITIAL_SESSION doesn't fire
+      // This handles edge cases where the event might be delayed or not fire
+      setTimeout(() => {
+        // Only finish if restoration is still in progress and INITIAL_SESSION hasn't fired
+        // The INITIAL_SESSION handler will have set restorationComplete to true if it fired
+        if (this.sessionRestorationState.isRestoring && !this.sessionRestorationState.restorationComplete) {
+          logger.debug('AuthService', 'INITIAL_SESSION event did not fire, finishing restoration');
+          this.finishSessionRestoration();
+        }
+      }, 100); // 100ms fallback - INITIAL_SESSION should fire immediately when listener is set up
     } catch (error) {
       const restorationError = error instanceof Error
         ? error

package/src/services/EventService.ts

@@ -116,10 +116,6 @@ export class EventService extends BaseService implements IEventService {
     if (user?.id) {
       try {
         this.isSuperAdmin = await isSuperAdmin(user.id as UUID);
-        logger.debug('EventService', 'Updated super admin status', {
-          userId: user.id,
-          isSuperAdmin: this.isSuperAdmin
-        });
       } catch (error) {
         logger.warn('EventService', 'Failed to check super admin status', { error });
         this.isSuperAdmin = false; // Default to false on error
@@ -151,9 +147,10 @@ export class EventService extends BaseService implements IEventService {
 
   // Event state getters
   getEvents(): Event[] {
-    // Return a new array reference so React can detect changes
-    // This ensures useMemo dependencies work correctly
-    return [...this.events];
+    // Return stable array reference - only create new array when events actually change
+    // This prevents unnecessary re-renders when getEvents() is called on every render
+    // The service's notify() mechanism handles change detection
+    return this.events;
   }
 
   getSelectedEvent(): Event | null {
@@ -308,12 +305,6 @@ export class EventService extends BaseService implements IEventService {
   async initialize(): Promise<void> {
     // Only call super.initialize() which will call doInitialize() and fetchEvents()
     // Don't call fetchEvents() again here to avoid double-fetching
-    logger.debug('EventService', 'initialize() called', {
-      isInitializedRef: this.isInitializedRef,
-      hasUser: !!this.user,
-      hasSession: !!this.session,
-      appName: this.appName
-    });
     await super.initialize();
   }
 
@@ -322,23 +313,13 @@ export class EventService extends BaseService implements IEventService {
   }
 
   protected async doInitialize(): Promise<void> {
-    logger.debug('EventService', 'doInitialize() called', {
-      isInitializedRef: this.isInitializedRef,
-      isFetchingRef: this.isFetchingRef,
-      hasUser: !!this.user,
-      hasSession: !!this.session,
-      appName: this.appName
-    });
-    
     // Skip if already initialized
     if (this.isInitializedRef) {
-      logger.debug('EventService', 'Skipping initialization - already initialized');
       return;
     }
     
     // Skip if already fetching
     if (this.isFetchingRef) {
-      logger.debug('EventService', 'Skipping initialization - already fetching');
       return;
     }
     
@@ -355,16 +336,9 @@ export class EventService extends BaseService implements IEventService {
     // For event-required apps, selectedOrganisation may be null (org derived from event)
     // For org-required apps, selectedOrganisation is required
     if (!this.user) {
-      logger.debug('EventService', 'Skipping initialization - missing user');
       return;
     }
     
-    logger.debug('EventService', 'Initializing - fetching events', {
-      userId: this.user.id,
-      organisationId: this.selectedOrganisation?.id || 'derived-from-event',
-      appName: this.appName
-    });
-    
     // Initial setup - fetch events on initialization
     await this.fetchEvents(false);
     
@@ -380,12 +354,6 @@ export class EventService extends BaseService implements IEventService {
     // For event-required apps, selectedOrganisation may be null (org derived from event)
     // For org-required apps, selectedOrganisation is required
     if (!this.user || !this.session || !this.supabaseClient || !this.appName) {
-      logger.debug('EventService', 'Skipping fetchEvents - missing dependencies', {
-        hasUser: !!this.user,
-        hasSession: !!this.session,
-        hasSupabaseClient: !!this.supabaseClient,
-        appName: this.appName
-      });
       // Already false from initialization, just notify
       this.notify();
       return;
@@ -397,7 +365,6 @@ export class EventService extends BaseService implements IEventService {
 
     // Prevent multiple simultaneous fetches
     if (this.isFetchingRef) {
-      logger.debug('EventService', 'Skipping fetchEvents - already fetching');
       return;
     }
 
@@ -431,9 +398,6 @@ export class EventService extends BaseService implements IEventService {
         if (userIsSuperAdmin) {
           // Super admin: Pass null to see all events across all organisations
           organisationIdForRpc = null;
-          logger.debug('EventService', 'Super admin detected - fetching all events', {
-            userId: this.user.id
-          });
         } else {
           // Not super admin: determine org from context based on app type
           if (this.selectedEvent) {
@@ -443,10 +407,6 @@ export class EventService extends BaseService implements IEventService {
             // Event-required app with no selected event yet: pass null to get all accessible events
             // The RPC will filter by event app roles, returning all events the user has access to
             organisationIdForRpc = null;
-            logger.debug('EventService', 'Event-required app: fetching all accessible events (no event selected yet)', {
-              userId: this.user.id,
-              appName: this.appName
-            });
           } else if (this.selectedOrganisation) {
             // Org-required app: use selected organisation
             organisationIdForRpc = this.selectedOrganisation.id;
@@ -476,12 +436,6 @@ export class EventService extends BaseService implements IEventService {
         }
       }
       
-      logger.debug('EventService', 'Fetching events via RPC', {
-        userId: this.user.id,
-        organisationId: organisationIdForRpc,
-        appName: this.appName
-      });
-      
       // Call the RPC function following the established pattern
       // For super admins, pass null for p_organisation_id to see all events
       let { data, error: rpcError } = await this.supabaseClient.rpc('data_user_events_get', {
@@ -490,13 +444,6 @@ export class EventService extends BaseService implements IEventService {
         p_app_name: this.appName
       });
       
-      logger.debug('EventService', 'RPC response received', {
-        hasData: !!data,
-        dataLength: Array.isArray(data) ? data.length : 'not array',
-        hasError: !!rpcError,
-        error: rpcError
-      });
-
       if (rpcError) {
         logger.error('EventService', 'RPC error fetching events:', rpcError);
         throw new Error(rpcError.message || 'Failed to fetch events');

package/src/services/InactivityService.ts

@@ -145,12 +145,31 @@ export class InactivityService extends BaseService implements IInactivityService
     if (this.inactivityTracker) {
       this.inactivityTracker.resetActivity();
     }
+    
+    // Store previous values
+    const prevIsIdle = this._isIdle;
+    const prevShowWarning = this._showWarning;
+    const prevShowInactivityWarning = this._showInactivityWarning;
+    const prevInactivityTimeRemaining = this._inactivityTimeRemaining;
+    const prevTimeRemaining = this._timeRemaining;
+    
+    // Update state
     this._isIdle = false;
     this._showWarning = false;
     this._showInactivityWarning = false;
     this._inactivityTimeRemaining = 0;
     this._timeRemaining = this.idleTimeoutMs;
-    this.notify();
+    
+    // Only notify if values actually changed
+    if (
+      prevIsIdle !== this._isIdle ||
+      prevShowWarning !== this._showWarning ||
+      prevShowInactivityWarning !== this._showInactivityWarning ||
+      prevInactivityTimeRemaining !== this._inactivityTimeRemaining ||
+      prevTimeRemaining !== this._timeRemaining
+    ) {
+      this.notify();
+    }
   }
 
   startTracking(): void {
@@ -275,10 +294,63 @@ export class InactivityService extends BaseService implements IInactivityService
     let idleTimer: NodeJS.Timeout | null = null;
     let warningTimer: NodeJS.Timeout | null = null;
     let lastActivity = Date.now();
-
-    const resetTimers = () => {
-      lastActivity = Date.now();
+    let pollInterval: NodeJS.Timeout | null = null;
+    
+    // Store previous state for comparison
+    let prevIsIdle = false;
+    let prevShowWarning = false;
+    let prevShowInactivityWarning = false;
+    let prevInactivityTimeRemaining = 0;
+    let prevTimeRemaining = this.idleTimeoutMs;
+
+    // Poll every 10 seconds to check for state changes
+    const pollInactivityState = () => {
+      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;
+      const newShowInactivityWarning = newShowWarning;
+      const newInactivityTimeRemaining = newShowWarning 
+        ? Math.ceil((this.idleTimeoutMs - timeSinceActivity) / 1000)
+        : 0;
+      const newTimeRemaining = Math.max(0, timeUntilIdle);
+      
+      // Check if state actually changed
+      const stateChanged = 
+        prevIsIdle !== newIsIdle ||
+        prevShowWarning !== newShowWarning ||
+        prevShowInactivityWarning !== newShowInactivityWarning ||
+        prevInactivityTimeRemaining !== newInactivityTimeRemaining ||
+        prevTimeRemaining !== newTimeRemaining;
+      
+      // Only update and notify if state changed
+      if (stateChanged) {
+        this._isIdle = newIsIdle;
+        this._showWarning = newShowWarning;
+        this._showInactivityWarning = newShowInactivityWarning;
+        this._inactivityTimeRemaining = newInactivityTimeRemaining;
+        this._timeRemaining = newTimeRemaining;
+        
+        // Update previous state
+        prevIsIdle = newIsIdle;
+        prevShowWarning = newShowWarning;
+        prevShowInactivityWarning = newShowInactivityWarning;
+        prevInactivityTimeRemaining = newInactivityTimeRemaining;
+        prevTimeRemaining = newTimeRemaining;
+        
+        this.notify();
+        
+        // Handle idle logout if needed
+        if (newIsIdle && timeSinceActivity >= this.idleTimeoutMs) {
+          this.handleIdleLogout();
+        }
+      }
       
+      // Update timers based on current state
       if (idleTimer) {
         clearTimeout(idleTimer);
         idleTimer = null;
@@ -288,47 +360,58 @@ export class InactivityService extends BaseService implements IInactivityService
         clearTimeout(warningTimer);
         warningTimer = null;
       }
-
-      this._showInactivityWarning = false;
-      this._inactivityTimeRemaining = 0;
-      this._isIdle = false;
-      this._showWarning = false;
-      this.notify();
-    };
-
-    const startIdleTimer = () => {
-      if (idleTimer) {
-        clearTimeout(idleTimer);
+      
+      // Set up timers for next state transitions
+      if (!newIsIdle && timeUntilIdle > 0) {
+        idleTimer = setTimeout(() => {
+          pollInactivityState();
+        }, Math.min(10000, timeUntilIdle));
       }
-
-      idleTimer = setTimeout(() => {
-        this._isIdle = true;
-        this._showWarning = true;
-        this.notify();
-        
-        // Start warning timer
+      
+      if (newShowWarning && timeUntilIdle > 0) {
         warningTimer = setTimeout(() => {
           this.handleIdleLogout();
-        }, this.warnBeforeMs);
-      }, this.idleTimeoutMs - this.warnBeforeMs);
+        }, timeUntilIdle);
+      }
     };
 
-    const startWarningTimer = () => {
+    const resetTimers = () => {
+      // Only update lastActivity - don't notify yet
+      lastActivity = Date.now();
+      
+      // Clear timers
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        idleTimer = null;
+      }
+      
       if (warningTimer) {
         clearTimeout(warningTimer);
+        warningTimer = null;
       }
-
-      warningTimer = setTimeout(() => {
-        this.handleIdleLogout();
-      }, this.warnBeforeMs);
+      
+      // Reset state values (will be checked on next poll)
+      this._showInactivityWarning = false;
+      this._inactivityTimeRemaining = 0;
+      this._isIdle = false;
+      this._showWarning = false;
+      
+      // Update previous state to match
+      prevIsIdle = false;
+      prevShowWarning = false;
+      prevShowInactivityWarning = false;
+      prevInactivityTimeRemaining = 0;
+      prevTimeRemaining = this.idleTimeoutMs;
+      
+      // Poll will check and notify if needed
     };
 
-    // Activity detection
+    // Activity detection - only updates lastActivity, doesn't notify
     const activityEvents = ['mousedown', 'mousemove', 'keypress', 'scroll', 'touchstart', 'click'];
     
     const handleActivity = () => {
       resetTimers();
-      startIdleTimer();
+      // Don't call notify - polling will handle state updates
     };
 
     // Add event listeners
@@ -336,8 +419,13 @@ export class InactivityService extends BaseService implements IInactivityService
       document.addEventListener(event, handleActivity, true);
     });
 
-    // Start initial timer
-    startIdleTimer();
+    // Start polling every 10 seconds
+    pollInterval = setInterval(() => {
+      pollInactivityState();
+    }, 10000); // 10 seconds
+
+    // Initial poll
+    pollInactivityState();
 
     // Store cleanup function
     this.cleanupHandlers = () => {
@@ -350,6 +438,11 @@ export class InactivityService extends BaseService implements IInactivityService
         clearTimeout(warningTimer);
         warningTimer = null;
       }
+      
+      if (pollInterval) {
+        clearInterval(pollInterval);
+        pollInterval = null;
+      }
 
       activityEvents.forEach(event => {
         document.removeEventListener(event, handleActivity, true);
@@ -364,6 +457,6 @@ export class InactivityService extends BaseService implements IInactivityService
     };
 
     this._isTracking = true;
-    this.notify();
+    this.notify(); // Initial notification only
   }
 }