@jmruthers/pace-core 0.5.74 → 0.5.76

package/src/providers/EventProvider.tsx

@@ -1,426 +1,16 @@
-import React, {
-  createContext,
-  useContext,
-  useState,
-  useEffect,
-  useLayoutEffect,
-  useCallback,
-  useRef,
-  useMemo,
-} from 'react';
-import { useUnifiedAuth } from './UnifiedAuthProvider';
-import { useOrganisations } from './OrganisationProvider';
-import { setOrganisationContext } from '../utils/organisationContext';
-import { DebugLogger } from '../utils/debugLogger';
-import { applyPalette, clearPalette } from '../theming/runtime';
-import type { PaletteData, ColorPalette } from '../theming/runtime';
+/**
+ * @file Re-export for EventProvider
+ * @package @jmruthers/pace-core
+ * @module Providers
+ * @since 0.1.0
+ * 
+ * Re-exports the service-based EventProvider for backward compatibility.
+ */
+
+export { EventServiceProvider as EventProvider } from './services/EventServiceProvider';
+export type { EventServiceProviderProps as EventProviderProps } from './services/EventServiceProvider';
+
+// Re-export context and hook  
+export { EventServiceContext, useEventService } from './services/EventServiceProvider';
+export type { EventServiceContextType, EventContextType } from './services/EventServiceProvider';
 
