@jmruthers/pace-core 0.5.89 → 0.5.91

package/src/components/PaceLoginPage/PaceLoginPage.tsx

@@ -292,15 +292,18 @@ export const PaceLoginPage: React.FC<PaceLoginPageProps> = ({
     try {
       const { error } = await signIn(data.email, data.password);
 
-      if (!error) {
-        // Navigation will be handled by the useEffect that checks app access
-        // Don't navigate here if requireAppAccess is true
-        if (!requireAppAccess) {
-          try {
-            navigate(onSuccessRedirectPath, { replace: true });
-          } catch (navError) {
-            console.error('Navigation error after sign-in:', navError);
-          }
+      if (error) {
+        // Throw error so LoginForm can catch and display it
+        throw error;
+      }
+
+      // Navigation will be handled by the useEffect that checks app access
+      // Don't navigate here if requireAppAccess is true
+      if (!requireAppAccess) {
+        try {
+          navigate(onSuccessRedirectPath, { replace: true });
+        } catch (navError) {
+          console.error('Navigation error after sign-in:', navError);
         }
       }
     } finally {
@@ -325,11 +328,14 @@ export const PaceLoginPage: React.FC<PaceLoginPageProps> = ({
             console.error('Login error:', error);
           }}
         />
-        {authError && (
-          <em className="mt-4 text-destructive text-center">
-            {authError.message}
-          </em>
-        )}
+        {(() => {
+          const benign = !!(authError && (
+            authError.name === 'AuthSessionMissingError' || /Auth session missing/i.test(authError.message)
+          ));
+          return authError && !benign ? (
+            <em className="mt-4 text-destructive text-center">{authError.message}</em>
+          ) : null;
+        })()}
         {accessError && (
           <em className="mt-4 text-destructive text-center">
             {accessError}

package/src/hooks/public/usePublicEvent.ts

@@ -224,7 +224,6 @@ export function usePublicEvent(
                 event_catering_email,
                 event_news,
                 event_billing,
-                event_footer,
                 event_email
               `)
               .eq('event_code', eventCode)
@@ -301,7 +300,6 @@ export function usePublicEvent(
             event_catering_email,
             event_news,
             event_billing,
-            event_footer,
             event_email
           `)
           .eq('event_code', eventCode)

package/src/services/AuthService.ts

@@ -453,42 +453,42 @@ export class AuthService extends BaseService implements IAuthService {
         // Record error but continue to attempt getUser to satisfy edge cases
         console.debug('[AuthService] getSession returned error, attempting to fetch user anyway');
         this.authError = sessionError;
+        
+        // Attempt getUser as fallback when getSession fails
+        try {
+          const getUserFn = (this.supabaseClient.auth as any)?.getUser as (() => Promise<{ data?: { user?: User | null }, error?: AuthError | null }>) | undefined;
+          if (typeof getUserFn === 'function') {
+            const userResult = await getUserFn();
+            const currentUser = userResult?.data?.user ?? null;
+            const userError = userResult?.error ?? null;
+            
+            if (currentUser) {
+              this.user = currentUser;
+              // If we got a user but no session, we still don't have a valid session
+              this.session = null;
+            }
+            if (userError && !this.authError) {
+              this.authError = userError;
+            }
+          }
+        } catch (getUserError) {
+          // If getUser also fails, we've already recorded the sessionError
+          console.debug('[AuthService] getUser also failed:', getUserError);
+        }
       }
 
       if (currentSession) {
         this.session = currentSession;
         this.user = currentSession.user;
         this.authError = null;
-      } else {
-        console.debug('[AuthService] No active session found, checking for existing user');
+      } else if (!sessionError) {
+        // Only skip getUser if we didn't already attempt it due to a sessionError
+        // Treat missing session as a normal cold-start state on public pages (e.g., login)
+        // Do not call getUser() which can raise AuthSessionMissingError and surface a noisy banner
+        console.debug('[AuthService] No active session found; treating as normal unauthenticated state');
         this.session = null;
-        // Safely call getUser without destructuring
-        let currentUser: User | null = null;
-        let userError: AuthError | null = null;
-        const getUserFn = (this.supabaseClient.auth as any)?.getUser as (() => Promise<{ data?: { user?: User | null }, error?: AuthError | null }>) | undefined;
-        if (typeof getUserFn === 'function') {
-          const userResult = await getUserFn();
-          currentUser = userResult?.data?.user ?? null;
-          userError = userResult?.error ?? null;
-        }
-
-        if (userError) {
-          console.debug('[AuthService] getUser returned error during restoration');
-          this.authError = userError;
-        }
-
-        if (currentUser) {
-          this.user = currentUser;
-          console.debug('[AuthService] Found user without active session during restoration');
-        } else {
-          this.user = null;
-          this.session = null;
-        }
-
-        // Only clear authError if we successfully got user or had no errors
-        if (!userError && !sessionError) {
-          this.authError = null;
-        }
+        this.user = null;
+        this.authError = null;
       }
 
       // Finish successfully even if earlier calls reported an error, to avoid noisy warnings in benign cases

package/src/services/EventService.ts

@@ -14,6 +14,7 @@ import { IEventService } from './interfaces/IEventService';
 import { Event } from '../types/unified';
 import { Organisation } from '../types/organisation';
 import { DebugLogger } from '../utils/debugLogger';
+import { applyPalette, clearPalette } from '../theming/runtime';
 
 export class EventService extends BaseService implements IEventService {
   private events: Event[] = [];
@@ -135,6 +136,8 @@ export class EventService extends BaseService implements IEventService {
       this.persistEventSelection(event.event_id);
       // Reset the user cleared flag when selecting an event
       this.userClearedEventRef = false;
+      // Apply theme for the newly selected event
+      this.updateThemeForSelectedEvent();
     } else {
       this.selectedEvent = null;
       this.setSelectedEventId?.(null);
@@ -145,6 +148,8 @@ export class EventService extends BaseService implements IEventService {
       this.hasAutoSelectedRef = false;
       // Mark that user explicitly cleared the event to prevent auto-selection
       this.userClearedEventRef = true;
+      // Clear theme when event is cleared
+      this.updateThemeForSelectedEvent();
     }
     this.notify();
   }
@@ -175,6 +180,8 @@ export class EventService extends BaseService implements IEventService {
       if (persistedEvent) {
         this.selectedEvent = persistedEvent;
         this.setSelectedEventId?.(persistedEventId);
+        // Apply theme for persisted event
+        this.updateThemeForSelectedEvent();
         return true;
       } else {
         // Clear invalid persisted event
@@ -218,6 +225,8 @@ export class EventService extends BaseService implements IEventService {
       this.selectedEvent = nextEvent;
       this.setSelectedEventId?.(nextEvent.event_id);
       this.persistEventSelection(nextEvent.event_id);
+      // Apply theme for auto-selected event
+      this.updateThemeForSelectedEvent();
     }
   }
 
@@ -338,6 +347,62 @@ export class EventService extends BaseService implements IEventService {
     }
   }
 
+  /**
+   * Parse and normalize event_colours to PaletteData (supports ev-* keys and string JSON)
+   */
+  private parseAndNormalizeEventColours(input: unknown): { main: any; sec: any; acc: any } | null {
+    try {
+      if (!input) return null;
+      let obj: any = input;
+      if (typeof input === 'string') {
+        try {
+          obj = JSON.parse(input);
+        } catch {
+          return null;
+        }
+      } else if (typeof input !== 'object') {
+        return null;
+      }
+
+      const pick = (o: any, pref: string, plain: string) => (o?.[pref] ?? o?.[plain]) || null;
+      const main = pick(obj, 'ev-main', 'main');
+      const sec  = pick(obj, 'ev-sec',  'sec');
+      const acc  = pick(obj, 'ev-acc',  'acc');
+      if (!main && !sec && !acc) return null;
+
+      // Fill helper: ensure all TW shades exist using raw or 500 as fallback
+      const shades = ['50','100','200','300','400','500','600','700','800','900','950'];
+      const fill = (p: any) => {
+        if (!p) return {} as any;
+        const out: any = {};
+        for (const s of shades) out[s] = p[s] || p?.raw || p?.['500'];
+        if (p?.raw) out.raw = p.raw;
+        return out;
+      };
+
+      return { main: fill(main), sec: fill(sec), acc: fill(acc) };
+    } catch (error) {
+      console.warn('[EventService] Failed to parse/normalize event colours:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Apply or clear runtime theme variables based on the current selected event's colours
+   */
+  private updateThemeForSelectedEvent(): void {
+    try {
+      const normalized = this.parseAndNormalizeEventColours(this.selectedEvent?.event_colours);
+      if (normalized) {
+        applyPalette(normalized);
+      } else {
+        clearPalette();
+      }
+    } catch (error) {
+      console.warn('[EventService] Failed to update theme from event colours:', error);
+    }
+  }
+
   getNextEventByDate(events?: Event[]): Event | null {
     const eventsToUse = events || this.events;
     if (!eventsToUse || eventsToUse.length === 0) {

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

@@ -0,0 +1,35 @@
+import { describe, it, expect, vi } from 'vitest';
+import { AuthService } from '../../services/AuthService';
+
+// Minimal Supabase auth mock sufficient for restoreSession/initialize paths
+function createSupabaseMock() {
+  const auth = {
+    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;
+    }),
+  } as any;
+
+  return { auth } as any;
+}
+
+describe('AuthService.restoreSession (no session startup)', () => {
+  it('does not call getUser() and does not set authError when session is null', async () => {
+    const supabase = createSupabaseMock();
+    const service = new AuthService(supabase);
+
+    // initialize() triggers setup listener and restoreSession()
+    await service.initialize();
+
+    // Assertions
+    expect(supabase.auth.getSession).toHaveBeenCalledTimes(1);
+    expect(supabase.auth.getUser).not.toHaveBeenCalled();
+    expect(service.getError()).toBeNull();
+    expect(service.getUser()).toBeNull();
+    expect(service.getSession()).toBeNull();
+  });
+});
+
+

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

@@ -518,23 +518,22 @@ describe('AuthService', () => {
       expect(mockSupabase.auth.getUser).toHaveBeenCalled();
     });
 
-    it('should handle initialization with getUser error', async () => {
-      const userError = new AuthError('User error');
+    it('should not call getUser when getSession succeeds with no session (prevents AuthSessionMissingError)', async () => {
       mockSupabase.auth.getSession.mockResolvedValue({
         data: { session: null },
         error: null
       });
-      mockSupabase.auth.getUser.mockResolvedValue({
-        data: { user: null },
-        error: userError
-      });
       mockSupabase.auth.onAuthStateChange.mockReturnValue({
         data: { subscription: { unsubscribe: vi.fn() } }
       });
 
       await authService.initialize();
 
-      expect(mockSupabase.auth.getUser).toHaveBeenCalled();
+      // When getSession succeeds with no session, getUser is NOT called to prevent
+      // AuthSessionMissingError from being raised on public pages (e.g., login page)
+      // This is intentional behavior to avoid noisy error banners for benign unauthenticated states
+      expect(mockSupabase.auth.getSession).toHaveBeenCalled();
+      expect(mockSupabase.auth.getUser).not.toHaveBeenCalled();
     });
 
     it('should restore session from storage during initialization', async () => {

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

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from 'vitest';
+import { EventService } from '../../services/EventService';
+
+function createSupabaseMock() {
+  const auth = {
+    onAuthStateChange: vi.fn().mockReturnValue({ unsubscribe: () => {} }),
+  } as any;
+  return { auth } as any;
+}
+
+const baseEvent = {
+  event_id: 'e1',
+  event_name: 'Test',
+  organisation_id: 'org1',
+};
+
+describe('EventService event_colours normalization', () => {
+  it('applies palettes when event_colours uses ev-* keys (object)', async () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    // @ts-ignore access private for test by casting
+    (svc as any).selectedEvent = {
+      ...baseEvent,
+      event_colours: {
+        'ev-main': { raw: { L: 0.75, C: 0.1, H: 200 }, '500': { L: 0.75, C: 0.1, H: 200 } },
+        'ev-sec':  { raw: { L: 0.7, C: 0.12, H: 260 }, '500': { L: 0.7, C: 0.12, H: 260 } },
+        'ev-acc':  { raw: { L: 0.65, C: 0.14, H: 20 },  '500': { L: 0.65, C: 0.14, H: 20 } },
+      },
+    };
+
+    // Spy on document style updates by calling the method and ensuring no throw
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+
+  it('parses string JSON with ev-* keys', () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    const payload = JSON.stringify({
+      'ev-main': { '500': { L: 0.75, C: 0.1, H: 200 }, raw: { L: 0.75, C: 0.1, H: 200 } },
+      'ev-sec':  { '500': { L: 0.7, C: 0.12, H: 260 }, raw: { L: 0.7, C: 0.12, H: 260 } },
+      'ev-acc':  { '500': { L: 0.65, C: 0.14, H: 20 }, raw: { L: 0.65, C: 0.14, H: 20 } },
+    });
+    // @ts-ignore private
+    (svc as any).selectedEvent = { ...baseEvent, event_colours: payload };
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+
+  it('accepts plain main/sec/acc', () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    // @ts-ignore private
+    (svc as any).selectedEvent = {
+      ...baseEvent,
+      event_colours: {
+        main: { '500': { L: 0.75, C: 0.1, H: 200 } },
+        sec:  { '500': { L: 0.7, C: 0.12, H: 260 } },
+        acc:  { '500': { L: 0.65, C: 0.14, H: 20 } },
+      },
+    };
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+
+  it('clears when invalid structure', () => {
+    const supabase = createSupabaseMock();
+    const svc = new EventService(supabase, null, null, 'APP', { id: 'org1' } as any, () => {});
+    // @ts-ignore private
+    (svc as any).selectedEvent = { ...baseEvent, event_colours: { something: {} } };
+    expect(() => (svc as any).updateThemeForSelectedEvent()).not.toThrow();
+  });
+});
+
+