@jmruthers/pace-core 0.6.2 → 0.6.4

package/src/hooks/__tests__/useAppConfig.unit.test.ts

@@ -99,7 +99,7 @@ describe('useAppConfig Hook', () => {
     vi.restoreAllMocks();
   });
 
-    describe('Public Page Context', () => {
+  describe('Public Page Context', () => {
     beforeEach(() => {
       mockUseIsPublicPage.mockReturnValue(true);
     });
@@ -107,8 +107,6 @@ describe('useAppConfig Hook', () => {
     it('should return public page configuration when in public context', () => {
       const { result } = renderHook(() => useAppConfig());
 
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
       expect(result.current.isLoading).toBe(false);
       // Note: If VITE_APP_NAME is set in .env (e.g., CORE), the hook will use it.
       // Otherwise, it defaults to 'PACE'. This test verifies it returns a valid string.
@@ -122,8 +120,6 @@ describe('useAppConfig Hook', () => {
       const { result } = renderHook(() => useAppConfig());
 
       // Public pages should always have these characteristics
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
       expect(result.current.isLoading).toBe(false);
       expect(typeof result.current.appName).toBe('string');
     });
@@ -134,80 +130,23 @@ describe('useAppConfig Hook', () => {
       mockUseIsPublicPage.mockReturnValue(false);
       // Set default mock for useUnifiedAuth
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: { requires_event: true },
         appName: 'PACE',
       } as any);
     });
 
     it('should return configuration from UnifiedAuthProvider when available', () => {
-      const mockAppConfig = {
-        requires_event: false,
-      };
       const mockAppName = 'AuthApp';
 
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: mockAppConfig,
         appName: mockAppName,
       } as any);
 
       const { result } = renderHook(() => useAppConfig());
 
-      expect(result.current.supportsDirectAccess).toBe(true);
-      expect(result.current.requiresEvent).toBe(false);
       expect(result.current.isLoading).toBe(false);
       expect(result.current.appName).toBe('AuthApp');
     });
 
-    it('should handle requires_event: true', () => {
-      const mockAppConfig = {
-        requires_event: true,
-      };
-      const mockAppName = 'EventApp';
-
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: mockAppConfig,
-        appName: mockAppName,
-      } as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.appName).toBe('EventApp');
-    });
-
-    it('should handle null appConfig (loading state)', () => {
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: null,
-        appName: 'LoadingApp',
-      } as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
-      expect(result.current.isLoading).toBe(true);
-      expect(result.current.appName).toBe('LoadingApp');
-    });
-
-    it('should handle undefined appConfig.requires_event', () => {
-      const mockAppConfig = {};
-      const mockAppName = 'DefaultApp';
-
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: mockAppConfig,
-        appName: mockAppName,
-      } as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.appName).toBe('DefaultApp');
-    });
-
     it('should handle UnifiedAuthProvider error and return fallback', () => {
       mockUseUnifiedAuthFn.mockImplementation(() => {
         throw new Error('Provider not available');
@@ -215,8 +154,6 @@ describe('useAppConfig Hook', () => {
 
       const { result } = renderHook(() => useAppConfig());
 
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
       expect(result.current.isLoading).toBe(false);
       expect(result.current.appName).toBe('PACE');
     });
@@ -228,8 +165,6 @@ describe('useAppConfig Hook', () => {
 
       const { result } = renderHook(() => useAppConfig());
 
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
       expect(result.current.isLoading).toBe(false);
       expect(result.current.appName).toBe('PACE');
     });
@@ -241,8 +176,6 @@ describe('useAppConfig Hook', () => {
 
       const { result } = renderHook(() => useAppConfig());
 
-      expect(result.current.supportsDirectAccess).toBe(false);
-      expect(result.current.requiresEvent).toBe(true);
       expect(result.current.isLoading).toBe(false);
       expect(result.current.appName).toBe('PACE');
     });
@@ -264,11 +197,9 @@ describe('useAppConfig Hook', () => {
     it('should memoize authenticated configuration based on dependencies', () => {
       mockUseIsPublicPage.mockReturnValue(false);
 
-      const mockAppConfig = { requires_event: false };
       const mockAppName = 'TestApp';
 
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: mockAppConfig,
         appName: mockAppName,
       } as any);
 
@@ -281,25 +212,21 @@ describe('useAppConfig Hook', () => {
 
       expect(result.current).toBe(firstResult);
 
-      // Rerender with different appConfig
+      // Rerender with different appName
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: { requires_event: true },
-        appName: mockAppName,
+        appName: 'DifferentApp',
       } as any);
 
       rerender();
 
       expect(result.current).not.toBe(firstResult);
-      expect(result.current.requiresEvent).toBe(true);
+      expect(result.current.appName).toBe('DifferentApp');
     });
 
     it('should memoize authenticated configuration based on appName changes', () => {
       mockUseIsPublicPage.mockReturnValue(false);
 
-      const mockAppConfig = { requires_event: false };
-
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: mockAppConfig,
         appName: 'App1',
       } as any);
 
@@ -309,7 +236,6 @@ describe('useAppConfig Hook', () => {
 
       // Rerender with different appName
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: mockAppConfig,
         appName: 'App2',
       } as any);
 
@@ -327,7 +253,6 @@ describe('useAppConfig Hook', () => {
 
       const { result: publicResult } = renderHook(() => useAppConfig());
 
-      expect(publicResult.current.supportsDirectAccess).toBe(false);
       // Note: App name depends on environment - may be 'PACE' (default) or 'CORE' (from .env)
       expect(typeof publicResult.current.appName).toBe('string');
       expect(['PACE', 'CORE']).toContain(publicResult.current.appName);
@@ -335,13 +260,11 @@ describe('useAppConfig Hook', () => {
       // Test authenticated page context separately
       mockUseIsPublicPage.mockReturnValue(false);
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: { requires_event: false },
         appName: 'AuthApp',
       } as any);
 
       const { result: authResult } = renderHook(() => useAppConfig());
 
-      expect(authResult.current.supportsDirectAccess).toBe(true);
       expect(authResult.current.appName).toBe('AuthApp');
     });
   });
@@ -350,30 +273,13 @@ describe('useAppConfig Hook', () => {
     it('should return correct types for all return values', () => {
       mockUseIsPublicPage.mockReturnValue(false);
       mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: { requires_event: false },
         appName: 'TypeTestApp',
       } as any);
 
       const { result } = renderHook(() => useAppConfig());
 
-      expect(typeof result.current.supportsDirectAccess).toBe('boolean');
-      expect(typeof result.current.requiresEvent).toBe('boolean');
       expect(typeof result.current.isLoading).toBe('boolean');
       expect(typeof result.current.appName).toBe('string');
     });
-
-    it('should handle malformed appConfig objects', () => {
-      mockUseIsPublicPage.mockReturnValue(false);
-      mockUseUnifiedAuthFn.mockReturnValue({
-        appConfig: { requires_event: 'not-a-boolean' },
-        appName: 'MalformedApp',
-      } as any);
-
-      const { result } = renderHook(() => useAppConfig());
-
-      // The hook uses the value directly, so it will be truthy
-      expect(result.current.requiresEvent).toBe('not-a-boolean');
-      expect(result.current.supportsDirectAccess).toBe(false);
-    });
   });
 });

