@jmruthers/pace-core 0.5.188 → 0.5.190

package/src/providers/services/EventServiceProvider.tsx

@@ -31,17 +31,18 @@ export interface EventServiceProviderProps {
   setSelectedEventId: (eventId: string | null) => void;
 }
 
-export function EventServiceProvider({ 
-  children, 
-  supabaseClient, 
-  user, 
-  session, 
+export function EventServiceProvider({
+  children,
+  supabaseClient,
+  user,
+  session,
   appName,
   selectedOrganisation,
   setSelectedEventId
 }: EventServiceProviderProps) {
   // Create service instance once with useRef to avoid recreation on dependency changes
   const eventServiceRef = useRef<EventService | null>(null);
+  const initializingRef = useRef(false);
   
   if (!eventServiceRef.current) {
     eventServiceRef.current = new EventService(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
@@ -53,25 +54,44 @@ export function EventServiceProvider({
   // Note: eventService is a ref and never changes, so we don't include it in dependencies
   useEffect(() => {
     let isMounted = true;
-    
+
+    if (initializingRef.current) {
+      return;
+    }
+
     const updateAndInitialize = async () => {
-      // Update dependencies (now async to handle user change cleanup)
-      await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
-      
-      if (!isMounted) return;
-      
-      // Re-initialize service when dependencies change
-      await eventService.initialize().catch(error => {
-        if (isMounted) {
-          logger.error('EventServiceProvider', 'Failed to initialize event service:', error);
-        }
-      });
+      initializingRef.current = true;
+
+      try {
+        logger.debug('EventServiceProvider', 'Updating dependencies and initializing', {
+          hasUser: !!user,
+          hasSession: !!session,
+          appName,
+          hasSelectedOrganisation: !!selectedOrganisation,
+          organisationId: selectedOrganisation?.id
+        });
+
+        // Update dependencies (now async to handle user change cleanup)
+        await eventService.updateDependencies(supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId);
+
+        if (!isMounted) return;
+
+        // Re-initialize service when dependencies change
+        await eventService.initialize().catch(error => {
+          if (isMounted) {
+            logger.error('EventServiceProvider', 'Failed to initialize event service:', error);
+          }
+        });
+      } finally {
+        initializingRef.current = false;
+      }
     };
 
     updateAndInitialize();
 
     return () => {
       isMounted = false;
+      initializingRef.current = false;
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
     // eventService is a ref and never changes, so we exclude it from dependencies

package/src/providers/services/InactivityServiceProvider.tsx

@@ -25,8 +25,8 @@ export interface InactivityServiceProviderProps {
   supabaseClient: SupabaseClient;
   user: User | null;
   session: Session | null;
-  idleTimeoutMs?: number;
-  warnBeforeMs?: number;
+  idleTimeoutMs: number; // REQUIRED: No default - must be explicitly provided
+  warnBeforeMs: number; // REQUIRED: No default - must be explicitly provided
   onIdleLogout: (reason: 'inactivity') => void;
 }
 
@@ -35,8 +35,8 @@ export function InactivityServiceProvider({
   supabaseClient, 
   user, 
   session, 
-  idleTimeoutMs = 30 * 60 * 1000,
-  warnBeforeMs = 60 * 1000,
+  idleTimeoutMs, // REQUIRED: No default - must be explicitly provided
+  warnBeforeMs, // REQUIRED: No default - must be explicitly provided
   onIdleLogout
 }: InactivityServiceProviderProps) {
   // Create service instance once with useRef to avoid recreation on dependency changes

package/src/providers/services/OrganisationServiceProvider.tsx

@@ -52,7 +52,14 @@ export function OrganisationServiceProvider({
     organisationService.initialize()
       .catch(error => {
         if (isMounted) {
-          logger.error('OrganisationServiceProvider', 'Failed to initialize organisation service:', error);
+          // "User has no access to active organisations" is a valid state for users without orgs (e.g., profile pages)
+          // Log it as a warning instead of an error to reduce noise
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          if (errorMessage === 'User has no access to active organisations') {
+            logger.warn('OrganisationServiceProvider', 'User has no active organisations (this is expected for users without organisation access):', error);
+          } else {
+            logger.error('OrganisationServiceProvider', 'Failed to initialize organisation service:', error);
+          }
         }
       });
 

package/src/providers/services/UnifiedAuthProvider.tsx

@@ -16,6 +16,7 @@ import { EventServiceProvider } from './EventServiceProvider';
 import { InactivityServiceProvider } from './InactivityServiceProvider';
 import { useAuthService } from '../../hooks/services/useAuthService';
 import { useOrganisationService } from '../../hooks/services/useOrganisationService';
+import { useOrganisations } from '../../hooks/useOrganisations';
 import { useEventService } from '../../hooks/services/useEventService';
 import { useInactivityService } from '../../hooks/services/useInactivityService';
 import { useSessionRestoration } from '../../hooks/useSessionRestoration';
@@ -154,6 +155,7 @@ function UnifiedAuthContextProvider({
   children, 
   appName,
   appConfig = { requires_event: true }, // Default to requiring events
+  supabaseClient: supabaseClientProp,
   ...props 
 }: UnifiedAuthProviderProps) {
   const authService = useAuthService();
@@ -196,27 +198,57 @@ function UnifiedAuthContextProvider({
   const currentSession = authService.getSession();
   const isAuth = !!(currentUser && currentSession);
   
-  // Get supabase client early so we can use it in useEffect
-  const supabase = authService.getSupabaseClient();
+  // Stabilize supabase client reference to prevent infinite re-renders
+  // Memoize the supabaseClient prop to ensure a stable reference across renders
+  // This is critical for preventing infinite loops when supabase is used in useEffect dependency arrays
+  // The reference will only change when supabaseClientProp actually changes (different instance)
+  // If the consuming app creates the client once and reuses it, this will be stable
+  const supabase = useMemo(() => supabaseClientProp, [supabaseClientProp]);
   
   // Resolve appId immediately when user logs in (don't wait for organisation/event)
   // This makes appId available early for navigation menu filtering
   const [appId, setAppId] = useState<string | undefined>(undefined);
   const isResolvingAppIdRef = useRef(false);
+  const resolvedAppIdRef = useRef<string | undefined>(undefined);
+  const resolvedUserIdRef = useRef<string | undefined>(undefined);
   
   useEffect(() => {
+    // Clear appId when user logs out or changes
+    if (!isAuth) {
+      // User logged out - clear all refs and state
+      resolvedAppIdRef.current = undefined;
+      resolvedUserIdRef.current = undefined;
+      setAppId(undefined);
+      return;
+    }
+    
+    // User changed - clear previous resolution to allow re-resolution for new user
+    if (currentUser?.id && resolvedUserIdRef.current && resolvedUserIdRef.current !== currentUser.id) {
+      resolvedAppIdRef.current = undefined;
+      resolvedUserIdRef.current = undefined;
+      setAppId(undefined);
+    }
+    
     // Resolve appId as soon as we have user + supabase + appName
     // Don't wait for organisation or event - appId resolution only needs user + appName
+    // Extract userId to stable const to prevent reference issues
+    const currentUserId = currentUser?.id;
+    
+    // Only resolve if we haven't already resolved for this user
     if (
       isAuth &&
-      currentUser?.id &&
+      currentUserId &&
       supabase &&
       appName &&
-      !appId &&
+      resolvedUserIdRef.current !== currentUserId && // Haven't resolved for this user yet
       !isResolvingAppIdRef.current
     ) {
+      // CRITICAL FIX: Set refs IMMEDIATELY (synchronously) before async operation
+      // This prevents race conditions where effect re-runs before async completes
       isResolvingAppIdRef.current = true;
-      const userId = currentUser.id;
+      resolvedUserIdRef.current = currentUserId; // Set BEFORE async, not after
+      
+      const userId = currentUserId;
       const appNameValue = appName;
       
       // Resolve appId immediately
@@ -231,11 +263,16 @@ function UnifiedAuthContextProvider({
           });
           
           if (result?.appId) {
+            resolvedAppIdRef.current = result.appId;
+            // resolvedUserIdRef already set above to prevent race conditions
             setAppId(result.appId);
             logger.debug('UnifiedAuthProvider', 'appId resolved on login', {
               appId: result.appId,
               appName: appNameValue
             });
+          } else {
+            // No appId returned - reset ref to allow retry
+            resolvedUserIdRef.current = undefined;
           }
         } catch (error) {
           logger.error('UnifiedAuthProvider', 'Failed to resolve appId on login', {
@@ -243,39 +280,71 @@ function UnifiedAuthContextProvider({
             appName: appNameValue,
             userId
           });
+          // Reset ref on error to allow retry
+          resolvedUserIdRef.current = undefined;
         } finally {
           isResolvingAppIdRef.current = false;
         }
       }).catch((importError) => {
         logger.error('UnifiedAuthProvider', 'Failed to import RBAC API', importError);
         isResolvingAppIdRef.current = false;
+        // Reset ref on import error to allow retry
+        resolvedUserIdRef.current = undefined;
       });
     }
-    
-    // Clear appId when user logs out
-    if (!isAuth) {
-      setAppId(undefined);
-    }
-  }, [isAuth, currentUser?.id, supabase, appName, appId]);
+  }, [isAuth, currentUser?.id, supabase, appName]); // Removed appId from deps - it's the output, not an input. currentUser?.id is stable primitive.
 
   // Subscribe to service state changes to trigger re-renders
   // Use useReducer to force updates when services notify
   const [, forceUpdate] = useReducer(x => x + 1, 0);
-  
+  const forceUpdateTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const debouncedForceUpdate = useCallback(() => {
+    if (forceUpdateTimeoutRef.current) {
+      clearTimeout(forceUpdateTimeoutRef.current);
+    }
+
+    forceUpdateTimeoutRef.current = setTimeout(() => {
+      forceUpdate();
+      forceUpdateTimeoutRef.current = null;
+    }, 0);
+  }, [forceUpdate]);
+
+  // Use refs for services to avoid dependency on service instances
+  // This prevents re-subscriptions when service instances change reference
+  const authServiceRef = useRef(authService);
+  const organisationServiceRef = useRef(organisationService);
+  const eventServiceRef = useRef(eventService);
+  const inactivityServiceRef = useRef(inactivityService);
+
+  // Update refs when services change
   useEffect(() => {
-    // Subscribe to all service changes
-    const unsubscribeAuth = authService.subscribe(() => forceUpdate());
-    const unsubscribeOrg = organisationService.subscribe(() => forceUpdate());
-    const unsubscribeEvent = eventService.subscribe(() => forceUpdate());
-    const unsubscribeInactivity = inactivityService.subscribe(() => forceUpdate());
-    
+    authServiceRef.current = authService;
+    organisationServiceRef.current = organisationService;
+    eventServiceRef.current = eventService;
+    inactivityServiceRef.current = inactivityService;
+  }, [authService, organisationService, eventService, inactivityService]);
+
+  // Subscribe using refs - only depends on debouncedForceUpdate
+  // This prevents re-subscriptions when service instances change
+  useEffect(() => {
+    // Subscribe to all service changes using current refs
+    const unsubscribeAuth = authServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeOrg = organisationServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeEvent = eventServiceRef.current.subscribe(debouncedForceUpdate);
+    const unsubscribeInactivity = inactivityServiceRef.current.subscribe(debouncedForceUpdate);
+
     return () => {
       unsubscribeAuth();
       unsubscribeOrg();
       unsubscribeEvent();
       unsubscribeInactivity();
+
+      if (forceUpdateTimeoutRef.current) {
+        clearTimeout(forceUpdateTimeoutRef.current);
+      }
     };
-  }, [authService, organisationService, eventService, inactivityService]);
+  }, [debouncedForceUpdate]);
 
   // Get loading states - these will trigger re-renders when services change
   const authLoading = authService.isLoading();
@@ -287,10 +356,14 @@ function UnifiedAuthContextProvider({
   // Extract all primitive values from services to use in dependencies
   const authError = authService.getError();
   // supabase is already declared above (line 198)
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  const rawSelectedOrganisation = organisationService.getSelectedOrganisation();
   const organisations = organisationService.getOrganisations();
   const userMemberships = organisationService.getUserMemberships();
   const organisationError = organisationService.getError();
+  
+  // For event-required apps, selectedOrganisation is not in context (org derived from event)
+  // For org-required apps, selectedOrganisation is available
+  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
   const hasValidOrganisationContext = organisationService.hasValidOrganisationContext();
   const isContextReady = organisationService.isContextReady();
   const events = eventService.getEvents();
@@ -500,19 +573,32 @@ function EventServiceProviderWrapper({
   supabaseClient,
   user,
   session,
-  appName
+  appName,
+  appConfig
 }: {
   children: React.ReactNode;
   supabaseClient: SupabaseClient;
   user: User | null;
   session: Session | null;
   appName: string;
+  appConfig?: { requires_event: boolean } | null;
 }) {
-  const organisationService = useOrganisationService();
-  const selectedOrganisation = organisationService.getSelectedOrganisation();
+  // Use useOrganisations() hook for better reactivity - it subscribes to service changes
+  // This ensures EventServiceProvider re-renders when selectedOrganisation changes
+  const { selectedOrganisation: rawSelectedOrganisation } = useOrganisations();
+
+  // FIX: For event-required apps, don't pass selectedOrganisation to EventService
+  // Organisation will be derived from the selected event instead
+  // This prevents EventService from filtering events by the wrong organisation
+  const selectedOrganisation = appConfig?.requires_event ? null : rawSelectedOrganisation;
 
   // Always render EventServiceProvider - it handles null user/session gracefully
   // This ensures EventServiceContext is always available for components calling useEvents()
+  // Memoize setSelectedEventId to prevent unnecessary re-initializations
+  const setSelectedEventId = useCallback(() => {
+    // Event selection is now handled at the application level
+  }, []);
+
   return (
     <EventServiceProvider
       supabaseClient={supabaseClient}
@@ -520,9 +606,7 @@ function EventServiceProviderWrapper({
       session={session}
       appName={appName}
       selectedOrganisation={selectedOrganisation}
-      setSelectedEventId={() => {
-        // Event selection is now handled at the application level
-      }}
+      setSelectedEventId={setSelectedEventId}
     >
       {children}
     </EventServiceProvider>
@@ -557,6 +641,7 @@ function ServiceAwareProviders({
         user={authService.getUser()}
         session={authService.getSession()}
         appName={appName}
+        appConfig={appConfig}
       >
         <InactivityServiceProvider
           supabaseClient={supabaseClient}
@@ -595,9 +680,9 @@ export function UnifiedAuthProvider({
   persistState = true,
   enablePersistence,
   requireOrganisationContext = true,
-  idleTimeoutMs = 30 * 60 * 1000, // 30 minutes
-  warnBeforeMs = 60 * 1000, // 60 seconds
-  onIdleLogout,
+  idleTimeoutMs, // REQUIRED: No default - must be explicitly provided
+  warnBeforeMs, // REQUIRED: No default - must be explicitly provided
+  onIdleLogout, // REQUIRED: No default - must be explicitly provided
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }: UnifiedAuthProviderProps) {
@@ -634,3 +719,4 @@ export function UnifiedAuthProvider({
     </AuthServiceProvider>
   );
 }
+