@jmruthers/pace-core 0.6.5 → 0.6.7

package/src/services/EventService.ts

@@ -59,11 +59,6 @@ export class EventService extends BaseService implements IEventService {
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
-    logger.debug('EventService', `Instance created [ID:${this.instanceId}]`, {
-      appName,
-      hasUser: !!user,
-      userId: user?.id
-    });
   }
 
   getInstanceId(): number {
@@ -112,11 +107,6 @@ export class EventService extends BaseService implements IEventService {
       this.userClearedEventRef = false;
       this.hasAutoSelectedRef = false;
       
-      logger.debug('EventService', `User changed [ID:${this.instanceId}]`, {
-        previousUserId,
-        newUserId,
-        willInitialize: newUserId !== null
-      });
     }
     
     this.supabaseClient = supabaseClient;
@@ -142,10 +132,6 @@ export class EventService extends BaseService implements IEventService {
 
         if (isRBACInitialized()) {
           this.isSuperAdmin = await checkSuperAdmin(user.id as UUID);
-          logger.debug('EventService', 'Super admin status updated in updateDependencies', {
-            userId: user.id,
-            isSuperAdmin: this.isSuperAdmin
-          });
         } else {
           // RBAC not initialized - this should be rare since UnifiedAuthProvider initializes it synchronously
           // Keep existing value (don't reset to false) to avoid clearing a previously determined super admin status
@@ -260,11 +246,6 @@ export class EventService extends BaseService implements IEventService {
       });
       // Reset the user cleared flag when selecting an event
       this.userClearedEventRef = false;
-      logger.debug('EventService', 'Event selected', {
-        eventId: event.event_id,
-        eventName: event.event_name,
-        userClearedEventRef: this.userClearedEventRef
-      });
     } else {
       const previousEventId = this.selectedEvent?.event_id;
       this.selectedEvent = null;
@@ -277,11 +258,6 @@ export class EventService extends BaseService implements IEventService {
       this.hasAutoSelectedRef = false;
       // Mark that user explicitly cleared the event to prevent auto-selection
       this.userClearedEventRef = true;
-      logger.debug('EventService', 'Event cleared via setSelectedEvent(null)', {
-        previousEventId,
-        userClearedEventRef: this.userClearedEventRef,
-        stackTrace: new Error().stack
-      });
     }
     this.notify();
   }
@@ -407,13 +383,11 @@ export class EventService extends BaseService implements IEventService {
   protected async doInitialize(): Promise<void> {
     // Skip if already initialized
     if (this.isInitializedRef) {
-      logger.debug('EventService', 'Skipping initialization - already initialized');
       return;
     }
     
     // Skip if already fetching
     if (this.isFetchingRef) {
-      logger.debug('EventService', 'Skipping initialization - already fetching');
       return;
     }
     
@@ -430,27 +404,14 @@ export class EventService extends BaseService implements IEventService {
     // For event-required apps, selectedOrganisation may be null (org derived from event)
     // For org-required apps, selectedOrganisation is required
     if (!this.user) {
-      logger.debug('EventService', 'Skipping initialization - no user');
       return;
     }
     
-    logger.debug('EventService', 'Initializing', {
-      userId: this.user.id,
-      appName: this.appName,
-      hasSelectedOrganisation: !!this.selectedOrganisation,
-      hasSupabaseClient: !!this.supabaseClient,
-      hasSession: !!this.session
-    });
-    
     // Initial setup - fetch events on initialization
     await this.fetchEvents(false);
     
     // Mark as initialized after successful fetch
     this.isInitializedRef = true;
-    logger.debug('EventService', 'Initialization complete', {
-      eventsCount: this.events.length,
-      hasError: !!this.error
-    });
   }
 
   protected doCleanup(): void {
@@ -505,10 +466,6 @@ export class EventService extends BaseService implements IEventService {
           userIsSuperAdmin = await checkSuperAdmin(this.user.id as UUID);
           // Update cached value for future use
           this.isSuperAdmin = userIsSuperAdmin;
-          logger.debug('EventService', 'Super admin check completed', {
-            userId: this.user.id,
-            isSuperAdmin: userIsSuperAdmin
-          });
         } else {
           // RBAC not initialized - this should be rare since UnifiedAuthProvider initializes it synchronously
           // Use cached value from updateDependencies as fallback
@@ -544,10 +501,6 @@ export class EventService extends BaseService implements IEventService {
           } else {
             // No context available - pass null to get all accessible events via event-app roles
             // This allows users with event-app roles to see their events even without org context
-            logger.debug('EventService', 'No organisation context available, fetching all accessible events', {
-              hasSelectedEvent: !!this.selectedEvent,
-              hasSelectedOrganisation: !!this.selectedOrganisation
-            });
             organisationIdForRpc = null; // Will return events user has access to via event-app roles
           }
         }
@@ -580,14 +533,6 @@ export class EventService extends BaseService implements IEventService {
       
       // Call the RPC function following the established pattern
       // For super admins, pass null for p_organisation_id to see all events
-      logger.debug('EventService', 'Fetching events', {
-        userId: this.user.id,
-        organisationIdForRpc,
-        appName: this.appName,
-        hasSelectedEvent: !!this.selectedEvent,
-        hasSelectedOrganisation: !!this.selectedOrganisation,
-        isSuperAdmin: userIsSuperAdmin
-      });
       
       let { data, error: rpcError } = await this.supabaseClient.rpc('data_user_events_get', {
         p_user_id: this.user.id,
@@ -595,11 +540,6 @@ export class EventService extends BaseService implements IEventService {
         p_app_name: this.appName
       });
       
-      logger.debug('EventService', 'RPC response', {
-        dataLength: data?.length || 0,
-        hasError: !!rpcError,
-        error: rpcError
-      });
       
       if (rpcError) {
         logger.error('EventService', 'RPC error fetching events:', rpcError);
@@ -671,10 +611,7 @@ export class EventService extends BaseService implements IEventService {
             this.setSelectedEventId?.(null);
             // Restore the previous userClearedEventRef value - this was an automatic clear, not user-initiated
             this.userClearedEventRef = previousUserClearedRef;
-            logger.debug('EventService', 'Cleared selected event - no longer in events list', {
-              previousEventId: selectedEventId,
-              eventsCount: transformedEvents.length
-            });
+            // Cleared selected event - no longer in events list
           }
         }
 
@@ -685,62 +622,32 @@ export class EventService extends BaseService implements IEventService {
         if (!skipLoadPersisted) {
           const persistedEventLoaded = await this.loadPersistedEvent(transformedEvents);
           
-          logger.debug('EventService', 'Event selection check', {
-            persistedEventLoaded,
-            userClearedEventRef: this.userClearedEventRef,
-            eventsCount: transformedEvents.length,
-            hasSelectedEvent: !!this.selectedEvent
-          });
-          
           // If no persisted event was loaded and user hasn't explicitly cleared an event, auto-select the next event
           if (!persistedEventLoaded && !this.userClearedEventRef) {
             const nextEvent = this.getNextEventByDate(transformedEvents);
-            logger.debug('EventService', 'Auto-selection attempt', {
-              nextEventFound: !!nextEvent,
-              nextEventId: nextEvent?.event_id,
-              nextEventDate: nextEvent?.event_date
-            });
             if (nextEvent) {
               this.hasAutoSelectedRef = true;
               // Use setSelectedEvent() to ensure consistent behavior
               // Theme will be applied by useEventTheme() hook
               this.setSelectedEvent(nextEvent);
-              logger.debug('EventService', 'Auto-selected next event', {
-                eventId: nextEvent.event_id,
-                eventName: nextEvent.event_name,
-                eventDate: nextEvent.event_date
-              });
-            } else {
-              logger.debug('EventService', 'No next event found for auto-selection', {
-                eventsCount: transformedEvents.length,
-                eventsWithDates: transformedEvents.filter(e => e.event_date).length
-              });
             }
           } else if (persistedEventLoaded) {
-            logger.debug('EventService', 'Skipped auto-selection - persisted event loaded');
+            // Skipped auto-selection - persisted event loaded
           } else if (this.userClearedEventRef) {
-            logger.debug('EventService', 'Skipped auto-selection - user explicitly cleared event');
+            // Skipped auto-selection - user explicitly cleared event
           }
         } else {
           // If skipping persisted event load, still do auto-selection for new users
           if (!this.userClearedEventRef) {
             const nextEvent = this.getNextEventByDate(transformedEvents);
-            logger.debug('EventService', 'Auto-selection attempt (skip persisted)', {
-              nextEventFound: !!nextEvent,
-              nextEventId: nextEvent?.event_id
-            });
             if (nextEvent) {
               this.hasAutoSelectedRef = true;
               // Use setSelectedEvent() to ensure consistent behavior
               // Theme will be applied by useEventTheme() hook
               this.setSelectedEvent(nextEvent);
-              logger.debug('EventService', 'Auto-selected next event (skip persisted)', {
-                eventId: nextEvent.event_id,
-                eventName: nextEvent.event_name
-              });
             }
           } else {
-            logger.debug('EventService', 'Skipped auto-selection (skip persisted) - user explicitly cleared event');
+            // Skipped auto-selection (skip persisted) - user explicitly cleared event
           }
         }
       }

package/src/services/InactivityService.ts

@@ -205,6 +205,14 @@ export class InactivityService extends BaseService implements IInactivityService
       logger.error('InactivityService', 'Error during idle logout:', error);
     }
     
+    // Clear sessionStorage on logout
+    try {
+      sessionStorage.clear();
+    } catch (storageError) {
+      // Ignore storage errors (e.g., in private browsing mode)
+      logger.warn('InactivityService', 'Failed to clear sessionStorage', { error: storageError });
+    }
+    
     // Call app callback for navigation/redirect
     this.onIdleLogout?.('inactivity');
     this.notify();
@@ -231,6 +239,14 @@ export class InactivityService extends BaseService implements IInactivityService
       logger.error('InactivityService', 'Error during manual sign out:', error);
     }
     
+    // Clear sessionStorage on logout
+    try {
+      sessionStorage.clear();
+    } catch (storageError) {
+      // Ignore storage errors (e.g., in private browsing mode)
+      logger.warn('InactivityService', 'Failed to clear sessionStorage', { error: storageError });
+    }
+    
     // Call app callback for navigation/redirect
     this.onIdleLogout?.('inactivity');
     this.notify();

package/src/services/OrganisationService.ts

@@ -70,10 +70,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
-    logger.debug('OrganisationService', `Instance created [ID:${this.instanceId}]`, {
-      hasUser: !!user,
-      userId: user?.id
-    });
   }
 
   getInstanceId(): number {
@@ -164,10 +160,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
     if (userChanged || needsRetry || isEmpty) {
       if (userChanged) {
-        logger.debug('OrganisationService', `User changed [ID:${this.instanceId}], resetting initialization`, {
-          previousUserId,
-          newUserId
-        });
       } else if (needsRetry) {
         logger.debug('OrganisationService', `Previous error detected [ID:${this.instanceId}], retrying initialization`);
       } else if (isEmpty) {
@@ -293,7 +285,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     // SECURITY: Only initialize if we have an authenticated user
     // This prevents premature initialization during early auth states
     if (!this.user) {
-      logger.debug('OrganisationService', 'Skipping initialization - no user');
       return;
     }
 
@@ -337,34 +328,13 @@ export class OrganisationService extends BaseService implements IOrganisationSer
   }
 
   private async setDatabaseOrganisationContext(organisation: Organisation): Promise<void> {
-    if (!this.supabaseClient || !this.session) {
-      logger.warn('OrganisationService', 'No Supabase client or session available for setting organisation context');
-      this._isContextReady = false;
-      this.notify();
-      return;
-    }
-
-    try {
-      // Add timeout to prevent hanging
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error('Context setting timeout after 5 seconds')), 5000);
-      });
-      
-      const contextPromise = setOrganisationContext(this.supabaseClient, organisation.id);
-      
-      await Promise.race([contextPromise, timeoutPromise]);
-      
-      // Database organisation context set successfully
-      this._isContextReady = true;
-      this.notify();
-    } catch (error) {
-      logger.error('OrganisationService', 'Failed to set database organisation context:', error);
-      // Set context ready to true anyway - this is a non-critical operation
-      // The app should still work without database context
-      this._isContextReady = true;
-      this.notify();
-      // Don't throw - this is a non-critical operation
-    }
+    // Organisation context is now handled via secure client and explicit parameters
+    // This function is kept for backward compatibility but is effectively a no-op
+    // The setOrganisationContext function has been deprecated and no longer sets database context
+    
+    // Mark context as ready immediately since context is handled elsewhere
+    this._isContextReady = true;
+    this.notify();
   }
 
   private async loadUserOrganisations(): Promise<void> {
@@ -416,9 +386,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this._error = null;
     this.notify();
 
-    logger.debug('OrganisationService', 'Loading organisations for user', {
-      userId: this.user.id
-    });
       
     try {
       // Get user's organisation roles directly from rbac_organisation_roles table
@@ -500,10 +467,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         
         organisations = Array.from(organisationsMap.values());
         
-        logger.debug('OrganisationService', 'Query results', {
-          membershipsCount: memberships.length,
-          organisationsCount: organisations.length
-        });
         
         // Extract organisations from join results
       } catch (queryError) {

package/src/services/__tests__/OrganisationService.test.ts

@@ -866,10 +866,19 @@ describe('OrganisationService', () => {
         mockSession
       );
 
-      serviceWithoutClient.setSelectedOrganisation(mockOrganisation);
-
-      // Should handle gracefully
-      await new Promise(resolve => setTimeout(resolve, 100));
+      // Initially context is not ready
+      expect(serviceWithoutClient.isContextReady()).toBe(false);
+      
+      // setSelectedOrganisation requires a valid organisation in the organisations list
+      // Since we don't have a client, we can't load organisations, so this will throw
+      // or the organisation won't be in the list. The context ready state should remain false.
+      try {
+        await serviceWithoutClient.switchOrganisation(mockOrganisation.id);
+      } catch {
+        // Expected to fail
+      }
+      
+      // Context should still be false since organisation switch failed
       expect(serviceWithoutClient.isContextReady()).toBe(false);
     });
 
@@ -880,10 +889,19 @@ describe('OrganisationService', () => {
         null
       );
 
-      serviceWithoutSession.setSelectedOrganisation(mockOrganisation);
-
-      // Should handle gracefully
-      await new Promise(resolve => setTimeout(resolve, 100));
+      // Initially context is not ready
+      expect(serviceWithoutSession.isContextReady()).toBe(false);
+      
+      // Without a session, loadUserOrganisations will return early and not load organisations
+      // So setSelectedOrganisation will fail because the organisation isn't in the list
+      // The context ready state should remain false
+      try {
+        await serviceWithoutSession.switchOrganisation(mockOrganisation.id);
+      } catch {
+        // Expected to fail
+      }
+      
+      // Context should still be false since organisation switch failed
       expect(serviceWithoutSession.isContextReady()).toBe(false);
     });
   });