package/src/hooks/useAppConfig.ts

@@ -4,26 +4,19 @@
  * @module Hooks/useAppConfig
  * @since 0.4.0
  *
- * Hook for accessing app configuration like direct access support and event requirements.
- * This is a convenience hook that extracts app config from the UnifiedAuthProvider.
+ * Hook for accessing app name and loading state.
+ * 
+ * NOTE: Scope configuration (requires_event) is now page-level only (rbac_app_pages.scope_type).
+ * Use getPageScopeType() to determine if a specific page requires event or organisation context.
  *
  * @example
  * ```tsx
  * function MyComponent() {
- *   const { supportsDirectAccess, requiresEvent, isLoading } = useAppConfig();
+ *   const { appName, isLoading } = useAppConfig();
  *   
  *   if (isLoading) return <div>Loading...</div>;
  *   
- *   return (
- *     <div>
- *       {supportsDirectAccess && (
- *         <div>This app supports direct access!</div>
- *       )}
- *       {requiresEvent && (
- *         <EventSelector />
- *       )}
- *     </div>
- *   );
+ *   return <div>App: {appName}</div>;
  * }
  * ```
  */
@@ -33,10 +26,8 @@ import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
 import { useIsPublicPage, PublicPageContext } from '../components/PublicLayout/PublicPageProvider';
 
 export interface UseAppConfigReturn {
-  supportsDirectAccess: boolean;
-  requiresEvent: boolean;
-  isLoading: boolean;
   appName: string;
+  isLoading: boolean;
 }
 
 /**
@@ -92,32 +83,26 @@ export function useAppConfig(): UseAppConfigReturn {
     };
     
     return useMemo(() => ({
-      supportsDirectAccess: false, // Public pages don't support direct access
-      requiresEvent: true, // Public pages always require an event
-      isLoading: false,
-      appName: getAppName()
+      appName: getAppName(),
+      isLoading: false
     }), [contextAppName, hasPublicContext]);
   }
   
   // For authenticated pages, use UnifiedAuthProvider
   try {
-    const { appConfig, appName } = useUnifiedAuth();
+    const { appName } = useUnifiedAuth();
     return useMemo(() => ({
-      supportsDirectAccess: !(appConfig?.requires_event ?? true),
-      requiresEvent: appConfig?.requires_event ?? true,
-      isLoading: appConfig === null,
-      appName
-    }), [appConfig?.requires_event, appName]);
+      appName,
+      isLoading: false
+    }), [appName]);
   } catch (error) {
     // Fallback if UnifiedAuthProvider is not available
     return useMemo(() => ({
-      supportsDirectAccess: false,
-      requiresEvent: true,
-      isLoading: false,
       appName: contextAppName ||
         getNodeEnvVar('VITE_APP_NAME') ||
         getNodeEnvVar('NEXT_PUBLIC_APP_NAME') ||
-        'PACE'
+        'PACE',
+      isLoading: false
     }), [contextAppName]);
   }
 } 

package/src/hooks/useFileDisplay.ts

@@ -34,7 +34,7 @@
  * ```
  */
 
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import { FileReference, FileCategory } from '../types/file-reference';
 import { getPublicUrl, getSignedUrl, generateFileUrlsBatch } from '../utils/storage/helpers';
