@jmruthers/pace-core 0.6.10 → 0.6.12

package/src/services/EventService.ts

@@ -86,129 +86,123 @@ export class EventService extends BaseService implements IEventService {
     const newOrgId = selectedOrganisation?.id;
     const previousUserId = this.user?.id || null;
     const newUserId = user?.id || null;
-    const _previousAppName = this.appName;
-    
-    // If user changed, clear previous user's event selection from storage
-    if (previousUserId !== newUserId) {
-      if (previousUserId !== null) {
-        await this.clearEventSelectionForUser(previousUserId);
-      }
-      // If user is now null (logout), clear current selection state
-      if (newUserId === null) {
-        this.selectedEvent = null;
-        this.setSelectedEventId?.(null);
-      }
-      // Reset initialization when user changes
-      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;
-      
+
+    await this.handleUserChange(previousUserId, newUserId);
+    this.applyNewDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
+    await this.updateSuperAdminStatus(user);
+    this.handleOrganisationChange(previousOrgId, newOrgId);
+
+    this.notify();
+  }
+
+  private async handleUserChange(previousUserId: string | null, newUserId: string | null): Promise<void> {
+    if (previousUserId === newUserId) {
+      return;
     }
-    
+    if (previousUserId !== null) {
+      await this.clearEventSelectionForUser(previousUserId);
+    }
+    if (newUserId === null) {
+      this.selectedEvent = null;
+      this.setSelectedEventId?.(null);
+    }
+    this.resetInitialization();
+    this.isInitializedRef = false;
+    this.isFetchingRef = false;
+    this.userClearedEventRef = false;
+    this.hasAutoSelectedRef = false;
+  }
+
+  private applyNewDependencies(
+    supabaseClient: SupabaseClient,
+    user: User | null,
+    session: Session | null,
+    appName: string,
+    selectedOrganisation: Organisation | null,
+    setSelectedEventId: (eventId: string | null) => void
+  ): void {
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
-    
-    // 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 {
-        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);
-        } 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 in updateDependencies', { 
-          error,
+  private async updateSuperAdminStatus(user: User | null): Promise<void> {
+    if (!user?.id) {
+      this.isSuperAdmin = false;
+      return;
+    }
+    try {
+      const { isRBACInitialized, isSuperAdmin: checkSuperAdmin, setupRBAC } = await import('../rbac/api');
+      if (!isRBACInitialized() && this.supabaseClient) {
+        setupRBAC(this.supabaseClient);
+      }
+      if (isRBACInitialized()) {
+        const result = await checkSuperAdmin(user.id as UUID);
+        this.isSuperAdmin = result.ok && result.data;
+      } else {
+        logger.warn('EventService', 'RBAC not initialized in updateDependencies, keeping existing super admin status', {
           userId: user.id,
-          existingIsSuperAdmin: this.isSuperAdmin
+          existingIsSuperAdmin: this.isSuperAdmin,
+          note: 'RBAC should be initialized by UnifiedAuthProvider. This may indicate EventService is being used outside the provider.'
         });
-        // 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;
+    } catch (error) {
+      logger.warn('EventService', 'Failed to check super admin status in updateDependencies', {
+        error,
+        userId: user.id,
+        existingIsSuperAdmin: this.isSuperAdmin
+      });
     }
-    
-    // If organisation changed (from null to value, or different org, or value to null), reset initialization
-    // This ensures events are re-fetched when organisation context changes
-    // For event-required apps, selectedOrganisation will be null, so we need to reset when it changes from undefined/null to null
-    if (previousOrgId !== newOrgId) {
-      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)
-      // 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);
-        }
+  private handleOrganisationChange(previousOrgId: string | undefined | null, newOrgId: string | undefined | null): void {
+    if (previousOrgId === newOrgId) {
+      return;
+    }
+    this.resetInitialization();
+    this.isInitializedRef = false;
+    this.isFetchingRef = false;
+
+    const shouldClearEvents = !this.isSuperAdmin;
+    const isFirstOrgSet =
+      (previousOrgId === null || previousOrgId === undefined) &&
+      newOrgId !== null &&
+      newOrgId !== undefined;
+
+    if (isFirstOrgSet) {
+      const hadAutoSelectedEvent = this.hasAutoSelectedRef && !!this.selectedEvent;
+      this.userClearedEventRef = false;
+      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
+      });
+      return;
+    }
+
+    const switchingOrgs =
+      previousOrgId != null &&
+      newOrgId != null &&
+      previousOrgId !== newOrgId;
+    const orgRemoved = previousOrgId != null && newOrgId === null;
+
+    if (switchingOrgs && shouldClearEvents) {
+      this.events = [];
+      this.setSelectedEvent(null);
+    } else if (orgRemoved && shouldClearEvents) {
+      this.events = [];
+      this.setSelectedEvent(null);
     }
-    
-    this.notify();
   }
 
   // Event state getters
