@jmruthers/pace-core 0.5.145 → 0.5.147

package/docs/api/interfaces/UsePublicEventOptions.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UsePublicEventOptions
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UsePublicEventOptions
 
 # Interface: UsePublicEventOptions
 

package/docs/api/interfaces/UsePublicEventReturn.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UsePublicEventReturn
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UsePublicEventReturn
 
 # Interface: UsePublicEventReturn
 

package/docs/api/interfaces/UsePublicFileDisplayOptions.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UsePublicFileDisplayOptions
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UsePublicFileDisplayOptions
 
 # Interface: UsePublicFileDisplayOptions
 

package/docs/api/interfaces/UsePublicFileDisplayReturn.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UsePublicFileDisplayReturn
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UsePublicFileDisplayReturn
 
 # Interface: UsePublicFileDisplayReturn
 

package/docs/api/interfaces/UsePublicRouteParamsReturn.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UsePublicRouteParamsReturn
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UsePublicRouteParamsReturn
 
 # Interface: UsePublicRouteParamsReturn
 

package/docs/api/interfaces/UseResolvedScopeOptions.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UseResolvedScopeOptions
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UseResolvedScopeOptions
 
 # Interface: UseResolvedScopeOptions
 

package/docs/api/interfaces/UseResolvedScopeReturn.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UseResolvedScopeReturn
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UseResolvedScopeReturn
 
 # Interface: UseResolvedScopeReturn
 

package/docs/api/interfaces/UseResourcePermissionsOptions.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UseResourcePermissionsOptions
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UseResourcePermissionsOptions
 
 # Interface: UseResourcePermissionsOptions
 

package/docs/api/interfaces/UserEventAccess.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UserEventAccess
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UserEventAccess
 
 # Interface: UserEventAccess
 

package/docs/api/interfaces/UserMenuProps.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UserMenuProps
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UserMenuProps
 
 # Interface: UserMenuProps
 

package/docs/api/interfaces/UserProfile.md

@@ -1,4 +1,4 @@
-[@jmruthers/pace-core - v0.5.145](../README.md) / [Exports](../modules.md) / UserProfile
+[@jmruthers/pace-core - v0.5.147](../README.md) / [Exports](../modules.md) / UserProfile
 
 # Interface: UserProfile
 

package/docs/api/modules.md

@@ -1,6 +1,6 @@
-[@jmruthers/pace-core - v0.5.145](README.md) / Exports
+[@jmruthers/pace-core - v0.5.147](README.md) / Exports
 
-# @jmruthers/pace-core - v0.5.145
+# @jmruthers/pace-core - v0.5.147
 
 **`File`**
 

package/docs/rbac/RBAC_EVENT_CONTEXT_LOADING.md

