@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/providers/__tests__/UnifiedAuthProvider.test.tsx

@@ -6,7 +6,7 @@
 import React from 'react';
 import { render, screen, waitFor } from '@testing-library/react';
 import { vi, describe, it, expect } from 'vitest';
-import { UnifiedAuthProvider, useUnifiedAuth } from '../UnifiedAuthProvider';
+import { UnifiedAuthProvider, useUnifiedAuth } from '../services/UnifiedAuthProvider';
 
 // Mock the debug logger
 vi.mock('../../utils/debugLogger', () => ({
@@ -15,11 +15,35 @@ vi.mock('../../utils/debugLogger', () => ({
   },
 }));
 
+// Create mock user and session
+const mockUser = {
+  id: 'test-user-id',
+  email: 'test@example.com',
+  user_metadata: {},
+  app_metadata: {},
+} as any;
+
+const mockSession = {
+  access_token: 'test-token',
+  refresh_token: 'test-refresh-token',
+  user: mockUser,
+  expires_at: Date.now() + 3600000,
+} as any;
+
 // Create mock Supabase client
 const createMockSupabaseClient = () => ({
   auth: {
-    getSession: vi.fn(),
-    onAuthStateChange: vi.fn(),
+    getSession: vi.fn().mockResolvedValue({
+      data: { session: mockSession },
+      error: null
+    }),
+    getUser: vi.fn().mockResolvedValue({
+      data: { user: mockUser },
+      error: null
+    }),
+    onAuthStateChange: vi.fn().mockReturnValue({
+      data: { subscription: { unsubscribe: vi.fn() } }
+    }),
     signInWithPassword: vi.fn(),
     signUp: vi.fn(),
     signOut: vi.fn(),
@@ -47,12 +71,22 @@ const TestComponent = () => {
 };
 
 describe('UnifiedAuthProvider', () => {
-  const mockSupabaseClient = createMockSupabaseClient();
+  let mockSupabaseClient: ReturnType<typeof createMockSupabaseClient>;
+  const defaultProps = {
+    idleTimeoutMs: 30 * 60 * 1000,
+    warnBeforeMs: 60 * 1000,
+    onIdleLogout: vi.fn(),
+  };
+
+  beforeEach(() => {
+    // Create a fresh mock client for each test
+    mockSupabaseClient = createMockSupabaseClient();
+  });
 
   describe('Rendering', () => {
     it('renders without crashing', () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
@@ -62,7 +96,7 @@ describe('UnifiedAuthProvider', () => {
 
     it('renders with custom app name', () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Custom App">
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Custom App" {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
@@ -84,15 +118,15 @@ describe('UnifiedAuthProvider', () => {
   describe('Context Values', () => {
     it('provides all required context values', async () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
 
-      // Wait for services to initialize
+      // Wait for services to initialize and user/session to be loaded
       await waitFor(() => {
-        expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      });
+        expect(screen.getByTestId('hasUser')).toHaveTextContent('true');
+      }, { timeout: 3000 });
 
       expect(screen.getByTestId('hasUser')).toHaveTextContent('true');
       expect(screen.getByTestId('hasSession')).toHaveTextContent('true');
@@ -148,7 +182,7 @@ describe('UnifiedAuthProvider', () => {
 
     it('uses default configuration', () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
@@ -158,7 +192,7 @@ describe('UnifiedAuthProvider', () => {
   });
 
   describe('[integration] Provider Composition', () => {
-    it('composes with child providers without errors', () => {
+    it('composes with child providers without errors', async () => {
       const TestCompositionComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -173,16 +207,20 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestCompositionComponent />
         </UnifiedAuthProvider>
       );
 
       expect(screen.getByTestId('composition-success')).toHaveTextContent('composed');
-      expect(screen.getByTestId('has-all-contexts')).toHaveTextContent('yes');
+      
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('has-all-contexts')).toHaveTextContent('yes');
+      }, { timeout: 3000 });
     });
 
-    it('provides complete unified context', () => {
+    it('provides complete unified context', async () => {
       const TestCompleteContextComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -198,11 +236,16 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestCompleteContextComponent />
         </UnifiedAuthProvider>
       );
 
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('user-context')).toHaveTextContent('present');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('user-context')).toHaveTextContent('present');
       expect(screen.getByTestId('session-context')).toHaveTextContent('present');
       expect(screen.getByTestId('organisation-context')).toHaveTextContent('missing');
@@ -368,7 +411,7 @@ describe('UnifiedAuthProvider', () => {
   });
 
   describe('[integration] Hook Integration', () => {
-    it('integrates useUnifiedAuth with all contexts', () => {
+    it('integrates useUnifiedAuth with all contexts', async () => {
       const TestHookIntegrationComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -385,11 +428,16 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestHookIntegrationComponent />
         </UnifiedAuthProvider>
       );
 
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('hook-access')).toHaveTextContent('full');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('hook-access')).toHaveTextContent('full');
       expect(screen.getByTestId('hook-methods')).toHaveTextContent('complete');
     });
@@ -427,7 +475,7 @@ describe('UnifiedAuthProvider', () => {
       expect(screen.getByTestId('user-stable')).toHaveTextContent('stable');
     });
 
-    it('handles concurrent hook usage', () => {
+    it('handles concurrent hook usage', async () => {
       const TestConcurrentComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -446,13 +494,17 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestConcurrentComponent />
         </UnifiedAuthProvider>
       );
 
       expect(screen.getByTestId('concurrent-safe')).toHaveTextContent('safe');
-      expect(screen.getByTestId('all-reads')).toHaveTextContent('success');
+      
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('all-reads')).toHaveTextContent('success');
+      }, { timeout: 3000 });
     });
   });
 
@@ -485,7 +537,7 @@ describe('UnifiedAuthProvider', () => {
       expect(screen.getByTestId('app-name-consistent')).toHaveTextContent('consistent');
     });
 
-    it('configures RBAC features when enabled', () => {
+    it('configures RBAC features when enabled', async () => {
       const TestRBACConfigComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -502,12 +554,16 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} enableRBAC={true}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" enableRBAC={true} {...defaultProps}>
           <TestRBACConfigComponent />
         </UnifiedAuthProvider>
       );
 
-      expect(screen.getByTestId('rbac-enabled')).toHaveTextContent('enabled');
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('rbac-enabled')).toHaveTextContent('enabled');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('session-available')).toBeInTheDocument();
     });
 

package/src/providers/index.ts

@@ -12,6 +12,3 @@ export * from './services/EventServiceProvider';
 export * from './services/OrganisationServiceProvider';
 export * from './services/InactivityServiceProvider';
 export * from './services/AuthServiceProvider';
-
-// RBAC Provider - Use @jmruthers/pace-core/rbac instead
-// Note: RBAC functionality has been moved to the dedicated RBAC module

package/src/providers/services/AuthServiceProvider.tsx

@@ -8,7 +8,7 @@
  * Provides authentication service instance to React components.
  */
 
-import React, { createContext, useContext, useMemo, useEffect, useState } from 'react';
+import React, { createContext, useMemo, useEffect, useState } from 'react';
 import { type SupabaseClient } from '@supabase/supabase-js';
 import { AuthService } from '../../services/AuthService';
 import type { SessionRestorationState } from '../../types/auth';
@@ -44,11 +44,6 @@ export function AuthServiceProvider({ children, supabaseClient, appName }: AuthS
     const unsubscribe = authService.subscribe(() => {
       const restorationState = authService.getSessionRestorationState();
       setSessionRestoration(restorationState);
-
-      const isDev = typeof import.meta !== 'undefined' && (import.meta.env.DEV || import.meta.env.MODE === 'development');
-      if (isDev) {
-        logger.debug('AuthServiceProvider', 'Session restoration state updated', restorationState);
-      }
     });
 
     return () => {
@@ -78,14 +73,4 @@ export function AuthServiceProvider({ children, supabaseClient, appName }: AuthS
       {children}
     </AuthServiceContext.Provider>
   );
-}
-
-export const useAuthService = (): AuthService => {
-  const context = useContext(AuthServiceContext);
-  
-  if (!context) {
-    throw new Error('useAuthService must be used within AuthServiceProvider');
-  }
-  
-  return context.authService;
-};
+}

package/src/providers/services/EventServiceProvider.tsx

@@ -8,19 +8,17 @@
  * Provides event service instance to React components.
  */
 
-import React, { createContext, useContext, useMemo, useEffect, useRef } from 'react';
+import React, { createContext, useMemo, useEffect, useRef } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { EventService } from '../../services/EventService';
 import { logger } from '../../utils/core/logger';
+import type { Organisation } from '../../types/organisation';
 
 // Context type
 export interface EventServiceContextType {
   eventService: EventService;
 }
 
-// Backward compatibility type alias
-export type EventContextType = EventServiceContextType;
-
 export const EventServiceContext = createContext<EventServiceContextType | null>(null);
 
 export interface EventServiceProviderProps {
@@ -29,7 +27,7 @@ export interface EventServiceProviderProps {
   user: User | null;
   session: Session | null;
   appName: string;
-  selectedOrganisation: any;
+  selectedOrganisation: Organisation | null;
   setSelectedEventId: (eventId: string | null) => void;
 }
 
@@ -76,6 +74,13 @@ export function EventServiceProvider({
     };
   }, [eventService, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
 
+  // Cleanup service on unmount only
+  useEffect(() => {
+    return () => {
+      eventService.cleanup();
+    };
+  }, [eventService]);
+
   const contextValue = useMemo(() => ({
     eventService
   }), [eventService]);
@@ -85,14 +90,4 @@ export function EventServiceProvider({
       {children}
     </EventServiceContext.Provider>
   );
-}
-
-export const useEventService = (): EventService => {
-  const context = useContext(EventServiceContext);
-  
-  if (!context) {
-    throw new Error('useEventService must be used within EventServiceProvider');
-  }
-  
-  return context.eventService;
-};
+}

package/src/providers/services/InactivityServiceProvider.tsx

@@ -8,7 +8,7 @@
  * Provides inactivity service instance to React components.
  */
 
-import React, { createContext, useContext, useMemo, useEffect, useRef } from 'react';
+import React, { createContext, useMemo, useEffect, useRef } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { InactivityService } from '../../services/InactivityService';
 import { logger } from '../../utils/core/logger';
@@ -66,6 +66,13 @@ export function InactivityServiceProvider({
     };
   }, [inactivityService, supabaseClient, user, session, idleTimeoutMs, warnBeforeMs, onIdleLogout]);
 
+  // Cleanup service on unmount only
+  useEffect(() => {
+    return () => {
+      inactivityService.cleanup();
+    };
+  }, [inactivityService]);
+
   const contextValue = useMemo(() => ({
     inactivityService
   }), [inactivityService]);
@@ -75,14 +82,4 @@ export function InactivityServiceProvider({
       {children}
     </InactivityServiceContext.Provider>
   );
-}
-
-export const useInactivityService = (): InactivityService => {
-  const context = useContext(InactivityServiceContext);
-  
-  if (!context) {
-    throw new Error('useInactivityService must be used within InactivityServiceProvider');
-  }
-  
-  return context.inactivityService;
-};
+}

package/src/providers/services/OrganisationServiceProvider.tsx

@@ -8,7 +8,7 @@
  * Provides organisation service instance to React components.
  */
 
-import React, { createContext, useContext, useMemo, useEffect, useRef } from 'react';
+import React, { createContext, useMemo, useEffect, useRef } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { OrganisationService } from '../../services/OrganisationService';
 import { logger } from '../../utils/core/logger';
@@ -60,6 +60,13 @@ export function OrganisationServiceProvider({
     };
   }, [organisationService, user, session]);
 
+  // Cleanup service on unmount only
+  useEffect(() => {
+    return () => {
+      organisationService.cleanup();
+    };
+  }, [organisationService]);
+
   const contextValue = useMemo(() => ({
     organisationService
   }), [organisationService]);
@@ -69,14 +76,4 @@ export function OrganisationServiceProvider({
       {children}
     </OrganisationServiceContext.Provider>
   );
-}
-
-export const useOrganisationService = (): OrganisationService => {
-  const context = useContext(OrganisationServiceContext);
-  
-  if (!context) {
-    throw new Error('useOrganisationService must be used within OrganisationServiceProvider');
-  }
-  
-  return context.organisationService;
-};
+}

package/src/providers/services/UnifiedAuthProvider.tsx

@@ -8,7 +8,7 @@
  * Note: RBAC functionality is available via useRBAC() hook from '@jmruthers/pace-core/rbac'
  */
 
-import React, { createContext, useContext, useMemo, useCallback, useRef } from 'react';
+import React, { createContext, useContext, useMemo, useCallback, useRef, useEffect, useState } from 'react';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { AuthServiceProvider } from './AuthServiceProvider';
 import { OrganisationServiceProvider } from './OrganisationServiceProvider';
@@ -20,7 +20,7 @@ import { useEventService } from '../../hooks/services/useEventService';
 import { useInactivityService } from '../../hooks/services/useInactivityService';
 import { useSessionRestoration } from '../../hooks/useSessionRestoration';
 import type { Organisation, OrganisationMembership } from '../../types/organisation';
-import type { Event } from '../../types/unified';
+import type { Event } from '../../types/event';
 import type { AuthError } from '@supabase/supabase-js';
 import type { SessionRestorationState } from '../../types/auth';
 import { logger } from '../../utils/core/logger';
@@ -47,9 +47,12 @@ export interface UnifiedAuthContextType {
   isAuthenticated: boolean;
   authLoading: boolean;
   authError: AuthError | null;
-  error: AuthError | null; // Alias for authError for backward compatibility
   supabase: SupabaseClient | null;
   
+  // App context (resolved immediately on login)
+  appName: string;
+  appId: string | undefined; // Resolved from appName when user logs in
+  
   // Auth methods
   signIn: (email: string, password?: string) => Promise<{ error: AuthError | null }>;
   signUp: (email: string, password: string) => Promise<{ error: AuthError | null }>;
@@ -103,7 +106,6 @@ export interface UnifiedAuthContextType {
   handleSignOutNow: () => Promise<void>;
 
   // Additional unified properties
-  appName: string;
   appConfig: { requires_event: boolean } | null;
   isLoading: boolean;
   hasErrors: boolean;
@@ -191,6 +193,68 @@ function UnifiedAuthContextProvider({
   const currentUser = authService.getUser();
   const currentSession = authService.getSession();
   const isAuth = !!(currentUser && currentSession);
+  
+  // Get supabase client early so we can use it in useEffect
+  const supabase = authService.getSupabaseClient();
+  
+  // Resolve appId immediately when user logs in (don't wait for organisation/event)
+  // This makes appId available early for navigation menu filtering
+  const [appId, setAppId] = useState<string | undefined>(undefined);
+  const isResolvingAppIdRef = useRef(false);
+  
+  useEffect(() => {
+    // Resolve appId as soon as we have user + supabase + appName
+    // Don't wait for organisation or event - appId resolution only needs user + appName
+    if (
+      isAuth &&
+      currentUser?.id &&
+      supabase &&
+      appName &&
+      !appId &&
+      !isResolvingAppIdRef.current
+    ) {
+      isResolvingAppIdRef.current = true;
+      const userId = currentUser.id;
+      const appNameValue = appName;
+      
+      // Resolve appId immediately
+      import('../../rbac/api').then(async ({ resolveAppContext, setupRBAC }) => {
+        try {
+          // Ensure RBAC is initialized (idempotent - safe to call multiple times)
+          setupRBAC(supabase);
+          
+          const result = await resolveAppContext({
+            userId,
+            appName: appNameValue
+          });
+          
+          if (result?.appId) {
+            setAppId(result.appId);
+            logger.debug('UnifiedAuthProvider', 'appId resolved on login', {
+              appId: result.appId,
+              appName: appNameValue
+            });
+          }
+        } catch (error) {
+          logger.error('UnifiedAuthProvider', 'Failed to resolve appId on login', {
+            error: error instanceof Error ? error.message : String(error),
+            appName: appNameValue,
+            userId
+          });
+        } finally {
+          isResolvingAppIdRef.current = false;
+        }
+      }).catch((importError) => {
+        logger.error('UnifiedAuthProvider', 'Failed to import RBAC API', importError);
+        isResolvingAppIdRef.current = false;
+      });
+    }
+    
+    // Clear appId when user logs out
+    if (!isAuth) {
+      setAppId(undefined);
+    }
+  }, [isAuth, currentUser?.id, supabase, appName, appId]);
 
   // Get loading states - these will trigger re-renders when services change
   const authLoading = authService.isLoading();
@@ -201,7 +265,7 @@ function UnifiedAuthContextProvider({
   
   // Extract all primitive values from services to use in dependencies
   const authError = authService.getError();
-  const supabase = authService.getSupabaseClient();
+  // supabase is already declared above (line 198)
   const selectedOrganisation = organisationService.getSelectedOrganisation();
   const organisations = organisationService.getOrganisations();
   const userMemberships = organisationService.getUserMemberships();
@@ -266,18 +330,7 @@ function UnifiedAuthContextProvider({
         prevState.isAuthenticated !== currentState.isAuthenticated ||
         prevState.userEmail !== currentState.userEmail ||
         prevState.totalLoading !== currentState.totalLoading) {
-      logger.debug('UnifiedAuthContext', 'Auth state changed:', {
-        isAuthenticated: isAuth,
-        user: currentUser?.email,
-        session: currentSession ? 'exists' : 'null',
-        totalLoading,
-        authLoading,
-        orgLoading,
-        eventLoading,
-        orgContextReady: isContextReady,
-        sessionRestoration,
-        sessionRestorationTimedOut,
-      });
+      // State change detected, notify subscribers
       prevStateRef.current = currentState;
     }
   }
@@ -291,7 +344,6 @@ function UnifiedAuthContextProvider({
     isAuthenticated: isAuth,
     authLoading: authLoading,
     authError: authError,
-    error: authError, // Alias for backward compatibility
     supabase: supabase,
     
     // Auth methods
@@ -348,6 +400,7 @@ function UnifiedAuthContextProvider({
 
     // Additional unified properties
     appName,
+    appId, // Resolved immediately on login
     appConfig: appConfig,
     isLoading: totalLoading,
     hasErrors: hasErrors,
@@ -384,6 +437,7 @@ function UnifiedAuthContextProvider({
     totalLoading,
     hasErrors,
     appName,
+    appId,
     appConfig,
     sessionRestoration,
     sessionRestorationTimedOut,
@@ -526,6 +580,19 @@ export function UnifiedAuthProvider({
   renderInactivityWarning,
   dangerouslyDisableInactivity = false
 }: UnifiedAuthProviderProps) {
+  // Warn if supabaseClient reference changes (indicates multiple client instances)
+  const clientRef = useRef(supabaseClient);
+  useEffect(() => {
+    if (clientRef.current !== supabaseClient) {
+      logger.warn('UnifiedAuthProvider', 'Supabase client reference changed - this may indicate multiple client instances are being created', {
+        previousClient: clientRef.current,
+        newClient: supabaseClient,
+        note: 'Ensure you create the Supabase client once and reuse it. Creating multiple clients can cause performance issues and the "Multiple GoTrueClient instances" warning.'
+      });
+      clientRef.current = supabaseClient;
+    }
+  }, [supabaseClient]);
+
   return (
     <AuthServiceProvider supabaseClient={supabaseClient} appName={appName}>
       <ServiceAwareProviders

package/src/providers/services/__tests__/AuthServiceProvider.integration.test.tsx

@@ -11,7 +11,8 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
-import { AuthServiceProvider, useAuthService } from '../AuthServiceProvider';
+import { AuthServiceProvider } from '../AuthServiceProvider';
+import { useAuthService } from '../../../hooks/services/useAuthService';
 import { type SupabaseClient, type User, type Session } from '@supabase/supabase-js';
 import { Logger, LogLevel } from '../../../utils/core/logger';
 
@@ -131,7 +132,9 @@ describe('AuthServiceProvider Integration', () => {
   describe('Service Integration', () => {
     it('should initialize service on mount', async () => {
       const mockSubscription = { unsubscribe: vi.fn() };
-      vi.mocked(mockSupabase.auth.onAuthStateChange).mockReturnValue(mockSubscription);
+      vi.mocked(mockSupabase.auth.onAuthStateChange).mockReturnValue({
+        data: { subscription: mockSubscription }
+      } as any);
 
       render(
         <AuthServiceProvider supabaseClient={mockSupabase}>
@@ -147,7 +150,9 @@ describe('AuthServiceProvider Integration', () => {
 
     it('should cleanup service on unmount', async () => {
       const mockSubscription = { unsubscribe: vi.fn() };
-      vi.mocked(mockSupabase.auth.onAuthStateChange).mockReturnValue(mockSubscription);
+      vi.mocked(mockSupabase.auth.onAuthStateChange).mockReturnValue({
+        data: { subscription: mockSubscription }
+      } as any);
 
       const { unmount } = render(
         <AuthServiceProvider supabaseClient={mockSupabase}>
@@ -173,7 +178,9 @@ describe('AuthServiceProvider Integration', () => {
       
       vi.mocked(mockSupabase.auth.onAuthStateChange).mockImplementation((callback) => {
         capturedCallback = callback;
-        return mockSubscription;
+        return {
+          data: { subscription: mockSubscription }
+        } as any;
       });
 
       render(