@jmruthers/pace-core 0.5.78 → 0.5.80

package/src/providers/services/UnifiedAuthProvider.tsx

@@ -8,7 +8,7 @@
  * Note: RBAC functionality is available via useRBAC() hook from '@jmruthers/pace-core/rbac'
  */
 
-import React, { createContext, useContext, useMemo } from 'react';
+import React, { createContext, useContext, useMemo, useCallback, useRef } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { AuthServiceProvider } from './AuthServiceProvider';
 import { OrganisationServiceProvider } from './OrganisationServiceProvider';
@@ -177,19 +177,88 @@ function UnifiedAuthContextProvider({
   const eventLoading = eventService.isLoading();
   const totalLoading = authLoading || orgLoading || eventLoading;
   
-  // Log auth state for debugging with detailed loading states
-  console.log('[UnifiedAuthContext] Auth state:', {
-    isAuthenticated: isAuth,
-    user: currentUser?.email,
-    session: currentSession ? 'exists' : 'null',
-    totalLoading,
-    authLoading,
-    orgLoading,
-    eventLoading,
-    orgContextReady: organisationService.isContextReady()
-  });
+  // Extract all primitive values from services to use in dependencies
+  const authError = authService.getError();
+  const supabase = authService.getSupabaseClient();
+  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const organisations = organisationService.getOrganisations();
+  const userMemberships = organisationService.getUserMemberships();
+  const organisationError = organisationService.getError();
+  const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
+  const isContextReady = organisationService.isContextReady();
+  const events = eventService.getEvents();
+  const selectedEvent = eventService.getSelectedEvent();
+  const eventError = eventService.getError();
+  const showInactivityWarning = inactivityService.getShowInactivityWarning();
+  const inactivityTimeRemaining = inactivityService.getInactivityTimeRemaining();
+  const isIdle = inactivityService.isIdle();
+  const timeRemaining = inactivityService.getTimeRemaining();
+  const showWarning = inactivityService.isWarningShown();
+  const isTracking = inactivityService.isTracking();
+  const hasErrors = !!(authError || organisationError || eventError);
+
+  // Create stable references for all methods using useCallback
+  const signIn = useCallback((email: string, password?: string) => authService.signIn(email, password), [authService]);
+  const signUp = useCallback((email: string, password: string) => authService.signUp(email, password), [authService]);
+  const signOut = useCallback(() => authService.signOut(), [authService]);
+  const resetPassword = useCallback((email: string) => authService.resetPassword(email), [authService]);
+  const updatePassword = useCallback((password: string) => authService.updatePassword(password), [authService]);
+  const refreshSession = useCallback(() => authService.refreshSession(), [authService]);
+  
+  const switchOrganisation = useCallback((orgId: string) => organisationService.switchOrganisation(orgId), [organisationService]);
+  const getUserRole = useCallback((orgId?: string) => organisationService.getUserRole(orgId), [organisationService]);
+  const validateOrganisationAccess = useCallback((orgId: string) => organisationService.validateOrganisationAccess(orgId), [organisationService]);
+  const refreshOrganisations = useCallback(() => organisationService.refreshOrganisations(), [organisationService]);
+  const ensureOrganisationContext = useCallback(() => organisationService.ensureOrganisationContext(), [organisationService]);
+  const isOrganisationSecure = useCallback(() => organisationService.isOrganisationSecure(), [organisationService]);
+  const getPrimaryOrganisation = useCallback(() => organisationService.getPrimaryOrganisation(), [organisationService]);
+  
+  const setSelectedEvent = useCallback((event: Event | null) => eventService.setSelectedEvent(event), [eventService]);
+  const refreshEvents = useCallback(() => eventService.refreshEvents(), [eventService]);
+  
+  const resetActivity = useCallback(() => inactivityService.resetActivity(), [inactivityService]);
+  const startTracking = useCallback(() => inactivityService.startTracking(), [inactivityService]);
+  const stopTracking = useCallback(() => inactivityService.stopTracking(), [inactivityService]);
+  const handleIdleLogout = useCallback(() => inactivityService.handleIdleLogout(), [inactivityService]);
+  const handleStaySignedIn = useCallback(() => inactivityService.handleStaySignedIn(), [inactivityService]);
+  const handleSignOutNow = useCallback(() => inactivityService.handleSignOutNow(), [inactivityService]);
+
+  // Use ref to track previous state for conditional logging (dev only)
+  const prevStateRef = useRef<{
+    isAuthenticated: boolean;
+    userEmail: string | undefined;
+    totalLoading: boolean;
+  } | null>(null);
   
-  // Memoized combined context value
+  // Only log when state actually changes (dev mode detection)
+  const isDev = import.meta.env.DEV || import.meta.env.MODE === 'development';
+  if (isDev) {
+    const currentState = {
+      isAuthenticated: isAuth,
+      userEmail: currentUser?.email,
+      totalLoading,
+    };
+    
+    const prevState = prevStateRef.current;
+    if (!prevState || 
+        prevState.isAuthenticated !== currentState.isAuthenticated ||
+        prevState.userEmail !== currentState.userEmail ||
+        prevState.totalLoading !== currentState.totalLoading) {
+      console.log('[UnifiedAuthContext] Auth state changed:', {
+        isAuthenticated: isAuth,
+        user: currentUser?.email,
+        session: currentSession ? 'exists' : 'null',
+        totalLoading,
+        authLoading,
+        orgLoading,
+        eventLoading,
+        orgContextReady: isContextReady
+      });
+      prevStateRef.current = currentState;
+    }
+  }
+  
+  // Memoized combined context value - only depends on primitive values
   const contextValue = useMemo<UnifiedAuthContextType>(() => {
     return {
     // Auth state
@@ -197,69 +266,121 @@ function UnifiedAuthContextProvider({
     session: currentSession,
     isAuthenticated: isAuth,
     authLoading: authLoading,
-    authError: authService.getError(),
-    error: authService.getError(), // Alias for backward compatibility
-    supabase: authService.getSupabaseClient(),
+    authError: authError,
+    error: authError, // Alias for backward compatibility
+    supabase: supabase,
     
     // Auth methods
-    signIn: authService.signIn.bind(authService),
-    signUp: authService.signUp.bind(authService),
-    signOut: authService.signOut.bind(authService),
-    resetPassword: authService.resetPassword.bind(authService),
-    updatePassword: authService.updatePassword.bind(authService),
-    refreshSession: authService.refreshSession.bind(authService),
+    signIn,
+    signUp,
+    signOut,
+    resetPassword,
+    updatePassword,
+    refreshSession,
 
     // Organisation state
-    selectedOrganisation: organisationService.getSelectedOrganisation(),
-    organisations: organisationService.getOrganisations(),
-    userMemberships: organisationService.getUserMemberships(),
+    selectedOrganisation: selectedOrganisation,
+    organisations: organisations,
+    userMemberships: userMemberships,
     organisationLoading: orgLoading,
-    organisationError: organisationService.getError(),
-    hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),
-    isContextReady: organisationService.isContextReady(),
+    organisationError: organisationError,
+    hasValidOrganisationContext: hasValidOrganisationContext,
+    isContextReady: isContextReady,
     
     // Organisation methods
-    switchOrganisation: organisationService.switchOrganisation.bind(organisationService),
-    getUserRole: organisationService.getUserRole.bind(organisationService),
-    validateOrganisationAccess: organisationService.validateOrganisationAccess.bind(organisationService),
-    refreshOrganisations: organisationService.refreshOrganisations.bind(organisationService),
-    ensureOrganisationContext: organisationService.ensureOrganisationContext.bind(organisationService),
-    isOrganisationSecure: organisationService.isOrganisationSecure.bind(organisationService),
-    getPrimaryOrganisation: organisationService.getPrimaryOrganisation.bind(organisationService),
+    switchOrganisation,
+    getUserRole,
+    validateOrganisationAccess,
+    refreshOrganisations,
+    ensureOrganisationContext,
+    isOrganisationSecure,
+    getPrimaryOrganisation,
 
     // Event state
-    events: eventService.getEvents(),
-    selectedEvent: eventService.getSelectedEvent(),
+    events: events,
+    selectedEvent: selectedEvent,
     eventLoading: eventLoading,
-    eventError: eventService.getError(),
+    eventError: eventError,
     
     // Event methods
-    setSelectedEvent: eventService.setSelectedEvent.bind(eventService),
-    refreshEvents: eventService.refreshEvents.bind(eventService),
+    setSelectedEvent,
+    refreshEvents,
 
     // Inactivity state
-    showInactivityWarning: inactivityService.getShowInactivityWarning(),
-    inactivityTimeRemaining: inactivityService.getInactivityTimeRemaining(),
-    isIdle: inactivityService.isIdle(),
-    timeRemaining: inactivityService.getTimeRemaining(),
-    showWarning: inactivityService.isWarningShown(),
-    isTracking: inactivityService.isTracking(),
+    showInactivityWarning: showInactivityWarning,
+    inactivityTimeRemaining: inactivityTimeRemaining,
+    isIdle: isIdle,
+    timeRemaining: timeRemaining,
+    showWarning: showWarning,
+    isTracking: isTracking,
     
     // Inactivity methods
-    resetActivity: inactivityService.resetActivity.bind(inactivityService),
-    startTracking: inactivityService.startTracking.bind(inactivityService),
-    stopTracking: inactivityService.stopTracking.bind(inactivityService),
-    handleIdleLogout: inactivityService.handleIdleLogout.bind(inactivityService),
-    handleStaySignedIn: inactivityService.handleStaySignedIn.bind(inactivityService),
-    handleSignOutNow: inactivityService.handleSignOutNow.bind(inactivityService),
+    resetActivity,
+    startTracking,
+    stopTracking,
+    handleIdleLogout,
+    handleStaySignedIn,
+    handleSignOutNow,
 
     // Additional unified properties
     appName,
     appConfig: appConfig,
     isLoading: totalLoading,
-    hasErrors: !!(authService.getError() || organisationService.getError() || eventService.getError()),
+    hasErrors: hasErrors,
   };
-  }, [authService, organisationService, eventService, inactivityService, appName, appConfig, currentUser, currentSession, isAuth, authLoading, orgLoading, eventLoading, totalLoading]);
+  }, [
+    // All primitive values extracted from services
+    // Note: Arrays/objects from services are stable references (same reference unless data changes)
+    currentUser,
+    currentSession,
+    isAuth,
+    authLoading,
+    authError,
+    supabase,
+    selectedOrganisation,
+    organisations,
+    userMemberships,
+    orgLoading,
+    organisationError,
+    hasValidOrganisationContext,
+    isContextReady,
+    events,
+    selectedEvent,
+    eventLoading,
+    eventError,
+    showInactivityWarning,
+    inactivityTimeRemaining,
+    isIdle,
+    timeRemaining,
+    showWarning,
+    isTracking,
+    totalLoading,
+    hasErrors,
+    appName,
+    appConfig,
+    // Stable function references from useCallback (services are stable, so callbacks are too)
+    signIn,
+    signUp,
+    signOut,
+    resetPassword,
+    updatePassword,
+    refreshSession,
+    switchOrganisation,
+    getUserRole,
+    validateOrganisationAccess,
+    refreshOrganisations,
+    ensureOrganisationContext,
+    isOrganisationSecure,
+    getPrimaryOrganisation,
+    setSelectedEvent,
+    refreshEvents,
+    resetActivity,
+    startTracking,
+    stopTracking,
+    handleIdleLogout,
+    handleStaySignedIn,
+    handleSignOutNow,
+  ]);
 
   return (
     <UnifiedAuthContext.Provider value={contextValue}>
@@ -285,11 +406,8 @@ function EventServiceProviderWrapper({
   const organisationService = useOrganisationService();
   const selectedOrganisation = organisationService.getSelectedOrganisation();
 
-  // Only render EventServiceProvider if user and session are available
-  if (!user || !session) {
-    return <>{children}</>;
-  }
-
+  // Always render EventServiceProvider - it handles null user/session gracefully
+  // This ensures EventServiceContext is always available for components calling useEvents()
   return (
     <EventServiceProvider
       supabaseClient={supabaseClient}

package/src/services/EventService.ts

@@ -89,6 +89,10 @@ export class EventService extends BaseService implements IEventService {
 
   // Event state getters
   getEvents(): Event[] {
+    console.log('[EventService] getEvents() called, returning:', {
+      count: this.events.length,
+      events: this.events.map(e => ({ id: e.event_id, name: e.event_name }))
+    });
     return this.events;
   }
 
@@ -298,6 +302,10 @@ export class EventService extends BaseService implements IEventService {
         }));
 
         this.events = transformedEvents;
+        console.log('[EventService] Set events in service:', {
+          count: transformedEvents.length,
+          events: transformedEvents.map(e => ({ id: e.event_id, name: e.event_name }))
+        });
         this.error = null;
 
         // Reset auto-selection ref for new events

package/src/styles/core.css

@@ -176,7 +176,6 @@
     margin: 0.25lh 0;
     padding-left: 1.5rem;
   }
-
   ul {
     list-style-type: disc;
   }
@@ -198,7 +197,7 @@
 
   small {
     font-size: 0.875em;
-    color: var(--color-main-500);
+    color: var(--color-main-600);
   }
   
   .appGradient {