@@ -138,14 +138,25 @@ export function useFileDisplay(
   const [isLoading, setIsLoading] = useState<boolean>(false);
   const [error, setError] = useState<Error | null>(null);
 
+  // Ref to track if component is mounted and effect is active
+  // This prevents state updates from stale async operations
+  const isMountedRef = useRef(true);
+
+  // Helper to safely set state only if component is still mounted
+  const safeSetState = <T,>(setter: (value: T) => void, value: T) => {
+    if (isMountedRef.current) {
+      setter(value);
+    }
+  };
+
   const fetchFiles = useCallback(async (): Promise<void> => {
     if (!table_name || !record_id || !supabase) {
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(new Map());
-      setFileCount(0);
-      setIsLoading(false);
+      safeSetState(setFileUrl, null);
+      safeSetState(setFileReference, null);
+      safeSetState(setFileReferences, []);
+      safeSetState(setFileUrls, new Map());
+      safeSetState(setFileCount, 0);
+      safeSetState(setIsLoading, false);
       return;
     }
 
@@ -177,13 +188,13 @@ export function useFileDisplay(
               expiresIn: 3600
             });
             const regeneratedUrl = signedUrlResult?.url || null;
-            setFileUrl(regeneratedUrl);
-            setFileReference(cachedData.fileReference);
-            setFileReferences(cachedData.fileReferences || []);
-            setFileUrls(cachedData.fileUrls || new Map());
-            setFileCount(cachedData.fileCount || 0);
-            setIsLoading(false);
-            setError(null);
+            safeSetState(setFileUrl, regeneratedUrl);
+            safeSetState(setFileReference, cachedData.fileReference);
+            safeSetState(setFileReferences, cachedData.fileReferences || []);
+            safeSetState(setFileUrls, cachedData.fileUrls || new Map());
+            safeSetState(setFileCount, cachedData.fileCount || 0);
+            safeSetState(setIsLoading, false);
+            safeSetState(setError, null);
             return;
           } catch (err) {
             // If signed URL regeneration fails, fall through to normal fetch
@@ -192,20 +203,20 @@ export function useFileDisplay(
         }
         
         // Normal cache hit for public files or files with URLs
-        setFileUrl(cachedData.fileUrl || null);
-        setFileReference(cachedData.fileReference || null);
-        setFileReferences(cachedData.fileReferences || []);
-        setFileUrls(cachedData.fileUrls || new Map());
-        setFileCount(cachedData.fileCount || 0);
-        setIsLoading(false);
-        setError(null);
+        safeSetState(setFileUrl, cachedData.fileUrl || null);
+        safeSetState(setFileReference, cachedData.fileReference || null);
+        safeSetState(setFileReferences, cachedData.fileReferences || []);
+        safeSetState(setFileUrls, cachedData.fileUrls || new Map());
+        safeSetState(setFileCount, cachedData.fileCount || 0);
+        safeSetState(setIsLoading, false);
+        safeSetState(setError, null);
         return;
       }
     }
 
     try {
-      setIsLoading(true);
-      setError(null);
+      safeSetState(setIsLoading, true);
+      safeSetState(setError, null);
 
       const service = createFileReferenceService(supabase);
       let files: FileReference[] = [];
@@ -485,11 +496,11 @@ export function useFileDisplay(
       }
 
       if (files.length === 0) {
-        setFileUrl(null);
-        setFileReference(null);
-        setFileReferences([]);
-        setFileUrls(new Map());
-        setFileCount(0);
+        safeSetState(setFileUrl, null);
+        safeSetState(setFileReference, null);
+        safeSetState(setFileReferences, []);
+        safeSetState(setFileUrls, new Map());
+        safeSetState(setFileCount, 0);
         
         // Cache empty result
         if (enableCache) {
@@ -503,14 +514,14 @@ export function useFileDisplay(
         return;
       }
 
-      setFileReferences(files);
-      setFileCount(files.length);
+      safeSetState(setFileReferences, files);
+      safeSetState(setFileCount, files.length);
 
       if (category && files.length > 0) {
         // Single file mode - get first file
         const firstFile = files[0];
         // Removed verbose debug logs - only log on errors
-        setFileReference(firstFile);
+        safeSetState(setFileReference, firstFile);
         
         // Generate URL based on file visibility
         let url: string | null = null;
@@ -533,7 +544,7 @@ export function useFileDisplay(
             });
           }
         }
-        setFileUrl(url);
+        safeSetState(setFileUrl, url);
       } else {
         // Multiple files mode - generate URLs for all files in batch
         const urlMap = await generateFileUrlsBatch(supabase, files, {
@@ -542,9 +553,9 @@ export function useFileDisplay(
               userId: organisation_id ? undefined : record_id,
               expiresIn: 3600
             });
-        setFileUrls(urlMap);
-        setFileReference(null);
-        setFileUrl(null);
+        safeSetState(setFileUrls, urlMap);
+        safeSetState(setFileReference, null);
+        safeSetState(setFileUrl, null);
       }
 
       // Cache the result
@@ -588,30 +599,46 @@ export function useFileDisplay(
     } catch (err) {
       logger.error('useFileDisplay', 'Error fetching files:', err);
       const error = err instanceof Error ? err : new Error('Unknown error occurred');
-      setError(error);
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(new Map());
-      setFileCount(0);
+      safeSetState(setError, error);
+      safeSetState(setFileUrl, null);
+      safeSetState(setFileReference, null);
+      safeSetState(setFileReferences, []);
+      safeSetState(setFileUrls, new Map());
+      safeSetState(setFileCount, 0);
     } finally {
-      setIsLoading(false);
+      safeSetState(setIsLoading, false);
     }
   }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
 
   // Fetch files when parameters change
   useEffect(() => {
+    // Mark as mounted when effect runs
+    isMountedRef.current = true;
+
     if (table_name && record_id && supabase) {
-      fetchFiles();
+      // Call fetchFiles - it will check isMountedRef before setting state
+      fetchFiles().catch((err) => {
+        // Only set error if component is still mounted
+        if (isMountedRef.current) {
+          safeSetState(setError, err instanceof Error ? err : new Error('Unknown error'));
+        }
+      });
     } else {
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(new Map());
-      setFileCount(0);
-      setIsLoading(false);
-      setError(null);
+      // Only update state if component is still mounted
+      safeSetState(setFileUrl, null);
+      safeSetState(setFileReference, null);
+      safeSetState(setFileReferences, []);
+      safeSetState(setFileUrls, new Map());
+      safeSetState(setFileCount, 0);
+      safeSetState(setIsLoading, false);
+      safeSetState(setError, null);
     }
+
+    // Cleanup: mark as unmounted when dependencies change or component unmounts
+    // This prevents state updates from stale requests
+    return () => {
+      isMountedRef.current = false;
+    };
     // fetchFiles is memoized; we only need to re-run when parameters change
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [table_name, record_id, organisation_id, supabase]);

package/src/index.ts

@@ -230,11 +230,10 @@ export { LoadingSpinner } from './components/LoadingSpinner/LoadingSpinner';
 export { SessionRestorationLoader } from './components/SessionRestorationLoader/SessionRestorationLoader';
 export type { SessionRestorationLoaderProps } from './components/SessionRestorationLoader/SessionRestorationLoader';
 
-// EVENT MANAGEMENT
-export { EventSelector } from './components/EventSelector/EventSelector';
-
-// ORGANISATION MANAGEMENT
-export { OrganisationSelector } from './components/OrganisationSelector/OrganisationSelector';
+// CONTEXT SELECTION
+// Unified context selector (shows all accessible orgs and events)
+export { ContextSelector } from './components/ContextSelector/ContextSelector';
+export type { ContextSelectorProps } from './components/ContextSelector/ContextSelector';
 export { useOrganisationPermissions } from './hooks/useOrganisationPermissions';
 export { useOrganisationSecurity } from './hooks/useOrganisationSecurity';
 export { createSecureDataAccess } from './utils/security/secureDataAccess';

package/src/providers/services/AuthServiceProvider.tsx

@@ -8,7 +8,7 @@
  * Provides authentication service instance to React components.
  */
 
-import React, { createContext, useMemo, useEffect, useState } from 'react';
+import React, { createContext, useMemo, useEffect, useState, useRef } from 'react';
 import { type SupabaseClient } from '@supabase/supabase-js';
 import { AuthService } from '../../services/AuthService';
 import type { SessionRestorationState } from '../../types/auth';
@@ -47,11 +47,21 @@ export interface AuthServiceProviderProps {
  * @returns The auth service provider
  */
 export function AuthServiceProvider({ children, supabaseClient, appName }: AuthServiceProviderProps) {
-  // Create service instance with useMemo to prevent recreation on every render
-  const authService = useMemo(
-    () => new AuthService(supabaseClient, appName),
-    [supabaseClient, appName]
-  );
+  // Create service instance once with useRef to avoid recreation on dependency changes
+  const authServiceRef = useRef<AuthService | null>(null);
+  
+  if (!authServiceRef.current) {
+    authServiceRef.current = new AuthService(supabaseClient, appName);
+  }
+  
+  const authService = authServiceRef.current;
+
+  // Update dependencies when they change
+  useEffect(() => {
+    // Note: AuthService doesn't have an updateDependencies method yet, 
+    // but we should ensure the client is current if it's used directly
+    // This is safer than recreation
+  }, [authService, supabaseClient, appName]);
 
   const [sessionRestoration, setSessionRestoration] = useState<SessionRestorationState>(
     () => authService.getSessionRestorationState()
@@ -71,7 +81,7 @@ export function AuthServiceProvider({ children, supabaseClient, appName }: AuthS
 
   // Initialize service on mount
   useEffect(() => {
-    authService.initialize().catch(error => {
+    authService.initialize().catch((error: unknown) => {
       logger.error('AuthServiceProvider', 'Failed to initialize auth service:', error);
     });
 

package/src/providers/services/EventServiceProvider.tsx

@@ -73,7 +73,16 @@ export function EventServiceProvider({
   useEffect(() => {
     let isMounted = true;
 
+    logger.debug('EventServiceProvider', 'useEffect triggered', {
+      hasUser: !!user,
+      userId: user?.id,
+      hasSession: !!session,
+      appName,
+      isInitializing: initializingRef.current
+    });
+
     if (initializingRef.current) {
+      logger.debug('EventServiceProvider', 'Skipping - already initializing');
       return;
     }
 
@@ -81,17 +90,36 @@ export function EventServiceProvider({
       initializingRef.current = true;
 
       try {
+        logger.debug('EventServiceProvider', 'Updating dependencies and initializing', {
+          hasUser: !!user,
+          userId: user?.id,
+          hasSession: !!session,
+          appName,
+          hasSelectedOrganisation: !!selectedOrganisation
+        });
+
         // 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);
-          }
-        });
+        // Only initialize if we have a user (required for fetching events)
+        if (user && session && supabaseClient && appName) {
+          logger.debug('EventServiceProvider', 'Initializing event service');
+          await eventService.initialize().catch(error => {
+            if (isMounted) {
+              logger.error('EventServiceProvider', 'Failed to initialize event service:', error);
+            }
+          });
+        } else {
+          logger.debug('EventServiceProvider', 'Skipping initialization - missing required dependencies', {
+            hasUser: !!user,
+            hasSession: !!session,
+            hasSupabaseClient: !!supabaseClient,
+            appName
+          });
+        }
       } finally {
         initializingRef.current = false;
       }