-import { Event } from '../types/unified';
-
-export interface EventContextType {
-  events: Event[];
-  selectedEvent: Event | null;
-  isLoading: boolean;
-  error: Error | null;
-  setSelectedEvent: (event: Event | null) => void;
-  refreshEvents: () => Promise<void>;
-}
-
-const EventContext = createContext<EventContextType | undefined>(undefined);
-
-export const useEvents = () => {
-  const context = useContext(EventContext);
-  if (context === undefined) {
-    throw new Error('useEvents must be used within an EventProvider');
-  }
-  return context;
-};
-
-export interface EventProviderProps {
-  children: React.ReactNode;
-}
-
-// Helper function to get the next event by date
-function getNextEventByDate(events: Event[]): Event | null {
-  if (!events || events.length === 0) {
-    return null;
-  }
-
-  const now = new Date();
-  const futureEvents = events.filter(event => {
-    if (!event.event_date) return false;
-    const eventDate = new Date(event.event_date);
-    return eventDate >= now;
-  });
-
-  if (futureEvents.length === 0) {
-    return null;
-  }
-
-  // Sort by date (ascending) to get the next event
-  const sortedFutureEvents = futureEvents.sort((a, b) => {
-    const dateA = new Date(a.event_date!);
-    const dateB = new Date(b.event_date!);
-    return dateA.getTime() - dateB.getTime();
-  });
-
-  return sortedFutureEvents[0];
-}
-
-export function EventProvider({ children }: EventProviderProps) {
-  const [events, setEvents] = useState<Event[]>([]);
-  const [selectedEvent, setSelectedEventState] = useState<Event | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-  const { user, session, supabase, appName, setSelectedEventId } = useUnifiedAuth();
-  
-  // Refs to prevent infinite loops
-  const isInitializedRef = useRef(false);
-  const isFetchingRef = useRef(false);
-  const hasAutoSelectedRef = useRef(false);
-  const userClearedEventRef = useRef(false);
-  const setSelectedEventIdRef = useRef(setSelectedEventId);
-  
-  // Try to get organisation context, but don't fail if not available
-  let selectedOrganisation = null;
-  let ensureOrganisationContext = null;
-  
-  try {
-    const orgContext = useOrganisations();
-    selectedOrganisation = orgContext.selectedOrganisation;
-    ensureOrganisationContext = orgContext.ensureOrganisationContext;
-  } catch (error) {
-    console.warn('[EventProvider] Organisation context not available:', error);
-  }
-
-  // Load persisted event selection with tab-scoped storage
-  const loadPersistedEvent = useCallback(async (events: Event[]) => {
-    try {
-      // Try sessionStorage first (tab-specific)
-      let persistedEventId = sessionStorage.getItem('pace-core-selected-event');
-      
-      // Fallback to localStorage if no sessionStorage value (for new tabs)
-      if (!persistedEventId) {
-        persistedEventId = localStorage.getItem('pace-core-selected-event');
-        // If we found a value in localStorage, also store it in sessionStorage for this tab
-        if (persistedEventId) {
-          sessionStorage.setItem('pace-core-selected-event', persistedEventId);
-        }
-      }
-      
-      if (persistedEventId && events.length > 0) {
-        const persistedEvent = events.find(event => event.event_id === persistedEventId);
-        if (persistedEvent) {
-          DebugLogger.log('EventProvider', 'Restoring persisted event:', persistedEvent.event_name);
-          setSelectedEventState(persistedEvent);
-          setSelectedEventId(persistedEventId);
-          return true;
-        } else {
-          DebugLogger.log('EventProvider', 'Persisted event not found in current events, clearing storage');
-          // Clear invalid persisted event
-          sessionStorage.removeItem('pace-core-selected-event');
-          localStorage.removeItem('pace-core-selected-event');
-        }
-      }
-    } catch (error) {
-      console.warn('[EventProvider] Failed to load persisted event:', error);
-    }
-    return false;
-  }, [setSelectedEventId]);
-
-  // Persist event selection with tab-scoped storage
-  const persistEventSelection = useCallback((eventId: string) => {
-    try {
-      // Store in sessionStorage for tab-specific persistence
-      sessionStorage.setItem('pace-core-selected-event', eventId);
-      // Also store in localStorage as fallback for new tabs
-      localStorage.setItem('pace-core-selected-event', eventId);
-    } catch (error) {
-      console.warn('[EventProvider] Failed to persist event selection:', error);
-    }
-  }, []);
-
-  // Auto-select next event
-  const autoSelectNextEvent = useCallback((events: Event[]) => {
-    const nextEvent = getNextEventByDate(events);
-    if (nextEvent) {
-      DebugLogger.log('EventProvider', 'Auto-selecting next event:', nextEvent.event_name);
-      setSelectedEventState(nextEvent);
-      setSelectedEventId(nextEvent.event_id);
-      persistEventSelection(nextEvent.event_id);
-    }
-  }, [setSelectedEventId, persistEventSelection]);
-
-  // Main fetch function
-  const fetchEvents = useCallback(async () => {
-    if (!user || !session || !supabase || !appName || !selectedOrganisation) {
-      DebugLogger.log('EventProvider', 'Missing required dependencies, skipping fetch');
-      setIsLoading(false);
-      return;
-    }
-
-    // Prevent multiple simultaneous fetches
-    if (isFetchingRef.current) {
-      DebugLogger.log('EventProvider', 'Already fetching events, skipping');
-      return;
-    }
-
-    DebugLogger.log('EventProvider', 'User and organisation found, fetching events for:', {
-      userId: user.id,
-      appName: appName,
-      organisationId: selectedOrganisation.id,
-      organisationName: selectedOrganisation.display_name
-    });
-
-    isFetchingRef.current = true;
-    let isMounted = true;
-
-    try {
-      // Ensure organisation context is set
-      if (ensureOrganisationContext) {
-        await ensureOrganisationContext();
-        await setOrganisationContext(supabase, selectedOrganisation.id);
-      }
-
-      // Call the RPC function following the established pattern
-      DebugLogger.log('EventProvider', 'Calling data_user_events_get RPC with:', {
-        user_id: user.id,
-        organisation_id: selectedOrganisation.id,
-        app_name: appName
-      });
-
-      const { data, error: rpcError } = await supabase.rpc('data_user_events_get', {
-        p_user_id: user.id,
-        p_organisation_id: selectedOrganisation.id,
-        p_app_name: appName
-      });
-
-      DebugLogger.log('EventProvider', 'RPC response:', {
-        data,
-        error: rpcError,
-        dataLength: data?.length || 0,
-        organisationId: selectedOrganisation.id
-      });
-
-      if (rpcError) {
-        throw new Error(rpcError.message || 'Failed to fetch events');
-      }
-
-      if (isMounted) {
-        const eventsData = data || [];
-        console.log('[EventProvider] Loaded events:', eventsData.map((event: any) => ({
-          eventId: event.event_id,
-          eventName: event.event_name,
-          organisationId: event.organisation_id,
-          selectedOrganisationId: selectedOrganisation?.id
-        })));
-
-        // Transform the data to match our Event interface
-        const transformedEvents: Event[] = eventsData.map((event: any) => ({
-          id: event.event_id, // Use event_id as the primary id
-          event_id: event.event_id,
-          event_name: event.event_name,
-          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: event.organisation_id,
-          is_visible: event.is_visible,
-          // Legacy compatibility
-          name: event.event_name,
-          start_date: event.event_date
-        }));
-
-        setEvents(transformedEvents);
-        setError(null);
-
-        // Note: Event colors are automatically applied when selectedEvent changes (see useEffect below)
-
-        // Reset auto-selection ref for new events
-        hasAutoSelectedRef.current = false;
-
-        // Try to restore persisted event first
-        const persistedEventLoaded = await loadPersistedEvent(transformedEvents);
-        
-        // If no persisted event was loaded, auto-select the next event
-        if (!persistedEventLoaded) {
-          const nextEvent = getNextEventByDate(transformedEvents);
-          if (nextEvent) {
-            DebugLogger.log('EventProvider', 'Auto-selecting next event after no persisted event found:', nextEvent.event_name);
-            hasAutoSelectedRef.current = true;
-            setSelectedEventState(nextEvent);
-            setSelectedEventIdRef.current(nextEvent.event_id);
-            persistEventSelection(nextEvent.event_id);
-          }
-        }
-      }
-    } catch (err) {
-      console.error('[EventProvider] Error fetching events:', err);
-      const _error = err instanceof Error ? err : new Error('Unknown error occurred');
-      
-      if (isMounted) {
-        setError(_error);
-        setEvents([]);
-      }
-    } finally {
-      if (isMounted) {
-        setIsLoading(false);
-      }
-      isFetchingRef.current = false;
-    }
-
-    return () => {
-      isMounted = false;
-    };
-  }, [user, session, supabase, appName, selectedOrganisation, ensureOrganisationContext, loadPersistedEvent, autoSelectNextEvent]);
-
-  // Initialize events only once
-  useEffect(() => {
-    if (!isInitializedRef.current) {
-      isInitializedRef.current = true;
-      fetchEvents();
-    }
-  }, [fetchEvents]);
-
-  // Update ref when setSelectedEventId changes
-  useEffect(() => {
-    setSelectedEventIdRef.current = setSelectedEventId;
-  }, [setSelectedEventId]);
-
-  // Auto-select next event when events are loaded and no event is selected
-  useLayoutEffect(() => {
-    if (events.length > 0 && !selectedEvent && !hasAutoSelectedRef.current && !userClearedEventRef.current) {
-      const nextEvent = getNextEventByDate(events);
-      if (nextEvent) {
-        DebugLogger.log('EventProvider', 'Auto-selecting next event:', nextEvent.event_name);
-        hasAutoSelectedRef.current = true;
-        setSelectedEventState(nextEvent);
-        setSelectedEventIdRef.current(nextEvent.event_id);
-        persistEventSelection(nextEvent.event_id);
-      }
-    }
-  }, [events, selectedEvent]);
-
-  // Apply event theming when selected event changes
-  useEffect(() => {
-    console.log('[EventProvider] Event theming useEffect triggered, selectedEvent:', selectedEvent?.event_name, selectedEvent?.event_colours);
-    
-    if (!selectedEvent) {
-      console.log('[EventProvider] No selected event, clearing palette');
-      clearPalette();
-      return;
-    }
-
-    const eventColours = selectedEvent.event_colours;
-    console.log('[EventProvider] Event colours:', eventColours);
-    console.log('[EventProvider] Event colours keys:', Object.keys(eventColours as object || {}));
-
-    if (!eventColours || typeof eventColours !== 'object') {
-      console.log('[EventProvider] No valid event_colours, clearing palette');
-      clearPalette();
-      return;
-    }
-
-    // Map event palette keys (ev-main, ev-sec, ev-acc) to app palette keys (main, sec, acc)
-    // This matches the format used in pace-admin's eventColorManager
-    const evMainPalette = ((eventColours as any)['ev-main'] as ColorPalette) || ((eventColours as any).main as ColorPalette) || {};
-    const evSecPalette = ((eventColours as any)['ev-sec'] as ColorPalette) || ((eventColours as any).sec as ColorPalette) || {};
-    const evAccPalette = ((eventColours as any)['ev-acc'] as ColorPalette) || ((eventColours as any).acc as ColorPalette) || {};
-    
-    console.log('[EventProvider] Mapped palettes:', {
-      'ev-main': Object.keys(evMainPalette),
-      'ev-sec': Object.keys(evSecPalette),
-      'ev-acc': Object.keys(evAccPalette),
-    });
-    
-    const fullPalette: PaletteData = {
-      main: evMainPalette,
-      sec: evSecPalette,
-      acc: evAccPalette,
-    };
-    
-    // Check if we have at least one valid palette
-    if (!fullPalette.main && !fullPalette.sec && !fullPalette.acc) {
-      console.log('[EventProvider] No valid palettes found in event_colours, clearing palette');
-      clearPalette();
-      return;
-    }
-
-    console.log('[EventProvider] Applying full palette:', fullPalette);
-
-    try {
-      applyPalette(fullPalette);
-      console.log('[EventProvider] Palette applied successfully');
-    } catch (error) {
-      console.error('[EventProvider] Failed to apply event palette:', error);
-    }
-  }, [selectedEvent]);
-
-  const setSelectedEvent = useCallback((event: Event | null) => {
-    if (event) {
-      // SECURITY: Validate event belongs to current organisation
-      try {
-        console.log('[EventProvider] Event selection validation:', {
-          eventId: event.event_id,
-          eventName: event.event_name,
-          eventOrganisationId: event.organisation_id,
-          selectedOrganisationId: selectedOrganisation?.id,
-          selectedOrganisationName: selectedOrganisation?.display_name,
-          match: event.organisation_id === selectedOrganisation?.id
-        });
-        
-        if (selectedOrganisation && event.organisation_id !== selectedOrganisation.id) {
-          console.error('[EventProvider] Event organisation_id does not match selected organisation', {
-            eventOrganisationId: event.organisation_id,
-            selectedOrganisationId: selectedOrganisation.id,
-            eventName: event.event_name
-          });
-          return;
-        }
-      } catch (error) {
-        console.error('[EventProvider] Error during event validation:', error);
-      }
-
-      setSelectedEventState(event);
-      setSelectedEventId(event.event_id);
-      persistEventSelection(event.event_id);
-      // Reset the user cleared flag when selecting an event
-      userClearedEventRef.current = false;
-    } else {
-      setSelectedEventState(null);
-      setSelectedEventId(null);
-      // Clear both sessionStorage and localStorage
-      sessionStorage.removeItem('pace-core-selected-event');
-      localStorage.removeItem('pace-core-selected-event');
-      // Reset the auto-selection flag when clearing the event
-      hasAutoSelectedRef.current = false;
-      // Mark that user explicitly cleared the event to prevent auto-selection
-      userClearedEventRef.current = true;
-    }
-  }, [selectedOrganisation, setSelectedEventId, persistEventSelection]);
-
-  const refreshEvents = useCallback(async () => {
-    isInitializedRef.current = false;
-    isFetchingRef.current = false;
-    // Reset the user cleared flag when refreshing events
-    userClearedEventRef.current = false;
-    await fetchEvents();
-  }, [fetchEvents]);
-
-  // Memoize the context value to prevent unnecessary re-renders
-  const contextValue: EventContextType = useMemo(() => ({
-    events,
-    selectedEvent,
-    isLoading,
-    error,
-    setSelectedEvent,
-    refreshEvents,
-  }), [events, selectedEvent, isLoading, error, setSelectedEvent, refreshEvents]);
-
-  return (
-    <EventContext.Provider value={contextValue}>
-      {children}
-    </EventContext.Provider>
-  );
-}

