@jmruthers/pace-core 0.5.87 → 0.5.89

package/src/hooks/__tests__/ServiceHooks.test.tsx

@@ -0,0 +1,615 @@
+/**
+ * @file Service Hooks Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__
+ * @since 0.1.0
+ *
+ * Unit tests for service hooks.
+ * Tests React hooks that provide access to services.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import * as React from 'react';
+import { useAuthService } from '../services/useAuthService';
+import { useOrganisationService } from '../services/useOrganisationService';
+import { useEventService } from '../services/useEventService';
+import { useInactivityService } from '../services/useInactivityService';
+import { useAuth } from '../services/useAuth';
+import { useCurrentOrganisation } from '../services/useCurrentOrganisation';
+import { useCurrentEvent } from '../services/useCurrentEvent';
+
+// Mock usePermissions hook for service hooks tests
+vi.mock('../../rbac/hooks/usePermissions', () => ({
+  usePermissions: vi.fn(() => ({
+    permissions: { 'events:read': true },
+    roles: ['admin'],
+    accessLevel: 'ADMIN',
+    rbacLoading: false,
+    rbacError: null,
+    selectedEventId: 'event-1',
+    userEventAccess: [],
+    eventAccessLoading: false,
+    selectedOrganisationId: 'org-1',
+    appConfig: { name: 'test' },
+    hasPermission: vi.fn(),
+    hasAnyPermission: vi.fn(),
+    hasAllPermissions: vi.fn(),
+    hasRole: vi.fn(),
+    hasAccessLevel: vi.fn(),
+    canAccess: vi.fn(),
+    validatePermission: vi.fn(),
+    validateAccess: vi.fn(),
+    refreshPermissions: vi.fn(),
+    setSelectedEventId: vi.fn(),
+    loadUserEventAccess: vi.fn(),
+    getUserEventAccess: vi.fn(),
+    requireOrganisationContext: vi.fn(() => 'org-1'),
+  }))
+}));
+
+import { usePermissions } from '../../rbac/hooks/usePermissions';
+
+// Create a mock for useContext that can be controlled
+const mockUseContext = vi.fn();
+
+// Mock React module
+vi.mock('react', async () => {
+  const actual = await vi.importActual('react');
+  return {
+    ...actual,
+    useContext: (...args: any[]) => mockUseContext(...args),
+  };
+});
+
+// Mock the provider contexts
+vi.mock('../../providers/services/AuthServiceProvider', () => ({
+  AuthServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/RBACServiceProvider', () => ({
+  RBACServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/OrganisationServiceProvider', () => ({
+  OrganisationServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/EventServiceProvider', () => ({
+  EventServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/InactivityServiceProvider', () => ({
+  InactivityServiceContext: { _currentValue: null },
+}));
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  auth: {
+    getSession: vi.fn(),
+    getUser: vi.fn(),
+    onAuthStateChange: vi.fn(() => ({ data: { subscription: { unsubscribe: vi.fn() } } })),
+    signInWithPassword: vi.fn(),
+    signUp: vi.fn(),
+    signOut: vi.fn(),
+    resetPasswordForEmail: vi.fn(),
+    updateUser: vi.fn(),
+    refreshSession: vi.fn()
+  },
+  rpc: vi.fn(),
+  from: vi.fn()
+});
+
+// Mock user and session
+const mockUser = {
+  id: 'user-1',
+  email: 'test@example.com'
+};
+
+const mockSession = {
+  access_token: 'token',
+  user: mockUser
+};
+
+const mockOrganisation = {
+  id: 'org-1',
+  display_name: 'Test Organisation'
+};
+
+// Mock service classes
+const createMockService = (name: string) => ({
+  subscribe: vi.fn(() => vi.fn()), // Return unsubscribe function
+  cleanup: vi.fn(),
+  // Add service-specific methods as needed
+  [name]: vi.fn()
+});
+
+describe('Service Hooks', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+
+  beforeEach(() => {
+    mockSupabase = createMockSupabaseClient();
+    // Reset the mock before each test
+    mockUseContext.mockReset();
+  });
+
+  describe('useAuthService', () => {
+    it('should return AuthService from context', () => {
+      const mockService = createMockService('auth');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      // Mock the context with proper structure
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      const { result } = renderHook(() => useAuthService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      // Mock the context to return null
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useAuthService(), { wrapper });
+      }).toThrow('useAuthService must be used within AuthServiceProvider');
+    });
+
+    it('should subscribe to service changes', () => {
+      const mockService = createMockService('auth');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      renderHook(() => useAuthService(), { wrapper });
+
+      expect(mockService.subscribe).toHaveBeenCalled();
+    });
+  });
+
+  describe('useOrganisationService', () => {
+    it('should return OrganisationService from context', () => {
+      const mockService = createMockService('organisation');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ organisationService: mockService });
+
+      const { result } = renderHook(() => useOrganisationService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useOrganisationService(), { wrapper });
+      }).toThrow('useOrganisationService must be used within OrganisationServiceProvider');
+    });
+  });
+
+  describe('useEventService', () => {
+    it('should return EventService from context', () => {
+      const mockService = createMockService('event');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ eventService: mockService });
+
+      const { result } = renderHook(() => useEventService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useEventService(), { wrapper });
+      }).toThrow('useEventService must be used within EventServiceProvider');
+    });
+  });
+
+  describe('useInactivityService', () => {
+    it('should return InactivityService from context', () => {
+      const mockService = createMockService('inactivity');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      vi.spyOn(React, 'useContext').mockReturnValue({ inactivityService: mockService });
+
+      const { result } = renderHook(() => useInactivityService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useInactivityService(), { wrapper });
+      }).toThrow('useInactivityService must be used within InactivityServiceProvider');
+    });
+  });
+
+  describe('useAuth', () => {
+    it('should return auth service properties and methods', () => {
+      const mockService = {
+        getUser: vi.fn(() => mockUser),
+        getSession: vi.fn(() => mockSession),
+        isAuthenticated: vi.fn(() => true),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSupabaseClient: vi.fn(() => mockSupabase),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      expect(result.current.user).toBe(mockUser);
+      expect(result.current.session).toBe(mockSession);
+      expect(result.current.isAuthenticated).toBe(true);
+      expect(result.current.authLoading).toBe(false);
+      expect(result.current.authError).toBeNull();
+      expect(typeof result.current.signIn).toBe('function');
+      expect(typeof result.current.signUp).toBe('function');
+      expect(typeof result.current.signOut).toBe('function');
+      expect(typeof result.current.resetPassword).toBe('function');
+      expect(typeof result.current.updatePassword).toBe('function');
+      expect(typeof result.current.refreshSession).toBe('function');
+    });
+  });
+
+  describe('usePermissions', () => {
+    it('should return RBAC service properties and methods', () => {
+      const mockService = {
+        getPermissions: vi.fn(() => ({ 'events:read': true })),
+        getRoles: vi.fn(() => ['admin']),
+        getAccessLevel: vi.fn(() => 'ADMIN'),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSelectedEventId: vi.fn(() => 'event-1'),
+        getAppConfig: vi.fn(() => ({ name: 'test' })),
+        getUserEventAccess: vi.fn(() => []),
+        isEventAccessLoading: vi.fn(() => false),
+        getSelectedOrganisationId: vi.fn(() => 'org-1'),
+        hasPermission: vi.fn(),
+        hasAnyPermission: vi.fn(),
+        hasAllPermissions: vi.fn(),
+        hasRole: vi.fn(),
+        hasAccessLevel: vi.fn(),
+        canAccess: vi.fn(),
+        validatePermission: vi.fn(),
+        validateAccess: vi.fn(),
+        refreshPermissions: vi.fn(),
+        setSelectedEventId: vi.fn(),
+        loadUserEventAccess: vi.fn(),
+        requireOrganisationContext: vi.fn(() => 'org-1'),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ rbacService: mockService });
+
+      const { result } = renderHook(() => usePermissions('user-1', { organisationId: 'org-1', eventId: 'event-1', appId: 'test-app' }), { wrapper });
+
+      expect(result.current.permissions).toEqual({ 'events:read': true });
+      expect(result.current.roles).toEqual(['admin']);
+      expect(result.current.accessLevel).toBe('ADMIN');
+      expect(result.current.rbacLoading).toBe(false);
+      expect(result.current.rbacError).toBeNull();
+      expect(result.current.selectedEventId).toBe('event-1');
+      expect(result.current.userEventAccess).toEqual([]);
+      expect(result.current.eventAccessLoading).toBe(false);
+      expect(result.current.selectedOrganisationId).toBe('org-1');
+      expect(result.current.appConfig).toEqual({ name: 'test' });
+      expect(typeof result.current.hasPermission).toBe('function');
+      expect(typeof result.current.hasAnyPermission).toBe('function');
+      expect(typeof result.current.hasAllPermissions).toBe('function');
+      expect(typeof result.current.hasRole).toBe('function');
+      expect(typeof result.current.hasAccessLevel).toBe('function');
+      expect(typeof result.current.canAccess).toBe('function');
+      expect(typeof result.current.validatePermission).toBe('function');
+      expect(typeof result.current.validateAccess).toBe('function');
+      expect(typeof result.current.refreshPermissions).toBe('function');
+      expect(typeof result.current.setSelectedEventId).toBe('function');
+      expect(typeof result.current.loadUserEventAccess).toBe('function');
+      expect(typeof result.current.getUserEventAccess).toBe('function');
+      expect(typeof result.current.requireOrganisationContext).toBe('function');
+    });
+  });
+
+  describe('useCurrentOrganisation', () => {
+    it('should return organisation service properties and methods', () => {
+      const mockService = {
+        getSelectedOrganisation: vi.fn(() => mockOrganisation),
+        getOrganisations: vi.fn(() => [mockOrganisation]),
+        getUserMemberships: vi.fn(() => []),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        hasValidOrganisationContext: vi.fn(() => true),
+        isContextReady: vi.fn(() => true),
+        switchOrganisation: vi.fn(),
+        getUserRole: vi.fn(),
+        validateOrganisationAccess: vi.fn(),
+        refreshOrganisations: vi.fn(),
+        ensureOrganisationContext: vi.fn(() => mockOrganisation),
+        isOrganisationSecure: vi.fn(() => true),
+        getPrimaryOrganisation: vi.fn(() => mockOrganisation),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ organisationService: mockService });
+
+      const { result } = renderHook(() => useCurrentOrganisation(), { wrapper });
+
+      expect(result.current.selectedOrganisation).toBe(mockOrganisation);
+      expect(result.current.organisations).toEqual([mockOrganisation]);
+      expect(result.current.userMemberships).toEqual([]);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(result.current.hasValidOrganisationContext).toBe(true);
+      expect(typeof result.current.switchOrganisation).toBe('function');
+      expect(typeof result.current.getUserRole).toBe('function');
+      expect(typeof result.current.validateOrganisationAccess).toBe('function');
+      expect(typeof result.current.refreshOrganisations).toBe('function');
+      expect(typeof result.current.ensureOrganisationContext).toBe('function');
+      expect(typeof result.current.isOrganisationSecure).toBe('function');
+      expect(typeof result.current.getPrimaryOrganisation).toBe('function');
+    });
+  });
+
+  describe('useCurrentEvent', () => {
+    it('should return event service properties and methods', () => {
+      const mockEvent = {
+        id: 'event-1',
+        event_id: 'event-1',
+        event_name: 'Test Event',
+        event_date: '2024-01-01T00:00:00Z',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: '#FF0000',
+        event_logo: '',
+        organisation_id: 'org-1',
+        is_visible: true,
+        name: 'Test Event',
+        start_date: '2024-01-01T00:00:00Z'
+      };
+
+      const mockService = {
+        getEvents: vi.fn(() => [mockEvent]),
+        getSelectedEvent: vi.fn(() => mockEvent),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        setSelectedEvent: vi.fn(),
+        refreshEvents: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ eventService: mockService });
+
+      const { result } = renderHook(() => useCurrentEvent(), { wrapper });
+
+      expect(result.current.events).toEqual([mockEvent]);
+      expect(result.current.selectedEvent).toBe(mockEvent);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(typeof result.current.setSelectedEvent).toBe('function');
+      expect(typeof result.current.refreshEvents).toBe('function');
+    });
+  });
+
+  describe('Hook Integration', () => {
+    it('should work with multiple hooks simultaneously', () => {
+      const mockAuthService = {
+        getUser: vi.fn(() => mockUser),
+        getSession: vi.fn(() => mockSession),
+        isAuthenticated: vi.fn(() => true),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSupabaseClient: vi.fn(() => mockSupabase),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+      
+      const mockRBACService = {
+        getPermissions: vi.fn(() => ({})),
+        getRoles: vi.fn(() => []),
+        getAccessLevel: vi.fn(() => 'VIEWER'),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSelectedEventId: vi.fn(() => null),
+        getAppConfig: vi.fn(() => null),
+        getUserEventAccess: vi.fn(() => []),
+        isEventAccessLoading: vi.fn(() => false),
+        getSelectedOrganisationId: vi.fn(() => null),
+        hasPermission: vi.fn(),
+        hasAnyPermission: vi.fn(),
+        hasAllPermissions: vi.fn(),
+        hasRole: vi.fn(),
+        hasAccessLevel: vi.fn(),
+        canAccess: vi.fn(),
+        validatePermission: vi.fn(),
+        validateAccess: vi.fn(),
+        refreshPermissions: vi.fn(),
+        setSelectedEventId: vi.fn(),
+        loadUserEventAccess: vi.fn(),
+        requireOrganisationContext: vi.fn(() => 'org-1'),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+      
+      const mockOrganisationService = {
+        getSelectedOrganisation: vi.fn(() => mockOrganisation),
+        getOrganisations: vi.fn(() => [mockOrganisation]),
+        getUserMemberships: vi.fn(() => []),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        hasValidOrganisationContext: vi.fn(() => true),
+        isContextReady: vi.fn(() => true),
+        switchOrganisation: vi.fn(),
+        getUserRole: vi.fn(),
+        validateOrganisationAccess: vi.fn(),
+        refreshOrganisations: vi.fn(),
+        ensureOrganisationContext: vi.fn(() => mockOrganisation),
+        isOrganisationSecure: vi.fn(() => true),
+        getPrimaryOrganisation: vi.fn(() => mockOrganisation),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+      
+      const mockEventService = {
+        getEvents: vi.fn(() => []),
+        getSelectedEvent: vi.fn(() => null),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        setSelectedEvent: vi.fn(),
+        refreshEvents: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      // Test individual hooks
+      mockUseContext.mockReturnValue({ authService: mockAuthService });
+      const { result: authResult } = renderHook(() => useAuth(), { wrapper });
+
+      mockUseContext.mockReturnValue({ rbacService: mockRBACService });
+      const { result: permissionsResult } = renderHook(() => usePermissions('user-1', { organisationId: 'org-1', eventId: 'event-1', appId: 'test-app' }), { wrapper });
+
+      mockUseContext.mockReturnValue({ organisationService: mockOrganisationService });
+      const { result: organisationResult } = renderHook(() => useCurrentOrganisation(), { wrapper });
+
+      mockUseContext.mockReturnValue({ eventService: mockEventService });
+      const { result: eventResult } = renderHook(() => useCurrentEvent(), { wrapper });
+
+      expect(authResult.current).toBeDefined();
+      expect(permissionsResult.current).toBeDefined();
+      expect(organisationResult.current).toBeDefined();
+      expect(eventResult.current).toBeDefined();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle service errors gracefully', () => {
+      const mockService = {
+        getUser: vi.fn(() => null),
+        getSession: vi.fn(() => null),
+        isAuthenticated: vi.fn(() => false),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => new Error('Service error')),
+        getSupabaseClient: vi.fn(() => null),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      expect(result.current.authError).toBeDefined();
+      expect(result.current.authError?.message).toBe('Service error');
+    });
+
+    it('should handle missing service methods gracefully', () => {
+      const mockService = {
+        getUser: vi.fn(),
+        getSession: vi.fn(),
+        isAuthenticated: vi.fn(),
+        isLoading: vi.fn(),
+        getError: vi.fn(() => null),
+        getSupabaseClient: vi.fn(),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      // Should not throw error
+      expect(() => {
+        const { result } = renderHook(() => useAuth(), { wrapper });
+        expect(result.current).toBeDefined();
+      }).not.toThrow();
+    });
+  });
+});

package/src/hooks/public/usePublicEventLogo.ts

@@ -67,6 +67,8 @@
 import { useState, useEffect, useCallback, useMemo } from 'react';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { Database } from '../../types/database';
+import { getPublicUrl } from '../../utils/storage/helpers';
+import { FileCategory } from '../../types/file-reference';
 
 // Simple in-memory cache for public data
 const publicDataCache = new Map<string, { data: any; timestamp: number; ttl: number }>();
@@ -176,36 +178,30 @@ 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
-      });
+      // Get event logo from file_references using new RPC function
+      const { data, error: rpcError } = await (supabase as any)
+        .rpc('data_file_reference_by_category_list', {
+          p_table_name: 'event',
+          p_record_id: eventId,
+          p_category: FileCategory.EVENT_LOGOS,
+          p_organisation_id: organisationId
+        });
 
       if (rpcError) {
         throw new Error(rpcError.message || 'Failed to fetch logo');
       }
 
-      if (!data || data.length === 0 || !data[0] || !data[0].logo_url) {
+      if (!data || data.length === 0 || !data[0]?.file_path) {
         setLogoUrl(null);
         return;
       }
 
-      // Get the file path from the RPC function (it returns file_path as logo_url)
-      const logoPath = data[0].logo_url;
-
-      // Construct the full public URL using Supabase client's storage API
-      const { data: urlData } = supabase.storage
-        .from('public-files')
-        .getPublicUrl(logoPath);
-
-      if (!urlData?.publicUrl) {
-        console.warn('[usePublicEventLogo] Failed to construct public URL for path:', logoPath);
-        setLogoUrl(null);
-        return;
-      }
+      // Get the file path from the RPC response
+      const logoPath = data[0].file_path;
+      const isPublic = data[0].is_public ?? true; // Event logos should be public
 
-      const logoUrl = urlData.publicUrl;
+      // Generate public URL using bucket-aware helper (public-files bucket for public files)
+      const logoUrl = getPublicUrl(supabase, logoPath, isPublic);
 
       // Validate image existence if requested
       if (validateImage) {