@jmruthers/pace-core 0.5.189 → 0.5.191

package/src/hooks/usePermissionCache.test.ts

@@ -7,8 +7,8 @@
  * Comprehensive tests for the usePermissionCache hook covering all critical functionality.
  */
 
-import { renderHook, waitFor, act } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
 import { usePermissionCache } from './usePermissionCache';
 
 // Mock the dependencies
@@ -29,6 +29,16 @@ vi.mock('../rbac/api', () => ({
   isPermittedCached: vi.fn()
 }));
 
+const loggerSpy = vi.hoisted(() => ({
+  warn: vi.fn(),
+  error: vi.fn()
+}));
+
+vi.mock('../utils/core/logger', () => ({
+  logger: loggerSpy,
+  createLogger: () => loggerSpy
+}));
+
 import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
 import { useOrganisations } from './useOrganisations';
 import { useEvents } from './useEvents';
@@ -41,7 +51,7 @@ const mockIsPermittedCached = vi.mocked(isPermittedCached);
 describe('usePermissionCache', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    
+
     // Setup default mocks
     mockUseUnifiedAuthFn.mockReturnValue({
       user: { id: 'user-123' },
@@ -50,19 +60,19 @@ describe('usePermissionCache', () => {
       selectedOrganisationId: 'org-123',
       selectedEventId: undefined
     } as any);
-    
+
     mockUseOrganisations.mockReturnValue({
       selectedOrganisation: { id: 'org-123' }
     } as any);
-    
+
     mockUseEvents.mockReturnValue({
       selectedEvent: null
     } as any);
-    
+
     mockIsPermittedCached.mockResolvedValue(true);
   });
 
-    describe('Hook Initialization', () => {
+  describe('Hook Initialization', () => {
     it('initializes with default configuration', () => {
       const { result } = renderHook(() => usePermissionCache());
 
@@ -130,6 +140,16 @@ describe('usePermissionCache', () => {
       expect(results.every(r => r.hasPermission)).toBe(true);
     });
 
+    it('handles empty permission arrays gracefully', async () => {
+      const { result } = renderHook(() => usePermissionCache());
+
+      const results = await result.current.checkMultiplePermissions([]);
+
+      expect(results).toEqual([]);
+      expect(mockIsPermittedCached).not.toHaveBeenCalled();
+      expect(loggerSpy.warn).toHaveBeenCalled();
+    });
+
     it('handles permission check errors gracefully', async () => {
       mockIsPermittedCached.mockRejectedValueOnce(new Error('Permission check failed'));
 
@@ -137,6 +157,7 @@ describe('usePermissionCache', () => {
 
       const hasPermission = await result.current.checkPermission('read', 'users');
       expect(hasPermission).toBe(false);
+      expect(loggerSpy.error).toHaveBeenCalled();
     });
 
     it('handles missing user context gracefully', () => {
@@ -153,6 +174,23 @@ describe('usePermissionCache', () => {
       expect(result.current).toBeDefined();
       expect(result.current.checkPermission).toBeInstanceOf(Function);
     });
+
+    it('deduplicates concurrent permission checks', async () => {
+      mockIsPermittedCached.mockImplementation(
+        () => new Promise(resolve => setTimeout(() => resolve(true), 50))
+      );
+
+      const { result } = renderHook(() => usePermissionCache());
+
+      const [first, second] = await Promise.all([
+        result.current.checkPermission('read', 'users'),
+        result.current.checkPermission('read', 'users')
+      ]);
+
+      expect(first).toBe(true);
+      expect(second).toBe(true);
+      expect(mockIsPermittedCached).toHaveBeenCalledTimes(1);
+    });
   });
 
   describe('Cache Management', () => {
@@ -196,10 +234,23 @@ describe('usePermissionCache', () => {
       
       // Check again - should not use cache
       await result.current.checkPermission('read', 'users');
-      
+
       expect(mockIsPermittedCached).toHaveBeenCalledTimes(2);
     });
 
+    it('invalidates cache entries by pattern', async () => {
+      const { result } = renderHook(() => usePermissionCache());
+
+      await result.current.checkPermission('read', 'dashboard');
+      await result.current.checkPermission('read', 'admin');
+
+      result.current.invalidateCache('dashboard');
+
+      await result.current.checkPermission('read', 'dashboard');
+
+      expect(mockIsPermittedCached).toHaveBeenCalledTimes(3);
+    });
+
     it('respects max cache size', async () => {
       const { result } = renderHook(() => usePermissionCache({
         maxCacheSize: 2
@@ -246,6 +297,32 @@ describe('usePermissionCache', () => {
       expect(debugInfo.totalChecks).toBe(2);
     });
 
+    it('returns cached permissions for a page', async () => {
+      mockIsPermittedCached
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false)
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false);
+
+      const { result } = renderHook(() => usePermissionCache());
+
+      await result.current.checkMultiplePermissions([
+        ['read', 'dashboard'],
+        ['create', 'dashboard'],
+        ['update', 'dashboard'],
+        ['delete', 'dashboard']
+      ]);
+
+      const cachedPermissions = result.current.getCachedPermissions('dashboard');
+
+      expect(cachedPermissions).toEqual([
+        { operation: 'read', hasPermission: true },
+        { operation: 'create', hasPermission: false },
+        { operation: 'update', hasPermission: true },
+        { operation: 'delete', hasPermission: false }
+      ]);
+    });
+
     it('tracks average response time', async () => {
       const { result } = renderHook(() => usePermissionCache());
 

package/src/hooks/useQueryCache.ts

@@ -51,6 +51,27 @@ function runCacheCleanup() {
 if (typeof window !== 'undefined' && !cleanupTimer) {
   cleanupTimer = setInterval(runCacheCleanup, CLEANUP_INTERVAL_MS);
   log.debug('Query cache cleanup initialized.');
+  
+  // Cleanup on page unload to prevent memory leaks
+  window.addEventListener('beforeunload', () => {
+    if (cleanupTimer) {
+      clearInterval(cleanupTimer);
+      cleanupTimer = null;
+      log.debug('Query cache cleanup timer cleared on page unload.');
+    }
+  });
+}
+
+/**
+ * Manually cleanup the query cache cleanup timer
+ * Useful for testing or when the module is reloaded
+ */
+export function cleanupQueryCache(): void {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+    log.debug('Query cache cleanup timer cleared.');
+  }
 }
 
 export interface UseQueryCacheOptions {
@@ -91,12 +112,12 @@ export interface UseQueryCacheReturn {
  * const { getCachedQuery } = useQueryCache(supabase);
  * 
  * const person = await getCachedQuery(
- *   'pace_person',
+ *   'core_person',
  *   'user_id',
  *   userId,
  *   async () => {
  *     const { data } = await supabase
- *       .from('pace_person')
+ *       .from('core_person')
  *       .select('id, first_name, last_name, email')
  *       .eq('user_id', userId)
  *       .single();
@@ -199,7 +220,7 @@ export function useQueryCache(supabase?: SupabaseClient<Database>): UseQueryCach
  */
 export const queryCacheHelpers = {
   /**
-   * Cache pace_person queries by user_id
+   * Cache core_person queries by user_id
    * TTL: 5 minutes
    */
   pacePersonByUserId: <T>(
@@ -207,7 +228,7 @@ export const queryCacheHelpers = {
     userId: string,
     fetchFn: () => Promise<T>
   ): Promise<T> => {
-    const cacheKey = `pace_person:user_id:${userId}`;
+    const cacheKey = `core_person:user_id:${userId}`;
     const now = Date.now();
     const ttl = 300 * 1000; // 5 minutes
     
@@ -237,7 +258,7 @@ export const queryCacheHelpers = {
   },
   
   /**
-   * Cache pace_member queries by person_id
+   * Cache core_member queries by person_id
    * TTL: 5 minutes
    */
   paceMemberByPersonId: <T>(
@@ -245,7 +266,7 @@ export const queryCacheHelpers = {
     personId: string,
     fetchFn: () => Promise<T>
   ): Promise<T> => {
-    const cacheKey = `pace_member:person_id:${personId}`;
+    const cacheKey = `core_member:person_id:${personId}`;
     const now = Date.now();
     const ttl = 300 * 1000; // 5 minutes
     

package/src/hooks/useSecureDataAccess.test.ts

@@ -14,6 +14,8 @@ import { useUnifiedAuth } from '../providers';
 import { useOrganisations } from './useOrganisations';
 import { setOrganisationContext } from '../utils/context/organisationContext';
 import { createMockSupabaseClient, createMockQueryBuilderWithData } from '../__tests__/helpers/supabaseMock';
+import { useResolvedScope } from '../rbac/hooks/useResolvedScope';
+import { useSuperAdminBypass } from '../rbac/hooks/useSuperAdminBypass';
 
 // Mock the providers
 vi.mock('../providers', () => ({
@@ -29,11 +31,23 @@ vi.mock('../utils/context/organisationContext', () => ({
   setOrganisationContext: vi.fn()
 }));
 
+// Mock useResolvedScope
+vi.mock('../rbac/hooks/useResolvedScope', () => ({
+  useResolvedScope: vi.fn()
+}));
+
+// Mock useSuperAdminBypass
+vi.mock('../rbac/hooks/useSuperAdminBypass', () => ({
+  useSuperAdminBypass: vi.fn()
+}));
+
 
 describe('useSecureDataAccess', () => {
   const mockUseUnifiedAuth = vi.mocked(useUnifiedAuth);
   const mockUseOrganisations = vi.mocked(useOrganisations);
   const mockSetOrganisationContext = vi.mocked(setOrganisationContext);
+  const mockUseResolvedScope = vi.mocked(useResolvedScope);
+  const mockUseSuperAdminBypass = vi.mocked(useSuperAdminBypass);
 
   const mockUser = {
     id: 'user-123',
@@ -93,6 +107,22 @@ describe('useSecureDataAccess', () => {
       ensureOrganisationContext: vi.fn().mockReturnValue(mockSelectedOrganisation),
       // Add other required properties
     } as any);
+    
+    // Mock useResolvedScope to return resolved scope with organisationId
+    mockUseResolvedScope.mockReturnValue({
+      resolvedScope: {
+        organisationId: 'org-123',
+        eventId: undefined,
+        appId: undefined,
+      },
+      isLoading: false,
+      error: null,
+    });
+    
+    // Mock useSuperAdminBypass to return not super admin
+    mockUseSuperAdminBypass.mockReturnValue({
+      isSuperAdmin: false,
+    });
   });
 
     describe('Hook Initialization', () => {
@@ -113,9 +143,10 @@ describe('useSecureDataAccess', () => {
       expect(mockUseUnifiedAuth).toHaveBeenCalled();
     });
 
-    it('depends on useOrganisations hook', () => {
+    it('depends on useResolvedScope hook', () => {
       renderHook(() => useSecureDataAccess());
-      expect(mockUseOrganisations).toHaveBeenCalled();
+      // useSecureDataAccess now uses useResolvedScope instead of useOrganisations
+      expect(mockUseResolvedScope).toHaveBeenCalled();
     });
   });
 
@@ -123,9 +154,9 @@ describe('useSecureDataAccess', () => {
     it('executes secure query with organisation filtering', async () => {
       const { result } = renderHook(() => useSecureDataAccess());
 
-      const data = await result.current.secureQuery('event', '*', { active: true });
+      const data = await result.current.secureQuery('core_events', '*', { active: true });
       
-      expect(freshMockSupabase.from).toHaveBeenCalledWith('event');
+      expect(freshMockSupabase.from).toHaveBeenCalledWith('core_events');
       expect(freshMockQueryBuilder.select).toHaveBeenCalledWith('*');
       expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('organisation_id', 'org-123');
       expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('active', true);
@@ -239,9 +270,9 @@ describe('useSecureDataAccess', () => {
     it('executes secure update with organisation filtering', async () => {
       const { result } = renderHook(() => useSecureDataAccess());
 
-      const data = await result.current.secureUpdate('event', { event_name: 'Updated Event' }, { id: 'event-123' });
+      const data = await result.current.secureUpdate('core_events', { event_name: 'Updated Event' }, { id: 'event-123' });
       
-      expect(freshMockSupabase.from).toHaveBeenCalledWith('event');
+      expect(freshMockSupabase.from).toHaveBeenCalledWith('core_events');
       expect(freshMockQueryBuilder.update).toHaveBeenCalledWith({ event_name: 'Updated Event' });
       expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('id', 'event-123');
       expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('organisation_id', 'org-123');
@@ -276,9 +307,9 @@ describe('useSecureDataAccess', () => {
     it('executes secure delete with organisation filtering', async () => {
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await result.current.secureDelete('event', { id: 'event-123' });
+      await result.current.secureDelete('core_events', { id: 'event-123' });
       
-      expect(freshMockSupabase.from).toHaveBeenCalledWith('event');
+      expect(freshMockSupabase.from).toHaveBeenCalledWith('core_events');
       expect(freshMockQueryBuilder.delete).toHaveBeenCalled();
       expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('id', 'event-123');
       expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('organisation_id', 'org-123');
@@ -328,15 +359,22 @@ describe('useSecureDataAccess', () => {
     });
 
     it('handles missing organisation context', () => {
-      mockUseOrganisations.mockReturnValue({
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: freshMockSupabase,
+        isAuthenticated: true,
+        signOut: vi.fn(),
         selectedOrganisation: null,
-        getUserRole: vi.fn().mockReturnValue('no_access'),
-        validateOrganisationAccess: vi.fn().mockResolvedValue(false),
-        ensureOrganisationContext: vi.fn().mockImplementation(() => {
-          throw new Error('Organisation context is required but not available');
-        }),
-        // Add other required properties
+        selectedEvent: null,
       } as any);
+      
+      // Mock useResolvedScope to return null scope when no context available
+      mockUseResolvedScope.mockReturnValue({
+        resolvedScope: null,
+        isLoading: false,
+        error: null,
+      });
 
       const { result } = renderHook(() => useSecureDataAccess());
 
@@ -344,21 +382,15 @@ describe('useSecureDataAccess', () => {
     });
 
     it('validates organisation access before operations', async () => {
-      const mockValidateAccess = vi.fn().mockResolvedValue(true);
-      mockUseOrganisations.mockReturnValue({
-        selectedOrganisation: mockSelectedOrganisation,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: mockValidateAccess,
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockSelectedOrganisation),
-        // Add other required properties
-      } as any);
-
+      // The hook uses useResolvedScope to get organisationId, which is already mocked in beforeEach
+      // The validation happens in validateContext which checks resolvedScope.organisationId
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await result.current.secureQuery('users', '*');
+      // Use 'event' table which is in the tablesWithOrganisation list
+      await result.current.secureQuery('core_events', '*');
       
-      // The hook doesn't call validateOrganisationAccess, it calls ensureOrganisationContext
-      expect(mockUseOrganisations().ensureOrganisationContext).toHaveBeenCalled();
+      // Verify that the query was executed with organisation filter
+      expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('organisation_id', 'org-123');
     });
   });
 
@@ -394,16 +426,16 @@ describe('useSecureDataAccess', () => {
     });
 
     it('handles organisation access validation failures', async () => {
-      mockUseOrganisations.mockReturnValue({
-        selectedOrganisation: mockSelectedOrganisation,
-        getUserRole: vi.fn().mockReturnValue('no_access'),
-        validateOrganisationAccess: vi.fn().mockResolvedValue(false),
-        // Add other required properties
-      } as any);
+      // Mock useResolvedScope to return null scope to simulate missing context
+      mockUseResolvedScope.mockReturnValue({
+        resolvedScope: null,
+        isLoading: false,
+        error: null,
+      });
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await expect(result.current.secureQuery('users', '*')).rejects.toThrow();
+      await expect(result.current.secureQuery('users', '*')).rejects.toThrow('Organisation context is required for data access');
     });
   });
 
@@ -411,7 +443,7 @@ describe('useSecureDataAccess', () => {
     it('prevents data leaks between organisations', async () => {
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await result.current.secureQuery('event', '*');
+      await result.current.secureQuery('core_events', '*');
       
       // Verify organisation_id filter is always applied
       expect(freshMockQueryBuilder.eq).toHaveBeenCalledWith('organisation_id', 'org-123');
@@ -467,13 +499,25 @@ describe('useSecureDataAccess', () => {
 
       // Change organisation
       const newOrganisation = { id: 'org-456', name: 'New Organisation' };
-      mockUseOrganisations.mockReturnValue({
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: freshMockSupabase,
+        isAuthenticated: true,
+        signOut: vi.fn(),
         selectedOrganisation: newOrganisation,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockResolvedValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(newOrganisation),
-        // Add other required properties
       } as any);
+      
+      // Update useResolvedScope mock to return new organisation
+      mockUseResolvedScope.mockReturnValue({
+        resolvedScope: {
+          organisationId: 'org-456',
+          eventId: undefined,
+          appId: undefined,
+        },
+        isLoading: false,
+        error: null,
+      });
 
       rerender();
 
@@ -487,9 +531,10 @@ describe('useSecureDataAccess', () => {
       expect(mockUseUnifiedAuth).toHaveBeenCalled();
     });
 
-    it('integrates with useOrganisations hook correctly', () => {
+    it('integrates with useResolvedScope hook correctly', () => {
       renderHook(() => useSecureDataAccess());
-      expect(mockUseOrganisations).toHaveBeenCalled();
+      // useSecureDataAccess now uses useResolvedScope instead of useOrganisations
+      expect(mockUseResolvedScope).toHaveBeenCalled();
     });
 
     it('uses organisation context from provider', () => {