@jmruthers/pace-core 0.5.76 → 0.5.78

package/src/rbac/types.ts

@@ -40,7 +40,7 @@ export type PermissionCheck = {
   pageId?: UUID | string;
 };
 
-export type PermissionMap = Record<string /* pageId */, Operation[]>;
+export type PermissionMap = Record<Permission, boolean> & Partial<Record<'*', boolean>>;
 
 // ============================================================================
 // ROLE TYPES
@@ -162,6 +162,17 @@ export interface RBACAuditEvent {
   created_at: string;
 }
 
+export interface RBACAppContext {
+  appId: UUID;
+  hasAccess: boolean;
+}
+
+export interface RBACRoleContext {
+  globalRole: GlobalRole | null;
+  organisationRole: OrganisationRole | null;
+  eventAppRole: EventAppRole | null;
+}
+
 // ============================================================================
 // CACHE TYPES
 // ============================================================================

package/src/services/AuthService.ts

@@ -11,12 +11,11 @@
 import { type SupabaseClient, type User, type Session, AuthError } from '@supabase/supabase-js';
 import { BaseService } from './base/BaseService';
 import { IAuthService, AuthResult } from './interfaces/IAuthService';
-import { DebugLogger } from '../utils/debugLogger';
 
 export class AuthService extends BaseService implements IAuthService {
   private user: User | null = null;
   private session: Session | null = null;
-  private authLoading = true;
+  private authLoading = false;
   private authError: AuthError | null = null;
   private supabaseClient: SupabaseClient | null = null;
   private authStateSubscription: any = null;
@@ -307,16 +306,12 @@ export class AuthService extends BaseService implements IAuthService {
       this.authStateSubscription = this.supabaseClient.auth.onAuthStateChange(
         (event, session) => {
           try {
-            DebugLogger.log('AuthService', 'Auth state changed:', event, session?.user?.email);
-            
             // Handle different auth events
             if (event === 'SIGNED_OUT') {
-              DebugLogger.log('AuthService', 'User signed out, clearing all state');
               this.session = null;
               this.user = null;
               this.authError = null;
             } else if (event === 'SIGNED_IN' || event === 'TOKEN_REFRESHED') {
-              DebugLogger.log('AuthService', 'User signed in or token refreshed');
               this.session = session;
               this.user = session?.user ?? null;
               
@@ -325,7 +320,6 @@ export class AuthService extends BaseService implements IAuthService {
                 this.authError = null;
               }
             } else if (event === 'INITIAL_SESSION') {
-              DebugLogger.log('AuthService', 'Initial session event');
               if (session) {
                 this.session = session;
                 this.user = session.user ?? null;
@@ -357,8 +351,6 @@ export class AuthService extends BaseService implements IAuthService {
     }
 
     try {
-      DebugLogger.log('AuthService', 'Initializing authentication...');
-      
       // First, try to get the current session
       const { data: { session: currentSession }, error: sessionError } = await this.supabaseClient.auth.getSession();
       
@@ -368,19 +360,14 @@ export class AuthService extends BaseService implements IAuthService {
       }
 
       if (currentSession) {
-        DebugLogger.log('AuthService', 'Session restored from storage:', currentSession.user?.email);
         this.session = currentSession;
         this.user = currentSession.user;
         this.authError = null;
       } else {
-        DebugLogger.log('AuthService', 'No session found in storage');
         // Try to get user anyway (in case session is expired but user exists)
         const { data: { user: currentUser }, error: userError } = await this.supabaseClient.auth.getUser();
         
-        if (userError) {
-          DebugLogger.log('AuthService', 'No user found:', userError.message);
-        } else if (currentUser) {
-          DebugLogger.log('AuthService', 'User found without session:', currentUser.email);
+        if (!userError && currentUser) {
           this.user = currentUser;
           // Don't set session if it's null - this prevents issues
         }

package/src/services/EventService.ts

@@ -8,23 +8,25 @@
  * Handles event management and selection with organisation context validation.
  */
 
+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 { Organisation } from '../types/organisation';
 import { DebugLogger } from '../utils/debugLogger';
 
 export class EventService extends BaseService implements IEventService {
   private events: Event[] = [];
   private selectedEvent: Event | null = null;
-  private _isLoading = true;
+  private _isLoading = false; // Start as false to avoid blocking UI
   private error: Error | null = null;
 
   // 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 appName: string = '';
-  private selectedOrganisation: any = null;
+  private selectedOrganisation: Organisation | null = null;
   private setSelectedEventId: ((eventId: string | null) => void) | null = null;
 
   // Internal state management
@@ -34,11 +36,11 @@ export class EventService extends BaseService implements IEventService {
   private userClearedEventRef = false;
 
   constructor(
-    supabaseClient: any,
-    user: any,
-    session: any,
+    supabaseClient: SupabaseClient,
+    user: User | null,
+    session: Session | null,
     appName: string,
-    selectedOrganisation: any,
+    selectedOrganisation: Organisation | null,
     setSelectedEventId: (eventId: string | null) => void
   ) {
     super();
@@ -52,19 +54,36 @@ export class EventService extends BaseService implements IEventService {
 
   // Update dependencies
   updateDependencies(
-    supabaseClient: any,
-    user: any,
-    session: any,
+    supabaseClient: SupabaseClient,
+    user: User | null,
+    session: Session | null,
     appName: string,
-    selectedOrganisation: any,
+    selectedOrganisation: Organisation | null,
     setSelectedEventId: (eventId: string | null) => void
   ): void {
+    const previousOrgId = this.selectedOrganisation?.id;
+    const newOrgId = selectedOrganisation?.id;
+    
     this.supabaseClient = supabaseClient;
     this.user = user;
     this.session = session;
     this.appName = appName;
     this.selectedOrganisation = selectedOrganisation;
     this.setSelectedEventId = setSelectedEventId;
+    
+    // If organisation changed (from null to value, or different org), reset initialization
+    // This ensures events are re-fetched when organisation context becomes available
+    if (previousOrgId !== newOrgId) {
+      this.resetInitialization(); // Reset BaseService's isInitialized flag
+      this.isInitializedRef = false;
+      this.isFetchingRef = false;
+      // Clear events when switching organisations
+      if (previousOrgId !== null && newOrgId !== previousOrgId) {
+        this.events = [];
+        this.selectedEvent = null;
+      }
+    }
+    
     this.notify();
   }
 
@@ -153,14 +172,12 @@ export class EventService extends BaseService implements IEventService {
       
       if (persistedEventId && events.length > 0) {
         const persistedEvent = events.find(event => event.event_id === persistedEventId);
-        if (persistedEvent) {
-          DebugLogger.log('EventService', 'Restoring persisted event:', persistedEvent.event_name);
-          this.selectedEvent = persistedEvent;
-          this.setSelectedEventId?.(persistedEventId);
-          return true;
-        } else {
-          DebugLogger.log('EventService', 'Persisted event not found in current events, clearing storage');
-          // Clear invalid persisted event
+      if (persistedEvent) {
+        this.selectedEvent = persistedEvent;
+        this.setSelectedEventId?.(persistedEventId);
+        return true;
+      } else {
+        // Clear invalid persisted event
           sessionStorage.removeItem('pace-core-selected-event');
           localStorage.removeItem('pace-core-selected-event');
         }
@@ -198,7 +215,6 @@ export class EventService extends BaseService implements IEventService {
   autoSelectNextEvent(events: Event[]): void {
     const nextEvent = this.getNextEventByDate(events);
     if (nextEvent) {
-      DebugLogger.log('EventService', 'Auto-selecting next event:', nextEvent.event_name);
       this.selectedEvent = nextEvent;
       this.setSelectedEventId?.(nextEvent.event_id);
       this.persistEventSelection(nextEvent.event_id);
@@ -226,49 +242,31 @@ export class EventService extends BaseService implements IEventService {
 
   private async fetchEvents(): Promise<void> {
     if (!this.user || !this.session || !this.supabaseClient || !this.appName || !this.selectedOrganisation) {
-      DebugLogger.log('EventService', 'Missing required dependencies, skipping fetch');
-      this._isLoading = false;
+      // Already false from initialization, just notify
       this.notify();
       return;
     }
+    
+    // Only set loading to true if we actually have dependencies and are going to fetch
+    this._isLoading = true;
+    this.notify();
 
     // Prevent multiple simultaneous fetches
     if (this.isFetchingRef) {
-      DebugLogger.log('EventService', 'Already fetching events, skipping');
       return;
     }
 
-    DebugLogger.log('EventService', 'User and organisation found, fetching events for:', {
-      userId: this.user.id,
-      appName: this.appName,
-      organisationId: this.selectedOrganisation.id,
-      organisationName: this.selectedOrganisation.display_name
-    });
-
     this.isFetchingRef = true;
     let isMounted = true;
 
     try {
       // Call the RPC function following the established pattern
-      DebugLogger.log('EventService', 'Calling data_user_events_get RPC with:', {
-        user_id: this.user.id,
-        organisation_id: this.selectedOrganisation.id,
-        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
       });
 
-      DebugLogger.log('EventService', 'RPC response:', {
-        data,
-        error: rpcError,
-        dataLength: data?.length || 0,
-        organisationId: this.selectedOrganisation.id
-      });
-
       if (rpcError) {
         throw new Error(rpcError.message || 'Failed to fetch events');
       }
@@ -312,7 +310,6 @@ export class EventService extends BaseService implements IEventService {
         if (!persistedEventLoaded && !this.userClearedEventRef) {
           const nextEvent = this.getNextEventByDate(transformedEvents);
           if (nextEvent) {
-            DebugLogger.log('EventService', 'Auto-selecting next event after no persisted event found:', nextEvent.event_name);
             this.hasAutoSelectedRef = true;
             this.selectedEvent = nextEvent;
             this.setSelectedEventId?.(nextEvent.event_id);

package/src/services/OrganisationService.ts

@@ -18,14 +18,13 @@ import type {
   OrganisationHierarchy
 } from '../types/organisation';
 import { setOrganisationContext } from '../utils/organisationContext';
-import { DebugLogger } from '../utils/debugLogger';
 
 export class OrganisationService extends BaseService implements IOrganisationService {
   private _selectedOrganisation: Organisation | null = null;
   private _organisations: Organisation[] = [];
   private _userMemberships: OrganisationMembership[] = [];
   private _roleMapState: Map<string, string> = new Map();
-  private _isLoading = true;
+  private _isLoading = false;
   private _error: Error | null = null;
   private _isContextReady = false;
   private retryCount = 0;
@@ -52,7 +51,9 @@ export class OrganisationService extends BaseService implements IOrganisationSer
   getSelectedOrganisation(): Organisation | null { return this._selectedOrganisation; }
   getOrganisations(): Organisation[] { return this._organisations; }
   getUserMemberships(): OrganisationMembership[] { return this._userMemberships; }
-  isLoading(): boolean { return this._isLoading; }
+  isLoading(): boolean { 
+    return this._isLoading;
+  }
   getError(): Error | null { return this._error; }
   hasValidOrganisationContext(): boolean { return !!(this._selectedOrganisation && !this._isLoading && !this._error && this._isContextReady); }
   isContextReady(): boolean { return this._isContextReady; }
@@ -101,15 +102,23 @@ export class OrganisationService extends BaseService implements IOrganisationSer
 
   // Update dependencies
   updateDependencies(user: User | null, session: Session | null): void {
+    const wasAuthenticated = !!(this.user && this.session);
+    const isAuthenticated = !!(user && session);
+    
     this.user = user;
     this.session = session;
+    
+    // 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.notify();
   }
 
   // Organisation methods
   async switchOrganisation(orgId: string): Promise<void> {
-    DebugLogger.log("OrganisationService", "Switching to organisation:", orgId);
-    
     // Validate access
     if (!this.validateOrganisationAccess(orgId)) {
       throw new Error(`User does not have access to organisation ${orgId}`) as OrganisationSecurityError;
@@ -128,7 +137,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     // Set database organisation context
     await this.setDatabaseOrganisationContext(targetOrg);
     
-    DebugLogger.log("OrganisationService", "Switched to organisation:", targetOrg.display_name);
     this.notify();
   }
 
@@ -206,7 +214,11 @@ export class OrganisationService extends BaseService implements IOrganisationSer
   // Lifecycle methods
   async initialize(): Promise<void> {
     await super.initialize();
-    await this.loadUserOrganisations();
+    
+    // Don't load if already loading (prevents duplicate loads during rapid auth events)
+    if (!this.isLoadingRef) {
+      await this.loadUserOrganisations();
+    }
   }
 
   cleanup(): void {
@@ -214,9 +226,11 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this.isLoadingRef = false;
     this.hasFailedRef = false;
     this.lastLoadTimeRef = 0;
-    // Abort any pending requests
+    // Don't abort pending requests - let them complete naturally
+    // Aborting causes React StrictMode issues where requests are cancelled mid-flight
+    // The requests will complete on their own and update state if needed
     if (this.abortControllerRef) {
-      this.abortControllerRef.abort();
+      // Clear the reference but don't abort - let requests complete
       this.abortControllerRef = null;
     }
     // Reset state
@@ -247,13 +261,25 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     }
 
     try {
-      await setOrganisationContext(this.supabaseClient, organisation.id);
-      DebugLogger.log('OrganisationService', 'Database organisation context set to:', organisation.display_name);
+      console.log('[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);
+      });
+      
+      const contextPromise = setOrganisationContext(this.supabaseClient, organisation.id);
+      
+      await Promise.race([contextPromise, timeoutPromise]);
+      
+      console.log('[OrganisationService] Database organisation context set successfully');
       this._isContextReady = true;
       this.notify();
     } catch (error) {
       console.error('[OrganisationService] Failed to set database organisation context:', error);
-      this._isContextReady = false;
+      // 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
     }
@@ -266,7 +292,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     
     if (!this.user || !this.session || !this.supabaseClient) {
       // Clear state when no user, session, or supabase client
-      DebugLogger.log('OrganisationService', 'Clearing organisation state - no user, session, or supabase client');
       this._selectedOrganisation = null;
       this._organisations = [];
       this._userMemberships = [];
@@ -279,6 +304,9 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     // Additional check to prevent loading during auth state changes
     if (this.isLoadingRef) {
       console.log("OrganisationService", "Already loading, skipping duplicate load");
+      // Ensure loading state is correct
+      this._isLoading = true;
+      this.notify();
       return;
     }
 
@@ -286,6 +314,13 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     const now = Date.now();
     if (now - this.lastLoadTimeRef < 2000) {
       console.log("OrganisationService", "Too soon since last load, skipping");
+      // Ensure loading state is correct
+      if (this._organisations.length > 0 || this._selectedOrganisation) {
+        this._isLoading = false;
+      } else {
+        this._isLoading = true;
+      }
+      this.notify();
       return;
     }
 
@@ -305,9 +340,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
     this.notify();
       
     try {
-      DebugLogger.log("OrganisationService", "Loading organisations for user:", this.user.id);
-      
-      // Debug: Log Supabase client configuration
       console.log("[OrganisationService] Supabase client ready:", {
         isConnected: !!this.supabaseClient,
         hasAuth: !!this.supabaseClient.auth,
@@ -418,8 +450,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         }
       }
       
-      DebugLogger.log("OrganisationService", "Raw memberships data:", memberships);
-      
       if (!memberships || memberships.length === 0) {
         throw new Error('User has no active organisation memberships') as OrganisationSecurityError;
       }
@@ -451,8 +481,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         throw new Error('No valid organisation IDs found in memberships') as OrganisationSecurityError;
       }
       
-      DebugLogger.log("OrganisationService", "Valid organisation IDs:", organisationIds);
-      
       // Check if request was aborted before making organisations query
       if (abortSignal.aborted) {
         throw new Error('Request aborted');
@@ -486,8 +514,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
         throw new Error('User has no access to active organisations') as OrganisationSecurityError;
       }
 
-      DebugLogger.log("OrganisationService", "Active organisations:", activeOrgs);
-      
       this._organisations = activeOrgs;
       this._userMemberships = memberships as OrganisationMembership[];
       
@@ -507,7 +533,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
             const validPersistedOrg = activeOrgs.find(org => org.id === persistedOrg.id);
             if (validPersistedOrg) {
               initialOrg = validPersistedOrg;
-              DebugLogger.log("OrganisationService", "Restored persisted organisation:", initialOrg.display_name);
             } else {
               console.warn("[OrganisationService] Persisted organisation not found in active orgs, clearing cache");
               localStorage.removeItem('pace-core-selected-organisation');
@@ -527,10 +552,9 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       if (!initialOrg) {
         const adminMembership = memberships.find((m: any) => m.role === 'org_admin');
         if (adminMembership) {
-          const foundOrg = organisations.find((org: any) => org.id === adminMembership.organisation_id);
+          const foundOrg = organisations.find((org) => org.id === adminMembership.organisation_id);
           if (foundOrg) {
             initialOrg = foundOrg;
-            DebugLogger.log("OrganisationService", "Selected org_admin organisation:", initialOrg.display_name);
           }
         }
       }
@@ -538,7 +562,6 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       // 3. Fall back to first organisation
       if (!initialOrg) {
         initialOrg = activeOrgs[0];
-        DebugLogger.log("OrganisationService", "Selected first organisation:", initialOrg.display_name);
       }
       
       if (!initialOrg) {
@@ -550,11 +573,8 @@ export class OrganisationService extends BaseService implements IOrganisationSer
       // Persist selection
       localStorage.setItem('pace-core-selected-organisation', JSON.stringify(initialOrg));
       
-      DebugLogger.log("OrganisationService", "Organisation context established:", {
-        selectedOrganisation: initialOrg.display_name,
-        totalOrganisations: activeOrgs.length,
-        userRole: roleMap.get(initialOrg.id)
-      });
+      // Set database organisation context
+      await this.setDatabaseOrganisationContext(initialOrg);
       
       // Reset retry count and failed flag on success
       this.retryCount = 0;

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

@@ -46,7 +46,7 @@ describe('AuthService', () => {
       expect(authService.getUser()).toBeNull();
       expect(authService.getSession()).toBeNull();
       expect(authService.isAuthenticated()).toBe(false);
-      expect(authService.isLoading()).toBe(true);
+      expect(authService.isLoading()).toBe(false);
       expect(authService.getError()).toBeNull();
     });
 

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

@@ -95,7 +95,7 @@ describe('EventService', () => {
     it('should initialize with default state', () => {
       expect(eventService.getEvents()).toEqual([]);
       expect(eventService.getSelectedEvent()).toBeNull();
-      expect(eventService.isLoading()).toBe(true);
+      expect(eventService.isLoading()).toBe(false);
       expect(eventService.getError()).toBeNull();
     });
 

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

@@ -126,7 +126,7 @@ describe('OrganisationService', () => {
       expect(organisationService.getSelectedOrganisation()).toBeNull();
       expect(organisationService.getOrganisations()).toEqual([]);
       expect(organisationService.getUserMemberships()).toEqual([]);
-      expect(organisationService.isLoading()).toBe(true);
+      expect(organisationService.isLoading()).toBe(false);
       expect(organisationService.getError()).toBeNull();
       expect(organisationService.hasValidOrganisationContext()).toBe(false);
     });

package/src/services/base/BaseService.ts

@@ -75,6 +75,14 @@ export abstract class BaseService {
     return this.isInitialized;
   }
 
+  /**
+   * Reset initialization state (allows re-initialization)
+   * Use when dependencies change and service needs to re-initialize
+   */
+  protected resetInitialization(): void {
+    this.isInitialized = false;
+  }
+
   /**
    * Override in subclasses to implement initialization logic
    */