@jmruthers/pace-core 0.5.165 → 0.5.167

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

@@ -23,9 +23,13 @@ import { getPermissionMap } from '../api';
 
 // Mock data
 const mockUserId = 'user-123';
+const mockOrgId = 'org-123';
+const mockEventId = 'event-123';
+const mockAppId = 'app-123';
 const mockScope = {
-  organisationId: 'org-123',
-  eventId: 'event-123'
+  organisationId: mockOrgId,
+  eventId: mockEventId,
+  appId: mockAppId
 };
 
 const mockPermissionMap = {
@@ -47,7 +51,7 @@ describe('usePermissions Hook', () => {
     describe('Permission Fetching', () => {
     it('fetches permissions for valid user', async () => {
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       expect(result.current.isLoading).toBe(true);
       expect(result.current.permissions).toEqual({});
@@ -63,7 +67,7 @@ describe('usePermissions Hook', () => {
       const error = new Error('Failed to fetch permissions');
       mockGetPermissionMap.mockRejectedValue(error);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -73,7 +77,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('returns empty permissions for invalid user', async () => {
-      const { result } = renderHook(() => usePermissions('', mockScope));
+      const { result } = renderHook(() => usePermissions('', mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -112,7 +116,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('hasPermission returns correct boolean', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -126,7 +130,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('hasAnyPermission works with multiple permissions', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -138,7 +142,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('hasAllPermissions works with multiple permissions', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -150,7 +154,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles empty permission lists', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -165,7 +169,7 @@ describe('usePermissions Hook', () => {
     it('refetch function works correctly', async () => {
       mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -184,7 +188,7 @@ describe('usePermissions Hook', () => {
         .mockResolvedValueOnce(mockPermissionMap)
         .mockRejectedValueOnce(new Error('Refetch error'));
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -203,7 +207,7 @@ describe('usePermissions Hook', () => {
     it('shows loading state during initial fetch', () => {
       mockGetPermissionMap.mockImplementation(() => new Promise(() => {})); // Never resolves
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       expect(result.current.isLoading).toBe(true);
       expect(result.current.permissions).toEqual({});
@@ -213,7 +217,7 @@ describe('usePermissions Hook', () => {
     it('shows loading state during refetch', async () => {
       mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -233,7 +237,7 @@ describe('usePermissions Hook', () => {
     it('handles non-Error exceptions', async () => {
       mockGetPermissionMap.mockRejectedValue('String error');
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.error).toBeInstanceOf(Error);
@@ -246,7 +250,7 @@ describe('usePermissions Hook', () => {
         .mockRejectedValueOnce(new Error('Initial error'))
         .mockResolvedValueOnce(mockPermissionMap);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.error).toBeDefined();
@@ -275,7 +279,7 @@ describe('usePermissions Hook', () => {
 
       mockGetPermissionMap.mockResolvedValue(superAdminPermissions);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -304,7 +308,7 @@ describe('usePermissions Hook', () => {
 
       mockGetPermissionMap.mockResolvedValue(orgAdminPermissions);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -333,7 +337,7 @@ describe('usePermissions Hook', () => {
 
       mockGetPermissionMap.mockResolvedValue(eventAdminPermissions);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -363,7 +367,7 @@ describe('usePermissions Hook', () => {
 
       mockGetPermissionMap.mockResolvedValue(memberPermissions);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -393,7 +397,7 @@ describe('usePermissions Hook', () => {
 
       mockGetPermissionMap.mockResolvedValue(participantPermissions);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -465,7 +469,7 @@ describe('usePermissions Hook', () => {
 
   describe('Edge Cases', () => {
     it('handles null userId', async () => {
-      const { result } = renderHook(() => usePermissions(null as any, mockScope));
+      const { result } = renderHook(() => usePermissions(null as any, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -475,7 +479,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles undefined userId', async () => {
-      const { result } = renderHook(() => usePermissions(undefined as any, mockScope));
+      const { result } = renderHook(() => usePermissions(undefined as any, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -487,7 +491,7 @@ describe('usePermissions Hook', () => {
     it('handles empty scope', async () => {
       mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, {} as any));
+      const { result } = renderHook(() => usePermissions(mockUserId, '', undefined, undefined));
 
       // Wait for the hook to complete loading
       await waitFor(() => {
@@ -506,7 +510,7 @@ describe('usePermissions Hook', () => {
 
       mockGetPermissionMap.mockResolvedValue(largePermissionMap);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -517,7 +521,7 @@ describe('usePermissions Hook', () => {
     it('handles empty permission map', async () => {
       mockGetPermissionMap.mockResolvedValue({});
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -532,9 +536,8 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles scope with empty organisationId', async () => {
-      const invalidScope = { organisationId: '', eventId: 'event-123' };
       
-      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, '', 'event-123', undefined));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(true);
@@ -544,9 +547,8 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles scope with whitespace-only organisationId', async () => {
-      const invalidScope = { organisationId: '   ', eventId: 'event-123' };
       
-      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, '   ', 'event-123', undefined));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(true);
@@ -560,7 +562,7 @@ describe('usePermissions Hook', () => {
     it('maintains stable references for same permissions', async () => {
       mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
 
-      const { result, rerender } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result, rerender } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -580,7 +582,7 @@ describe('usePermissions Hook', () => {
     it('handles rapid permission checks efficiently', async () => {
       mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
 
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -601,7 +603,7 @@ describe('usePermissions Hook', () => {
 
   describe('[integration] Cache Invalidation', () => {
     it('refetches after cache invalidation', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);

package/src/rbac/hooks/usePermissions.ts

@@ -27,13 +27,20 @@ import { getRBACLogger } from '../config';
  * Hook to get user's permissions in a scope
  * 
  * @param userId - User ID
- * @param scope - Scope for permission checking
+ * @param organisationId - Organisation ID
+ * @param eventId - Event ID (optional)
+ * @param appId - Application ID (optional)
  * @returns Permission state and methods
  * 
  * @example
  * ```tsx
  * function MyComponent() {
- *   const { permissions, isLoading, error } = usePermissions(userId, scope);
+ *   const { permissions, isLoading, error } = usePermissions(
+ *     userId, 
+ *     organisationId, 
+ *     eventId, 
+ *     appId
+ *   );
  *   
  *   if (isLoading) return <div>Loading...</div>;
  *   if (error) return <div>Error: {error.message}</div>;
@@ -47,29 +54,31 @@ import { getRBACLogger } from '../config';
  * }
  * ```
  */
-export function usePermissions(userId: UUID, scope: Scope) {
+export function usePermissions(
+  userId: UUID, 
+  organisationId: string | undefined, 
+  eventId: string | undefined, 
+  appId: string | undefined
+) {
   const [permissions, setPermissions] = useState<PermissionMap>({} as PermissionMap);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<Error | null>(null);
   const isFetchingRef = useRef(false);
   const logger = getRBACLogger();
   
-  // Extract individual values to ensure React detects changes
-  // This is critical - React compares these values, not the object reference
-  const orgId = scope.organisationId || '';
-  const eventId = scope.eventId;
-  const appId = scope.appId;
+  // Track previous appId to detect when it becomes available
+  const prevAppIdRef = useRef<string | undefined>(appId);
+  
+  // Normalize organisationId to empty string if undefined
+  const orgId = organisationId || '';
   
   // Log when hook is called with new scope (every render)
   // This helps us see if React is calling the hook with updated scope
   logger.warn('[usePermissions] Hook called with scope', {
     userId,
-    extractedOrgId: orgId,
-    extractedEventId: eventId,
-    extractedAppId: appId,
-    scopeOrgId: scope.organisationId,
-    scopeEventId: scope.eventId,
-    scopeAppId: scope.appId,
+    organisationId: orgId,
+    eventId,
+    appId,
     hasAppId: !!appId,
     hasOrganisationId: !!orgId
   });
@@ -78,17 +87,17 @@ export function usePermissions(userId: UUID, scope: Scope) {
   React.useEffect(() => {
     logger.warn('[usePermissions] Scope changed (useEffect)', {
       userId,
-      organisationId: scope.organisationId,
-      eventId: scope.eventId,
-      appId: scope.appId,
-      hasAppId: !!scope.appId,
-      hasOrganisationId: !!scope.organisationId
+      organisationId,
+      eventId,
+      appId,
+      hasAppId: !!appId,
+      hasOrganisationId: !!organisationId
     });
-  }, [scope.organisationId, scope.eventId, scope.appId, userId]);
+  }, [userId, organisationId, eventId, appId]);
 
   // Add timeout for missing organisation context (3 seconds)
   useEffect(() => {
-    if (!scope.organisationId || scope.organisationId === null || (typeof scope.organisationId === 'string' && scope.organisationId.trim() === '')) {
+    if (!orgId || orgId === null || (typeof orgId === 'string' && orgId.trim() === '')) {
       const timeoutId = setTimeout(() => {
         setError(new Error('Organisation context is required for permission checks'));
         setIsLoading(false);
@@ -100,16 +109,28 @@ export function usePermissions(userId: UUID, scope: Scope) {
     if (error?.message === 'Organisation context is required for permission checks') {
       setError(null);
     }
-  }, [scope.organisationId, error]);
+  }, [organisationId, error]);
 
   useEffect(() => {
     const fetchPermissions = async () => {
+      // Log appId change detection
+      const appIdChanged = prevAppIdRef.current !== appId;
+      if (appIdChanged) {
+        logger.warn('[usePermissions] appId changed detected!', {
+          prevAppId: prevAppIdRef.current,
+          newAppId: appId,
+          hasAppId: !!appId
+        });
+        prevAppIdRef.current = appId;
+      }
+      
       logger.warn('[usePermissions] Fetch useEffect triggered', {
         userId,
         orgId,
         eventId,
         appId,
         hasAppId: !!appId,
+        appIdChanged,
         isFetching: isFetchingRef.current
       });
 
@@ -176,15 +197,15 @@ export function usePermissions(userId: UUID, scope: Scope) {
         setIsLoading(true);
         setError(null);
         
-        // Build scope object from extracted values
-        const scopeForFetch: Scope = {
+        // Build scope object for API call
+        const scope: Scope = {
           organisationId: orgId,
           eventId: eventId,
           appId: appId
         };
         
         // Fetch new permissions - don't clear old ones until we have new ones
-        const permissionMap = await getPermissionMap({ userId, scope: scopeForFetch });
+        const permissionMap = await getPermissionMap({ userId, scope });
         
         logger.warn('[usePermissions] Permissions fetched successfully', {
           permissionCount: Object.keys(permissionMap).length,
@@ -211,7 +232,7 @@ export function usePermissions(userId: UUID, scope: Scope) {
     };
 
     fetchPermissions();
-  }, [userId, scope.organisationId, scope.eventId, scope.appId]);
+  }, [userId, organisationId, eventId, appId]);
 
   const hasPermission = useCallback((permission: Permission): boolean => {
     if (permissions['*']) {
@@ -248,7 +269,7 @@ export function usePermissions(userId: UUID, scope: Scope) {
 
     // Don't fetch permissions if scope is invalid (e.g., organisationId is null/empty)
     // IMPORTANT: Don't clear existing permissions - keep them until we have new ones
-    if (!scope.organisationId || scope.organisationId === null || (typeof scope.organisationId === 'string' && scope.organisationId.trim() === '')) {
+    if (!orgId || orgId === null || (typeof orgId === 'string' && orgId.trim() === '')) {
       // Keep existing permissions, just mark as loading
       setIsLoading(true);
       setError(null);
@@ -260,6 +281,13 @@ export function usePermissions(userId: UUID, scope: Scope) {
       setIsLoading(true);
       setError(null);
       
+      // Build scope object for API call
+      const scope: Scope = {
+        organisationId: orgId,
+        eventId: eventId,
+        appId: appId
+      };
+      
       // Fetch new permissions - don't clear old ones until we have new ones
       const permissionMap = await getPermissionMap({ userId, scope });
       
@@ -276,7 +304,7 @@ export function usePermissions(userId: UUID, scope: Scope) {
       setIsLoading(false);
       isFetchingRef.current = false;
     }
-  }, [userId, scope.organisationId, scope.eventId, scope.appId]);
+  }, [userId, organisationId, eventId, appId]);
 
   // Memoize the return object to prevent unnecessary re-renders
   return useMemo(() => ({