package/src/providers/InactivityProvider.tsx

@@ -1,238 +1,15 @@
 /**
- * @file Inactivity Provider
+ * @file Re-export for InactivityProvider
  * @package @jmruthers/pace-core
- * @module Providers/Inactivity
+ * @module Providers
  * @since 0.1.0
- *
- * Handles inactivity tracking, auto-logout, and warning modals.
- * Separated from UnifiedAuthProvider for better maintainability.
+ * 
+ * Re-exports the service-based InactivityProvider for backward compatibility.
  */
 
-import React, { createContext, useContext, useState, useEffect, useCallback, useMemo } from 'react';
-import { useInactivityTracker } from '../hooks/useInactivityTracker';
-import { InactivityWarningModal } from '../components/InactivityWarningModal/InactivityWarningModal';
+export { InactivityServiceProvider as InactivityProvider } from './services/InactivityServiceProvider';
+export type { InactivityServiceProviderProps as InactivityProviderProps, InactivityServiceContextType as InactivityContextType } from './services/InactivityServiceProvider';
 
-// Inactivity context type
-export interface InactivityContextType {
-  // Inactivity state
-  showInactivityWarning: boolean;
-  inactivityTimeRemaining: number;
-  isIdle: boolean;
-  timeRemaining: number;
-  showWarning: boolean;
-  isTracking: boolean;
-  
-  // Inactivity methods
-  resetActivity: () => void;
-  startTracking: () => void;
-  stopTracking: () => void;
-  handleIdleLogout: () => Promise<void>;
-  handleStaySignedIn: () => void;
-  handleSignOutNow: () => Promise<void>;
-}
+// Re-export hook
+export { useInactivityService as useInactivity } from '../hooks/services/useInactivityService';
 
