@jmruthers/pace-core 0.5.74 → 0.5.76

package/src/rbac/hooks/usePermissions.test.ts

@@ -598,4 +598,300 @@ describe('usePermissions Hook', () => {
       expect(end - start).toBeLessThan(100); // Should complete in under 100ms
     });
   });
+
+  describe('[integration] Cache Invalidation', () => {
+    it('refetches after cache invalidation', async () => {
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.permissions).toEqual(mockPermissionMap);
+
+      // Invalidate and refetch
+      const newPermissions = { ...mockPermissionMap, 'new:permission': true };
+      mockGetPermissionMap.mockResolvedValue(newPermissions);
+      result.current.refetch();
+
+      await waitFor(() => {
+        expect(result.current.permissions).toEqual(newPermissions);
+      });
+    });
+
+    it('handles cache expiration gracefully', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // First fetch should be cached, second should refetch
+      const callCount = mockGetPermissionMap.mock.calls.length;
+      result.current.refetch();
+
+      await waitFor(() => {
+        expect(mockGetPermissionMap).toHaveBeenCalledTimes(callCount + 1);
+      });
+    });
+
+    it('maintains consistent permissions across multiple refetches', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Multiple refetches should maintain consistency
+      result.current.refetch();
+      await waitFor(() => expect(mockGetPermissionMap).toHaveBeenCalled());
+
+      result.current.refetch();
+      await waitFor(() => expect(mockGetPermissionMap).toHaveBeenCalled());
+    });
+  });
+
+  describe('[integration] Concurrent Operations', () => {
+    it('handles concurrent permission checks', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Simulate concurrent permission checks
+      const promises = [];
+      for (let i = 0; i < 10; i++) {
+        promises.push(
+          Promise.resolve(result.current.hasPermission('read:users'))
+        );
+      }
+
+      const results = await Promise.all(promises);
+      expect(results.every(r => r === true)).toBe(true);
+    });
+
+    it('handles rapid scope changes without errors', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result, rerender } = renderHook(
+        ({ userId, scope }) => usePermissions(userId, scope),
+        {
+          initialProps: { userId: mockUserId, scope: mockScope }
+        }
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Rapid scope changes
+      const scopes = [
+        { ...mockScope, eventId: 'event-1' },
+        { ...mockScope, eventId: 'event-2' },
+        { ...mockScope, eventId: 'event-3' }
+      ];
+
+      for (const scope of scopes) {
+        rerender({ userId: mockUserId, scope });
+        await waitFor(() => {
+          expect(result.current.isLoading).toBe(false);
+        }, { timeout: 100 });
+      }
+
+      expect(result.current.error).toBeNull();
+    });
+
+    it('handles mixed permission and refetch operations', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Mix permission checks with refetch
+      result.current.hasPermission('read:users');
+      result.current.refetch();
+      result.current.hasAnyPermission(['read:users', 'create:users']);
+      result.current.refetch();
+      result.current.hasAllPermissions(['read:users']);
+
+      await waitFor(() => {
+        expect(mockGetPermissionMap).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('[integration] Permission Resolution Edge Cases', () => {
+    it('handles organization context changes', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result, rerender } = renderHook(
+        ({ userId, scope }) => usePermissions(userId, scope),
+        {
+          initialProps: { userId: mockUserId, scope: mockScope }
+        }
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Change organization
+      const newScope = { ...mockScope, organisationId: 'org-456' };
+      rerender({ userId: mockUserId, scope: newScope });
+
+      await waitFor(() => {
+        expect(mockGetPermissionMap).toHaveBeenCalledTimes(2);
+      });
+    });
+
+    it('handles event context changes', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result, rerender } = renderHook(
+        ({ userId, scope }) => usePermissions(userId, scope),
+        {
+          initialProps: { userId: mockUserId, scope: mockScope }
+        }
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Change event
+      const newScope = { ...mockScope, eventId: 'event-456' };
+      rerender({ userId: mockUserId, scope: newScope });
+
+      await waitFor(() => {
+        expect(mockGetPermissionMap).toHaveBeenCalledTimes(2);
+      });
+    });
+
+    it('handles permission resolution with partial scope', async () => {
+      const partialScope = { organisationId: mockScope.organisationId };
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, partialScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.permissions).toEqual(mockPermissionMap);
+    });
+  });
+
+  describe('[integration] Error Recovery', () => {
+    it('recovers from transient errors', async () => {
+      mockGetPermissionMap
+        .mockRejectedValueOnce(new Error('Transient error'))
+        .mockResolvedValueOnce(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.error).toBeDefined();
+      });
+
+      result.current.refetch();
+
+      await waitFor(() => {
+        expect(result.current.error).toBeNull();
+        expect(result.current.permissions).toEqual(mockPermissionMap);
+      });
+    });
+
+    it('handles network timeout gracefully', async () => {
+      mockGetPermissionMap.mockImplementation(
+        () => new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Timeout')), 100)
+        )
+      );
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.error).toBeDefined();
+      });
+    });
+
+    it('maintains stability after error recovery', async () => {
+      mockGetPermissionMap
+        .mockRejectedValueOnce(new Error('Error'))
+        .mockResolvedValue(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.error).toBeDefined();
+      });
+
+      result.current.refetch();
+
+      await waitFor(() => {
+        expect(result.current.error).toBeNull();
+        expect(result.current.permissions).toEqual(mockPermissionMap);
+      });
+
+      // After recovery, operations should work normally
+      expect(result.current.hasPermission('read:users')).toBe(true);
+    });
+  });
+
+  describe('[integration] State Management', () => {
+    it('preserves state across hook re-renders', async () => {
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result, rerender } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      const firstPermissions = result.current.permissions;
+      rerender();
+      const secondPermissions = result.current.permissions;
+
+      expect(firstPermissions).toEqual(secondPermissions);
+      expect(result.current.hasPermission).toBe(result.current.hasPermission);
+      expect(result.current.refetch).toBe(result.current.refetch);
+    });
+
+    it('handles empty organization ID edge case', async () => {
+      const invalidScope = { organisationId: '', eventId: 'event-123' };
+      
+      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope as any));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBeDefined();
+      });
+
+      expect(result.current.permissions).toEqual({});
+    });
+
+    it('handles null event ID', async () => {
+      const scopeWithNullEvent = { organisationId: 'org-123', eventId: null as any };
+      
+      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, scopeWithNullEvent));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.permissions).toEqual(mockPermissionMap);
+    });
+  });
 });

