@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/providers/OrganisationProvider.tsx

@@ -1,19 +1,83 @@
 /**
- * @file Re-export for OrganisationProvider
+ * @file Organisation Provider
  * @package @jmruthers/pace-core
  * @module Providers
  * @since 0.1.0
+ *
+ * React provider for organisation context.
+ * This is a convenience wrapper around OrganisationServiceProvider that
+ * automatically gets auth context from UnifiedAuthProvider.
  * 
- * Re-exports the service-based OrganisationProvider for backward compatibility.
+ * Note: If you're using UnifiedAuthProvider, it already includes
+ * OrganisationServiceProvider internally, so this component is mainly
+ * for backward compatibility or standalone usage.
  */
 
-export { OrganisationServiceProvider as OrganisationProvider } from './services/OrganisationServiceProvider';
-export type { OrganisationServiceProviderProps as OrganisationProviderProps } from './services/OrganisationServiceProvider';
+import React from 'react';
+import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
+import { OrganisationServiceProvider } from './services/OrganisationServiceProvider';
+import type { OrganisationProviderProps as BaseOrganisationProviderProps } from '../types/organisation';
 
-// Re-export context and hook
-export { OrganisationServiceContext, useOrganisationService } from './services/OrganisationServiceProvider';
-export type { OrganisationServiceContextType } from './services/OrganisationServiceProvider';
+export interface OrganisationProviderProps extends BaseOrganisationProviderProps {
+  children: React.ReactNode;
+  requireOrganisationContext?: boolean;
+  autoSelectPrimaryOrganisation?: boolean;
+  onOrganisationChange?: (organisation: any) => void;
+}
 
-// Re-export convenience hook for backward compatibility
-export { useOrganisations } from '../hooks/useOrganisations';
+/**
+ * OrganisationProvider component
+ * 
+ * Wraps OrganisationServiceProvider and automatically gets auth context.
+ * 
+ * @example
+ * ```tsx
+ * <UnifiedAuthProvider supabaseClient={supabase} appName="my-app">
+ *   <OrganisationProvider>
+ *     <App />
+ *   </OrganisationProvider>
+ * </UnifiedAuthProvider>
+ * ```
+ */
+export function OrganisationProvider({ 
+  children,
+  requireOrganisationContext,
+  autoSelectPrimaryOrganisation,
+  onOrganisationChange
+}: OrganisationProviderProps) {
+  // Get auth context from UnifiedAuthProvider
+  const authContext = useUnifiedAuth();
+  
+  // If we're inside UnifiedAuthProvider, it already includes OrganisationServiceProvider
+  // So we can just pass through the children
+  // However, if the auth context is not available, we need to handle that
+  if (!authContext) {
+    // If no auth context, we can't provide organisation service
+    // This might happen if used outside UnifiedAuthProvider
+    // In that case, we should probably throw an error or show a message
+    console.warn('OrganisationProvider: No auth context available. Make sure OrganisationProvider is used inside UnifiedAuthProvider.');
+    return <>{children}</>;
+  }
+
+  const { supabase, user, session } = authContext;
+
+  // Wrap with OrganisationServiceProvider
+  // Note: The props like requireOrganisationContext, autoSelectPrimaryOrganisation
+  // are handled by the OrganisationService internally, not by the provider
+  // Note: supabase is mapped to supabaseClient for OrganisationServiceProvider
+  if (!supabase) {
+    console.warn('OrganisationProvider: No supabase client available.');
+    return <>{children}</>;
+  }
+
+  return (
+    <OrganisationServiceProvider
+      supabaseClient={supabase}
+      user={user}
+      session={session}
+    >
+      {children}
+    </OrganisationServiceProvider>
+  );
+}
 

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

@@ -72,22 +72,122 @@ vi.mock('../../hooks/services/useInactivityService', () => ({
 }));
 
 // Import after mocks so provider uses mocked modules
-import { UnifiedAuthProvider, useUnifiedAuth } from './UnifiedAuthProvider';
+import { UnifiedAuthProvider, useUnifiedAuth } from './services/UnifiedAuthProvider';
 
 // Mock all the child providers with simple implementations
 // Mock service providers actually used by UnifiedAuthProvider