-const InactivityContext = createContext<InactivityContextType | undefined>(undefined);
-
-export const useInactivity = () => {
-  const context = useContext(InactivityContext);
-  if (!context) {
-    throw new Error('useInactivity must be used within an InactivityProvider');
-  }
-  return context;
-};
-
-export interface InactivityProviderProps {
-  children: React.ReactNode;
-  user: any; // User from auth context
-  session: any; // Session from auth context
-  supabaseClient: any; // Supabase client
-  idleTimeoutMs?: number; // Default: 30 minutes
-  warnBeforeMs?: number; // Default: 60 seconds
-  onIdleLogout?: (reason: 'inactivity') => void; // App handles redirect/navigation
-  renderInactivityWarning?: (args: {
-    timeRemaining: number;
-    onStaySignedIn: () => void;
-    onSignOutNow: () => void;
-  }) => React.ReactNode; // Optional custom warning UI
-  dangerouslyDisableInactivity?: boolean; // Dev-only; must not disable in production
-}
-
-export function InactivityProvider({
-  children,
-  user,
-  session,
-  supabaseClient,
-  idleTimeoutMs = 30 * 60 * 1000, // 30 minutes
-  warnBeforeMs = 60 * 1000, // 60 seconds
-  onIdleLogout,
-  renderInactivityWarning,
-  dangerouslyDisableInactivity = false
-}: InactivityProviderProps) {
-  // Inactivity state
-  const [showInactivityWarning, setShowInactivityWarning] = useState(false);
-  const [inactivityTimeRemaining, setInactivityTimeRemaining] = useState(0);
-
-  // Production safety check for inactivity feature
-  useEffect(() => {
-    if (typeof window !== 'undefined') {
-      const isProduction = import.meta.env.MODE === 'production';
-      
-      if (isProduction && dangerouslyDisableInactivity) {
-        console.error('[InactivityProvider] CRITICAL: dangerouslyDisableInactivity is not allowed in production! Auto-enabling inactivity feature.');
-      }
-      
-      if (!isProduction && dangerouslyDisableInactivity) {
-        console.warn('[InactivityProvider] Inactivity feature disabled for development. This will NOT work in production.');
-      }
-    }
-  }, [dangerouslyDisableInactivity]);
-
-  // Inactivity tracking
-  const isInactivityEnabled = typeof window !== 'undefined' && 
-    (import.meta.env.MODE !== 'production' ? !dangerouslyDisableInactivity : true);
-
-  const {
-    isIdle,
-    timeRemaining,
-    showWarning,
-    resetActivity,
-    startTracking,
-    stopTracking,
-    isTracking
-  } = useInactivityTracker({
-    idleTimeoutMs,
-    warnBeforeMs,
-    enabled: isInactivityEnabled && !!user && !!session,
-    onIdle: useCallback(() => {
-      // Handle idle logout inline to avoid circular dependency
-      setShowInactivityWarning(false);
-      setInactivityTimeRemaining(0);
-      
-      // Sign out via Supabase
-      if (supabaseClient) {
-        supabaseClient.auth.signOut().catch((error: any) => {
-          console.error('[InactivityProvider] Error during idle logout:', error);
-        });
-      }
-      
-      // Call app callback for navigation/redirect
-      onIdleLogout?.('inactivity');
-    }, [supabaseClient, onIdleLogout]),
-    onWarning: useCallback(() => {
-      setShowInactivityWarning(true);
-      setInactivityTimeRemaining(warnBeforeMs);
-    }, [warnBeforeMs]),
-    onActivity: useCallback(() => {
-      setShowInactivityWarning(false);
-      setInactivityTimeRemaining(0);
-    }, [])
-  });
-
-  // Handle idle logout (for manual calls)
-  const handleIdleLogout = useCallback(async () => {
-    // Hide warning
-    setShowInactivityWarning(false);
-    setInactivityTimeRemaining(0);
-    
-    // Stop tracking
-    stopTracking();
-    
-    // Sign out via Supabase
-    try {
-      if (supabaseClient) {
-        await supabaseClient.auth.signOut();
-      }
-    } catch (error: any) {
-      console.error('[InactivityProvider] Error during idle logout:', error);
-    }
-    
-    // Call app callback for navigation/redirect
-    onIdleLogout?.('inactivity');
-  }, [supabaseClient, onIdleLogout, stopTracking]);
-
-  // Handle stay signed in
-  const handleStaySignedIn = useCallback(() => {
-    setShowInactivityWarning(false);
-    setInactivityTimeRemaining(0);
-    resetActivity();
-  }, [resetActivity]);
-
-  // Handle sign out now
-  const handleSignOutNow = useCallback(async () => {
-    setShowInactivityWarning(false);
-    setInactivityTimeRemaining(0);
-    stopTracking();
-    
-    // Sign out via Supabase
-    try {
-      if (supabaseClient) {
-        await supabaseClient.auth.signOut();
-      }
-    } catch (error: any) {
-      console.error('[InactivityProvider] Error during manual sign out:', error);
-    }
-    
-    // Call app callback for navigation/redirect
-    onIdleLogout?.('inactivity');
-  }, [supabaseClient, onIdleLogout, stopTracking]);
-
-  // Update inactivity time remaining
-  useEffect(() => {
-    if (showWarning && timeRemaining > 0) {
-      setInactivityTimeRemaining(Math.ceil(timeRemaining / 1000)); // Convert to seconds
-    }
-  }, [showWarning, timeRemaining]);
-
-  // Memoized context value
-  const contextValue = useMemo<InactivityContextType>(() => ({
-    showInactivityWarning,
-    inactivityTimeRemaining,
-    isIdle,
-    timeRemaining,
-    showWarning,
-    isTracking,
-    resetActivity,
-    startTracking,
-    stopTracking,
-    handleIdleLogout,
-    handleStaySignedIn,
-    handleSignOutNow,
-  }), [
-    showInactivityWarning,
-    inactivityTimeRemaining,
-    isIdle,
-    timeRemaining,
-    showWarning,
-    isTracking,
-    resetActivity,
-    startTracking,
-    stopTracking,
-    handleIdleLogout,
-    handleStaySignedIn,
-    handleSignOutNow,
-  ]);
-
-  return (
-    <InactivityContext.Provider value={contextValue}>
-      {children}
-      
-      {/* Inactivity Warning Modal */}
-      {showInactivityWarning && (
-        renderInactivityWarning ? (
-          renderInactivityWarning({
-            timeRemaining: inactivityTimeRemaining,
-            onStaySignedIn: handleStaySignedIn,
-            onSignOutNow: handleSignOutNow
-          })
-        ) : (
-          <InactivityWarningModal
-            isOpen={showInactivityWarning}
-            timeRemaining={inactivityTimeRemaining}
-            onStaySignedIn={handleStaySignedIn}
-            onSignOutNow={handleSignOutNow}
-          />
-        )
-      )}
-    </InactivityContext.Provider>
-  );
-}