@@ -0,0 +1,222 @@
+# RBAC Event Context Loading - How It Works
+
+## Overview
+
+For event-based apps (`requires_event: true`), RBAC waits for event context to be ready before loading permissions. This document explains how this works and answers common questions.
+
+## How RBAC Detects Event Context Availability
+
+### Automatic Detection via React Hooks
+
+RBAC uses React's dependency system to automatically detect when event context becomes available:
+
+1. **`useRBAC` hook watches event state**:
+   - `eventLoading` - boolean indicating if events are loading
+   - `selectedEvent` - the currently selected event object (or null)
+
+2. **`loadRBACContext` callback depends on event state**:
+   ```typescript
+   const loadRBACContext = useCallback(async () => {
+     // ... loading logic
+   }, [selectedEvent, eventLoading, ...other dependencies]);
+   ```
+
+3. **`useEffect` automatically re-runs when callback changes**:
+   ```typescript
+   useEffect(() => {
+     loadRBACContext();
+   }, [loadRBACContext]);
+   ```
+
+### Flow Diagram
+
+```
+1. Component mounts → useRBAC called
+2. loadRBACContext created (depends on eventLoading, selectedEvent)
+3. useEffect runs → calls loadRBACContext()
+4. If eventLoading=true OR selectedEvent=null:
+   → Log: "Waiting for event context"
+   → Set isLoading=true
+   → Return early (don't load RBAC)
+5. When eventLoading changes to false AND selectedEvent becomes available:
+   → loadRBACContext callback is recreated (dependency changed)
+   → useEffect detects callback changed → re-runs
+   → loadRBACContext() called again
+   → This time: eventLoading=false AND selectedEvent exists
+   → Proceeds to load RBAC context
+   → Log: "Loading RBAC context"
+   → Log: "RBAC context loaded successfully"
+```
+
+## Should You See the "Waiting for Event Context" Log?
+
+**Yes, you should see this log** when:
+- App has `requires_event: true`
+- Event context is loading (`eventLoading: true`) OR no event selected (`selectedEvent: null`)
+
+**Log level**: `INFO` (should be visible in console)
+
+**Log message**:
+```
+[useRBAC] Waiting for event context before loading RBAC context
+```
+
+**If you don't see this log**, it might mean:
+1. App doesn't have `requires_event: true` configured
+2. Event context loads too quickly (race condition)
+3. Log level is set too high (unlikely, as it's INFO level)
+
+## Is RBAC Loading Automatic?
+
+**Yes, RBAC loading is completely automatic**. You don't need to call anything explicitly.
+
+### How It Works Automatically
+
+1. **`useRBAC` hook is called automatically** when:
+   - Component using RBAC mounts (e.g., `NavigationMenu`, `PagePermissionGuard`)
+   - Or when you explicitly call `useRBAC()` in a component
+
+2. **React's dependency system triggers re-runs**:
+   - When `eventLoading` changes from `true` → `false`
+   - When `selectedEvent` changes from `null` → object
+   - The `loadRBACContext` callback is recreated
+   - The `useEffect` detects the change and re-runs
+   - RBAC context loads automatically
+
+### What You Need to Do
+
+**Nothing!** Just ensure:
+- ✅ `setupRBAC(supabase)` is called in your app initialization
+- ✅ `UnifiedAuthProvider` has `appConfig={{ requires_event: true }}` for event-based apps
+- ✅ `EventProvider` is wrapping your app (for event-based apps)
+- ✅ Event context is loading correctly
+
+## How to Manually Trigger RBAC Loading (For Testing)
+
+### Option 1: Force Re-render
+
+If you need to manually trigger RBAC loading for testing:
+
+```typescript
+import { useRBAC } from '@jmruthers/pace-core/rbac';
+
+function TestComponent() {
+  const { isLoading, error, permissionMap } = useRBAC();
+  const [forceReload, setForceReload] = useState(0);
+  
+  const manualReload = () => {
+    setForceReload(prev => prev + 1);
+    // This will cause useRBAC to re-run
+  };
+  
+  return (
+    <div>
+      <button onClick={manualReload}>Reload RBAC</button>
+      <div>Loading: {isLoading ? 'Yes' : 'No'}</div>
+      <div>Permissions: {Object.keys(permissionMap).length}</div>
+    </div>
+  );
+}
+```
+
+### Option 2: Call RPC Directly (Advanced)
+
+For debugging, you can call the RPC function directly:
+
+```typescript
+import { getEngine } from '@jmruthers/pace-core/rbac';
+
+async function testRBAC() {
+  const engine = getEngine();
+  
+  // Test app resolution
+  const appContext = await engine.resolveAppContext({
+    userId: 'your-user-id',
+    appName: 'TRAC'
+  });
+  console.log('App context:', appContext);
+  
+  // Test permission map
+  const permissionMap = await engine.getPermissionMap({
+    userId: 'your-user-id',
+    scope: {
+      organisationId: 'your-org-id',
+      eventId: 'your-event-id',
+      appId: appContext?.appId
+    }
+  });
+  console.log('Permission map:', permissionMap);
+}
+```
+
+### Option 3: Check Console Logs
+
+The fix includes detailed logging:
+
+1. **When waiting**: `[useRBAC] Waiting for event context before loading RBAC context`
+2. **When loading**: `[useRBAC] Loading RBAC context`
+3. **When successful**: `[useRBAC] RBAC context loaded successfully` (with permission count)
+
+## Troubleshooting
+
+### RBAC Not Loading After Event Context Ready
+
+**Symptoms**:
+- Event context loads (`eventLoading: false`, `selectedEvent` set)
+- No RBAC loading logs appear
+- Permission map remains empty
+
+**Check**:
+1. ✅ Verify `appConfig={{ requires_event: true }}` in `UnifiedAuthProvider`
+2. ✅ Verify database has `requires_event: true` for your app
+3. ✅ Check console for "Waiting for event context" log (should appear first)
+4. ✅ Check console for "Loading RBAC context" log (should appear after event ready)
+5. ✅ Verify `selectedEvent` is actually set (not null)
+6. ✅ Verify `eventLoading` is actually `false` (not `true`)
+
+**If still not working**:
+- Check browser console for any errors
+- Verify `setupRBAC(supabase)` was called
+- Check that `useRBAC` hook is being called somewhere (NavigationMenu calls it automatically)
+
+### Logs Not Appearing
+
+**If you don't see any logs**:
+1. Check log level - logs are `INFO` level, should be visible
+2. Check browser console filter settings
+3. Verify RBAC logger is configured correctly
+
+### Permission Map Still Empty
+
+**If permission map is empty after RBAC loads**:
+1. Check "RBAC context loaded successfully" log - what's the `permissionCount`?
+2. If `permissionCount: 0`, check:
+   - User has event-app role assigned
+   - Permissions exist for that role in database
+   - Event ID matches the selected event
+   - Organisation ID matches user's organisation
+
+## Expected Console Log Sequence
+
+For event-based apps, you should see this sequence:
+
+```
+1. [RBAC INFO] RBAC system initialized successfully
+2. [useRBAC] Waiting for event context before loading RBAC context
+   { eventLoading: true, hasSelectedEvent: false, appName: "TRAC" }
+3. [useRBAC] Loading RBAC context
+   { appName: "TRAC", requiresEvent: true, hasSelectedEvent: true, ... }
+4. [useRBAC] RBAC context loaded successfully
+   { appName: "TRAC", permissionCount: 32, ... }
+```
+
+## Summary
+
+- ✅ **RBAC detection is automatic** - React hooks handle it
+- ✅ **You should see "Waiting" log** - when event is loading
+- ✅ **RBAC loads automatically** - when event context becomes ready
+- ✅ **No manual triggering needed** - but you can force re-render for testing
+- ✅ **Detailed logs included** - to help debug issues
+
+The fix ensures RBAC waits for event context before loading, preventing NetworkError and ensuring permissions load correctly for event-based apps.
+

package/docs/rbac/RBAC_V0.5.147_FIX.md

@@ -0,0 +1,117 @@
+# RBAC v0.5.147 Fix - Event Context Loading
+
+## Problem
+
+RBAC wasn't loading for event-based apps because:
+1. **Logger filtering**: Critical logs were using `logger.info()` but RBAC logger defaults to `logLevel: 'warn'`, so logs were filtered out
+2. **Missing dependencies**: `appConfig` wasn't in `loadRBACContext` dependencies, so callback wasn't recreated when appConfig changed
+3. **No visibility**: No way to verify if `useRBAC` hook was being called
+
+## Fixes Applied
+
+### 1. Changed Log Levels to `warn`
+
+All critical logs now use `logger.warn()` instead of `logger.info()` so they're always visible:
+
+- `[useRBAC] Hook initialized` - Shows when hook is called
+- `[useRBAC] Waiting for event context before loading RBAC context` - Shows when waiting
+- `[useRBAC] Loading RBAC context` - Shows when loading starts
+- `[useRBAC] RBAC context loaded successfully` - Shows when loading completes
+
+### 2. Added Direct Console Logging
+
+Added direct `console.warn()` at hook initialization as a fallback to ensure visibility:
+
+```typescript
+console.warn('[useRBAC] Hook initialized (direct log)', hookInitLog);
+```
+
+This ensures logs are visible even if logger configuration is incorrect.
+
+### 3. Added `appConfig` to Dependencies
+
+Added `appConfig` to `loadRBACContext` callback dependencies so it recreates when appConfig changes:
+
+```typescript
+}, [appName, logger, resetState, selectedEvent, selectedEvent?.event_id, selectedOrganisation?.id, session, user, requiresEvent, eventLoading, appConfig]);
+```
+
+### 4. Improved `requiresEvent` Logic
+
+Changed default behavior when `appConfig` is `null`:
+
+```typescript
+// If appConfig is null initially, default to true (safer for event-based apps)
+const requiresEvent = appConfig?.requires_event ?? (appConfig === null ? true : false);
+```
+
+This prevents premature loading when appConfig hasn't loaded yet.
+
+### 5. Added useEffect Logging
+
+Added logging in `useEffect` to track when it runs:
+
+```typescript
+useEffect(() => {
+  logger.warn('[useRBAC] useEffect triggered - calling loadRBACContext', { ... });
+  loadRBACContext();
+}, [loadRBACContext, appName, requiresEvent, eventLoading, selectedEvent, user, session]);
+```
+
+### 6. Added Explicit useEffect Dependencies
+
+Added explicit dependencies to `useEffect` so it re-runs when event context changes:
+
+```typescript
+}, [loadRBACContext, appName, requiresEvent, eventLoading, selectedEvent, user, session]);
+```
+
+## Expected Console Logs
+
+After this fix, you should see this sequence:
+
+```
+1. [useRBAC] Hook initialized (direct log)
+   { appName: "TRAC", requiresEvent: true, ... }
+
+2. [useRBAC] useEffect triggered - calling loadRBACContext
+   { appName: "TRAC", requiresEvent: true, eventLoading: true, ... }
+
+3. [useRBAC] Waiting for event context before loading RBAC context
+   { eventLoading: true, hasSelectedEvent: false, appName: "TRAC" }
+
+4. [useRBAC] useEffect triggered - calling loadRBACContext
+   { appName: "TRAC", requiresEvent: true, eventLoading: false, hasSelectedEvent: true, ... }
+
+5. [useRBAC] Loading RBAC context
+   { appName: "TRAC", requiresEvent: true, hasSelectedEvent: true, ... }
+
+6. [useRBAC] RBAC context loaded successfully
+   { appName: "TRAC", permissionCount: 32, ... }
+```
+
+## Debugging Steps
+
+If you still don't see logs:
+
+1. **Check if hook is called**: Look for `[useRBAC] Hook initialized (direct log)` - this uses direct `console.warn()` so it should always appear
+2. **Check if effect runs**: Look for `[useRBAC] useEffect triggered` - this shows when the effect runs
+3. **Check event context**: Verify `eventLoading: false` and `hasSelectedEvent: true` in logs
+4. **Check appConfig**: Verify `appConfig` is not `null` and `requiresEvent: true` in logs
+
+## Testing
+
+To test the fix:
+
+1. Clear browser cache
+2. Restart dev server
+3. Open browser console
+4. Navigate to app
+5. Look for the log sequence above
+
+## Related Issues
+
+- Fixes: RBAC not loading for event-based apps
+- Related: NavigationMenu empty when `filterNavigationByPermissions={true}`
+- Related: RBAC logs not appearing
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmruthers/pace-core",
-  "version": "0.5.145",
+  "version": "0.5.147",
   "description": "Clean, modern React component library with Tailwind v4 styling and native utilities",
   "private": false,
   "publishConfig": {

package/src/rbac/hooks/useRBAC.ts

@@ -64,7 +64,25 @@ export function useRBAC(pageId?: string): UserRBACContext {
   }
   
   // Check if app requires event context
-  const requiresEvent = appConfig?.requires_event ?? false;
+  // IMPORTANT: If appConfig is null initially, default to true (safer for event-based apps)
+  // This prevents premature loading when appConfig hasn't loaded yet
+  const requiresEvent = appConfig?.requires_event ?? (appConfig === null ? true : false);
+  
+  // Log hook initialization for debugging (use warn level so it's always visible)
+  // Also use direct console.log as fallback to ensure visibility
+  const hookInitLog = {
+    appName,
+    requiresEvent,
+    appConfig: appConfig ? JSON.stringify(appConfig) : 'null',
+    hasUser: !!user,
+    hasSession: !!session,
+    hasSelectedEvent: !!selectedEvent,
+    eventLoading,
+    selectedEventId: selectedEvent?.event_id
+  };
+  logger.warn('[useRBAC] Hook initialized', hookInitLog);
+  // Direct console.log as fallback to ensure we can see if hook is called
+  console.warn('[useRBAC] Hook initialized (direct log)', hookInitLog);
 
   const [globalRole, setGlobalRole] = useState<GlobalRole | null>(null);
   const [organisationRole, setOrganisationRole] = useState<OrganisationRole | null>(null);
@@ -94,10 +112,13 @@ export function useRBAC(pageId?: string): UserRBACContext {
       if (eventLoading || !selectedEvent) {
         // Event context not ready yet - don't load RBAC yet
         // This prevents premature RPC calls that can cause NetworkError
-        logger.debug('[useRBAC] Waiting for event context before loading RBAC context', {
+        // Set loading state so React knows we're waiting
+        setIsLoading(true);
+        logger.warn('[useRBAC] Waiting for event context before loading RBAC context', {
           eventLoading,
           hasSelectedEvent: !!selectedEvent,
-          appName
+          appName,
+          selectedEventId: selectedEvent?.event_id
         });
         return;
       }
@@ -106,6 +127,14 @@ export function useRBAC(pageId?: string): UserRBACContext {
     setIsLoading(true);
     setError(null);
 
+    logger.warn('[useRBAC] Loading RBAC context', {
+      appName,
+      requiresEvent,
+      hasSelectedEvent: !!selectedEvent,
+      selectedEventId: selectedEvent?.event_id,
+      organisationId: selectedOrganisation?.id
+    });
+
     try {
       let appId: UUID | undefined;
       if (appName) {
@@ -152,6 +181,14 @@ export function useRBAC(pageId?: string): UserRBACContext {
       setGlobalRole(roleContext.globalRole);
       setOrganisationRole(roleContext.organisationRole);
       setEventAppRole(roleContext.eventAppRole || mapAccessLevelToEventRole(accessLevel));
+      
+      logger.warn('[useRBAC] RBAC context loaded successfully', {
+        appName,
+        permissionCount: Object.keys(map).length,
+        globalRole: roleContext.globalRole,
+        organisationRole: roleContext.organisationRole,
+        eventAppRole: roleContext.eventAppRole || mapAccessLevelToEventRole(accessLevel)
+      });
     } catch (err) {
       const handledError = err instanceof Error ? err : new Error('Failed to load RBAC context');
       logger.error('[useRBAC] Error loading RBAC context:', handledError);
@@ -160,7 +197,7 @@ export function useRBAC(pageId?: string): UserRBACContext {
     } finally {
       setIsLoading(false);
     }
-  }, [appName, logger, resetState, selectedEvent?.event_id, selectedOrganisation?.id, session, user, requiresEvent, eventLoading]);
+  }, [appName, logger, resetState, selectedEvent, selectedEvent?.event_id, selectedOrganisation?.id, session, user, requiresEvent, eventLoading, appConfig]);
 
   const hasGlobalPermission = useCallback(
     (permission: string): boolean => {
@@ -188,8 +225,17 @@ export function useRBAC(pageId?: string): UserRBACContext {
   const canManageEvent = useMemo(() => isSuperAdmin || eventAppRole === 'event_admin', [isSuperAdmin, eventAppRole]);
 
   useEffect(() => {
+    // Log when effect runs to help debug
+    logger.warn('[useRBAC] useEffect triggered - calling loadRBACContext', {
+      appName,
+      requiresEvent,
+      eventLoading,
+      hasSelectedEvent: !!selectedEvent,
+      hasUser: !!user,
+      hasSession: !!session
+    });
     loadRBACContext();
-  }, [loadRBACContext]);
+  }, [loadRBACContext, appName, requiresEvent, eventLoading, selectedEvent, user, session]);
 
   return {
     user,