@jmruthers/pace-core 0.5.121 → 0.5.123

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

@@ -0,0 +1,583 @@
+import React from 'react';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { usePublicEvent, clearPublicEventCache, getPublicEventCacheStats } from '../public/usePublicEvent';
+import { usePublicPageContext } from '../../components/PublicLayout/PublicPageProvider';
+
+// Mock the PublicPageProvider
+vi.mock('../../components/PublicLayout/PublicPageProvider', () => ({
+  usePublicPageContext: vi.fn(() => ({
+    environment: {
+      supabaseUrl: 'https://test.supabase.co',
+      supabaseKey: 'test-anon-key'
+    }
+  }))
+}));
+
+// Mock Supabase client
+const mockSupabaseClient = {
+  rpc: vi.fn(),
+  from: vi.fn(() => ({
+    select: vi.fn(() => ({
+      eq: vi.fn(() => ({
+        eq: vi.fn(() => ({
+          not: vi.fn(() => ({
+            limit: vi.fn(() => ({
+              single: vi.fn()
+            }))
+          }))
+        }))
+      }))
+    }))
+  }))
+};
+
+// Helper to create table query mocks
+const createTableQueryMock = () => ({
+  data: null,
+  error: null,
+  mockResolvedValueOnce: vi.fn(),
+  mockResolvedValue: vi.fn()
+});
+
+// Helper to create a complete table query chain
+const createTableQueryChain = (finalResult: any) => {
+  const mockChain = {
+    select: vi.fn().mockReturnThis(),
+    eq: vi.fn().mockReturnThis(),
+    not: vi.fn().mockReturnThis(),
+    limit: vi.fn().mockReturnThis(),
+    single: vi.fn().mockResolvedValue(finalResult)
+  };
+  return mockChain;
+};
+
+// Mock createClient
+vi.mock('@supabase/supabase-js', () => ({
+  createClient: vi.fn(() => mockSupabaseClient)
+}));
+
+// Mock environment variables
+const originalEnv = import.meta.env;
+
+describe('usePublicEvent', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    clearPublicEventCache();
+    
+    // Reset environment
+    Object.defineProperty(import.meta, 'env', {
+      value: {
+        VITE_SUPABASE_URL: 'https://test.supabase.co',
+        VITE_SUPABASE_ANON_KEY: 'test-anon-key'
+      },
+      writable: true
+    });
+
+    // Mock window object
+    Object.defineProperty(window, 'location', {
+      value: { href: 'https://test.com' },
+      writable: true
+    });
+
+    // Re-establish mock implementations after clearAllMocks
+    mockSupabaseClient.rpc.mockImplementation(() => 
+      Promise.resolve({
+        data: null,
+        error: null
+      })
+    );
+    
+    // Ensure the mock is properly configured
+    expect(mockSupabaseClient.rpc).toBeDefined();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    clearPublicEventCache();
+    Object.defineProperty(import.meta, 'env', {
+      value: originalEnv,
+      writable: true
+    });
+  });
+
+  describe('Basic Functionality', () => {
+    it('should initialize with loading state', () => {
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should fetch event data successfully via RPC', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.event).toEqual({
+        id: '123',
+        event_id: '123',
+        event_name: 'Test Event',
+        event_code: 'test-event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_logo: null,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        is_visible: true,
+        created_at: expect.any(String),
+        updated_at: expect.any(String),
+        name: 'Test Event',
+        start_date: '2024-01-01'
+      });
+      expect(result.current.error).toBe(null);
+    });
+
+    it('should handle event not found', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('nonexistent-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+
+    it('should handle invalid event code', async () => {
+      const { result } = renderHook(() => usePublicEvent(''));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toContain('Invalid event code or Supabase client not available');
+    });
+  });
+
+  describe('Caching', () => {
+    it('should cache event data', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com'
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result, rerender } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      // Rerender with same event code - should use cache
+      rerender();
+      
+      // Should not call RPC again
+      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(1);
+    });
+
+    it('should respect cache TTL', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com'
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event', { cacheTtl: 100 }));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      // Wait for cache to expire
+      await new Promise(resolve => setTimeout(resolve, 150));
+
+      // Rerender should fetch again
+      const { result: result2 } = renderHook(() => usePublicEvent('test-event', { cacheTtl: 100 }));
+      
+      await waitFor(() => {
+        expect(result2.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
+    });
+
+    it('should disable caching when requested', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      // Clear any existing cache
+      const { clearPublicEventCache } = await import('../public/usePublicEvent');
+      clearPublicEventCache();
+
+      // Use mockImplementation to handle multiple calls
+      let callCount = 0;
+      mockSupabaseClient.rpc.mockImplementation(() => {
+        callCount++;
+        return Promise.resolve({
+          data: [mockEventData],
+          error: null
+        });
+      });
+
+      const { result, rerender } = renderHook(
+        ({ eventCode }) => usePublicEvent(eventCode, { enableCache: false }),
+        { initialProps: { eventCode: 'test-event' } }
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      // Change the event code to force a new fetch
+      rerender({ eventCode: 'test-event-2' });
+      
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(callCount).toBe(2);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle RPC errors', async () => {
+      // Mock the RPC call to return an error object
+      const testError = { message: 'Database error', details: 'Test error details', hint: null, code: 'TEST_ERROR' };
+      mockSupabaseClient.rpc.mockImplementation(() => 
+        Promise.resolve({
+          data: null,
+          error: testError
+        })
+      );
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toBe('Database error');
+      expect(result.current.event).toBe(null);
+      
+      // Verify the mock was called
+      expect(mockSupabaseClient.rpc).toHaveBeenCalledWith('get_public_event_by_code', {
+        event_code_param: 'test-event'
+      });
+    });
+
+    it('should handle missing Supabase client', async () => {
+      // Mock the PublicPageProvider to return null environment
+      const mockUsePublicPageContext = vi.mocked(usePublicPageContext);
+      mockUsePublicPageContext.mockReturnValueOnce({
+        environment: {
+          supabaseUrl: '',
+          supabaseKey: ''
+        }
+      });
+
+      // Mock createClient to return null when environment is empty
+      const { createClient } = await import('@supabase/supabase-js');
+      vi.mocked(createClient).mockReturnValueOnce(null as any);
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toContain('Invalid event code or Supabase client not available');
+      expect(result.current.event).toBe(null);
+    });
+  });
+
+  describe('Provider Context Integration', () => {
+    it('should use PublicPageContext when available', async () => {
+      const mockContext = {
+        environment: {
+          supabaseUrl: 'https://context.supabase.co',
+          supabaseKey: 'context-anon-key'
+        }
+      };
+
+      vi.mocked(usePublicPageContext).mockReturnValue(mockContext);
+
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com',
+        event_logo: null
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.event).toBeTruthy();
+    });
+  });
+
+  describe('Refetch Functionality', () => {
+    it('should refetch data when refetch is called', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com'
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValue({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      // Call refetch
+      await act(async () => {
+        await result.current.refetch();
+      });
+
+      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
+    });
+
+    it('should clear cache when refetch is called', async () => {
+      const mockEventData = {
+        event_id: '123',
+        event_name: 'Test Event',
+        event_date: '2024-01-01',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: { primary: '#000000' },
+        organisation_id: 'org-123',
+        event_days: 1,
+        event_typicalunit: 'km',
+        event_rounddown: false,
+        event_youthmultiplier: 1.0,
+        event_catering_email: 'test@example.com',
+        event_news: 'Test news',
+        event_billing: 'Test billing',
+        event_footer: 'Test footer',
+        event_email: 'event@example.com'
+      };
+
+      mockSupabaseClient.rpc.mockResolvedValue({
+        data: [mockEventData],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      // Call refetch
+      await act(async () => {
+        await result.current.refetch();
+      });
+
+      // Should call RPC again (cache was cleared)
+      expect(mockSupabaseClient.rpc).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('Cache Management Utilities', () => {
+    it('should clear public event cache', () => {
+      // Add some data to cache
+      const stats = getPublicEventCacheStats();
+      expect(stats.size).toBe(0);
+
+      // Clear cache
+      clearPublicEventCache();
+      
+      const statsAfter = getPublicEventCacheStats();
+      expect(statsAfter.size).toBe(0);
+    });
+
+    it('should get cache statistics', () => {
+      const stats = getPublicEventCacheStats();
+      expect(stats).toEqual({
+        size: 0,
+        keys: []
+      });
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle null event data from RPC', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: null,
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+
+    it('should handle empty event data array from RPC', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+
+    it('should handle undefined event data from RPC', async () => {
+      mockSupabaseClient.rpc.mockResolvedValueOnce({
+        data: [undefined],
+        error: null
+      });
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.event).toBe(null);
+      expect(result.current.error).toEqual(new Error('Event not found'));
+    });
+  });
+});

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

@@ -83,7 +83,7 @@ describe('usePublicRouteParams', () => {
 
     it('should reject invalid event code formats', () => {
       const invalidCodes = [
-        'ab', // too short
+        'a', // too short (1 character)
         'a'.repeat(51), // too long
         'test@event', // invalid character
         'test event', // space
@@ -361,11 +361,14 @@ describe('usePublicRouteParams', () => {
         expect(generatePublicRoutePath('test-event')).toBe('/public/event/test-event/index');
         expect(generatePublicRoutePath('test-event', 'details')).toBe('/public/event/test-event/details');
         expect(generatePublicRoutePath('test-event', 'registration')).toBe('/public/event/test-event/registration');
+        // 2-character codes are now valid
+        expect(generatePublicRoutePath('GG')).toBe('/public/event/GG/index');
+        expect(generatePublicRoutePath('ab', 'page')).toBe('/public/event/ab/page');
       });
 
       it('should throw error for invalid event code', () => {
         expect(() => generatePublicRoutePath('invalid@code!')).toThrow('Invalid event code for route generation');
-        expect(() => generatePublicRoutePath('ab')).toThrow('Invalid event code for route generation');
+        expect(() => generatePublicRoutePath('a')).toThrow('Invalid event code for route generation'); // too short (1 character)
         expect(() => generatePublicRoutePath('')).toThrow('Invalid event code for route generation');
       });
     });
@@ -379,11 +382,15 @@ describe('usePublicRouteParams', () => {
         expect(extractEventCodeFromPath('/public/event/test-event-123')).toBe('test-event-123');
         expect(extractEventCodeFromPath('/public/event/test_event')).toBe('test_event');
         expect(extractEventCodeFromPath('/public/event/test123')).toBe('test123');
+        // 2-character codes are now valid
+        expect(extractEventCodeFromPath('/public/event/ab')).toBe('ab');
+        expect(extractEventCodeFromPath('/public/event/GG')).toBe('GG');
+        expect(extractEventCodeFromPath('/public/event/A1')).toBe('A1');
       });
 
       it('should return null for invalid paths', () => {
         expect(extractEventCodeFromPath('/public/event/')).toBe(null);
-        expect(extractEventCodeFromPath('/public/event/ab')).toBe(null); // too short
+        expect(extractEventCodeFromPath('/public/event/a')).toBe(null); // too short (1 character)
         expect(extractEventCodeFromPath('/public/event/test@event')).toBe(null); // invalid character
         expect(extractEventCodeFromPath('/public/event/test event')).toBe(null); // space
         expect(extractEventCodeFromPath('/public/event/')).toBe(null);

package/src/hooks/index.ts

@@ -22,7 +22,7 @@ export { useFocusTrap } from './useFocusTrap';
 export { useKeyboardShortcuts } from './useKeyboardShortcuts';
 export { useIsMobile } from './useIsMobile';
 
-// === EVENT THEMING HOOK ===
+// === EVENT HOOKS ===
 export { useEventTheme } from './useEventTheme';
 
 // === DATA & STATE HOOKS ===