@jmruthers/pace-core 0.5.67 → 0.5.69

package/README.md

@@ -2,6 +2,32 @@
 
 Clean, modern React component library with Tailwind v4 styling and native utilities.
 
+## ⚠️ Breaking Changes
+
+### Version 0.5.65+ - Mandatory Inactivity Timeouts
+
+The `UnifiedAuthProvider` now requires mandatory inactivity timeout configuration for security:
+
+```tsx
+// ❌ Before (will cause TypeScript errors)
+<UnifiedAuthProvider supabaseClient={supabase} appName="my-app">
+  <AppContent />
+</UnifiedAuthProvider>
+
+// ✅ After (required configuration)
+<UnifiedAuthProvider 
+  supabaseClient={supabase} 
+  appName="my-app"
+  idleTimeoutMs={30 * 60 * 1000}  // Required
+  warnBeforeMs={5 * 60 * 1000}    // Required
+  onIdleLogout={() => navigate('/login')}  // Required
+>
+  <AppContent />
+</UnifiedAuthProvider>
+```
+
+[📖 Migration Guide](./docs/migration-guides/unified-auth-provider-mandatory-timeouts.md)
+
 ## 🚀 PaceAppLayout Usage
 
 **PaceAppLayout uses React Router's nested routing pattern for optimal performance and scalability.**

package/dist/{DataTable-MFUXNGPR.js → DataTable-MPBSXUC6.js}

@@ -32,11 +32,10 @@ import {
   useDataTableContext,
   usePluginRegistry,
   useStateManager
-} from "./chunk-4HQ5BOVZ.js";
-import "./chunk-C7GUF747.js";
+} from "./chunk-NO5QHMDX.js";
+import "./chunk-FJTAWPAQ.js";
 import "./chunk-NHR52QAQ.js";
 import "./chunk-B2WTCLCV.js";
