@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/services/EventService.ts

@@ -11,8 +11,9 @@
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { BaseService } from './base/BaseService';
 import { IEventService } from './interfaces/IEventService';
-import { Event } from '../types/unified';
+import { Event } from '../types/event';
 import { Organisation } from '../types/organisation';
+import { assertOrganisationId } from '../types/core';
 import { logger } from '../utils/core/logger';
 import { secureStorage } from '../utils/security/secureStorage';
 
@@ -101,8 +102,12 @@ export class EventService extends BaseService implements IEventService {
       this.resetInitialization(); // Reset BaseService's isInitialized flag
       this.isInitializedRef = false;
       this.isFetchingRef = false;
-      // Clear events when switching organisations
-      if (previousOrgId !== null && newOrgId !== previousOrgId) {
+      // Clear events ONLY when switching between different organisations (not when org first becomes available)
+      if (previousOrgId !== null && newOrgId !== null && previousOrgId !== newOrgId) {
+        this.events = [];
+        this.selectedEvent = null;
+      } else if (previousOrgId !== null && newOrgId === null) {
+        // Organisation was removed - clear events
         this.events = [];
         this.selectedEvent = null;
       }
@@ -113,7 +118,9 @@ export class EventService extends BaseService implements IEventService {
 
   // Event state getters
   getEvents(): Event[] {
-    return this.events;
+    // Return a new array reference so React can detect changes
+    // This ensures useMemo dependencies work correctly
+    return [...this.events];
   }
 
   getSelectedEvent(): Event | null {
@@ -277,27 +284,9 @@ export class EventService extends BaseService implements IEventService {
 
   // Lifecycle methods
   async initialize(): Promise<void> {
+    // Only call super.initialize() which will call doInitialize() and fetchEvents()
+    // Don't call fetchEvents() again here to avoid double-fetching
     await super.initialize();
-    
-    // Clean up old global storage keys (backward compatibility)
-    // This ensures old data doesn't leak to new users
-    try {
-      // Remove old plain storage key
-      if (typeof sessionStorage !== 'undefined') {
-        sessionStorage.removeItem('pace-core-selected-event');
-      }
-      if (typeof localStorage !== 'undefined') {
-        localStorage.removeItem('pace-core-selected-event');
-        // Also remove old encrypted format if it exists
-        localStorage.removeItem('_sec_pace-core-selected-event');
-      }
-    } catch (error) {
-      logger.warn('EventService', 'Failed to clean up old storage keys:', error);
-    }
-    
-    // Load persisted event during initialization (don't skip)
-    // This ensures the last viewed event is restored before auto-selection happens
-    await this.fetchEvents(false);
   }
 
   cleanup(): void {
@@ -305,8 +294,32 @@ export class EventService extends BaseService implements IEventService {
   }
 
   protected async doInitialize(): Promise<void> {
+    // Skip if already initialized
+    if (this.isInitializedRef) {
+      return;
+    }
+    
+    // Skip if already fetching
+    if (this.isFetchingRef) {
+      return;
+    }
+    
+    // Clean up old storage keys (migration from old key format)
+    try {
+      sessionStorage.removeItem('pace-core-selected-event');
+      localStorage.removeItem('pace-core-selected-event');
+      localStorage.removeItem('_sec_pace-core-selected-event');
+    } catch (error) {
+      logger.warn('EventService', 'Failed to clean up old storage keys:', error);
+    }
+    
+    // Skip if no user or organisation
+    if (!this.user || !this.selectedOrganisation) {
+      return;
+    }
+    
     // Initial setup - fetch events on initialization
-    await this.fetchEvents();
+    await this.fetchEvents(false);
   }
 
   protected doCleanup(): void {
@@ -334,25 +347,12 @@ export class EventService extends BaseService implements IEventService {
 
     try {
       // Call the RPC function following the established pattern
-      logger.debug('EventService', 'Fetching events with params:', {
-        p_user_id: this.user.id,
-        p_organisation_id: this.selectedOrganisation.id,
-        p_app_name: this.appName
-      });
-      
       const { data, error: rpcError } = await this.supabaseClient.rpc('data_user_events_get', {
         p_user_id: this.user.id,
         p_organisation_id: this.selectedOrganisation.id,
         p_app_name: this.appName
       });
 
-      logger.debug('EventService', 'RPC call completed:', {
-        hasData: !!data,
-        dataLength: Array.isArray(data) ? data.length : 0,
-        hasError: !!rpcError,
-        errorMessage: rpcError?.message || 'No error'
-      });
-
       if (rpcError) {
         logger.error('EventService', 'RPC error fetching events:', rpcError);
         throw new Error(rpcError.message || 'Failed to fetch events');
@@ -362,8 +362,21 @@ export class EventService extends BaseService implements IEventService {
         const eventsData = data || [];
 
         // Transform the data to match our Event interface
-        const transformedEvents: Event[] = eventsData.map((event: any) => ({
-          id: event.event_id, // Use event_id as the primary id
+        // Type for RPC response from data_user_events_get
+        interface EventRpcResponse {
+          event_id: string;
+          event_name: string;
+          event_code: string;
+          event_date: string | null;
+          event_venue: string | null;
+          event_participants: number | null;
+          event_colours: Record<string, unknown> | null;
+          organisation_id: string;
+          is_visible: boolean;
+        }
+        
+        const transformedEvents: Event[] = eventsData.map((event: EventRpcResponse) => ({
+          id: event.event_id,
           event_id: event.event_id,
           event_name: event.event_name,
           event_code: event.event_code,
@@ -372,11 +385,10 @@ export class EventService extends BaseService implements IEventService {
           event_participants: event.event_participants,
           event_colours: event.event_colours,
           event_logo: '', // No logo field in event table
-          organisation_id: event.organisation_id,
+          organisation_id: assertOrganisationId(event.organisation_id),
           is_visible: event.is_visible,
-          // Legacy compatibility
-          name: event.event_name,
-          start_date: event.event_date
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString()
         }));
 
         this.events = transformedEvents;

package/src/services/InactivityService.ts

@@ -8,10 +8,22 @@
  * Handles inactivity tracking, auto-logout, and warning modals.
  */
 
+import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { BaseService } from './base/BaseService';
 import { IInactivityService } from './interfaces/IInactivityService';
 import { logger } from '../utils/core/logger';
 
+interface InactivityTracker {
+  isIdle: boolean;
+  timeRemaining: number;
+  showWarning: boolean;
+  isTracking: boolean;
+  resetActivity: () => void;
+  startTracking: () => void;
+  stopTracking: () => void;
+  cleanup?: () => void;
+}
+
 export class InactivityService extends BaseService implements IInactivityService {
   private _showInactivityWarning = false;
   private _inactivityTimeRemaining = 0;
@@ -21,21 +33,22 @@ export class InactivityService extends BaseService implements IInactivityService
   private _isTracking = false;
 
   // Dependencies
-  private supabaseClient: any = null;
-  private user: any = null;
-  private session: any = null;
+  private supabaseClient: SupabaseClient | null = null;
+  private user: User | null = null;
+  private session: Session | null = null;
   private idleTimeoutMs = 30 * 60 * 1000; // 30 minutes
   private warnBeforeMs = 60 * 1000; // 60 seconds
   private onIdleLogout: ((reason: 'inactivity') => void) | null = null;
 
   // Internal state management
-  private inactivityTracker: any = null;
+  private inactivityTracker: InactivityTracker | null = null;
   private isInactivityEnabled = true;
+  private cleanupHandlers: (() => void) | null = null;
 
   constructor(
-    supabaseClient: any,
-    user: any,
-    session: any,
+    supabaseClient: SupabaseClient | null,
+    user: User | null,
+    session: Session | null,
     idleTimeoutMs: number = 30 * 60 * 1000,
     warnBeforeMs: number = 60 * 1000,
     onIdleLogout: (reason: 'inactivity') => void
@@ -111,9 +124,9 @@ export class InactivityService extends BaseService implements IInactivityService
 
   // Update dependencies
   updateDependencies(
-    supabaseClient: any,
-    user: any,
-    session: any,
+    supabaseClient: SupabaseClient | null,
+    user: User | null,
+    session: Session | null,
     idleTimeoutMs?: number,
     warnBeforeMs?: number,
     onIdleLogout?: (reason: 'inactivity') => void
@@ -169,7 +182,7 @@ export class InactivityService extends BaseService implements IInactivityService
       if (this.supabaseClient) {
         await this.supabaseClient.auth.signOut();
       }
-    } catch (error: any) {
+    } catch (error) {
       logger.error('InactivityService', 'Error during idle logout:', error);
     }
     
@@ -195,7 +208,7 @@ export class InactivityService extends BaseService implements IInactivityService
       if (this.supabaseClient) {
         await this.supabaseClient.auth.signOut();
       }
-    } catch (error: any) {
+    } catch (error) {
       logger.error('InactivityService', 'Error during manual sign out:', error);
     }
     
@@ -211,8 +224,11 @@ export class InactivityService extends BaseService implements IInactivityService
   }
 
   cleanup(): void {
+    if (this.cleanupHandlers) {
+      this.cleanupHandlers();
+      this.cleanupHandlers = null;
+    }
     if (this.inactivityTracker) {
-      this.inactivityTracker.cleanup?.();
       this.inactivityTracker = null;
     }
     this._isTracking = false;
@@ -243,50 +259,14 @@ export class InactivityService extends BaseService implements IInactivityService
     if (typeof window === 'undefined') return;
 
     // Check if inactivity is enabled
-    this.isInactivityEnabled = this.user && this.session;
+    this.isInactivityEnabled = !!(this.user && this.session);
 
     if (!this.isInactivityEnabled) {
       return;
     }
 
-    try {
-      // Dynamically import the inactivity tracker hook
-      const { useInactivityTracker } = await import('../hooks/useInactivityTracker');
-      
-      // Create a mock implementation since we can't use hooks in services
-      // In a real implementation, you'd need to create a non-hook version
-      this.inactivityTracker = {
-        isIdle: false,
-        timeRemaining: 0,
-        showWarning: false,
-        isTracking: false,
-        resetActivity: () => {
-          this._isIdle = false;
-          this._timeRemaining = 0;
-          this._showWarning = false;
-          this.notify();
-        },
-        startTracking: () => {
-          this._isTracking = true;
-          this.notify();
-        },
-        stopTracking: () => {
-          this._isTracking = false;
-          this.notify();
-        },
-        cleanup: () => {
-          this._isTracking = false;
-          this._isIdle = false;
-          this._showWarning = false;
-          this._timeRemaining = 0;
-        }
-      };
-
-      // Set up event handlers
-      this.setupEventHandlers();
-    } catch (error) {
-      logger.error('InactivityService', 'Failed to setup inactivity tracker:', error);
-    }
+    // Set up event handlers directly (no need to import hooks - services are pure TypeScript)
+    this.setupEventHandlers();
   }
 
   private setupEventHandlers(): void {
@@ -360,7 +340,7 @@ export class InactivityService extends BaseService implements IInactivityService
     startIdleTimer();
 
     // Store cleanup function
-    this.inactivityTracker.cleanup = () => {
+    this.cleanupHandlers = () => {
       if (idleTimer) {
         clearTimeout(idleTimer);
         idleTimer = null;

package/src/services/OrganisationService.ts

@@ -19,6 +19,16 @@ import type {
 } from '../types/organisation';
 import { setOrganisationContext } from '../utils/context/organisationContext';
 import { logger } from '../utils/core/logger';
+import { assertUserId, assertOrganisationId } from '../types/core';
+
+// Type for RPC response from data_user_organisation_roles_get
+interface OrganisationRoleRpcResponse {
+  user_id: string;
+  organisation_id: string;
+  role: 'org_admin' | 'leader' | 'member' | 'supporter';
+  status: 'active' | 'inactive' | 'suspended';
+  [key: string]: unknown;
+}
 
 export class OrganisationService extends BaseService implements IOrganisationService {
   private _selectedOrganisation: Organisation | null = null;
@@ -112,7 +122,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     // If user logs out, allow re-initialization when they log back in
     if (wasAuthenticated && !isAuthenticated) {
       // Reset BaseService initialization state to allow re-initialization
-      (this as any).isInitialized = false;
+      this.resetInitialization();
     }
     
     this.notify();
@@ -150,7 +160,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
   }
 
   validateOrganisationAccess(orgId: string): boolean {
-    return this._userMemberships.some((m: any) => 
+    return this._userMemberships.some((m) => 
       m.organisation_id === orgId && 
       m.status === 'active' &&
       m.revoked_at === null
@@ -179,12 +189,12 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
   getPrimaryOrganisation(): Organisation | null {
     // Look for org_admin role first, then leader, then member
-    const rolePriority = ['org_admin', 'leader', 'member'];
+    const rolePriority = ['org_admin', 'leader', 'member'] as const;
     
     for (const role of rolePriority) {
-      const membership = this._userMemberships.find((m: any) => m.role === role);
+      const membership = this._userMemberships.find((m) => m.role === role);
       if (membership) {
-        return this._organisations.find((org: any) => org.id === membership.organisation_id) || null;
+        return this._organisations.find((org) => org.id === membership.organisation_id) || null;
       }
     }
     
@@ -262,8 +272,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     }
 
     try {
-      logger.debug('OrganisationService', 'Setting database organisation context for:', organisation.id);
-      
       // Add timeout to prevent hanging
       const timeoutPromise = new Promise((_, reject) => {
         setTimeout(() => reject(new Error('Context setting timeout after 5 seconds')), 5000);
@@ -273,7 +281,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       
       await Promise.race([contextPromise, timeoutPromise]);
       
-      logger.debug('OrganisationService', 'Database organisation context set successfully');
+      // Database organisation context set successfully
       this._isContextReady = true;
       this.notify();
     } catch (error) {
@@ -287,10 +295,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
   }
 
   private async loadUserOrganisations(): Promise<void> {
-    // Add call tracking to detect race conditions
-    const callId = Math.random().toString(36).substr(2, 9);
-    logger.debug('OrganisationService', `Starting loadUserOrganisations call ${callId}`);
-    
     if (!this.user || !this.session || !this.supabaseClient) {
       // Clear state when no user, session, or supabase client
       this._selectedOrganisation = null;
@@ -304,7 +308,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
     // Additional check to prevent loading during auth state changes
     if (this.isLoadingRef) {
-      logger.debug("OrganisationService", "Already loading, skipping duplicate load");
       // Ensure loading state is correct
       this._isLoading = true;
       this.notify();
@@ -314,7 +317,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     // Prevent rapid retries - minimum 2 seconds between attempts
     const now = Date.now();
     if (now - this.lastLoadTimeRef < 2000) {
-      logger.debug("OrganisationService", "Too soon since last load, skipping");
       // Ensure loading state is correct
       if (this._organisations.length > 0 || this._selectedOrganisation) {
         this._isLoading = false;
@@ -341,18 +343,10 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this.notify();
       
     try {
-      logger.debug("OrganisationService", "Supabase client ready:", {
-        isConnected: !!this.supabaseClient,
-        hasAuth: !!this.supabaseClient.auth,
-        hasRpc: !!this.supabaseClient.rpc
-      });
-      
       // Get user's organisation memberships using secure RPC function
       // Only get actual members (org_admin, leader, member) - exclude supporters
       let memberships, membershipError;
       try {
-        logger.debug("OrganisationService", "Making RPC call to data_user_organisation_roles_get...");
-        
         // Add timeout and abort signal to prevent hanging RPC calls
         const timeoutPromise = new Promise((_, reject) => {
           const timeoutId = setTimeout(() => reject(new Error('RPC call timeout after 10 seconds')), 10000);
@@ -372,22 +366,20 @@ export class OrganisationService extends BaseService implements IOrganisationSer
           throw new Error('Request aborted');
         }
         
-        const result = await Promise.race([rpcPromise, timeoutPromise]) as any;
-        
-        logger.debug("OrganisationService", "RPC call completed:", {
-          hasData: !!result.data,
-          hasError: !!result.error,
-          dataLength: result.data?.length || 0,
-          errorMessage: result.error?.message || 'No error'
-        });
+        const result = await Promise.race([rpcPromise, timeoutPromise]) as { data: OrganisationRoleRpcResponse[] | null; error: Error | null };
         
         // Filter to only actual members (org_admin, leader, member) - exclude supporters
-        memberships = result.data?.filter((role: any) => 
+        // Map to branded types when filtering
+        memberships = result.data?.filter((role) => 
           ['org_admin', 'leader', 'member'].includes(role.role)
-        ) || [];
+        ).map((m) => ({
+          ...m,
+          user_id: assertUserId(m.user_id),
+          organisation_id: assertOrganisationId(m.organisation_id),
+        })) || [];
         membershipError = result.error;
-      } catch (queryError: any) {
-        membershipError = queryError;
+      } catch (queryError) {
+        membershipError = queryError instanceof Error ? queryError : new Error(String(queryError));
       }
 
       if (membershipError) {
@@ -395,7 +387,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         
         // If RPC fails with timeout, try direct database query as fallback
         if (membershipError.message?.includes('timeout')) {
-          logger.debug("OrganisationService", "RPC timed out, trying direct database query as fallback...");
           try {
             // Check if request was aborted before making fallback query
             if (abortSignal.aborted) {
@@ -439,8 +430,12 @@ export class OrganisationService extends BaseService implements IOrganisationSer
               throw membershipError; // Throw original error
             }
             
-            logger.debug("OrganisationService", "Fallback query successful, got", fallbackData?.length || 0, "memberships");
-            memberships = fallbackData || [];
+            // Map to branded types
+            memberships = fallbackData?.map((m) => ({
+              ...m,
+              user_id: assertUserId(m.user_id),
+              organisation_id: assertOrganisationId(m.organisation_id),
+            })) || [];
             membershipError = null;
           } catch (fallbackErr) {
             logger.error("OrganisationService", "Fallback query failed:", fallbackErr);
@@ -457,7 +452,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
       // Get organisation details for the memberships
       const organisationIds = memberships
-        .map((m: any) => m.organisation_id)
+        .map((m) => m.organisation_id)
         .filter((id: string) => {
           // Better validation to prevent empty string UUID errors
           if (!id || typeof id !== 'string') {
@@ -503,7 +498,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
       // Create a map of organisation_id to role from the memberships data
       const roleMap = new Map<string, string>();
-      memberships?.forEach((membership: any) => {
+      memberships?.forEach((membership) => {
         roleMap.set(membership.organisation_id, membership.role);
       });
 
@@ -516,6 +511,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       }
 
       this._organisations = activeOrgs;
+      // Memberships already have branded types from earlier mapping
       this._userMemberships = memberships as OrganisationMembership[];
       
       // Store role map in component state for later use
@@ -551,7 +547,7 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       
       // 2. Fall back to org_admin role organisation (highest privilege)
       if (!initialOrg) {
-        const adminMembership = memberships.find((m: any) => m.role === 'org_admin');
+        const adminMembership = memberships.find((m) => m.role === 'org_admin');
         if (adminMembership) {
           const foundOrg = organisations.find((org) => org.id === adminMembership.organisation_id);
           if (foundOrg) {

package/src/services/__tests__/AuthService.restoreSession.test.ts

@@ -7,8 +7,12 @@ function createSupabaseMock() {
     getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
     getUser: vi.fn(), // should not be called when session is null
     onAuthStateChange: vi.fn().mockImplementation((cb: any) => {
-      // Provide a subscription-like object
-      return { unsubscribe: () => {} } as any;
+      // Provide a subscription-like object with data.subscription structure
+      const subscription = { unsubscribe: () => {} };
+      return { 
+        data: { subscription },
+        error: null
+      } as any;
     }),
   } as any;