@jmruthers/pace-core 0.5.141 → 0.5.143

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmruthers/pace-core",
-  "version": "0.5.141",
+  "version": "0.5.143",
   "description": "Clean, modern React component library with Tailwind v4 styling and native utilities",
   "private": false,
   "publishConfig": {

package/src/components/NavigationMenu/NavigationMenu.tsx

@@ -437,14 +437,24 @@ export const NavigationMenu = React.forwardRef<
     logger.warn('NavigationMenu', 'useRBAC not available, permission filtering disabled');
   }
 
+  // Get event context state for checking readiness
+  // Store the raw value to check if it's undefined (tests without event provider)
+  const eventLoadingRaw = authContext?.eventLoading;
+  const eventLoading = eventLoadingRaw ?? false;
+  const selectedEvent = authContext?.selectedEvent || null;
+  // Check org context readiness: use isContextReady if available, otherwise fall back to checking selectedOrganisation
+  // This handles both production (with isContextReady) and test scenarios (without it)
+  const orgContextReady = authContext?.isContextReady ?? (authContext?.selectedOrganisation?.id ? true : false);
+
   // Get resolved scope for permission checks
+  // Note: Always call useResolvedScope (hooks must be called unconditionally)
+  // When filterByPermissions is false, we'll simply ignore the resolved scope
   const { supabase } = authContext || {};
   const { selectedOrganisation } = authContext || {};
-  const selectedEvent = authContext?.selectedEvent || null;
   const { resolvedScope, isLoading: scopeLoading } = useResolvedScope({
-    supabase: supabase || null,
-    selectedOrganisationId: selectedOrganisation?.id || null,
-    selectedEventId: selectedEvent?.event_id || null
+    supabase: filterByPermissions ? (supabase || null) : null,
+    selectedOrganisationId: filterByPermissions ? (selectedOrganisation?.id || null) : null,
+    selectedEventId: filterByPermissions ? (selectedEvent?.event_id || null) : null
   });
 
   // Stabilize scope object to prevent unnecessary permission refetches
@@ -504,9 +514,18 @@ export const NavigationMenu = React.forwardRef<
     // Security: If filtering is enabled but we're missing required context or still loading, show NO items
     // This prevents security risk of showing items before permissions are verified
     if (filterByPermissions) {
-      // During initial load or when scope is loading, show nothing
-      if (!authContext || !rbacContext || scopeLoading || !resolvedScope?.organisationId) {
+      // CRITICAL: Wait for BOTH organisation AND event context to be ready before checking permissions
+      // This prevents the error "No organisation or event context available" when event context is still loading
+      const isOrgContextReady = orgContextReady && selectedOrganisation?.id;
+      // Event context is ready when not loading
+      // If eventLoadingRaw is undefined (tests without event provider), consider it ready
+      // Only wait for event context if we're actually loading events
+      const isEventContextReady = eventLoadingRaw === undefined ? true : !eventLoading;
+      
+      // During initial load or when scope/context is loading, show nothing
+      if (!authContext || !rbacContext || scopeLoading || !isOrgContextReady || !isEventContextReady) {
         // Still loading - show nothing to prevent security risk
+        // Note: We check both org and event context readiness to prevent premature permission checks
         return [];
       }
       
@@ -711,7 +730,13 @@ export const NavigationMenu = React.forwardRef<
     scopeLoading, 
     permissionsLoading,
     resolvedScope,
-    auditLog
+    auditLog,
+    // Add event context state to dependencies so we re-check permissions when event context becomes available
+    eventLoadingRaw,
+    eventLoading,
+    selectedEvent,
+    orgContextReady,
+    selectedOrganisation?.id
   ]);
 
   // Log navigation access attempts for debugging

package/src/services/EventService.ts

@@ -434,17 +434,38 @@ export class EventService extends BaseService implements IEventService {
       return startOfEventDate >= startOfToday;
     });
 