@@ -234,10 +228,15 @@ export class EventService extends BaseService implements IEventService {
   // Event methods
   setSelectedEvent(event: Event | null): void {
     if (event) {
-      // No validation needed: For event-required apps, org is derived from event
-      // For org-required apps, event is optional and doesn't need validation
-      // RLS policies handle security at the database level
-      this.selectedEvent = event;
+      // Ensure organisation_id is set when we have selectedOrganisation, so scope resolution
+      // (useResolvedScope / useDataTableScope) gets org early and permission checks succeed.
+      const orgId = (event as { organisation_id?: string | null }).organisation_id;
+      const missingOrg = !orgId || (typeof orgId === 'string' && orgId.trim() === '');
+      const eventToStore: Event =
+        missingOrg && this.selectedOrganisation?.id
+          ? ({ ...event, organisation_id: this.selectedOrganisation.id } as Event)
+          : event;
+      this.selectedEvent = eventToStore;
       this.setSelectedEventId?.(event.event_id);
       // Persist asynchronously (don't await to avoid blocking)
       this.persistEventSelection(event.event_id).catch(error => {
@@ -417,20 +416,146 @@ export class EventService extends BaseService implements IEventService {
     // Cleanup any resources
   }
 
+  private async resolveOrganisationIdForRpc(): Promise<string | null> {
+    let userIsSuperAdmin = this.isSuperAdmin;
+    try {
+      const { isRBACInitialized, isSuperAdmin: checkSuperAdmin, setupRBAC } = await import('../rbac/api');
+      if (!isRBACInitialized() && this.supabaseClient) {
+        setupRBAC(this.supabaseClient);
+      }
+      if (isRBACInitialized()) {
+        const result = await checkSuperAdmin(this.user!.id as UUID);
+        userIsSuperAdmin = result.ok && result.data;
+        this.isSuperAdmin = userIsSuperAdmin;
+      } else {
+        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) {
+        return null;
+      }
+      if (this.selectedEvent) {
+        return this.selectedEvent.organisation_id;
+      }
+      if (this.selectedOrganisation) {
+        return this.selectedOrganisation.id;
+      }
+      return null;
+    } catch (superAdminCheckError) {
+      if (this.isSuperAdmin) {
+        logger.warn('EventService', 'Super admin check failed, using cached super admin status', {
+          error: superAdminCheckError,
+          cachedIsSuperAdmin: this.isSuperAdmin
+        });
+        return null;
+      }
+      logger.warn('EventService', 'Failed to check super admin status, using organisation-scoped query', {
+        error: superAdminCheckError,
+        cachedIsSuperAdmin: this.isSuperAdmin
+      });
+      if (this.selectedEvent) {
+        return this.selectedEvent.organisation_id;
+      }
+      if (this.selectedOrganisation) {
+        return this.selectedOrganisation.id;
+      }
+      return null;
+    }
+  }
+
+  private transformRpcDataToEvents(data: unknown): Event[] {
+    interface EventRpcResponse {
+      event_id: string;
+      event_name: string;
+      event_code: string;
+      event_date: string | null;
+      event_venue: string | null;
+      event_participants: number | null;
+      event_colours: Record<string, unknown> | null;
+      organisation_id: string;
+      is_visible: boolean;
+    }
+    const eventsData = Array.isArray(data) ? data : [];
+    const transformed: Event[] = eventsData.map((event: EventRpcResponse) => ({
+      id: event.event_id,
+      event_id: event.event_id,
+      event_name: event.event_name,
+      event_code: event.event_code,
+      event_date: event.event_date ?? undefined,
+      event_venue: event.event_venue ?? undefined,
+      event_participants: event.event_participants ?? undefined,
+      event_colours: event.event_colours,
+      event_logo: '',
+      organisation_id: assertOrganisationId(event.organisation_id),
+      is_visible: event.is_visible,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    }));
+    return [...transformed].sort((a, b) => {
+      if (a.event_date && b.event_date) {
+        return new Date(b.event_date).getTime() - new Date(a.event_date).getTime();
+      }
+      if (a.event_date && !b.event_date) return -1;
+      if (!a.event_date && b.event_date) return 1;
+      return 0;
+    });
+  }
+
+  private validateSelectedEventInList(events: Event[]): void {
+    if (!this.selectedEvent) {
+      return;
+    }
+    const selectedEventId = this.selectedEvent.event_id;
+    const eventStillExists = events.some(e => e.event_id === selectedEventId);
+    if (!eventStillExists) {
+      const previousUserClearedRef = this.userClearedEventRef;
+      this.selectedEvent = null;
+      this.setSelectedEventId?.(null);
+      this.userClearedEventRef = previousUserClearedRef;
+    }
+  }
+
+  private async runPersistedOrAutoSelection(events: Event[], skipLoadPersisted: boolean): Promise<void> {
+    this.hasAutoSelectedRef = false;
+    if (!skipLoadPersisted) {
+      const persistedEventLoaded = await this.loadPersistedEvent(events);
+      if (!persistedEventLoaded && !this.userClearedEventRef) {
+        const nextEvent = this.getNextEventByDate(events);
+        if (nextEvent) {
+          this.hasAutoSelectedRef = true;
+          this.setSelectedEvent(nextEvent);
+        }
+      }
+    } else if (!this.userClearedEventRef) {
+      const nextEvent = this.getNextEventByDate(events);
+      if (nextEvent) {
+        this.hasAutoSelectedRef = true;
+        this.setSelectedEvent(nextEvent);
+      }
+    }
+  }
+
   private async fetchEvents(skipLoadPersisted: boolean = false): Promise<void> {
-    // 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) {
-      // Already false from initialization, just notify
       this.notify();
       return;
     }
-    
-    // Only set loading to true if we actually have dependencies and are going to fetch
+
     this._isLoading = true;
     this.notify();
 
-    // Prevent multiple simultaneous fetches
     if (this.isFetchingRef) {
       return;
     }
@@ -439,221 +564,31 @@ export class EventService extends BaseService implements IEventService {
     const isMounted = true;
 
     try {
-      // 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
-      // For org-required apps: org comes from selectedOrganisation
-      // Super admins: pass null to see all events
-      let organisationIdForRpc: string | null = null;
-      
-      // Check if user is super admin first
-      // 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 {
-        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);
-        }
+      const organisationIdForRpc = await this.resolveOrganisationIdForRpc();
 
-        // 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;
-        } 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 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.selectedOrganisation) {
-            // Use selected organisation
-            organisationIdForRpc = this.selectedOrganisation.id;
-          } else {
-            // 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
-            organisationIdForRpc = null; // Will return events user has access to via event-app roles
-          }
-        }
-      } catch (superAdminCheckError) {
-        // 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
-      
-      const { data, error: rpcError } = await this.supabaseClient.rpc('data_user_events_get', {
+      const { 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
       });
-      
-      
+
       if (rpcError) {
         logger.error('EventService', 'RPC error fetching events:', rpcError);
         throw new Error(rpcError.message || 'Failed to fetch events');
       }
 
       if (isMounted) {
-        const eventsData = data || [];
-
-        // Transform the data to match our Event interface
-        // Type for RPC response from data_user_events_get
-        interface EventRpcResponse {
-          event_id: string;
-          event_name: string;
-          event_code: string;
-          event_date: string | null;
-          event_venue: string | null;
-          event_participants: number | null;
-          event_colours: Record<string, unknown> | null;
-          organisation_id: string;
-          is_visible: boolean;
-        }
-        
-        const transformedEvents: Event[] = eventsData.map((event: EventRpcResponse) => ({
-          id: event.event_id,
-          event_id: event.event_id,
-          event_name: event.event_name,
-          event_code: event.event_code,
-          event_date: event.event_date,
-          event_venue: event.event_venue,
-          event_participants: event.event_participants,
-          event_colours: event.event_colours,
-          event_logo: '', // No logo field in event table
-          organisation_id: assertOrganisationId(event.organisation_id),
-          is_visible: event.is_visible,
-          created_at: new Date().toISOString(),
-          updated_at: new Date().toISOString()
-        }));
-
-        // 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;
+        const transformedEvents = this.transformRpcDataToEvents(data ?? []);
+        this.events = transformedEvents;
         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;
-            // Cleared selected event - no longer in events list
-          }
-        }
-
-        // Reset auto-selection ref for new events
-        this.hasAutoSelectedRef = false;
-
-        // Try to restore persisted event first (only if not skipping)
-        if (!skipLoadPersisted) {
-          const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
-          
-          // 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);
-            if (nextEvent) {
-              this.hasAutoSelectedRef = true;
-              // Use setSelectedEvent() to ensure consistent behavior
-              // Theme will be applied by useEventTheme() hook
-              this.setSelectedEvent(nextEvent);
-            }
-          } else if (persistedEventLoaded) {
-            // Skipped auto-selection - persisted event loaded
-          } else if (this.userClearedEventRef) {
-            // 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);
-            if (nextEvent) {
-              this.hasAutoSelectedRef = true;
-              // Use setSelectedEvent() to ensure consistent behavior
-              // Theme will be applied by useEventTheme() hook
-              this.setSelectedEvent(nextEvent);
-            }
-          } else {
-            // Skipped auto-selection (skip persisted) - user explicitly cleared event
-          }
-        }
+        this.validateSelectedEventInList(transformedEvents);
+        await this.runPersistedOrAutoSelection(transformedEvents, skipLoadPersisted);
       }
     } catch (err) {
       logger.error('EventService', 'Error fetching events:', err);
       const _error = err instanceof Error ? err : new Error('Unknown error occurred');
-      
+
       if (isMounted) {
         this.error = _error;
         this.events = [];