package/src/rbac/hooks/useRBAC.test.ts

@@ -16,11 +16,15 @@ vi.mock('../../providers/UnifiedAuthProvider', () => ({
   useUnifiedAuth: vi.fn()
 }));
 
-vi.mock('../../providers/OrganisationProvider', () => ({
+vi.mock('../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: vi.fn()
+}));
+
+vi.mock('../../hooks/useOrganisations', () => ({
   useOrganisations: vi.fn()
 }));
 
-vi.mock('../../providers/EventProvider', () => ({
+vi.mock('../../hooks/useEvents', () => ({
   useEvents: vi.fn()
 }));
 
@@ -30,9 +34,9 @@ const mockSupabaseClient = {
 };
 
 // Get the mocked functions
-import { useUnifiedAuth } from '../../providers/UnifiedAuthProvider';
-import { useOrganisations } from '../../providers/OrganisationProvider';
-import { useEvents } from '../../providers/EventProvider';
+import { useUnifiedAuth } from '../../providers';
+import { useOrganisations } from '../../hooks/useOrganisations';
+import { useEvents } from '../../hooks/useEvents';
 
 const mockUseUnifiedAuth = vi.mocked(useUnifiedAuth);
 const mockUseOrganisations = vi.mocked(useOrganisations);

package/src/rbac/hooks/useRBAC.ts

@@ -67,9 +67,9 @@
  */
 
 import { useState, useEffect, useCallback, useMemo } from 'react';
-import { useUnifiedAuth } from '../../providers/UnifiedAuthProvider';
-import { useOrganisations } from '../../providers/OrganisationProvider';
-import { useEvents } from '../../providers/EventProvider';
+import { useUnifiedAuth } from '../../providers/services/UnifiedAuthProvider';
+import { useOrganisations } from '../../hooks/useOrganisations';
+import { useEvents } from '../../hooks/useEvents';
 import type { 
   UserRBACContext, 
   GlobalRole, 

package/src/rbac/hooks/useResolvedScope.ts

@@ -0,0 +1,232 @@
+/**
+ * @file useResolvedScope Hook
+ * @package @jmruthers/pace-core
+ * @module RBAC/Hooks
+ * @since 1.0.0
+ * 
+ * Shared hook for resolving RBAC scope from various contexts.
+ * This hook is used by both DataTable and PagePermissionGuard to ensure
+ * consistent scope resolution logic.
+ */
+
+import { useEffect, useState, useRef } from 'react';
+import { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../../types/database';
+import type { Scope } from '../types';
+import { createScopeFromEvent } from '../utils/eventContext';
+import { getCurrentAppName } from '../../utils/appNameResolver';
+
+export interface UseResolvedScopeOptions {
+  /** Supabase client instance */
+  supabase: SupabaseClient<Database> | null;
+  /** Selected organisation ID */
+  selectedOrganisationId: string | null;
+  /** Selected event ID */
+  selectedEventId: string | null;
+}
+
+export interface UseResolvedScopeReturn {
+  /** Resolved scope, or null if not yet resolved */
+  resolvedScope: Scope | null;
+  /** Whether the scope resolution is in progress */
+  isLoading: boolean;
+  /** Error if scope resolution failed */
+  error: Error | null;
+}
+
+/**
+ * Resolves RBAC scope from organisation and event context
+ * 
+ * This hook handles the complex logic of determining the correct RBAC scope
+ * based on available context (organisation, event, app). It ensures consistent
+ * scope resolution across the application.
+ * 
+ * @param options - Hook options
+ * @returns Resolved scope and loading state
+ * 
+ * @example
+ * ```tsx
+ * const { resolvedScope, isLoading } = useResolvedScope({
+ *   supabase,
+ *   selectedOrganisationId,
+ *   selectedEventId
+ * });
+ * 
+ * if (isLoading) return <Loading />;
+ * if (!resolvedScope) return <Error />;
+ * 
+ * const permission = useCan(userId, resolvedScope, permission);
+ * ```
+ */
+export function useResolvedScope({
+  supabase,
+  selectedOrganisationId,
+  selectedEventId
+}: UseResolvedScopeOptions): UseResolvedScopeReturn {
+  const [resolvedScope, setResolvedScope] = useState<Scope | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  
+  // Use a ref to track the stable scope and only update it when it actually changes
+  const stableScopeRef = useRef<{ organisationId: string; appId: string; eventId: string | undefined }>({ 
+    organisationId: '', 
+    appId: '', 
+    eventId: undefined 
+  });
+  
+  // Only update the stable scope if the resolved scope has actually changed
+  if (resolvedScope && resolvedScope.organisationId) {
+    const newScope = {
+      organisationId: resolvedScope.organisationId,
+      appId: resolvedScope.appId,
+      eventId: resolvedScope.eventId
+    };
+    
+    // Only update if the scope has actually changed
+    if (stableScopeRef.current.organisationId !== newScope.organisationId ||
+        stableScopeRef.current.eventId !== newScope.eventId ||
+        stableScopeRef.current.appId !== newScope.appId) {
+      stableScopeRef.current = {
+        organisationId: newScope.organisationId,
+        appId: newScope.appId || '',
+        eventId: newScope.eventId
+      };
+    }
+  } else if (!resolvedScope) {
+    // Reset to empty scope when no resolved scope
+    stableScopeRef.current = { organisationId: '', appId: '', eventId: undefined };
+  }
+  
+  const stableScope = stableScopeRef.current;
+  
+  useEffect(() => {
+    let cancelled = false;
+    
+    const resolveScope = async () => {
+      setIsLoading(true);
+      setError(null);
+      
+      try {
+        // Get app ID from package.json or environment
+        let appId: string | undefined = undefined;
+        
+        // Try to resolve from database
+        if (supabase) {
+          const appName = getCurrentAppName();
+          if (appName) {
+            try {
+              const { data: app, error } = await supabase
+                .from('rbac_apps')
+                .select('id, name, is_active')
+                .eq('name', appName)
+                .eq('is_active', true)
+                .single() as { data: { id: string; name: string; is_active: boolean } | null; error: any };
+              
+              if (error) {
+                // Check if app exists but is inactive
+                const { data: inactiveApp } = await supabase
+                  .from('rbac_apps')
+                  .select('id, name, is_active')
+                  .eq('name', appName)
+                  .single() as { data: { id: string; name: string; is_active: boolean } | null };
+                
+                if (inactiveApp) {
+                  console.error(`[useResolvedScope] App "${appName}" exists but is inactive (is_active: ${inactiveApp.is_active})`);
+                } else {
+                  console.error(`[useResolvedScope] App "${appName}" not found in rbac_apps table`);
+                }
+              } else if (app) {
+                appId = app.id;
+              }
+            } catch (error) {
+              console.error('[useResolvedScope] Unexpected error resolving app ID:', error);
+            }
+          }
+        }
+
+        // If we have both organisation and event, use them directly
+        if (selectedOrganisationId && selectedEventId) {
+          if (!cancelled) {
+            setResolvedScope({
+              organisationId: selectedOrganisationId,
+              eventId: selectedEventId,
+              appId: appId
+            });
+            setIsLoading(false);
+          }
+          return;
+        }
+
+        // If we only have organisation, use it
+        if (selectedOrganisationId) {
+          if (!cancelled) {
+            setResolvedScope({
+              organisationId: selectedOrganisationId,
+              eventId: selectedEventId || undefined,
+              appId: appId
+            });
+            setIsLoading(false);
+          }
+          return;
+        }
+
+        // If we only have event, resolve organisation from event
+        if (selectedEventId && supabase) {
+          try {
+            const eventScope = await createScopeFromEvent(supabase, selectedEventId, appId);
+            if (!eventScope) {
+              console.error('[useResolvedScope] Could not resolve organization from event context');
+              if (!cancelled) {
+                setResolvedScope(null);
+                setError(new Error('Could not resolve organisation from event context'));
+                setIsLoading(false);
+              }
+              return;
+            }
+            // Preserve the resolved app ID
+            if (!cancelled) {
+              setResolvedScope({
+                ...eventScope,
+                appId: appId || eventScope.appId
+              });
+              setIsLoading(false);
+            }
+          } catch (err) {
+            console.error('[useResolvedScope] Error resolving scope from event:', err);
+            if (!cancelled) {
+              setResolvedScope(null);
+              setError(err as Error);
+              setIsLoading(false);
+            }
+          }
+          return;
+        }
+
+        // No context available
+        console.error('[useResolvedScope] No organisation or event context available');
+        if (!cancelled) {
+          setResolvedScope(null);
+          setError(new Error('No organisation or event context available'));
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err as Error);
+          setIsLoading(false);
+        }
+      }
+    };
+
+    resolveScope();
+    
+    return () => {
+      cancelled = true;
+    };
+  }, [selectedOrganisationId, selectedEventId, supabase]);
+  
+  return {
+    resolvedScope: stableScope.organisationId ? stableScope as Scope : null,
+    isLoading,
+    error
+  };
+}