@jmruthers/pace-core 0.5.164 → 0.5.166

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

@@ -27,9 +27,13 @@ vi.mock('../../api', () => ({
 import { getPermissionMap } from '../../api';
 
 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 = {
@@ -54,9 +58,9 @@ describe('usePermissions Integration Tests', () => {
   describe('Cache Behavior', () => {
     it('fetches permissions only once for same dependencies', async () => {
       const { result, rerender } = renderHook(
-        ({ userId, scope }) => usePermissions(userId, scope),
+        ({ userId, orgId, eventId, appId }) => usePermissions(userId, orgId, eventId, appId),
         {
-          initialProps: { userId: mockUserId, scope: mockScope }
+          initialProps: { userId: mockUserId, orgId: mockOrgId, eventId: mockEventId, appId: mockAppId }
         }
       );
 
@@ -75,9 +79,9 @@ describe('usePermissions Integration Tests', () => {
 
     it('refetches when organisationId changes', async () => {
       const { result, rerender } = renderHook(
-        ({ userId, scope }) => usePermissions(userId, scope),
+        ({ userId, orgId, eventId, appId }) => usePermissions(userId, orgId, eventId, appId),
         {
-          initialProps: { userId: mockUserId, scope: mockScope }
+          initialProps: { userId: mockUserId, orgId: mockOrgId, eventId: mockEventId, appId: mockAppId }
         }
       );
 
@@ -95,9 +99,9 @@ describe('usePermissions Integration Tests', () => {
 
     it('refetches when eventId changes', async () => {
       const { result, rerender } = renderHook(
-        ({ userId, scope }) => usePermissions(userId, scope),
+        ({ userId, orgId, eventId, appId }) => usePermissions(userId, orgId, eventId, appId),
         {
-          initialProps: { userId: mockUserId, scope: mockScope }
+          initialProps: { userId: mockUserId, orgId: mockOrgId, eventId: mockEventId, appId: mockAppId }
         }
       );
 
@@ -114,11 +118,10 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('refetches when appId changes', async () => {
-      const scopeWithApp = { ...mockScope, appId: 'app-1' };
       const { result, rerender } = renderHook(
-        ({ userId, scope }) => usePermissions(userId, scope),
+        ({ userId, orgId, eventId, appId }) => usePermissions(userId, orgId, eventId, appId),
         {
-          initialProps: { userId: mockUserId, scope: scopeWithApp }
+          initialProps: { userId: mockUserId, orgId: mockOrgId, eventId: mockEventId, appId: 'app-1' }
         }
       );
 
@@ -137,7 +140,7 @@ describe('usePermissions Integration Tests', () => {
 
   describe('Refetch Scenarios', () => {
     it('refetch updates permissions after external change', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -159,7 +162,7 @@ describe('usePermissions Integration Tests', () => {
     it('refetch clears error state', async () => {
       // First render with error
       mockGetPermissionMap.mockRejectedValueOnce(new Error('Network error'));
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.error).toBeDefined();
@@ -176,7 +179,7 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('refetch triggers API call', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -192,7 +195,7 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('refetch does nothing when userId is empty', async () => {
-      const { result } = renderHook(() => usePermissions('', mockScope));
+      const { result } = renderHook(() => usePermissions('', mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -207,8 +210,7 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('refetch does nothing when organisationId is empty', async () => {
-      const invalidScope = { ...mockScope, organisationId: '' };
-      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, '', mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(true);
@@ -225,7 +227,7 @@ describe('usePermissions Integration Tests', () => {
 
   describe('Concurrent Permission Checks', () => {
     it('handles rapid permission checks correctly', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -250,8 +252,8 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('handles multiple hooks with same scope', async () => {
-      const { result: result1 } = renderHook(() => usePermissions(mockUserId, mockScope));
-      const { result: result2 } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result: result1 } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+      const { result: result2 } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result1.current.isLoading).toBe(false);
@@ -266,8 +268,8 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('handles refetch from multiple components', async () => {
-      const { result: result1 } = renderHook(() => usePermissions(mockUserId, mockScope));
-      const { result: result2 } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result: result1 } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+      const { result: result2 } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result1.current.isLoading).toBe(false);
@@ -286,7 +288,7 @@ describe('usePermissions Integration Tests', () => {
 
   describe('Permission Array Operations', () => {
     it('hasAnyPermission handles complex arrays', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -298,7 +300,7 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('hasAllPermissions handles complex arrays', async () => {
-      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
@@ -316,7 +318,7 @@ describe('usePermissions Integration Tests', () => {
       }
 
       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);
@@ -371,8 +373,7 @@ describe('usePermissions Integration Tests', () => {
 
   describe('Invalid Scope Handling', () => {
     it('handles empty organisationId gracefully', async () => {
-      const invalidScope = { ...mockScope, organisationId: '' };
-      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, '', mockEventId, mockAppId));
 
       // Should not fetch with invalid scope
       await waitFor(() => {
@@ -381,8 +382,7 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('handles whitespace-only organisationId', async () => {
-      const invalidScope = { ...mockScope, organisationId: '   ' };
-      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, '   ', mockEventId, mockAppId));
 
       // Should not fetch with invalid scope
       await waitFor(() => {
@@ -391,9 +391,7 @@ describe('usePermissions Integration Tests', () => {
     });
 
     it('handles missing organisationId', async () => {
-      const invalidScope = { ...mockScope };
-      delete (invalidScope as any).organisationId;
-      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+      const { result } = renderHook(() => usePermissions(mockUserId, undefined, mockEventId, mockAppId));
 
       // Should not fetch with invalid scope
       await waitFor(() => {
@@ -405,9 +403,9 @@ describe('usePermissions Integration Tests', () => {
   describe('Memoization', () => {
     it('returns stable references for helpers', async () => {
       const { result, rerender } = renderHook(
-        ({ userId, scope }) => usePermissions(userId, scope),
+        ({ userId, orgId, eventId, appId }) => usePermissions(userId, orgId, eventId, appId),
         {
-          initialProps: { userId: mockUserId, scope: mockScope }
+          initialProps: { userId: mockUserId, orgId: mockOrgId, eventId: mockEventId, appId: mockAppId }
         }
       );
 

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,28 @@ 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;
+  // 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 +84,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: orgId,
+      eventId,
+      appId,
+      hasAppId: !!appId,
+      hasOrganisationId: !!orgId
     });
-  }, [scope.organisationId, scope.eventId, scope.appId, userId]);
+  }, [userId, orgId, 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,7 +106,7 @@ export function usePermissions(userId: UUID, scope: Scope) {
     if (error?.message === 'Organisation context is required for permission checks') {
       setError(null);
     }
-  }, [scope.organisationId, error]);
+  }, [orgId, error]);
 
   useEffect(() => {
     const fetchPermissions = async () => {
@@ -176,15 +182,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 +217,7 @@ export function usePermissions(userId: UUID, scope: Scope) {
     };
 
     fetchPermissions();
-  }, [userId, scope.organisationId, scope.eventId, scope.appId]);
+  }, [userId, orgId, eventId, appId]);
 
   const hasPermission = useCallback((permission: Permission): boolean => {
     if (permissions['*']) {
@@ -248,7 +254,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 +266,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 +289,7 @@ export function usePermissions(userId: UUID, scope: Scope) {
       setIsLoading(false);
       isFetchingRef.current = false;
     }
-  }, [userId, scope.organisationId, scope.eventId, scope.appId]);
+  }, [userId, orgId, eventId, appId]);
 
   // Memoize the return object to prevent unnecessary re-renders
   return useMemo(() => ({