@jmruthers/pace-core 0.5.68 → 0.5.70

package/src/hooks/index.ts

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

package/src/hooks/public/usePublicEvent.ts

@@ -172,9 +172,12 @@ export function usePublicEvent(
 
       try {
         // Try to call the public event RPC function first
-        const { data, error: rpcError } = await (supabase as any).rpc('get_public_event_by_code', {
+        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
@@ -188,10 +191,13 @@ export function usePublicEvent(
             
             // Try RPC call one more time after refresh
             try {
-              const { data: retryData, error: retryError } = await (supabase as any).rpc('get_public_event_by_code', {
+              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 {
@@ -201,7 +207,7 @@ export function usePublicEvent(
               console.warn('[usePublicEvent] RPC still failing after cache refresh, falling back to direct table access');
               
               // Fallback: Direct table access with public RLS policy
-            const { data: tableData, error: tableError } = await (supabase as any)
+            const tableResponse2 = await (supabase as any)
               .from('event')
               .select(`
                 event_id,
@@ -227,8 +233,11 @@ export function usePublicEvent(
               .limit(1)
               .single();
 
+            const tableData = tableResponse2?.data;
+            const tableError = tableResponse2?.error;
+
             if (tableError) {
-              throw new Error(tableError.message || 'Failed to fetch event from table');
+              throw new Error(tableError?.message || 'Failed to fetch event from table');
             }
 
             if (!tableData) {
@@ -238,7 +247,7 @@ export function usePublicEvent(
             }
 
             // Get event logo from file_references
-            const { data: logoData } = await (supabase as any)
+            const logoResponse = await (supabase as any)
               .from('file_references')
               .select('file_path')
               .eq('table_name', 'event')
@@ -247,6 +256,8 @@ export function usePublicEvent(
               .eq('file_metadata->>category', 'event_logos')
               .limit(1)
               .single();
+              
+            const logoData = logoResponse?.data;
 
             eventData = {
               ...tableData,
@@ -254,7 +265,12 @@ export function usePublicEvent(
             };
             }
           } else {
-            throw new Error(rpcError.message || 'Failed to fetch event');
+            // 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]) {
@@ -268,7 +284,7 @@ export function usePublicEvent(
         // If RPC call fails for any reason (including schema cache issues), try direct table access
         console.warn('[usePublicEvent] RPC call failed, falling back to direct table access:', rpcError);
         
-        const { data: tableData, error: tableError } = await (supabase as any)
+        const tableResponse = await (supabase as any)
           .from('event')
           .select(`
             event_id,
@@ -294,8 +310,11 @@ export function usePublicEvent(
           .limit(1)
           .single();
 
+        const tableData = tableResponse?.data;
+        const tableError = tableResponse?.error;
+
         if (tableError) {
-          throw new Error(tableError.message || 'Failed to fetch event from table');
+          throw new Error(tableError?.message || 'Failed to fetch event from table');
         }
 
         if (!tableData) {
@@ -305,7 +324,7 @@ export function usePublicEvent(
         }
 
         // Get event logo from file_references
-        const { data: logoData } = await (supabase as any)
+        const logoResponse = await (supabase as any)
           .from('file_references')
           .select('file_path')
           .eq('table_name', 'event')
@@ -314,6 +333,8 @@ export function usePublicEvent(
           .eq('file_metadata->>category', 'event_logos')
           .limit(1)
           .single();
+          
+        const logoData = logoResponse?.data;
 
         eventData = {
           ...tableData,

package/src/hooks/public/usePublicRouteParams.ts

@@ -87,15 +87,25 @@ interface UsePublicRouteParamsOptions {
 
 /**
  * Validate event code format
- * Event codes should be alphanumeric with optional hyphens/underscores
+ * Event codes should be alphanumeric with optional hyphens/underscores in the middle
  */
 function validateEventCodeFormat(eventCode: string): boolean {
   if (!eventCode || typeof eventCode !== 'string') return false;
   
   // Allow alphanumeric characters, hyphens, and underscores
   // Length between 3 and 50 characters
-  const eventCodeRegex = /^[a-zA-Z0-9_-]{3,50}$/;
-  return eventCodeRegex.test(eventCode);
+  // Must not start or end with hyphen/underscore
+  const eventCodeRegex = /^[a-zA-Z0-9][a-zA-Z0-9_-]{1,48}[a-zA-Z0-9]$/;
+  const matchesFormat = eventCodeRegex.test(eventCode);
+  
+  if (!matchesFormat) return false;
+  
+  // Additional check: no consecutive hyphens or underscores
+  if (eventCode.includes('--') || eventCode.includes('__') || eventCode.includes('-_') || eventCode.includes('_-')) {
+    return false;
+  }
+  
+  return true;
 }
 
 /**

package/src/hooks/services/useAuth.ts

@@ -0,0 +1,50 @@
+/**
+ * @file Auth Convenience Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * Convenience hook for authentication.
+ * Returns just the auth state and methods needed by components.
+ */
+
+import { useAuthService } from './useAuthService';
+import { type User, type Session, AuthError } from '@supabase/supabase-js';
+
+export interface AuthState {
+  user: User | null;
+  session: Session | null;
+  isAuthenticated: boolean;
+  authLoading: boolean;
+  authError: AuthError | null;
+  error: AuthError | null; // Alias for authError for backward compatibility
+  supabase: any | null;
+  
+  // Auth methods
+  signIn: (email: string, password?: string) => Promise<{ error: AuthError | null }>;
+  signUp: (email: string, password: string) => Promise<{ error: AuthError | null }>;
+  signOut: () => Promise<{ error: AuthError | null }>;
+  resetPassword: (email: string) => Promise<{ error: AuthError | null }>;
+  updatePassword: (password: string) => Promise<{ error: AuthError | null }>;
+  refreshSession: () => Promise<{ error: AuthError | null }>;
+}
+
+export function useAuth(): AuthState {
+  const authService = useAuthService();
+  
+  return {
+    user: authService.getUser(),
+    session: authService.getSession(),
+    isAuthenticated: authService.isAuthenticated(),
+    authLoading: authService.isLoading(),
+    authError: authService.getError(),
+    error: authService.getError(), // Alias for backward compatibility
+    supabase: authService.getSupabaseClient(),
+    signIn: authService.signIn.bind(authService),
+    signUp: authService.signUp.bind(authService),
+    signOut: authService.signOut.bind(authService),
+    resetPassword: authService.resetPassword.bind(authService),
+    updatePassword: authService.updatePassword.bind(authService),
+    refreshSession: authService.refreshSession.bind(authService),
+  };
+}

package/src/hooks/services/useAuthService.ts

@@ -0,0 +1,30 @@
+/**
+ * @file Auth Service Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * React hook for AuthService.
+ * Provides authentication service with reactive state updates.
+ */
+
+import { useContext, useReducer, useEffect } from 'react';
+import { AuthServiceContext } from '../../providers/services/AuthServiceProvider';
+import { AuthService } from '../../services/AuthService';
+
+export function useAuthService(): AuthService {
+  const context = useContext(AuthServiceContext);
+  
+  if (!context) {
+    throw new Error('useAuthService must be used within AuthServiceProvider');
+  }
+  
+  // Subscribe to service state changes
+  const [, forceUpdate] = useReducer(x => x + 1, 0);
+  
+  useEffect(() => {
+    return context.authService.subscribe(() => forceUpdate());
+  }, [context.authService]);
+  
+  return context.authService;
+}

package/src/hooks/services/useCurrentEvent.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Current Event Convenience Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * Convenience hook for current event.
+ * Returns just the event state and methods needed by components.
+ */
+
+import { useEventService } from './useEventService';
+import { Event } from '../../types/unified';
+
+export interface CurrentEventState {
+  events: Event[];
+  selectedEvent: Event | null;
+  isLoading: boolean;
+  error: Error | null;
+  
+  // Event methods
+  setSelectedEvent: (event: Event | null) => void;
+  refreshEvents: () => Promise<void>;
+}
+
+export function useCurrentEvent(): CurrentEventState {
+  const eventService = useEventService();
+  
+  return {
+    events: eventService.getEvents(),
+    selectedEvent: eventService.getSelectedEvent(),
+    isLoading: eventService.isLoading(),
+    error: eventService.getError(),
+    setSelectedEvent: eventService.setSelectedEvent.bind(eventService),
+    refreshEvents: eventService.refreshEvents.bind(eventService),
+  };
+}

package/src/hooks/services/useCurrentOrganisation.ts

@@ -0,0 +1,52 @@
+/**
+ * @file Current Organisation Convenience Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * Convenience hook for current organisation.
+ * Returns just the organisation state and methods needed by components.
+ */
+
+import { useOrganisationService } from './useOrganisationService';
+import type { Organisation, OrganisationMembership } from '../../types/organisation';
+
+export interface CurrentOrganisationState {
+  selectedOrganisation: Organisation | null;
+  organisations: Organisation[];
+  userMemberships: OrganisationMembership[];
+  isLoading: boolean;
+  error: Error | null;
+  hasValidOrganisationContext: boolean;
+  isContextReady: boolean;
+  
+  // Organisation methods
+  switchOrganisation: (orgId: string) => Promise<void>;
+  getUserRole: (orgId?: string) => string;
+  validateOrganisationAccess: (orgId: string) => boolean;
+  refreshOrganisations: () => Promise<void>;
+  ensureOrganisationContext: () => Organisation;
+  isOrganisationSecure: () => boolean;
+  getPrimaryOrganisation: () => Organisation | null;
+}
+
+export function useCurrentOrganisation(): CurrentOrganisationState {
+  const organisationService = useOrganisationService();
+  
+  return {
+    selectedOrganisation: organisationService.getSelectedOrganisation(),
+    organisations: organisationService.getOrganisations(),
+    userMemberships: organisationService.getUserMemberships(),
+    isLoading: organisationService.isLoading(),
+    error: organisationService.getError(),
+    hasValidOrganisationContext: organisationService.hasValidOrganisationContext(),
+    isContextReady: organisationService.isContextReady(),
+    switchOrganisation: organisationService.switchOrganisation.bind(organisationService),
+    getUserRole: organisationService.getUserRole.bind(organisationService),
+    validateOrganisationAccess: organisationService.validateOrganisationAccess.bind(organisationService),
+    refreshOrganisations: organisationService.refreshOrganisations.bind(organisationService),
+    ensureOrganisationContext: organisationService.ensureOrganisationContext.bind(organisationService),
+    isOrganisationSecure: organisationService.isOrganisationSecure.bind(organisationService),
+    getPrimaryOrganisation: organisationService.getPrimaryOrganisation.bind(organisationService),
+  };
+}

package/src/hooks/services/useEventService.ts

@@ -0,0 +1,30 @@
+/**
+ * @file Event Service Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * React hook for EventService.
+ * Provides event service with reactive state updates.
+ */
+
+import { useContext, useReducer, useEffect } from 'react';
+import { EventServiceContext } from '../../providers/services/EventServiceProvider';
+import { EventService } from '../../services/EventService';
+
+export function useEventService(): EventService {
+  const context = useContext(EventServiceContext);
+  
+  if (!context) {
+    throw new Error('useEventService must be used within EventServiceProvider');
+  }
+  
+  // Subscribe to service state changes
+  const [, forceUpdate] = useReducer(x => x + 1, 0);
+  
+  useEffect(() => {
+    return context.eventService.subscribe(() => forceUpdate());
+  }, [context.eventService]);
+  
+  return context.eventService;
+}

package/src/hooks/services/useInactivityService.ts

@@ -0,0 +1,30 @@
+/**
+ * @file Inactivity Service Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * React hook for InactivityService.
+ * Provides inactivity service with reactive state updates.
+ */
+
+import { useContext, useReducer, useEffect } from 'react';
+import { InactivityServiceContext } from '../../providers/services/InactivityServiceProvider';
+import { InactivityService } from '../../services/InactivityService';
+
+export function useInactivityService(): InactivityService {
+  const context = useContext(InactivityServiceContext);
+  
+  if (!context) {
+    throw new Error('useInactivityService must be used within InactivityServiceProvider');
+  }
+  
+  // Subscribe to service state changes
+  const [, forceUpdate] = useReducer(x => x + 1, 0);
+  
+  useEffect(() => {
+    return context.inactivityService.subscribe(() => forceUpdate());
+  }, [context.inactivityService]);
+  
+  return context.inactivityService;
+}

package/src/hooks/services/useOrganisationService.ts

@@ -0,0 +1,30 @@
+/**
+ * @file Organisation Service Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * React hook for OrganisationService.
+ * Provides organisation service with reactive state updates.
+ */
+
+import { useContext, useReducer, useEffect } from 'react';
+import { OrganisationServiceContext } from '../../providers/services/OrganisationServiceProvider';
+import { OrganisationService } from '../../services/OrganisationService';
+
+export function useOrganisationService(): OrganisationService {
+  const context = useContext(OrganisationServiceContext);
+  
+  if (!context) {
+    throw new Error('useOrganisationService must be used within OrganisationServiceProvider');
+  }
+  
+  // Subscribe to service state changes
+  const [, forceUpdate] = useReducer(x => x + 1, 0);
+  
+  useEffect(() => {
+    return context.organisationService.subscribe(() => forceUpdate());
+  }, [context.organisationService]);
+  
+  return context.organisationService;
+}

package/src/hooks/services/usePermissions.ts

@@ -0,0 +1,70 @@
+/**
+ * @file Permissions Convenience Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * Convenience hook for permissions.
+ * Returns just the permission state and methods needed by components.
+ */
+
+import { useRBACService } from './useRBACService';
+import { AccessLevel } from '../../types/unified';
+
+export interface PermissionsState {
+  permissions: Record<string, boolean>;
+  roles: string[];
+  accessLevel: AccessLevel;
+  rbacLoading: boolean;
+  rbacError: Error | null;
+  selectedEventId: string | null;
+  appConfig: any | null;
+  userEventAccess: any[];
+  eventAccessLoading: boolean;
+  selectedOrganisationId: string | null;
+  
+  // Permission methods
+  hasPermission: (permission: string, orgId?: string) => boolean;
+  hasAnyPermission: (permissions: string[], orgId?: string) => boolean;
+  hasAllPermissions: (permissions: string[], orgId?: string) => boolean;
+  hasRole: (role: string) => boolean;
+  hasAccessLevel: (level: AccessLevel) => boolean;
+  canAccess: (resource: string, action: string, orgId?: string) => boolean;
+  validatePermission: (permission: string, orgId?: string) => Promise<boolean>;
+  validateAccess: (resource: string, action: string, orgId?: string) => Promise<boolean>;
+  refreshPermissions: (eventId?: string, orgId?: string) => Promise<void>;
+  setSelectedEventId: (eventId: string | null) => void;
+  loadUserEventAccess: (orgId?: string) => Promise<void>;
+  getUserEventAccess: (eventId: string) => any | undefined;
+  requireOrganisationContext: () => string;
+}
+
+export function usePermissions(): PermissionsState {
+  const rbacService = useRBACService();
+  
+  return {
+    permissions: rbacService.getPermissions(),
+    roles: rbacService.getRoles(),
+    accessLevel: rbacService.getAccessLevel(),
+    rbacLoading: rbacService.isLoading(),
+    rbacError: rbacService.getError(),
+    selectedEventId: rbacService.getSelectedEventId(),
+    appConfig: rbacService.getAppConfig(),
+    userEventAccess: rbacService.getUserEventAccess(),
+    eventAccessLoading: rbacService.isEventAccessLoading(),
+    selectedOrganisationId: rbacService.getSelectedOrganisationId(),
+    hasPermission: rbacService.hasPermission.bind(rbacService),
+    hasAnyPermission: rbacService.hasAnyPermission.bind(rbacService),
+    hasAllPermissions: rbacService.hasAllPermissions.bind(rbacService),
+    hasRole: rbacService.hasRole.bind(rbacService),
+    hasAccessLevel: rbacService.hasAccessLevel.bind(rbacService),
+    canAccess: rbacService.canAccess.bind(rbacService),
+    validatePermission: rbacService.validatePermission.bind(rbacService),
+    validateAccess: rbacService.validateAccess.bind(rbacService),
+    refreshPermissions: rbacService.refreshPermissions.bind(rbacService),
+    setSelectedEventId: rbacService.setSelectedEventId.bind(rbacService),
+    loadUserEventAccess: rbacService.loadUserEventAccess.bind(rbacService),
+    getUserEventAccess: rbacService.getUserEventAccess.bind(rbacService),
+    requireOrganisationContext: rbacService.requireOrganisationContext.bind(rbacService),
+  };
+}

package/src/hooks/services/useRBACService.ts

@@ -0,0 +1,30 @@
+/**
+ * @file RBAC Service Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/Services
+ * @since 0.1.0
+ *
+ * React hook for RBACService.
+ * Provides RBAC service with reactive state updates.
+ */
+
+import { useContext, useReducer, useEffect } from 'react';
+import { RBACServiceContext } from '../../providers/services/RBACServiceProvider';
+import { RBACService } from '../../services/RBACService';
+
+export function useRBACService(): RBACService {
+  const context = useContext(RBACServiceContext);
+  
+  if (!context) {
+    throw new Error('useRBACService must be used within RBACServiceProvider');
+  }
+  
+  // Subscribe to service state changes
+  const [, forceUpdate] = useReducer(x => x + 1, 0);
+  
+  useEffect(() => {
+    return context.rbacService.subscribe(() => forceUpdate());
+  }, [context.rbacService]);
+  
+  return context.rbacService;
+}

package/src/hooks/useCounter.test.ts

@@ -19,11 +19,7 @@ const useCounter = (initialValue = 0) => {
 };
 
 describe('useCounter Hook', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Initialization', () => {
+    describe('Initialization', () => {
     it('initializes with default value', () => {
       const { result } = renderHook(() => useCounter());
       expect(result.current.count).toBe(0);

package/src/hooks/useEventTheme.ts

@@ -0,0 +1,86 @@
+/**
+ * @file Event Theme Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/EventTheme
+ * @since 2.0.0
+ * 
+ * Hook that automatically applies event-specific theming when an event is selected.
+ * This ensures consistent UX across all apps in the pace suite.
+ * 
+ * @example
+ * ```tsx
+ * import { useEventTheme } from '@jmruthers/pace-core/hooks';
+ * 
+ * function MyApp() {
+ *   // Automatically applies event colors when event is selected
+ *   useEventTheme();
+ *   
+ *   return <div>Your app content</div>;
+ * }
+ * ```
+ */
+
+import { useEffect } from 'react';
+import { useEvents } from '../providers/EventProvider';
+import { applyPalette, clearPalette } from '../theming/runtime';
+import type { PaletteData, ColorPalette } from '../theming/runtime';
+
+/**
+ * Hook that automatically applies event-specific theming
+ * 
+ * This hook watches the selected event and applies its colors using the theming system.
+ * It will:
+ * - Apply event colors when an event with `event_colours` is selected
+ * - Clear theming when no event is selected
+ * - Handle cleanup when the component unmounts
+ * 
+ * @returns void - This is an effect hook with no return value
+ */
+export function useEventTheme(): void {
+  const { selectedEvent } = useEvents();
+
+  useEffect(() => {
+    // If there's no selected event, clear any dynamic theming
+    if (!selectedEvent) {
+      clearPalette();
+      return;
+    }
+
+    // Check if the event has theme colors
+    const eventColours = selectedEvent.event_colours;
+
+    if (!eventColours || typeof eventColours !== 'object') {
+      clearPalette();
+      return;
+    }
+
+    // Validate that event_colours has the expected structure
+    const palette = eventColours as Partial<PaletteData>;
+    
+    // Check if we have at least one valid palette (main, sec, or acc)
+    if (!palette.main && !palette.sec && !palette.acc) {
+      clearPalette();
+      return;
+    }
+
+    // Apply the palette
+    // The system expects main, sec, and acc, so we ensure all are present (empty if needed)
+    const fullPalette: PaletteData = {
+      main: (palette.main as ColorPalette) || {},
+      sec: (palette.sec as ColorPalette) || {},
+      acc: (palette.acc as ColorPalette) || {},
+    };
+
+    try {
+      applyPalette(fullPalette);
+    } catch (error) {
+      console.error('[useEventTheme] Failed to apply event palette:', error);
+    }
+
+    // Cleanup function to clear palette when component unmounts or event changes
+    return () => {
+      // Don't clear on unmount since we want the theme to persist
+      // The next event selection will update it
+    };
+  }, [selectedEvent]);
+}

package/src/hooks/useOrganisationPermissions.test.ts

@@ -36,16 +36,13 @@ describe('useOrganisationPermissions', () => {
     ...overrides
   });
 
+  // Set up default mock for all tests
   beforeEach(() => {
     vi.clearAllMocks();
     mockUseOrganisations.mockReturnValue(createMockOrganisations() as any);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Hook Initialization', () => {
+      describe('Hook Initialization', () => {
     it('initializes with default organisation', () => {
       const { result } = renderHook(() => useOrganisationPermissions());
 

package/src/hooks/useOrganisationSecurity.test.ts

@@ -122,11 +122,7 @@ describe('useOrganisationSecurity', () => {
     } as any);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Super Admin Context', () => {
+    describe('Super Admin Context', () => {
     it('detects super admin from app_metadata', () => {
       const superAdminUser = {
         ...mockUser,

package/src/hooks/usePermissionCache.test.ts

@@ -39,11 +39,7 @@ describe('usePermissionCache', () => {
     mockUseRBAC.mockReturnValue(stableMockRBAC);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Hook Initialization', () => {
+    describe('Hook Initialization', () => {
     it('initializes with default configuration', () => {
       const { result } = renderHook(() => usePermissionCache());