@jmruthers/pace-core 0.6.4 → 0.6.6

package/src/hooks/public/usePublicEvent.ts

@@ -115,18 +115,12 @@ export function usePublicEvent(
   const [isLoading, setIsLoading] = useState<boolean>(true);
   const [error, setError] = useState<Error | null>(null);
 
-  // Get environment variables from public page context or fallback to direct access
-  let environment: { supabaseUrl: string | null; supabaseKey: string | null };
-  
-  try {
-    environment = usePublicPageContext().environment;
-  } catch {
-    // Fallback to direct environment variable access if not in PublicPageProvider
-    environment = {
-      supabaseUrl: (import.meta as any).env?.VITE_SUPABASE_URL || (import.meta as any).env?.NEXT_PUBLIC_SUPABASE_URL || null,
-      supabaseKey: (import.meta as any).env?.VITE_SUPABASE_PUBLISHABLE_KEY || (import.meta as any).env?.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY || null
-    };
-  }
+  // Call hook unconditionally - if provider is missing, it will throw
+  // Errors should be handled by error boundaries at a higher level
+  // We cannot conditionally call hooks
+  // For public pages, PublicPageProvider should always be present
+  const publicPageContext = usePublicPageContext();
+  const environment = publicPageContext.environment;
   
   // Create a simple Supabase client for public access
   const supabase = useMemo(() => {
@@ -140,17 +134,6 @@ export function usePublicEvent(
     return createClient<Database>(environment.supabaseUrl, environment.supabaseKey);
   }, [environment.supabaseUrl, environment.supabaseKey]);
 
-  // Helper function to try refreshing schema cache
-  const refreshSchemaCache = useCallback(async () => {
-    try {
-      // Try to trigger a schema refresh by querying a system table
-      await (supabase as any).from('information_schema.routines').select('routine_name').limit(1);
-    } catch (error) {
-      // Ignore errors, this is just an attempt to refresh cache
-      logger.debug('usePublicEvent', 'Schema cache refresh attempt failed:', error);
-    }
-  }, [supabase]);
-
   const fetchEvent = useCallback(async (): Promise<void> => {
     if (!eventCode || !supabase) {
       setError(new Error('Invalid event code or Supabase client not available'));
@@ -174,177 +157,66 @@ export function usePublicEvent(
       setIsLoading(true);
       setError(null);
 
-      let eventData: any = null;
-
-      try {
-        // Try to call the public event RPC function first
-        const response = await (supabase as any).rpc('get_public_event_by_code', {
-          event_code_param: eventCode
-        });
-        
-        const data = response?.data;
-        const rpcError = response?.error;
-
-        if (rpcError) {
-          // If RPC function doesn't exist or schema cache issue, try refresh first, then fallback
-          if (rpcError.message?.includes('Could not find the function') || 
-              rpcError.message?.includes('does not exist') ||
-              rpcError.message?.includes('schema cache')) {
-            logger.warn('usePublicEvent', 'RPC function not found or schema cache issue, attempting refresh:', rpcError.message);
-            
-            // Try to refresh schema cache first
-            await refreshSchemaCache();
-            
-            // Try RPC call one more time after refresh
-            try {
-              const retryResponse = await (supabase as any).rpc('get_public_event_by_code', {
-                event_code_param: eventCode
-              });
-              
-              const retryData = retryResponse?.data;
-              const retryError = retryResponse?.error;
-              
-              if (!retryError && retryData && retryData.length > 0) {
-                eventData = retryData[0];
-              } else {
-                throw new Error('RPC still failing after cache refresh');
-              }
-            } catch (retryError) {
-              logger.warn('usePublicEvent', 'RPC still failing after cache refresh, falling back to direct table access');
-              
-              // Fallback: Direct table access with public RLS policy
-            const tableResponse2 = await (supabase as any)
-              .from('core_events')
-              .select(`
-                event_id,
-                event_name,
-                event_date,
-                event_venue,
-                event_participants,
-                event_colours,
-                organisation_id,
-                event_days,
-                event_typicalunit,
-                event_rounddown,
-                event_youthmultiplier,
-                event_catering_email,
-                event_news,
-                event_billing,
-                event_email
-              `)
-              .eq('event_code', eventCode)
-              .eq('is_visible', true)
-              .not('organisation_id', 'is', null)
-              .limit(1)
-              .single();
-
-            const tableData = tableResponse2?.data;
-            const tableError = tableResponse2?.error;
-
-            if (tableError) {
-              throw new Error(tableError?.message || 'Failed to fetch event from table');
-            }
-
-            if (!tableData) {
-              setEvent(null);
-              setError(new Error('Event not found'));
-              return;
-            }
+      // Use direct table query (removed legacy RPC get_public_event_by_code)
+      const tableResponse = await (supabase as any)
+        .from('core_events')
+        .select(`
+          event_id,
+          event_name,
+          event_date,
+          event_venue,
+          event_participants,
+          event_colours,
+          organisation_id,
+          event_days,
+          event_typicalunit,
+          event_rounddown,
+          event_youthmultiplier,
+          event_catering_email,
+          event_news,
+          event_billing,
+          event_email
+        `)
+        .eq('event_code', eventCode)
+        .eq('is_visible', true)
+        .not('organisation_id', 'is', null)
+        .limit(1)
+        .single();
+
+      const tableData = tableResponse?.data;
+      const tableError = tableResponse?.error;
+
+      if (tableError) {
+        // Transform "No rows found" to user-friendly "Event not found"
+        const errorMessage = tableError.message === 'No rows found' || tableError.code === 'PGRST116'
+          ? 'Event not found'
+          : (tableError?.message || 'Failed to fetch event from table');
+        throw new Error(errorMessage);
+      }
 
-            // Get event logo from core_file_references
-            const logoResponse = await (supabase as any)
-              .from('core_file_references')
-              .select('file_path')
-              .eq('table_name', 'core_events')
-              .eq('record_id', tableData.event_id)
-              .eq('is_public', true)
-              .eq('file_metadata->>category', 'event_logos')
-              .limit(1)
-              .single();
-              
-            const logoData = logoResponse?.data;
+      if (!tableData) {
+        setEvent(null);
+        setError(new Error('Event not found'));
+        return;
+      }
 
-            eventData = {
-              ...tableData,
-              event_logo: logoData?.file_path || null
-            };
-            }
-          } else {
-            // For RPC errors that aren't schema cache issues, throw immediately without fallback
-            const errorMessage = rpcError?.message || rpcError?.toString() || 'Failed to fetch event';
-            setEvent(null);
-            setError(new Error(errorMessage));
-            setIsLoading(false);
-            return;
-          }
-        } else {
-          if (!data || data.length === 0 || !data[0]) {
-            setEvent(null);
-            setError(new Error('Event not found'));
-            return;
-          }
-          eventData = data[0];
-        }
-      } catch (rpcError) {
-        // If RPC call fails for any reason (including schema cache issues), try direct table access
-        logger.warn('usePublicEvent', 'RPC call failed, falling back to direct table access:', rpcError);
+      // Get event logo from core_file_references
+      const logoResponse = await (supabase as any)
+        .from('core_file_references')
+        .select('file_path')
+        .eq('table_name', 'core_events')
+        .eq('record_id', tableData.event_id)
+        .eq('is_public', true)
+        .eq('file_metadata->>category', 'event_logos')
+        .limit(1)
+        .single();
         
-        const tableResponse = await (supabase as any)
-          .from('core_events')
-          .select(`
-            event_id,
-            event_name,
-            event_date,
-            event_venue,
-            event_participants,
-            event_colours,
-            organisation_id,
-            event_days,
-            event_typicalunit,
-            event_rounddown,
-            event_youthmultiplier,
-            event_catering_email,
-            event_news,
-            event_billing,
-            event_email
-          `)
-          .eq('event_code', eventCode)
-          .eq('is_visible', true)
-          .not('organisation_id', 'is', null)
-          .limit(1)
-          .single();
-
-        const tableData = tableResponse?.data;
-        const tableError = tableResponse?.error;
+      const logoData = logoResponse?.data;
 
-        if (tableError) {
-          throw new Error(tableError?.message || 'Failed to fetch event from table');
-        }
-
-        if (!tableData) {
-          setEvent(null);
-          setError(new Error('Event not found'));
-          return;
-        }
-
-        // Get event logo from core_file_references
-        const logoResponse = await (supabase as any)
-          .from('core_file_references')
-          .select('file_path')
-          .eq('table_name', 'core_events')
-          .eq('record_id', tableData.event_id)
-          .eq('is_public', true)
-          .eq('file_metadata->>category', 'event_logos')
-          .limit(1)
-          .single();
-          
-        const logoData = logoResponse?.data;
-
-        eventData = {
-          ...tableData,
-          event_logo: logoData?.file_path || null
-        };
-      }
+      const eventData = {
+        ...tableData,
+        event_logo: logoData?.file_path || null
+      };
       
       // Transform to Event type
       const transformedEvent: Event = {

package/src/hooks/public/usePublicEventLogo.test.ts

@@ -33,6 +33,15 @@ describe('usePublicEventLogo', () => {
     fetchMock = vi.fn().mockResolvedValue({ ok: true });
     (globalThis as any).fetch = fetchMock;
     clearPublicLogoCache();
+    
+    // Setup default mock for the query chain: .from('core_file_references').select(...).eq(...).eq(...).eq(...).eq(...).limit(1).single()
+    const mockQueryBuilder = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      limit: vi.fn().mockReturnThis(),
+      single: vi.fn().mockResolvedValue({ data: null, error: null })
+    };
+    (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
   });
 
   afterEach(() => {
@@ -44,9 +53,19 @@ describe('usePublicEventLogo', () => {
     (globalThis as any).fetch = originalFetch;
   });
 
-  it('fetches and caches the logo when RPC succeeds', async () => {
+  it('fetches and caches the logo when query succeeds', async () => {
     const logoUrl = 'https://cdn.example.com/logo.png';
-    (mockSupabase.rpc as any).mockResolvedValue({ data: [{ logo_url: logoUrl }], error: null });
+    // usePublicEventLogo uses: .from('core_file_references').select('file_path').eq(...).eq(...).eq(...).eq(...).limit(1).single()
+    const mockQueryBuilder = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      limit: vi.fn().mockReturnThis(),
+      single: vi.fn().mockResolvedValue({ 
+        data: { file_path: logoUrl }, 
+        error: null 
+      })
+    };
+    (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
 
     const { result } = renderHook(() =>
       usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
@@ -54,7 +73,7 @@ describe('usePublicEventLogo', () => {
       })
     );
 
-    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl));
+    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl), { timeout: 2000 });
     expect(result.current.fallbackText).toBe('BE');
     expect(fetchMock).toHaveBeenCalledWith(logoUrl, { method: 'HEAD' });
 
@@ -66,9 +85,16 @@ describe('usePublicEventLogo', () => {
   it('refetch clears cache and requests fresh data', async () => {
     const firstUrl = 'https://cdn.example.com/logo.png';
     const secondUrl = 'https://cdn.example.com/logo-2.png';
-    (mockSupabase.rpc as any)
-      .mockResolvedValueOnce({ data: [{ logo_url: firstUrl }], error: null })
-      .mockResolvedValueOnce({ data: [{ logo_url: secondUrl }], error: null });
+    
+    const mockQueryBuilder = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      limit: vi.fn().mockReturnThis(),
+      single: vi.fn()
+        .mockResolvedValueOnce({ data: { file_path: firstUrl }, error: null })
+        .mockResolvedValueOnce({ data: { file_path: secondUrl }, error: null })
+    };
+    (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
 
     const { result } = renderHook(() =>
       usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
@@ -76,18 +102,27 @@ describe('usePublicEventLogo', () => {
       })
     );
 
-    await waitFor(() => expect(result.current.logoUrl).toBe(firstUrl));
+    await waitFor(() => expect(result.current.logoUrl).toBe(firstUrl), { timeout: 2000 });
 
     await act(async () => {
       await result.current.refetch();
     });
 
-    await waitFor(() => expect(result.current.logoUrl).toBe(secondUrl));
-    expect((mockSupabase.rpc as any)).toHaveBeenCalledTimes(2);
+    await waitFor(() => expect(result.current.logoUrl).toBe(secondUrl), { timeout: 2000 });
+    expect(mockQueryBuilder.single).toHaveBeenCalledTimes(2);
   });
 
-  it('exposes error state when RPC fails', async () => {
-    (mockSupabase.rpc as any).mockResolvedValue({ data: null, error: { message: 'RPC failed' } });
+  it('exposes error state when query fails', async () => {
+    const mockQueryBuilder = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      limit: vi.fn().mockReturnThis(),
+      single: vi.fn().mockResolvedValue({ 
+        data: null, 
+        error: { message: 'Query failed', code: 'PGRST116' } 
+      })
+    };
+    (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
 
     const { result } = renderHook(() =>
       usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
@@ -95,15 +130,24 @@ describe('usePublicEventLogo', () => {
       })
     );
 
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    await waitFor(() => expect(result.current.isLoading).toBe(false), { timeout: 2000 });
     expect(result.current.logoUrl).toBeNull();
-    expect(result.current.error).toEqual(new Error('RPC failed'));
+    expect(result.current.error).toBeNull(); // No error for PGRST116 (not found)
     expect(fetchMock).not.toHaveBeenCalled();
   });
 
   it('skips image validation when disabled', async () => {
     const logoUrl = 'https://cdn.example.com/logo.png';
-    (mockSupabase.rpc as any).mockResolvedValue({ data: [{ logo_url: logoUrl }], error: null });
+    const mockQueryBuilder = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      limit: vi.fn().mockReturnThis(),
+      single: vi.fn().mockResolvedValue({ 
+        data: { file_path: logoUrl }, 
+        error: null 
+      })
+    };
+    (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
 
     const { result } = renderHook(() =>
       usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
@@ -112,7 +156,7 @@ describe('usePublicEventLogo', () => {
       })
     );
 
-    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl));
+    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl), { timeout: 2000 });
     expect(fetchMock).not.toHaveBeenCalled();
   });
 
@@ -130,7 +174,16 @@ describe('usePublicEventLogo', () => {
 
   it('clears cached logo entries when clearPublicLogoCache is called', async () => {
     const logoUrl = 'https://cdn.example.com/logo.png';
-    (mockSupabase.rpc as any).mockResolvedValue({ data: [{ logo_url: logoUrl }], error: null });
+    const mockQueryBuilder = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      limit: vi.fn().mockReturnThis(),
+      single: vi.fn().mockResolvedValue({ 
+        data: { file_path: logoUrl }, 
+        error: null 
+      })
+    };
+    (mockSupabase.from as any).mockReturnValue(mockQueryBuilder);
 
     const { result } = renderHook(() =>
       usePublicEventLogo('event-123', 'Big Event', VALID_ORG_ID, {
@@ -138,7 +191,7 @@ describe('usePublicEventLogo', () => {
       })
     );
 
-    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl));
+    await waitFor(() => expect(result.current.logoUrl).toBe(logoUrl), { timeout: 2000 });
     expect(getPublicLogoCacheStats().size).toBe(1);
 
     clearPublicLogoCache();

package/src/hooks/public/usePublicEventLogo.ts

@@ -183,22 +183,32 @@ export function usePublicEventLogo(
       setIsLoading(true);
       setError(null);
 
-      // Call the public logo RPC function
-      const { data, error: rpcError } = await (supabase as any).rpc('get_public_event_logo', {
-        event_id_param: eventId,
-        organisation_id_param: organisationId
-      });
+      // Query logo directly from core_file_references (removed legacy RPC get_public_event_logo)
+      const { data: logoData, error: queryError } = await (supabase as any)
+        .from('core_file_references')
+        .select('file_path')
+        .eq('table_name', 'core_events')
+        .eq('record_id', eventId)
+        .eq('is_public', true)
+        .eq('file_metadata->>category', 'event_logos')
+        .limit(1)
+        .single();
 
-      if (rpcError) {
-        throw new Error(rpcError.message || 'Failed to fetch logo');
+      if (queryError) {
+        // If no logo found, that's okay - return null
+        if (queryError.code === 'PGRST116') {
+          setLogoUrl(null);
+          return;
+        }
+        throw new Error(queryError.message || 'Failed to fetch logo');
       }
 
-      if (!data || data.length === 0 || !data[0] || !data[0].logo_url) {
+      if (!logoData || !logoData.file_path) {
         setLogoUrl(null);
         return;
       }
 
-      const logoUrl = data[0].logo_url;
+      const logoUrl = logoData.file_path;
 
       // Validate image existence if requested
       if (validateImage) {

package/src/hooks/useAppConfig.ts

@@ -22,7 +22,7 @@
  */
 
 import { useMemo, useContext } from 'react';
-import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
+import { useUnifiedAuth, UnifiedAuthContext } from '../providers/services/UnifiedAuthProvider';
 import { useIsPublicPage, PublicPageContext } from '../components/PublicLayout/PublicPageProvider';
 
 export interface UseAppConfigReturn {
@@ -36,6 +36,8 @@ export interface UseAppConfigReturn {
  * @returns App configuration and loading state
  */
 export function useAppConfig(): UseAppConfigReturn {
+  // Call all hooks unconditionally at the top level
+  // Hooks must be called in the same order on every render
   // Check if we're in a public page context first
   const isPublicPage = useIsPublicPage();
   
@@ -43,10 +45,20 @@ export function useAppConfig(): UseAppConfigReturn {
   const publicPageContext = useContext(PublicPageContext);
   const hasPublicContext = publicPageContext !== undefined;
   const contextAppName = publicPageContext?.appName || null;
+  
+  // For authenticated pages, use UnifiedAuthProvider
+  // Use useContext directly to handle missing provider gracefully
+  // This allows the hook to work in test environments without providers
+  const authContext = useContext(UnifiedAuthContext);
+  const authAppName = authContext?.appName;
+  
   const getNodeEnvVar = (key: string): string | undefined =>
     typeof process !== 'undefined' && process.env ? process.env[key] : undefined;
   
-  if (isPublicPage) {
+  // Call all useMemo hooks unconditionally - use conditional logic only for computed values
+  const publicAppName = useMemo(() => {
+    if (!isPublicPage) return null;
+    
     const getAppName = (): string => {
       // When tests mock public mode without the provider, default to PACE
       if (!hasPublicContext) {
@@ -82,27 +94,17 @@ export function useAppConfig(): UseAppConfigReturn {
       return 'PACE';
     };
     
-    return useMemo(() => ({
-      appName: getAppName(),
-      isLoading: false
-    }), [contextAppName, hasPublicContext]);
-  }
+    return getAppName();
+  }, [isPublicPage, contextAppName, hasPublicContext]);
   
-  // For authenticated pages, use UnifiedAuthProvider
-  try {
-    const { appName } = useUnifiedAuth();
-    return useMemo(() => ({
-      appName,
-      isLoading: false
-    }), [appName]);
-  } catch (error) {
-    // Fallback if UnifiedAuthProvider is not available
-    return useMemo(() => ({
-      appName: contextAppName ||
-        getNodeEnvVar('VITE_APP_NAME') ||
-        getNodeEnvVar('NEXT_PUBLIC_APP_NAME') ||
-        'PACE',
-      isLoading: false
-    }), [contextAppName]);
-  }
+  const authenticatedAppName = useMemo(() => {
+    if (isPublicPage) return null;
+    return authAppName || 'PACE';
+  }, [isPublicPage, authAppName]);
+  
+  // Return the appropriate value based on context
+  return useMemo(() => ({
+    appName: publicAppName || authenticatedAppName || 'PACE',
+    isLoading: false
+  }), [publicAppName, authenticatedAppName]);
 }