package/src/services/base/BaseService.ts

@@ -38,9 +38,6 @@ export abstract class BaseService {
    * This triggers React re-renders
    */
   protected notify(): void {
-    const serviceName = this.constructor.name;
-    const instanceId = (this as any).instanceId || 'unknown';
-    logger.debug('BaseService', `[${serviceName} ID:${instanceId}] Notifying ${this.subscribers.length} subscribers`);
     this.subscribers.forEach(callback => {
       try {
         callback();

package/src/styles/core.css

@@ -206,6 +206,13 @@
   dialog::backdrop {
     background-color: oklch(from var(--color-main-700) l c h / 0.5);
   }
+
+  progress::indeterminate {
+    
+    background: var(--color-acc-600);
+    /*
+    background: linear-gradient(to right, var(--color-acc-700) 10%, var(--color-sec-200) 30%, var(--color-main-500) 70%, var(--color-acc-200) 90%); */
+  }
   
   .appGradient {
     background: linear-gradient(145deg, var(--color-main-100) 10%, var(--color-main-200) 30%, var(--color-main-200) 70%, var(--color-main-300) 90%);

package/src/theming/__tests__/parseEventColours.test.ts

@@ -88,7 +88,7 @@ describe('parseAndNormalizeEventColours', () => {
   });
 
   describe('Standard format only', () => {
-    it('returns null for legacy format with ev-main, ev-sec, ev-acc keys', () => {
+    it('normalizes legacy format with ev-main, ev-sec, ev-acc keys to standard format', () => {
       const input = {
         'ev-main': { 500: { L: 0.5, C: 0.2, H: 0 } },
         'ev-sec': { 500: { L: 0.5, C: 0.2, H: 120 } },
@@ -96,8 +96,14 @@ describe('parseAndNormalizeEventColours', () => {
       };
 
       const result = parseAndNormalizeEventColours(input);
-      // Legacy format is no longer supported - returns null
-      expect(result).toBeNull();
+      // Legacy format is normalized to standard format (ev-main -> main, etc.)
+      expect(result).not.toBeNull();
+      expect(result).toHaveProperty('main');
+      expect(result).toHaveProperty('sec');
+      expect(result).toHaveProperty('acc');
+      expect(result?.main).toHaveProperty('500');
+      expect(result?.sec).toHaveProperty('500');
+      expect(result?.acc).toHaveProperty('500');
     });
 
     it('uses standard keys when provided', () => {

package/src/theming/parseEventColours.ts

@@ -8,15 +8,13 @@
  * Handles multiple input formats and ensures consistent palette structure.
  */
 
-import { createLogger } from '../utils/core/logger';
-
-const log = createLogger('ParseEventColours');
 
 /**
  * Parse and normalize event_colours to PaletteData
  * 
  * Supports input formats:
- * - Object with 'main', 'sec', 'acc' keys
+ * - Object with 'main', 'sec', 'acc' keys (standard format)
+ * - Object with 'ev-main', 'ev-sec', 'ev-acc' keys (database format with prefix)
  * - JSON string that will be parsed
  * 
  * Only includes explicitly defined color values. Does not fill
@@ -38,6 +36,18 @@ const log = createLogger('ParseEventColours');
  * // Returns: { main: { 500: {...}, raw: {...} }, sec: { 500: {...} }, acc: { 500: {...} } }
  * ```
  * 
+ * @example
+ * ```ts
+ * // Database format with ev- prefix
+ * const colours = {
+ *   'ev-main': { 500: { L: 0.5, C: 0.2, H: 0 } },
+ *   'ev-sec': { 500: { L: 0.5, C: 0.2, H: 120 } },
+ *   'ev-acc': { 500: { L: 0.5, C: 0.2, H: 240 } }
+ * };
+ * const palette = parseAndNormalizeEventColours(colours);
+ * // Returns: { main: { 500: {...} }, sec: { 500: {...} }, acc: { 500: {...} } }
+ * ```
+ * 
  */
 export function parseAndNormalizeEventColours(input: unknown): { main: any; sec: any; acc: any } | null {
   try {
@@ -55,13 +65,16 @@ export function parseAndNormalizeEventColours(input: unknown): { main: any; sec:
       return null;
     }
 
-    // Use standard 'main'/'sec'/'acc' keys
-    const main = obj?.main || null;
-    const sec  = obj?.sec  || null;
-    const acc  = obj?.acc  || null;
+    // Support both standard keys (main/sec/acc) and prefixed keys (ev-main/ev-sec/ev-acc)
+    // Database may store with ev-* prefix, but we normalize to standard keys
+    const main = obj?.main || obj?.['ev-main'] || null;
+    const sec  = obj?.sec  || obj?.['ev-sec']  || null;
+    const acc  = obj?.acc  || obj?.['ev-acc'] || null;
     
     // If no palette data found, return null
-    if (!main && !sec && !acc) return null;
+    if (!main && !sec && !acc) {
+      return null;
+    }
 
     // Helper: only include explicitly defined color values
     // This ensures we don't include undefined shades in the palette
@@ -88,7 +101,6 @@ export function parseAndNormalizeEventColours(input: unknown): { main: any; sec:
       acc: fill(acc) 
     };
   } catch (error) {
-    log.warn('Failed to parse/normalize event colours:', error);
     return null;
   }
 }