-import "./chunk-VTJ5HCZB.js";
 import {
   DataChunkManager,
   SearchIndex,
@@ -48,10 +47,10 @@ import {
   throttle,
   useDataTablePerformance
 } from "./chunk-YNUBMSMV.js";
-import "./chunk-T2MQY57J.js";
+import "./chunk-6JILXFEA.js";
 import "./chunk-ULBI5JGB.js";
 import "./chunk-5BSLGBYI.js";
-import "./chunk-D7ARGIA3.js";
+import "./chunk-6RBH67W7.js";
 import "./chunk-PLDDJCW6.js";
 export {
   ActionButtons,
@@ -97,4 +96,4 @@ export {
   usePluginRegistry,
   useStateManager
 };
-//# sourceMappingURL=DataTable-MFUXNGPR.js.map
+//# sourceMappingURL=DataTable-MPBSXUC6.js.map

package/dist/{PublicLoadingSpinner-DdKXTkCZ.d.ts → PublicLoadingSpinner-BOdyU3u-.d.ts}

@@ -3139,7 +3139,7 @@ declare function usePublicPageContext$1(): {
 
 interface PublicPageHeaderProps {
     /** The event data for this public page */
-    event: Event;
+    event?: Event;
     /** The event code for this public page */
     eventCode: string;
     /** Optional page title */

package/dist/{UnifiedAuthProvider-CQNiemcB.d.ts → UnifiedAuthProvider-D02AMXgO.d.ts}

@@ -85,9 +85,9 @@ interface UnifiedAuthProviderProps {
     enablePersistence?: boolean;
     requireOrganisationContext?: boolean;
     enableRBAC?: boolean;
-    idleTimeoutMs?: number;
-    warnBeforeMs?: number;
-    onIdleLogout?: (reason: 'inactivity') => void;
+    idleTimeoutMs: number;
+    warnBeforeMs: number;
+    onIdleLogout: (reason: 'inactivity') => void;
     renderInactivityWarning?: (args: {
         timeRemaining: number;
         onStaySignedIn: () => void;

package/dist/{chunk-CKNY7HYS.js → chunk-2ARQW6VX.js}

@@ -3,11 +3,11 @@ import {
   init_UnifiedAuthProvider,
   useOrganisations,
   useUnifiedAuth
-} from "./chunk-T2MQY57J.js";
+} from "./chunk-6JILXFEA.js";
 import {
   init_organisationContext,
   setOrganisationContext
-} from "./chunk-D7ARGIA3.js";
+} from "./chunk-6RBH67W7.js";
 
 // src/hooks/useSecureDataAccess.ts
 init_UnifiedAuthProvider();
@@ -380,4 +380,4 @@ function useSecureDataAccess() {
 export {
   useSecureDataAccess
 };
-//# sourceMappingURL=chunk-CKNY7HYS.js.map
+//# sourceMappingURL=chunk-2ARQW6VX.js.map

package/dist/{chunk-T2MQY57J.js → chunk-6JILXFEA.js}

@@ -9,7 +9,7 @@ import {
   init_debugLogger,
   init_organisationContext,
   setOrganisationContext
-} from "./chunk-D7ARGIA3.js";
+} from "./chunk-6RBH67W7.js";
 import {
   __commonJS,
   __esm,
@@ -7304,6 +7304,7 @@ function OrganisationProvider({ children }) {
   const isLoadingRef = useRef2(false);
   const lastLoadTimeRef = useRef2(0);
   const hasFailedRef = useRef2(false);
+  const abortControllerRef = useRef2(null);
   const { user, session, supabase, signOut } = useUnifiedAuth();
   let navigate = null;
   try {
@@ -7368,6 +7369,11 @@ function OrganisationProvider({ children }) {
       console.log("OrganisationProvider", "Too soon since last load, skipping");
       return;
     }
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    abortControllerRef.current = new AbortController();
+    const abortSignal = abortControllerRef.current.signal;
     lastLoadTimeRef.current = now;
     isLoadingRef.current = true;
     setIsLoading(true);
@@ -7383,12 +7389,19 @@ function OrganisationProvider({ children }) {
       try {
         console.log("[OrganisationProvider] Making RPC call to data_user_organisation_roles_get...");
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error("RPC call timeout after 10 seconds")), 1e4);
+          const timeoutId = setTimeout(() => reject(new Error("RPC call timeout after 10 seconds")), 1e4);
+          abortSignal.addEventListener("abort", () => {
+            clearTimeout(timeoutId);
+            reject(new Error("Request aborted"));
+          });
         });
         const rpcPromise = supabase.rpc("data_user_organisation_roles_get", {
           p_user_id: user.id,
           p_organisation_id: null
         });
+        if (abortSignal.aborted) {
+          throw new Error("Request aborted");
+        }
         const result = await Promise.race([rpcPromise, timeoutPromise]);
         console.log("[OrganisationProvider] RPC call completed:", {
           hasData: !!result.data,
@@ -7408,6 +7421,9 @@ function OrganisationProvider({ children }) {
         if (membershipError.message?.includes("timeout")) {
           console.log("[OrganisationProvider] RPC timed out, trying direct database query as fallback...");
           try {
+            if (abortSignal.aborted) {
+              throw new Error("Request aborted");
+            }
             const { data: fallbackData, error: fallbackError } = await supabase.from("rbac_organisation_roles").select(`
                   id,
                   user_id,
@@ -7537,6 +7553,9 @@ function OrganisationProvider({ children }) {
         lengths: { original: finalOrganisationIds.length, safe: safeOrganisationIds.length }
       });
       console.log("[OrganisationProvider] Using direct table query with manual filtering");
+      if (abortSignal.aborted) {
+        throw new Error("Request aborted");
+      }
       const { data: allOrganisations, error: orgError } = await supabase.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at");
       if (orgError) {
         console.error("[OrganisationProvider] Error loading organisations:", orgError);
@@ -7616,6 +7635,7 @@ function OrganisationProvider({ children }) {
     } finally {
       isLoadingRef.current = false;
       setIsLoading(false);
+      abortControllerRef.current = null;
     }
   }, [user, session, supabase, clearAllCachedData]);
   useEffect7(() => {
@@ -7626,6 +7646,10 @@ function OrganisationProvider({ children }) {
         setIsLoading(false);
         return;
       }
+      if (retryCount > 0 && Date.now() - lastLoadTimeRef.current < 5e3) {
+        console.log("[OrganisationProvider] Circuit breaker active - too soon since last attempt");
+        return;
+      }
       console.log("[OrganisationProvider] Authentication stable, loading organizations... (retry:", retryCount, ")");
       loadUserOrganisations();
     } else if (!user && !session) {
@@ -7642,7 +7666,18 @@ function OrganisationProvider({ children }) {
       localStorage.removeItem(STORAGE_KEYS2.SELECTED_ORGANISATION);
       localStorage.removeItem(STORAGE_KEYS2.ORGANISATION_CONTEXT);
     }
-  }, [user, session, supabase, isLoading, retryCount]);
+  }, [user, session, supabase, loadUserOrganisations]);
+  useEffect7(() => {
+    return () => {
+      isLoadingRef.current = false;
+      hasFailedRef.current = false;
+      lastLoadTimeRef.current = 0;
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+    };
+  }, []);
   const handleLogoutAndRedirect = useCallback7(async () => {
     try {
       await signOut();
@@ -7835,6 +7870,297 @@ var init_OrganisationProvider = __esm({
   }
 });
 
+// src/providers/EventProvider.tsx
+var EventProvider_exports = {};
+__export(EventProvider_exports, {
+  EventProvider: () => EventProvider,
+  useEvents: () => useEvents
+});
+import {
+  createContext as createContext6,
+  useContext as useContext6,
+  useState as useState8,
+  useEffect as useEffect8,
+  useLayoutEffect,
+  useCallback as useCallback8,
+  useRef as useRef3,
+  useMemo as useMemo7
+} from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function getNextEventByDate(events) {
+  if (!events || events.length === 0) {
+    return null;
+  }
+  const now = /* @__PURE__ */ 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;
+  }
+  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];
+}
+function EventProvider({ children }) {
+  const [events, setEvents] = useState8([]);
+  const [selectedEvent, setSelectedEventState] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(true);
+  const [error, setError] = useState8(null);
+  const { user, session, supabase, appName, setSelectedEventId } = useUnifiedAuth();
+  const isInitializedRef = useRef3(false);
+  const isFetchingRef = useRef3(false);
+  const hasAutoSelectedRef = useRef3(false);
+  const userClearedEventRef = useRef3(false);
+  const setSelectedEventIdRef = useRef3(setSelectedEventId);
+  let selectedOrganisation = null;
+  let ensureOrganisationContext = null;
+  try {
+    const orgContext = useOrganisations();
+    selectedOrganisation = orgContext.selectedOrganisation;
+    ensureOrganisationContext = orgContext.ensureOrganisationContext;
+  } catch (error2) {
+    console.warn("[EventProvider] Organisation context not available:", error2);
+  }
+  const loadPersistedEvent = useCallback8(async (events2) => {
+    try {
+      let persistedEventId = sessionStorage.getItem("pace-core-selected-event");
+      if (!persistedEventId) {
+        persistedEventId = localStorage.getItem("pace-core-selected-event");
+        if (persistedEventId) {
+          sessionStorage.setItem("pace-core-selected-event", persistedEventId);
+        }
+      }
+      if (persistedEventId && events2.length > 0) {
+        const persistedEvent = events2.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");
+          sessionStorage.removeItem("pace-core-selected-event");
+          localStorage.removeItem("pace-core-selected-event");
+        }
+      }
+    } catch (error2) {
+      console.warn("[EventProvider] Failed to load persisted event:", error2);
+    }
+    return false;
+  }, [setSelectedEventId]);
+  const persistEventSelection = useCallback8((eventId) => {
+    try {
+      sessionStorage.setItem("pace-core-selected-event", eventId);
+      localStorage.setItem("pace-core-selected-event", eventId);
+    } catch (error2) {
+      console.warn("[EventProvider] Failed to persist event selection:", error2);
+    }
+  }, []);
+  const autoSelectNextEvent = useCallback8((events2) => {
+    const nextEvent = getNextEventByDate(events2);
+    if (nextEvent) {
+      DebugLogger.log("EventProvider", "Auto-selecting next event:", nextEvent.event_name);
+      setSelectedEventState(nextEvent);
+      setSelectedEventId(nextEvent.event_id);
+      persistEventSelection(nextEvent.event_id);
+    }
+  }, [setSelectedEventId, persistEventSelection]);
+  const fetchEvents = useCallback8(async () => {
+    if (!user || !session || !supabase || !appName || !selectedOrganisation) {
+      DebugLogger.log("EventProvider", "Missing required dependencies, skipping fetch");
+      setIsLoading(false);
+      return;
+    }
+    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,
+      organisationId: selectedOrganisation.id,
+      organisationName: selectedOrganisation.display_name
+    });
+    isFetchingRef.current = true;
+    let isMounted = true;
+    try {
+      if (ensureOrganisationContext) {
+        await ensureOrganisationContext();
+        await setOrganisationContext(supabase, selectedOrganisation.id);
+      }
+      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) => ({
+          eventId: event.event_id,
+          eventName: event.event_name,
+          organisationId: event.organisation_id,
+          selectedOrganisationId: selectedOrganisation?.id
+        })));
+        const transformedEvents = eventsData.map((event) => ({
+          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);
+        hasAutoSelectedRef.current = false;
+        const persistedEventLoaded = await loadPersistedEvent(transformedEvents);
+        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]);
+  useEffect8(() => {
+    if (!isInitializedRef.current) {
+      isInitializedRef.current = true;
+      fetchEvents();
+    }
+  }, [fetchEvents]);
+  useEffect8(() => {
+    setSelectedEventIdRef.current = setSelectedEventId;
+  }, [setSelectedEventId]);
+  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]);
+  const setSelectedEvent = useCallback8((event) => {
+    if (event) {
+      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 (error2) {
+        console.error("[EventProvider] Error during event validation:", error2);
+      }
+      setSelectedEventState(event);
+      setSelectedEventId(event.event_id);
+      persistEventSelection(event.event_id);
+      userClearedEventRef.current = false;
+    } else {
+      setSelectedEventState(null);
+      setSelectedEventId(null);
+      sessionStorage.removeItem("pace-core-selected-event");
+      localStorage.removeItem("pace-core-selected-event");
+      hasAutoSelectedRef.current = false;
+      userClearedEventRef.current = true;
+    }
+  }, [selectedOrganisation, setSelectedEventId, persistEventSelection]);
+  const refreshEvents = useCallback8(async () => {
+    isInitializedRef.current = false;
+    isFetchingRef.current = false;
+    userClearedEventRef.current = false;
+    await fetchEvents();
+  }, [fetchEvents]);
+  const contextValue = useMemo7(() => ({
+    events,
+    selectedEvent,
+    isLoading,
+    error,
+    setSelectedEvent,
+    refreshEvents
+  }), [events, selectedEvent, isLoading, error, setSelectedEvent, refreshEvents]);
+  return /* @__PURE__ */ jsx10(EventContext.Provider, { value: contextValue, children });
+}
+var EventContext, useEvents;
+var init_EventProvider = __esm({
+  "src/providers/EventProvider.tsx"() {
+    "use strict";
+    init_UnifiedAuthProvider();
+    init_OrganisationProvider();
+    init_organisationContext();
+    init_debugLogger();
+    EventContext = createContext6(void 0);
+    useEvents = () => {
+      const context = useContext6(EventContext);
+      if (context === void 0) {
+        throw new Error("useEvents must be used within an EventProvider");
+      }
+      return context;
+    };
+  }
+});
+
 export {
   AuthProvider,
   useAuth,
@@ -7877,7 +8203,11 @@ export {
   OrganisationProvider,
   useOrganisations,
   OrganisationProvider_exports,
-  init_OrganisationProvider
+  init_OrganisationProvider,
+  useEvents,
+  EventProvider,
+  EventProvider_exports,
+  init_EventProvider
 };
 /*! Bundled license information:
 
@@ -7891,4 +8221,4 @@ lodash/lodash.js:
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    *)
 */
-//# sourceMappingURL=chunk-T2MQY57J.js.map
+//# sourceMappingURL=chunk-6JILXFEA.js.map