@jmruthers/pace-core 0.6.2 → 0.6.4

package/src/services/AuthService.ts

@@ -23,6 +23,8 @@ type AuthStateSubscription = {
 };
 
 export class AuthService extends BaseService implements IAuthService {
+  private static instanceCount = 0;
+  private instanceId: number;
   private user: User | null = null;
   private session: Session | null = null;
   private authLoading = false;
@@ -43,12 +45,23 @@ export class AuthService extends BaseService implements IAuthService {
 
   constructor(supabaseClient: SupabaseClient, appName?: string) {
     super();
+    this.instanceId = ++AuthService.instanceCount;
     this.supabaseClient = supabaseClient;
     this.appName = appName;
+    logger.debug('AuthService', `Instance created [ID:${this.instanceId}]`, { appName });
+  }
+
+  getInstanceId(): number {
+    return this.instanceId;
   }
 
   // Auth state getters
   getUser(): User | null {
+    if (this.user) {
+      logger.debug('AuthService', `getUser() [ID:${this.instanceId}] returning user: ${this.user.id}`);
+    } else {
+      logger.debug('AuthService', `getUser() [ID:${this.instanceId}] returning null`);
+    }
     return this.user;
   }
 
@@ -398,6 +411,11 @@ export class AuthService extends BaseService implements IAuthService {
       const subscription = this.supabaseClient.auth.onAuthStateChange(
         (event: AuthChangeEvent, session: SupabaseSession | null) => {
           try {
+            logger.debug('AuthService', `Auth state change [ID:${this.instanceId}]`, {
+              event,
+              hasSession: !!session,
+              userId: session?.user?.id
+            });
             // Handle different auth events
             if (event === 'SIGNED_OUT') {
               this.session = null;
@@ -407,15 +425,15 @@ export class AuthService extends BaseService implements IAuthService {
               // Automatic session tracking (non-blocking)
               if (session?.user) {
                 this.trackSession('logout', session).catch(err => {
-                  logger.warn('AuthService', 'Failed to track logout session:', err);
+                  logger.warn('AuthService', `Failed to track logout session [ID:${this.instanceId}]:`, err);
                 });
               }
             } else if (event === 'SIGNED_IN' || event === 'TOKEN_REFRESHED') {
               this.session = session;
               this.user = session?.user ?? null;
 
-              // Only clear auth error if we have a valid session
-              if (session) {
+              // Ensure state is set before non-blocking tracking calls
+              if (session?.user) {
                 this.authError = null;
               }
               
@@ -423,7 +441,7 @@ export class AuthService extends BaseService implements IAuthService {
               // Only track on SIGNED_IN, not TOKEN_REFRESHED (to avoid duplicate login records)
               if (event === 'SIGNED_IN' && session?.user) {
                 this.trackSession('login', session).catch(err => {
-                  logger.warn('AuthService', 'Failed to track login session:', err);
+                  logger.warn('AuthService', `Failed to track login session [ID:${this.instanceId}]:`, err);
                 });
               }
             } else if (event === 'INITIAL_SESSION') {
@@ -452,16 +470,30 @@ export class AuthService extends BaseService implements IAuthService {
               // This ensures ProtectedRoute waits for session restoration to complete
               // before checking authentication state
               this.authLoading = false;
+              
+              // Final check: Ensure state matches what we just logged
+              logger.debug('AuthService', `State synchronized after INITIAL_SESSION [ID:${this.instanceId}]`, {
+                hasUser: !!this.user,
+                userId: this.user?.id
+              });
+              
               this.notify();
               return; // Return early to avoid setting loading to false again below
             }
 
-            // For other events (SIGNED_IN, SIGNED_OUT, TOKEN_REFRESHED), set loading to false
-            // INITIAL_SESSION is handled above and returns early
+            // For other events (SIGNED_IN, SIGNED_OUT, TOKEN_REFRESHED), set loading to false and notify
             this.authLoading = false;
+            
+            // Final check: Ensure state matches what we just logged
+            logger.debug('AuthService', `State synchronized after event [ID:${this.instanceId}]`, {
+              event,
+              hasUser: !!this.user,
+              userId: this.user?.id
+            });
+            
             this.notify();
           } catch (error) {
-            logger.warn('AuthService', 'Error in auth state change handler:', error);
+            logger.warn('AuthService', `Error in auth state change handler [ID:${this.instanceId}]:`, error);
             this.authLoading = false;
             this.notify();
           }

package/src/services/EventService.ts

@@ -16,11 +16,12 @@ import { Organisation } from '../types/organisation';
 import { assertOrganisationId } from '../types/core';
 import { logger } from '../utils/core/logger';
 import { secureStorage } from '../utils/security/secureStorage';
-import { isSuperAdmin, getAppConfigByName } from '../rbac/api';
+import { isSuperAdmin } from '../rbac/api';
 import type { UUID } from '../rbac/types';
-import type { AppConfig } from '../rbac/utils/contextValidator';
 
 export class EventService extends BaseService implements IEventService {
+  private static instanceCount = 0;
+  private instanceId: number;
   private events: Event[] = [];
   private selectedEvent: Event | null = null;
   private _isLoading = false; // Start as false to avoid blocking UI
@@ -34,7 +35,7 @@ export class EventService extends BaseService implements IEventService {
   private selectedOrganisation: Organisation | null = null;
   private setSelectedEventId: ((eventId: string | null) => void) | null = null;
   private isSuperAdmin: boolean = false; // Track super admin status for conditional validation
-  private appConfig: AppConfig | null = null; // Cache app config to avoid repeated lookups
+  // App config removed - scope is now page-level only (rbac_app_pages.scope_type)
 
   // Internal state management
   private isInitializedRef = false;
@@ -51,12 +52,22 @@ export class EventService extends BaseService implements IEventService {
     setSelectedEventId: (eventId: string | null) => void
   ) {
     super();
+    this.instanceId = ++EventService.instanceCount;
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
+    logger.debug('EventService', `Instance created [ID:${this.instanceId}]`, {
+      appName,
+      hasUser: !!user,
+      userId: user?.id
+    });
+  }
+
+  getInstanceId(): number {
+    return this.instanceId;
   }
 
   // Helper method to get user-scoped storage key
@@ -97,6 +108,15 @@ export class EventService extends BaseService implements IEventService {
       this.resetInitialization();
       this.isInitializedRef = false;
       this.isFetchingRef = false;
+      // Reset user cleared flag when new user logs in - allows auto-selection for new user
+      this.userClearedEventRef = false;
+      this.hasAutoSelectedRef = false;
+      
+      logger.debug('EventService', `User changed [ID:${this.instanceId}]`, {
+        previousUserId,
+        newUserId,
+        willInitialize: newUserId !== null
+      });
     }
     
     this.supabaseClient = supabaseClient;
@@ -106,19 +126,43 @@ export class EventService extends BaseService implements IEventService {
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
     
-    // Clear app config cache when app name changes
-    if (previousAppName !== appName) {
-      this.appConfig = null;
-    }
+    // App name changed - state will be reset by updateDependencies
     
     // Update super admin status when user changes
     // This allows super admins to select events from any organisation
+    // RBAC should be initialized synchronously by UnifiedAuthProvider, so this should always work
     if (user?.id) {
       try {
-        this.isSuperAdmin = await isSuperAdmin(user.id as UUID);
+        const { isRBACInitialized, isSuperAdmin: checkSuperAdmin, setupRBAC } = await import('../rbac/api');
+        
+        // Ensure RBAC is initialized if possible (defensive check for edge cases)
+        if (!isRBACInitialized() && this.supabaseClient) {
+          setupRBAC(this.supabaseClient);
+        }
+
+        if (isRBACInitialized()) {
+          this.isSuperAdmin = await checkSuperAdmin(user.id as UUID);
+          logger.debug('EventService', 'Super admin status updated in updateDependencies', {
+            userId: user.id,
+            isSuperAdmin: this.isSuperAdmin
+          });
+        } else {
+          // RBAC not initialized - this should be rare since UnifiedAuthProvider initializes it synchronously
+          // Keep existing value (don't reset to false) to avoid clearing a previously determined super admin status
+          logger.warn('EventService', 'RBAC not initialized in updateDependencies, keeping existing super admin status', {
+            userId: user.id,
+            existingIsSuperAdmin: this.isSuperAdmin,
+            note: 'RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider.'
+          });
+        }
       } catch (error) {
-        logger.warn('EventService', 'Failed to check super admin status', { error });
-        this.isSuperAdmin = false; // Default to false on error
+        logger.warn('EventService', 'Failed to check super admin status in updateDependencies', { 
+          error,
+          userId: user.id,
+          existingIsSuperAdmin: this.isSuperAdmin
+        });
+        // Don't reset to false on error - keep existing value to avoid blocking super admins
+        // The error might be transient, and we don't want to clear a valid super admin status
       }
     } else {
       this.isSuperAdmin = false;
@@ -131,14 +175,51 @@ export class EventService extends BaseService implements IEventService {
       this.resetInitialization(); // Reset BaseService's isInitialized flag
       this.isInitializedRef = false;
       this.isFetchingRef = false;
+      
+      // SECURITY: Super admins can see events regardless of organisation context
+      // Do not clear events for super admins when organisation context is removed
+      const shouldClearEvents = !this.isSuperAdmin;
+
+      // Determine if this is the first time an org is being set (from null/undefined to a value)
+      const isFirstOrgSet = (previousOrgId === null || previousOrgId === undefined) && newOrgId !== null && newOrgId !== undefined;
+      
       // Clear events ONLY when switching between different organisations (not when org first becomes available)
-      if (previousOrgId !== null && newOrgId !== null && previousOrgId !== newOrgId) {
-        this.events = [];
-        this.selectedEvent = null;
-      } else if (previousOrgId !== null && newOrgId === null) {
-        // Organisation was removed - clear events
-        this.events = [];
-        this.selectedEvent = null;
+      // IMPORTANT: Check isFirstOrgSet FIRST to prevent clearing when org is first set
+      if (isFirstOrgSet) {
+        // Organisation first becomes available - DO NOT clear the event, preserve it
+        // The event will be validated when events are re-fetched with org context
+        // If it's no longer valid, it will be cleared without setting userClearedEventRef = true
+        const hadAutoSelectedEvent = this.hasAutoSelectedRef && !!this.selectedEvent;
+        this.userClearedEventRef = false;
+        // Don't reset hasAutoSelectedRef if we had an auto-selected event - preserve it
+        // This ensures the event remains selected when org is first set
+        if (!hadAutoSelectedEvent) {
+          this.hasAutoSelectedRef = false;
+        }
+        logger.debug('EventService', 'Organisation first set - preserving event and resetting auto-selection flags', {
+          organisationId: newOrgId,
+          hasSelectedEvent: !!this.selectedEvent,
+          selectedEventId: this.selectedEvent?.event_id,
+          hadAutoSelectedEvent,
+          preservingEvent: hadAutoSelectedEvent,
+          previousOrgId,
+          newOrgId
+        });
+      } else if (previousOrgId !== null && previousOrgId !== undefined && newOrgId !== null && newOrgId !== undefined && previousOrgId !== newOrgId) {
+        // Switching between different organisations - clear events
+        if (shouldClearEvents) {
+          this.events = [];
+          // Use setSelectedEvent(null) to preserve userClearedEventRef flag if user explicitly cleared
+          // This prevents auto-selection from re-selecting the event after org switch
+          this.setSelectedEvent(null);
+        }
+      } else if (previousOrgId !== null && previousOrgId !== undefined && newOrgId === null) {
+        // Organisation was removed - clear events if not super admin
+        if (shouldClearEvents) {
+          this.events = [];
+          // Use setSelectedEvent(null) to preserve userClearedEventRef flag if user explicitly cleared
+          this.setSelectedEvent(null);
+        }
       }
     }
     
@@ -179,7 +260,13 @@ export class EventService extends BaseService implements IEventService {
       });
       // Reset the user cleared flag when selecting an event
       this.userClearedEventRef = false;
+      logger.debug('EventService', 'Event selected', {
+        eventId: event.event_id,
+        eventName: event.event_name,
+        userClearedEventRef: this.userClearedEventRef
+      });
     } else {
+      const previousEventId = this.selectedEvent?.event_id;
       this.selectedEvent = null;
       this.setSelectedEventId?.(null);
       // Clear from secure storage (don't await to avoid blocking)
@@ -190,6 +277,11 @@ export class EventService extends BaseService implements IEventService {
       this.hasAutoSelectedRef = false;
       // Mark that user explicitly cleared the event to prevent auto-selection
       this.userClearedEventRef = true;
+      logger.debug('EventService', 'Event cleared via setSelectedEvent(null)', {
+        previousEventId,
+        userClearedEventRef: this.userClearedEventRef,
+        stackTrace: new Error().stack
+      });
     }
     this.notify();
   }
@@ -220,7 +312,7 @@ export class EventService extends BaseService implements IEventService {
         const persistedEvent = events.find(event => event.event_id === persistedEventId);
         
         if (persistedEvent) {
-          // Use setSelectedEvent() to go through same path as EventSelector
+          // Use setSelectedEvent() to ensure consistent behavior
           // This ensures consistent behavior and proper notification
           // Theme will be applied by useEventTheme hook once user navigates away from login
           this.setSelectedEvent(persistedEvent);
@@ -315,11 +407,13 @@ export class EventService extends BaseService implements IEventService {
   protected async doInitialize(): Promise<void> {
     // 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;
     }
     
@@ -336,14 +430,27 @@ 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 - no user');
       return;
     }
     
+    logger.debug('EventService', 'Initializing', {
+      userId: this.user.id,
+      appName: this.appName,
+      hasSelectedOrganisation: !!this.selectedOrganisation,
+      hasSupabaseClient: !!this.supabaseClient,
+      hasSession: !!this.session
+    });
+    
     // Initial setup - fetch events on initialization
     await this.fetchEvents(false);
     
     // Mark as initialized after successful fetch
     this.isInitializedRef = true;
+    logger.debug('EventService', 'Initialization complete', {
+      eventsCount: this.events.length,
+      hasError: !!this.error
+    });
   }
 
   protected doCleanup(): void {
@@ -372,18 +479,7 @@ export class EventService extends BaseService implements IEventService {
     let isMounted = true;
 
     try {
-      // Load app config if not already cached (only once per app)
-      if (!this.appConfig && this.appName) {
-        try {
-          this.appConfig = await getAppConfigByName(this.appName);
-        } catch (configError) {
-          logger.warn('EventService', 'Failed to load app config, defaulting to event-required', {
-            error: configError
-          });
-          // Default to event-required for safety
-          this.appConfig = { requires_event: true };
-        }
-      }
+      // Scope is now page-level only - no app-level config needed
 
       // Determine organisationId for RPC call
       // For event-required apps: org is derived from selectedEvent (if available), or null to get all accessible events
@@ -392,58 +488,119 @@ export class EventService extends BaseService implements IEventService {
       let organisationIdForRpc: string | null = null;
       
       // Check if user is super admin first
-      let userIsSuperAdmin = false;
+      // RBAC should be initialized synchronously by UnifiedAuthProvider before EventService is used
+      // Use cached value as fallback for edge cases (e.g., EventService used outside UnifiedAuthProvider)
+      let userIsSuperAdmin = this.isSuperAdmin; // Start with cached value from updateDependencies
       try {
-        userIsSuperAdmin = await isSuperAdmin(this.user.id as UUID);
+        const { isRBACInitialized, isSuperAdmin: checkSuperAdmin, setupRBAC } = await import('../rbac/api');
+        
+        // Ensure RBAC is initialized if possible (defensive check for edge cases)
+        if (!isRBACInitialized() && this.supabaseClient) {
+          setupRBAC(this.supabaseClient);
+        }
+
+        // Check super admin status if RBAC is ready
+        // RBAC should always be initialized by UnifiedAuthProvider, but we check defensively
+        if (isRBACInitialized()) {
+          userIsSuperAdmin = await checkSuperAdmin(this.user.id as UUID);
+          // Update cached value for future use
+          this.isSuperAdmin = userIsSuperAdmin;
+          logger.debug('EventService', 'Super admin check completed', {
+            userId: this.user.id,
+            isSuperAdmin: userIsSuperAdmin
+          });
+        } else {
+          // RBAC not initialized - this should be rare since UnifiedAuthProvider initializes it synchronously
+          // Use cached value from updateDependencies as fallback
+          // If cached value is true, trust it to avoid blocking super admins
+          if (this.isSuperAdmin) {
+            userIsSuperAdmin = true;
+            logger.warn('EventService', 'RBAC not initialized, using cached super admin status', {
+              userId: this.user.id,
+              cachedIsSuperAdmin: this.isSuperAdmin,
+              note: 'RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider.'
+            });
+          } else {
+            logger.warn('EventService', 'RBAC not initialized, using cached non-super-admin status', {
+              userId: this.user.id,
+              cachedIsSuperAdmin: this.isSuperAdmin,
+              note: 'RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider.'
+            });
+          }
+        }
+        
         if (userIsSuperAdmin) {
           // Super admin: Pass null to see all events across all organisations
           organisationIdForRpc = null;
         } else {
-          // Not super admin: determine org from context based on app type
+          // Not super admin: determine org from available context
+          // Scope is now page-level only - use whatever context is available
           if (this.selectedEvent) {
             // If event is already selected, use its organisation
             organisationIdForRpc = this.selectedEvent.organisation_id;
-          } else if (this.appConfig?.requires_event === true) {
-            // 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;
           } else if (this.selectedOrganisation) {
-            // Org-required app: use selected organisation
+            // Use selected organisation
             organisationIdForRpc = this.selectedOrganisation.id;
           } else {
-            // No context available - this shouldn't happen for authenticated users
-            logger.warn('EventService', 'No organisation context available for event fetch', {
+            // No context available - pass null to get all accessible events via event-app roles
+            // This allows users with event-app roles to see their events even without org context
+            logger.debug('EventService', 'No organisation context available, fetching all accessible events', {
               hasSelectedEvent: !!this.selectedEvent,
-              hasSelectedOrganisation: !!this.selectedOrganisation,
-              appRequiresEvent: this.appConfig?.requires_event
+              hasSelectedOrganisation: !!this.selectedOrganisation
             });
-            organisationIdForRpc = null; // Will return empty list
+            organisationIdForRpc = null; // Will return events user has access to via event-app roles
           }
         }
       } catch (superAdminCheckError) {
-        // If super admin check fails, fall back to organisation-scoped query
-        logger.warn('EventService', 'Failed to check super admin status, using organisation-scoped query', {
-          error: superAdminCheckError
-        });
-        // Fallback: use available context
-        if (this.selectedEvent) {
-          organisationIdForRpc = this.selectedEvent.organisation_id;
-        } else if (this.appConfig?.requires_event === true) {
-          // Event-required app: pass null to get all accessible events
-          organisationIdForRpc = null;
-        } else if (this.selectedOrganisation) {
-          organisationIdForRpc = this.selectedOrganisation.id;
+        // If super admin check fails, use cached value as fallback
+        // If cached value is true, trust it to avoid blocking super admins
+        if (this.isSuperAdmin) {
+          userIsSuperAdmin = true;
+          organisationIdForRpc = null; // Super admin gets all events
+          logger.warn('EventService', 'Super admin check failed, using cached super admin status', {
+            error: superAdminCheckError,
+            cachedIsSuperAdmin: this.isSuperAdmin
+          });
+        } else {
+          // Fallback: use available context
+          logger.warn('EventService', 'Failed to check super admin status, using organisation-scoped query', {
+            error: superAdminCheckError,
+            cachedIsSuperAdmin: this.isSuperAdmin
+          });
+          if (this.selectedEvent) {
+            organisationIdForRpc = this.selectedEvent.organisation_id;
+          } else if (this.selectedOrganisation) {
+            organisationIdForRpc = this.selectedOrganisation.id;
+          } else {
+            // No context - pass null to get all accessible events via event-app roles
+            organisationIdForRpc = null;
+          }
         }
       }
       
       // Call the RPC function following the established pattern
       // For super admins, pass null for p_organisation_id to see all events
+      logger.debug('EventService', 'Fetching events', {
+        userId: this.user.id,
+        organisationIdForRpc,
+        appName: this.appName,
+        hasSelectedEvent: !!this.selectedEvent,
+        hasSelectedOrganisation: !!this.selectedOrganisation,
+        isSuperAdmin: userIsSuperAdmin
+      });
+      
       let { data, error: rpcError } = await this.supabaseClient.rpc('data_user_events_get', {
         p_user_id: this.user.id,
         p_organisation_id: organisationIdForRpc,
         p_app_name: this.appName
       });
       
+      logger.debug('EventService', 'RPC response', {
+        dataLength: data?.length || 0,
+        hasError: !!rpcError,
+        error: rpcError
+      });
+      
       if (rpcError) {
         logger.error('EventService', 'RPC error fetching events:', rpcError);
         throw new Error(rpcError.message || 'Failed to fetch events');
@@ -482,9 +639,45 @@ export class EventService extends BaseService implements IEventService {
           updated_at: new Date().toISOString()
         }));
 
-        this.events = transformedEvents;
+        // Sort events by event_date descending (newest first)
+        // Handle null dates by putting them at the end
+        const sortedEvents = [...transformedEvents].sort((a, b) => {
+          // If both have dates, sort descending (newest first)
+          if (a.event_date && b.event_date) {
+            return new Date(b.event_date).getTime() - new Date(a.event_date).getTime();
+          }
+          // If only one has a date, prioritize the one with a date
+          if (a.event_date && !b.event_date) return -1;
+          if (!a.event_date && b.event_date) return 1;
+          // If neither has a date, maintain original order
+          return 0;
+        });
+        
+        this.events = sortedEvents;
         this.error = null;
 
+        // Validate selected event - if it's no longer in the events list, clear it
+        // This can happen when org context changes or events are refreshed
+        // Don't set userClearedEventRef to true in this case - it's an automatic clear, not user-initiated
+        if (this.selectedEvent) {
+          const selectedEventId = this.selectedEvent.event_id;
+          const eventStillExists = transformedEvents.some(
+            e => e.event_id === selectedEventId
+          );
+          if (!eventStillExists) {
+            // Event no longer available - clear it but don't mark as user-cleared
+            const previousUserClearedRef = this.userClearedEventRef;
+            this.selectedEvent = null;
+            this.setSelectedEventId?.(null);
+            // Restore the previous userClearedEventRef value - this was an automatic clear, not user-initiated
+            this.userClearedEventRef = previousUserClearedRef;
+            logger.debug('EventService', 'Cleared selected event - no longer in events list', {
+              previousEventId: selectedEventId,
+              eventsCount: transformedEvents.length
+            });
+          }
+        }
+
         // Reset auto-selection ref for new events
         this.hasAutoSelectedRef = false;
 
@@ -492,26 +685,62 @@ export class EventService extends BaseService implements IEventService {
         if (!skipLoadPersisted) {
           const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
           
+          logger.debug('EventService', 'Event selection check', {
+            persistedEventLoaded,
+            userClearedEventRef: this.userClearedEventRef,
+            eventsCount: transformedEvents.length,
+            hasSelectedEvent: !!this.selectedEvent
+          });
+          
           // If no persisted event was loaded and user hasn't explicitly cleared an event, auto-select the next event
           if (!persistedEventLoaded && !this.userClearedEventRef) {
             const nextEvent = this.getNextEventByDate(transformedEvents);
+            logger.debug('EventService', 'Auto-selection attempt', {
+              nextEventFound: !!nextEvent,
+              nextEventId: nextEvent?.event_id,
+              nextEventDate: nextEvent?.event_date
+            });
             if (nextEvent) {
               this.hasAutoSelectedRef = true;
               // Use setSelectedEvent() to ensure consistent behavior
               // Theme will be applied by useEventTheme() hook
               this.setSelectedEvent(nextEvent);
+              logger.debug('EventService', 'Auto-selected next event', {
+                eventId: nextEvent.event_id,
+                eventName: nextEvent.event_name,
+                eventDate: nextEvent.event_date
+              });
+            } else {
+              logger.debug('EventService', 'No next event found for auto-selection', {
+                eventsCount: transformedEvents.length,
+                eventsWithDates: transformedEvents.filter(e => e.event_date).length
+              });
             }
+          } else if (persistedEventLoaded) {
+            logger.debug('EventService', 'Skipped auto-selection - persisted event loaded');
+          } else if (this.userClearedEventRef) {
+            logger.debug('EventService', 'Skipped auto-selection - user explicitly cleared event');
           }
         } else {
           // If skipping persisted event load, still do auto-selection for new users
           if (!this.userClearedEventRef) {
             const nextEvent = this.getNextEventByDate(transformedEvents);
+            logger.debug('EventService', 'Auto-selection attempt (skip persisted)', {
+              nextEventFound: !!nextEvent,
+              nextEventId: nextEvent?.event_id
+            });
             if (nextEvent) {
               this.hasAutoSelectedRef = true;
               // Use setSelectedEvent() to ensure consistent behavior
               // Theme will be applied by useEventTheme() hook
               this.setSelectedEvent(nextEvent);
+              logger.debug('EventService', 'Auto-selected next event (skip persisted)', {
+                eventId: nextEvent.event_id,
+                eventName: nextEvent.event_name
+              });
             }
+          } else {
+            logger.debug('EventService', 'Skipped auto-selection (skip persisted) - user explicitly cleared event');
           }
         }
       }