-    if (futureEvents.length === 0) {
-      return null;
+    if (futureEvents.length > 0) {
+      // 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];
     }
 
-    // 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();
+    // Fallback: If no future events found, return the most recent past event
+    // This handles cases where users only have access to past events
+    const pastEvents = eventsToUse.filter(event => {
+      if (!event.event_date) return false;
+      const eventDate = new Date(event.event_date);
+      const startOfEventDate = new Date(eventDate.getFullYear(), eventDate.getMonth(), eventDate.getDate()).getTime();
+      return startOfEventDate < startOfToday;
     });
 
-    return sortedFutureEvents[0];
+    if (pastEvents.length > 0) {
+      // Sort by date (descending) to get the most recent past event
+      const sortedPastEvents = pastEvents.sort((a, b) => {
+        const dateA = new Date(a.event_date!);
+        const dateB = new Date(b.event_date!);
+        return dateB.getTime() - dateA.getTime(); // Descending order
+      });
+
+      return sortedPastEvents[0];
+    }
+
+    // No events found at all
+    return null;
   }
 }

package/src/services/__tests__/EventService.test.ts

@@ -267,14 +267,20 @@ describe('EventService', () => {
       expect(nextEvent).toEqual(mockEvent2); // Future event should be selected
     });
 
-    it('should return null when no future events', async () => {
-      const pastEvent: Event = {
+    it('should return most recent past event when no future events', async () => {
+      const pastEvent1: Event = {
         ...mockEvent,
+        event_id: 'event-past-1',
         event_date: '2020-01-01T00:00:00Z'
       };
+      const pastEvent2: Event = {
+        ...mockEvent,
+        event_id: 'event-past-2',
+        event_date: '2021-06-15T00:00:00Z' // More recent past event
+      };
 
       mockSupabase.rpc.mockResolvedValue({
-        data: [pastEvent],
+        data: [pastEvent1, pastEvent2],
         error: null
       });
 
@@ -290,7 +296,9 @@ describe('EventService', () => {
       await service.initialize();
 
       const nextEvent = service.getNextEventByDate();
-      expect(nextEvent).toBeNull();
+      // Should return the most recent past event (pastEvent2)
+      expect(nextEvent).not.toBeNull();
+      expect(nextEvent?.event_id).toBe('event-past-2');
     });
 
     it('should persist event selection', async () => {
@@ -760,15 +768,23 @@ describe('EventService', () => {
       expect(nextEvent).toBeNull();
     });
 
-    it('should return null when all events are in the past', () => {
-      const pastEvent: Event = {
+    it('should return most recent past event when all events are in the past', () => {
+      const pastEvent1: Event = {
         ...mockEvent,
+        event_id: 'event-past-1',
         event_date: '2020-01-01T00:00:00Z'
       };
+      const pastEvent2: Event = {
+        ...mockEvent,
+        event_id: 'event-past-2',
+        event_date: '2022-03-20T00:00:00Z' // More recent past event
+      };
 
-      const nextEvent = eventService.getNextEventByDate([pastEvent]);
+      const nextEvent = eventService.getNextEventByDate([pastEvent1, pastEvent2]);
 
-      expect(nextEvent).toBeNull();
+      // Should return the most recent past event (pastEvent2)
+      expect(nextEvent).not.toBeNull();
+      expect(nextEvent?.event_id).toBe('event-past-2');
     });
 
     it('should select event on today\'s date', () => {
@@ -826,6 +842,30 @@ describe('EventService', () => {
       expect(nextEvent?.event_date).toBe(futureDate2.toISOString());
     });
 
+    it('should prefer future events over past events when both exist', () => {
+      const today = new Date();
+      const pastDate = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
+      const futureDate = new Date(today.getTime() + 30 * 24 * 60 * 60 * 1000); // 30 days from now
+
+      const pastEvent: Event = {
+        ...mockEvent,
+        event_id: 'event-past',
+        event_date: pastDate.toISOString()
+      };
+
+      const futureEvent: Event = {
+        ...mockEvent,
+        event_id: 'event-future',
+        event_date: futureDate.toISOString()
+      };
+
+      const nextEvent = eventService.getNextEventByDate([pastEvent, futureEvent]);
+
+      // Should prefer future event even if past event is more recent
+      expect(nextEvent).not.toBeNull();
+      expect(nextEvent?.event_id).toBe('event-future');
+    });
+
     it('should filter out events without dates', () => {
       const eventWithoutDate: Event = {
         ...mockEvent,