-vi.mock('./services/AuthServiceProvider', () => ({
-  AuthServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="auth-provider">{children}</div>,
-}));
-vi.mock('./services/OrganisationServiceProvider', () => ({
-  OrganisationServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="org-provider">{children}</div>,
-}));
-vi.mock('./services/EventServiceProvider', () => ({
-  EventServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="event-provider">{children}</div>,
-}));
-vi.mock('./services/InactivityServiceProvider', () => ({
-  InactivityServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="inactivity-provider">{children}</div>,
-}));
+vi.mock('./services/AuthServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/AuthServiceProvider')>();
+  const React = await import('react');
+  const mockAuthService = {
+    getUser: () => null,
+    getSession: () => null,
+    isLoading: () => false,
+    getError: () => null,
+    getSupabaseClient: () => ({}),
+    signIn: vi.fn(),
+    signUp: vi.fn(),
+    signOut: vi.fn(),
+    resetPassword: vi.fn(),
+    updatePassword: vi.fn(),
+    refreshSession: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+    getSessionRestorationState: () => ({ isRestoring: false, restorationComplete: false, restorationError: null }),
+  };
+  return {
+    ...actual,
+    AuthServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.AuthServiceContext.Provider value={{ authService: mockAuthService, sessionRestoration: { isRestoring: false, restorationComplete: false, restorationError: null } }}>
+        <div data-testid="auth-provider">{children}</div>
+      </actual.AuthServiceContext.Provider>
+    ),
+  };
+});
+vi.mock('./services/OrganisationServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/OrganisationServiceProvider')>();
+  const React = await import('react');
+  const mockOrganisationService = {
+    getSelectedOrganisation: () => null,
+    getOrganisations: () => [],
+    getUserMemberships: () => [],
+    isLoading: () => false,
+    getError: () => null,
+    hasValidOrganisationContext: () => false,
+    isContextReady: () => false,
+    switchOrganisation: vi.fn(),
+    getUserRole: vi.fn(),
+    validateOrganisationAccess: vi.fn(),
+    refreshOrganisations: vi.fn(),
+    ensureOrganisationContext: vi.fn(),
+    isOrganisationSecure: vi.fn(),
+    getPrimaryOrganisation: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+  };
+  return {
+    ...actual,
+    OrganisationServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.OrganisationServiceContext.Provider value={{ organisationService: mockOrganisationService }}>
+        <div data-testid="org-provider">{children}</div>
+      </actual.OrganisationServiceContext.Provider>
+    ),
+  };
+});
+vi.mock('./services/EventServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/EventServiceProvider')>();
+  const React = await import('react');
+  const mockEventService = {
+    getEvents: () => [],
+    getSelectedEvent: () => null,
+    isLoading: () => false,
+    getError: () => null,
+    setSelectedEvent: vi.fn(),
+    refreshEvents: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+  };
+  return {
+    ...actual,
+    EventServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.EventServiceContext.Provider value={{ eventService: mockEventService }}>
+        <div data-testid="event-provider">{children}</div>
+      </actual.EventServiceContext.Provider>
+    ),
+  };
+});
+vi.mock('./services/InactivityServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/InactivityServiceProvider')>();
+  const React = await import('react');
+  const mockInactivityService = {
+    getShowInactivityWarning: () => false,
+    getInactivityTimeRemaining: () => 0,
+    isIdle: () => false,
+    getTimeRemaining: () => 30 * 60 * 1000,
+    isWarningShown: () => false,
+    isTracking: () => false,
+    resetActivity: vi.fn(),
+    startTracking: vi.fn(),
+    stopTracking: vi.fn(),
+    handleIdleLogout: vi.fn(),
+    handleStaySignedIn: vi.fn(),
+    handleSignOutNow: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+  };
+  return {
+    ...actual,
+    InactivityServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.InactivityServiceContext.Provider value={{ inactivityService: mockInactivityService }}>
+        <div data-testid="inactivity-provider">{children}</div>
+      </actual.InactivityServiceContext.Provider>
+    ),
+  };
+});
 
 // No RBAC provider composition in UnifiedAuthProvider now; remove that assertion
 

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

@@ -6,7 +6,8 @@
 import React from 'react';
 import { render, screen, fireEvent } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { AuthServiceProvider as AuthProvider, useAuthService as useAuth } from '../services/AuthServiceProvider';
+import { AuthServiceProvider as AuthProvider } from '../services/AuthServiceProvider';
+import { useAuthService as useAuth } from '../../hooks/services/useAuthService';
 import { TEST_FIXTURES } from '../../__tests__/fixtures/test-data';
 
 // Mock the debug logger

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

@@ -6,7 +6,8 @@
 import React from 'react';
 import { render, screen, fireEvent } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { EventProvider, useEvents } from '../EventProvider';
+import { EventServiceProvider } from '../services/EventServiceProvider';
+import { useEvents } from '../../hooks/useEvents';
 import { TEST_FIXTURES } from '../../__tests__/fixtures/test-data';
 
 // Mock the debug logger
@@ -30,14 +31,16 @@ const mockUnifiedAuthState = {
   setSelectedEventId: vi.fn(),
 };
 
-vi.mock('../UnifiedAuthProvider', () => ({
-  useUnifiedAuth: () => ({
-    user: mockUnifiedAuthState.user,
-    session: mockUnifiedAuthState.session,
-    supabase: mockUnifiedAuthState.supabase,
-    appName: mockUnifiedAuthState.appName,
-    setSelectedEventId: mockUnifiedAuthState.setSelectedEventId,
-  }),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: mockUnifiedAuthState.user,
+  session: mockUnifiedAuthState.session,
+  supabase: mockUnifiedAuthState.supabase,
+  appName: mockUnifiedAuthState.appName,
+  setSelectedEventId: mockUnifiedAuthState.setSelectedEventId,
+}));
+vi.mock('../services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Mock OrganisationProvider
@@ -46,7 +49,7 @@ const mockOrganisationState = {
   ensureOrganisationContext: vi.fn(),
 };
 
-vi.mock('../OrganisationProvider', () => ({
+vi.mock('../../hooks/useOrganisations', () => ({
   useOrganisations: () => ({
     selectedOrganisation: mockOrganisationState.selectedOrganisation,
     ensureOrganisationContext: mockOrganisationState.ensureOrganisationContext,
@@ -130,9 +133,16 @@ const TestWrapper = ({
   mockOrganisationState.selectedOrganisation = selectedOrganisation;
 
   return (
-    <EventProvider supabaseClient={supabaseClient}>
+    <EventServiceProvider 
+      supabaseClient={supabaseClient || createMockSupabaseClient()}
+      user={user}
+      session={session}
+      appName={appName}
+      selectedOrganisation={selectedOrganisation}
+      setSelectedEventId={mockUnifiedAuthState.setSelectedEventId}
+    >
       {children}
-    </EventProvider>
+    </EventServiceProvider>
   );
 };
 
@@ -270,9 +280,8 @@ describe('EventProvider', () => {
       };
 
       render(<TestOutsideProvider />);
-      // The hook might not throw an error in this test environment
-      // Just verify the component renders
-      expect(screen.getByTestId('no-error')).toBeInTheDocument();
+      // The hook should throw an error when used outside the provider
+      expect(screen.getByTestId('error')).toHaveTextContent('useEventService must be used within EventServiceProvider');
     });
   });
 

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

@@ -4,9 +4,10 @@
  */
 
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { OrganisationProvider, useOrganisations } from '../OrganisationProvider';
+import { OrganisationServiceProvider } from '../services/OrganisationServiceProvider';
+import { useOrganisations } from '../../hooks/useOrganisations';
 import { TEST_FIXTURES } from '../../__tests__/fixtures/test-data';
 
 // Mock the debug logger
@@ -16,30 +17,68 @@ vi.mock('../../utils/debugLogger', () => ({
   },
 }));
 
+// Mock setOrganisationContext
+vi.mock('../../utils/context/organisationContext', () => ({
+  setOrganisationContext: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Create mock user and session
+const mockUser = {
+  id: '123e4567-e89b-12d3-a456-426614174001', // Valid UUID format
+  email: 'test@example.com',
+} 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 = () => ({
-  from: vi.fn(() => ({
-    select: vi.fn(() => ({
-      eq: vi.fn(() => ({
-        data: [
-          {
-            organisation_id: 'org-1',
-            organisation_name: 'Test Organisation 1',
-            role: 'admin',
-            is_primary: true,
-          },
-          {
-            organisation_id: 'org-2',
-            organisation_name: 'Test Organisation 2',
-            role: 'user',
-            is_primary: false,
-          },
-        ],
-        error: null,
-      })),
-    })),
-  })),
-});
+const createMockSupabaseClient = () => {
+  const orgId = '123e4567-e89b-12d3-a456-426614174000'; // Valid UUID format
+  const userId = '123e4567-e89b-12d3-a456-426614174001'; // Valid UUID format
+  
+  return {
+    rpc: vi.fn().mockResolvedValue({
+      data: [
+        {
+          user_id: userId,
+          organisation_id: orgId,
+          role: 'org_admin',
+          status: 'active',
+        },
+      ],
+      error: null,
+    }),
+    from: vi.fn((table: string) => {
+      if (table === 'organisations') {
+        return {
+          select: vi.fn().mockResolvedValue({
+            data: [
+              {
+                id: orgId,
+                name: 'Test Organisation 1',
+                display_name: 'Test Organisation 1',
+                subscription_tier: 'basic',
+                settings: {},
+                is_active: true,
+                parent_id: null,
+                created_at: '2023-01-01T00:00:00Z',
+                updated_at: '2023-01-01T00:00:00Z',
+              },
+            ],
+            error: null,
+          }),
+        };
+      }
+      return {
+        select: vi.fn().mockResolvedValue({ data: [], error: null }),
+      };
+    }),
+  };
+};
 
 // Test component that uses the organisation context
 const TestComponent = () => {
@@ -50,7 +89,7 @@ const TestComponent = () => {
       <div data-testid="organisations-count">{org.organisations.length}</div>
       <div data-testid="isLoading">{org.isLoading ? 'true' : 'false'}</div>
       <div data-testid="error">{org.error?.message || 'no-error'}</div>
-      <div data-testid="selectedOrg">{org.selectedOrganisation?.organisation_name || 'no-org'}</div>
+      <div data-testid="selectedOrg">{org.selectedOrganisation?.name || org.selectedOrganisation?.display_name || 'no-org'}</div>
       <div data-testid="hasValidContext">{org.hasValidOrganisationContext ? 'true' : 'false'}</div>
       <div data-testid="hasSetSelectedOrg">{typeof org.setSelectedOrganisation === 'function' ? 'true' : 'false'}</div>
       <div data-testid="hasRefreshOrg">{typeof org.refreshOrganisations === 'function' ? 'true' : 'false'}</div>
@@ -62,8 +101,8 @@ const TestComponent = () => {
 const TestWrapper = ({ 
   children, 
   supabaseClient, 
-  user = null, 
-  session = null 
+  user = mockUser, 
+  session = mockSession 
 }: { 
   children: React.ReactNode; 
   supabaseClient?: any;
@@ -71,9 +110,9 @@ const TestWrapper = ({
   session?: any;
 }) => {
   return (
-    <OrganisationProvider supabaseClient={supabaseClient} user={user} session={session}>
+    <OrganisationServiceProvider supabaseClient={supabaseClient || createMockSupabaseClient()} user={user} session={session}>
       {children}
-    </OrganisationProvider>
+    </OrganisationServiceProvider>
   );
 };
 
@@ -86,7 +125,7 @@ describe('OrganisationProvider', () => {
   });
 
   describe('Rendering', () => {
-    it('renders without crashing', () => {
+    it('renders without crashing', async () => {
       render(
         <TestWrapper supabaseClient={mockSupabaseClient}>
           <TestComponent />
@@ -94,7 +133,12 @@ describe('OrganisationProvider', () => {
       );
 
       expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+      
+      // Wait for organisations to load
+      await waitFor(() => {
+        expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('isLoading')).toHaveTextContent('false');
       expect(screen.getByTestId('error')).toHaveTextContent('no-error');
     });
@@ -111,18 +155,24 @@ describe('OrganisationProvider', () => {
   });
 
   describe('Context Values', () => {
-    it('provides all required context values', () => {
+    it('provides all required context values', async () => {
       render(
         <TestWrapper supabaseClient={mockSupabaseClient}>
           <TestComponent />
         </TestWrapper>
       );
 
+      // Wait for organisations to load and selected organisation to be set
+      await waitFor(() => {
+        expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+        expect(screen.getByTestId('selectedOrg')).not.toHaveTextContent('no-org');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
       expect(screen.getByTestId('isLoading')).toHaveTextContent('false');
       expect(screen.getByTestId('error')).toHaveTextContent('no-error');
-      expect(screen.getByTestId('selectedOrg')).toHaveTextContent('no-org');
-      expect(screen.getByTestId('hasValidContext')).toHaveTextContent('false');
+      expect(screen.getByTestId('selectedOrg')).not.toHaveTextContent('no-org');
+      expect(screen.getByTestId('hasValidContext')).toHaveTextContent('true');
       expect(screen.getByTestId('hasSetSelectedOrg')).toHaveTextContent('true');
       expect(screen.getByTestId('hasRefreshOrg')).toHaveTextContent('true');
     });
@@ -158,7 +208,8 @@ describe('OrganisationProvider', () => {
       );
 
       expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+      // Without supabase client, organisations won't load, so count should be 0
+      expect(screen.getByTestId('organisations-count')).toHaveTextContent('0');
     });
 
     it('handles missing user', () => {