@jmruthers/pace-core 0.5.114 → 0.5.116

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

@@ -0,0 +1,1063 @@
+/**
+ * @file useResolvedScope Hook Tests
+ * @package @jmruthers/pace-core
+ * @module RBAC/Hooks
+ * @since 1.0.0
+ *
+ * Comprehensive tests for the useResolvedScope hook following TEST_STANDARD.md.
+ * Tests focus on behavior: scope resolution from various contexts, loading states, and error handling.
+ */
+
+import { renderHook, waitFor } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { useResolvedScope } from './useResolvedScope';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../../types/database';
+
+// Mock dependencies
+vi.mock('../utils/eventContext', () => ({
+  createScopeFromEvent: vi.fn(),
+}));
+
+vi.mock('../../utils/appNameResolver', () => ({
+  getCurrentAppName: vi.fn(),
+}));
+
+import { createScopeFromEvent } from '../utils/eventContext';
+import { getCurrentAppName } from '../../utils/appNameResolver';
+import { createMockSupabaseClient } from '../../__tests__/helpers/supabaseMock';
+
+describe('useResolvedScope Hook', () => {
+  const mockCreateScopeFromEvent = vi.mocked(createScopeFromEvent);
+  const mockGetCurrentAppName = vi.mocked(getCurrentAppName);
+
+  let mockSupabase: SupabaseClient<Database>;
+  let sharedMockQuery: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    // Create a shared query builder that will be returned by from()
+    // Default to resolving successfully for app lookup
+    sharedMockQuery = {
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      single: vi.fn().mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      }),
+    };
+    
+    mockSupabase = {
+      from: vi.fn().mockReturnValue(sharedMockQuery),
+      rpc: vi.fn(),
+    } as any;
+    
+    mockGetCurrentAppName.mockReturnValue('test-app');
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Scope Resolution', () => {
+    it('resolves scope when both organisation and event are provided', async () => {
+      // Set up mock BEFORE rendering hook
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.resolvedScope).toBeNull();
+
+      // Wait for async app ID resolution to complete
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // The stable scope ref is updated in a useEffect that depends on resolvedScope state
+      // The return value checks stableScope.organisationId, so we need to wait for the ref update
+      // Force a re-render to pick up the ref change (refs don't trigger re-renders)
+      rerender();
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+          expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Verify the mock was called
+      expect(sharedMockQuery.single).toHaveBeenCalled();
+      
+      // The resolved scope should include organisation, event, and app ID
+      expect(result.current.resolvedScope).toEqual({
+        organisationId: 'org-123',
+        eventId: 'event-123',
+        appId: 'app-123',
+      });
+      expect(result.current.error).toBeNull();
+    });
+
+    it('resolves scope when only organisation is provided', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: null,
+        })
+      );
+
+      // Wait for async app ID resolution to complete
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // The stable scope ref is updated in a useEffect after resolvedScope state updates
+      // Force a rerender to pick up the ref change (refs don't trigger re-renders)
+      rerender();
+
+      // Wait for stable scope ref to update (happens in useEffect after state update)
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      expect(result.current.resolvedScope).toEqual({
+        organisationId: 'org-123',
+        eventId: undefined,
+        appId: 'app-123',
+      });
+      expect(result.current.error).toBeNull();
+    });
+
+    it('resolves scope from event when only event is provided', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      mockCreateScopeFromEvent.mockResolvedValue({
+        organisationId: 'org-456',
+        eventId: 'event-123',
+        appId: 'app-123',
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: null,
+          selectedEventId: 'event-123',
+        })
+      );
+
+      // Wait for async app ID resolution to complete
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // The stable scope ref is updated in a useEffect after resolvedScope state updates
+      // Force a rerender to pick up the ref change (refs don't trigger re-renders)
+      rerender();
+
+      // Wait for stable scope ref to update (happens in useEffect after state update)
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      expect(result.current.resolvedScope).toEqual({
+        organisationId: 'org-456',
+        eventId: 'event-123',
+        appId: 'app-123',
+      });
+      expect(result.current.error).toBeNull();
+      expect(mockCreateScopeFromEvent).toHaveBeenCalledWith(
+        mockSupabase,
+        'event-123',
+        'app-123'
+      );
+    });
+
+    it('handles no context available', async () => {
+      const { result } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: null,
+          selectedEventId: null,
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      expect(result.current.resolvedScope).toBeNull();
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toBe(
+        'No organisation or event context available'
+      );
+    });
+  });
+
+  describe('App ID Resolution', () => {
+    it('resolves app ID from database when app name is available', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      // Wait for async app ID resolution to complete
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // The stable scope ref is updated in a useEffect after resolvedScope state updates
+      // Force a rerender to pick up the ref change (refs don't trigger re-renders)
+      rerender();
+
+      // Wait for stable scope ref to update (happens in useEffect after state update)
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      expect(result.current.resolvedScope?.appId).toBe('app-123');
+    });
+
+    it('handles app not found in database', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: null,
+        error: { message: 'App not found' },
+      });
+
+      // Mock inactive app check - second call uses same query builder
+      sharedMockQuery.single.mockResolvedValueOnce({
+        data: null,
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Should still resolve scope without app ID
+      // Note: appId is set to empty string '' when not provided (not undefined)
+      expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+      expect(result.current.resolvedScope?.appId).toBe('');
+    });
+
+    it('handles inactive app', async () => {
+      // First call (with is_active=true filter) returns error
+      // Second call (without is_active filter) returns inactive app
+      sharedMockQuery.single
+        .mockResolvedValueOnce({
+          data: null,
+          error: { message: 'App not found' },
+        })
+        .mockResolvedValueOnce({
+          data: { id: 'app-123', name: 'test-app', is_active: false },
+          error: null,
+        });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Should still resolve scope without app ID (app is inactive)
+      // Note: appId is set to empty string '' when not provided (not undefined)
+      expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+      expect(result.current.resolvedScope?.appId).toBe('');
+    });
+
+    it('handles missing app name', async () => {
+      mockGetCurrentAppName.mockReturnValue(null);
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Note: appId is set to empty string '' when not provided (not undefined)
+      expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+      expect(result.current.resolvedScope?.appId).toBe('');
+    });
+
+    it('handles null supabase client', async () => {
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: null,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Should resolve scope without app ID when supabase is null
+      // Note: appId is set to empty string '' when not provided (not undefined)
+      expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+      expect(result.current.resolvedScope?.appId).toBe('');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('handles error when event scope resolution fails', async () => {
+      const error = new Error('Failed to resolve event scope');
+      mockCreateScopeFromEvent.mockResolvedValue(null);
+
+      const { result } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: null,
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      expect(result.current.resolvedScope).toBeNull();
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toBe(
+        'Could not resolve organisation from event context'
+      );
+    });
+
+    it('handles error when createScopeFromEvent throws', async () => {
+      const error = new Error('Database error');
+      mockCreateScopeFromEvent.mockRejectedValue(error);
+
+      const { result } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: null,
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      expect(result.current.resolvedScope).toBeNull();
+      expect(result.current.error).toEqual(error);
+    });
+
+    it('handles database error when resolving app ID', async () => {
+      sharedMockQuery.single.mockRejectedValueOnce(
+        new Error('Database connection failed')
+      );
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Should still resolve scope without app ID
+      // Note: appId is set to empty string '' when not provided (not undefined)
+      expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+      expect(result.current.resolvedScope?.appId).toBe('');
+    });
+  });
+
+  describe('Dependency Changes', () => {
+    it('refetches when organisation ID changes', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(
+        ({ selectedOrganisationId, selectedEventId }) =>
+          useResolvedScope({
+            supabase: mockSupabase,
+            selectedOrganisationId,
+            selectedEventId,
+          }),
+        {
+          initialProps: {
+            selectedOrganisationId: 'org-123',
+            selectedEventId: 'event-123',
+          },
+        }
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass current props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+          expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Change organisation
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-456',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass current props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-456',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope?.organisationId).toBe('org-456');
+        },
+        { timeout: 2000, interval: 10 }
+      );
+    });
+
+    it('refetches when event ID changes', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(
+        ({ selectedOrganisationId, selectedEventId }) =>
+          useResolvedScope({
+            supabase: mockSupabase,
+            selectedOrganisationId,
+            selectedEventId,
+          }),
+        {
+          initialProps: {
+            selectedOrganisationId: 'org-123',
+            selectedEventId: 'event-123',
+          },
+        }
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass current props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+          expect(result.current.resolvedScope?.eventId).toBe('event-123');
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Change event
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-456',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass current props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-456',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope?.eventId).toBe('event-456');
+        },
+        { timeout: 2000, interval: 10 }
+      );
+    });
+
+    it('refetches when supabase client changes', async () => {
+      const mockQuery1 = (mockSupabase.from as any)('rbac_apps');
+      mockQuery1.select().eq().eq().single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(
+        ({ supabase, selectedOrganisationId, selectedEventId }) =>
+          useResolvedScope({
+            supabase,
+            selectedOrganisationId,
+            selectedEventId,
+          }),
+        {
+          initialProps: {
+            supabase: mockSupabase,
+            selectedOrganisationId: 'org-123',
+            selectedEventId: 'event-123',
+          },
+        }
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass current props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Change supabase client - create new mock with shared query builder
+      const newSupabaseQuery = {
+        select: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockReturnThis(),
+        single: vi.fn().mockResolvedValue({
+          data: { id: 'app-456', name: 'test-app', is_active: true },
+          error: null,
+        }),
+      };
+      const newSupabase = {
+        from: vi.fn().mockReturnValue(newSupabaseQuery),
+        rpc: vi.fn(),
+      } as any;
+
+      rerender({
+        supabase: newSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass current props
+      rerender({
+        supabase: newSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope?.appId).toBe('app-456');
+        },
+        { timeout: 2000, interval: 10 }
+      );
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles empty string organisation ID', async () => {
+      const { result } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: '',
+          selectedEventId: null,
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      expect(result.current.resolvedScope).toBeNull();
+      expect(result.current.error).toBeInstanceOf(Error);
+    });
+
+    it('handles empty string event ID', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: '',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Should resolve with organisation only
+      expect(result.current.resolvedScope?.organisationId).toBe('org-123');
+      expect(result.current.resolvedScope?.eventId).toBeUndefined();
+    });
+
+    it('preserves app ID from event scope when resolving from event', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      mockCreateScopeFromEvent.mockResolvedValue({
+        organisationId: 'org-456',
+        eventId: 'event-123',
+        appId: 'app-789', // Different app ID from event scope
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: null,
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Should use resolved app ID (app-123) over event scope app ID
+      expect(result.current.resolvedScope?.appId).toBe('app-123');
+    });
+
+    it('uses event scope app ID when app ID not resolved from database', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: null,
+        error: { message: 'App not found' },
+      });
+
+      // Mock inactive app check - second call uses same query builder
+      sharedMockQuery.single.mockResolvedValueOnce({
+        data: null,
+        error: null,
+      });
+
+      mockCreateScopeFromEvent.mockResolvedValue({
+        organisationId: 'org-456',
+        eventId: 'event-123',
+        appId: 'app-789', // App ID from event scope
+      });
+
+      const { result, rerender } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: null,
+          selectedEventId: 'event-123',
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update - need to pass props
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Should use event scope app ID when database resolution fails
+      expect(result.current.resolvedScope?.appId).toBe('app-789');
+    });
+  });
+
+  describe('Loading States', () => {
+    it('shows loading state during initial resolution', () => {
+      sharedMockQuery.single.mockImplementation(
+        () => new Promise(() => {}) // Never resolves
+      );
+
+      const { result } = renderHook(() =>
+        useResolvedScope({
+          supabase: mockSupabase,
+          selectedOrganisationId: 'org-123',
+          selectedEventId: 'event-123',
+        })
+      );
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.resolvedScope).toBeNull();
+      expect(result.current.error).toBeNull();
+    });
+
+    it('shows loading state during refetch', async () => {
+      sharedMockQuery.single.mockResolvedValue({
+        data: { id: 'app-123', name: 'test-app', is_active: true },
+        error: null,
+      });
+
+      const { result, rerender } = renderHook(
+        ({ selectedOrganisationId, selectedEventId }) =>
+          useResolvedScope({
+            supabase: mockSupabase,
+            selectedOrganisationId,
+            selectedEventId,
+          }),
+        {
+          initialProps: {
+            selectedOrganisationId: 'org-123',
+            selectedEventId: 'event-123',
+          },
+        }
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update
+      rerender({
+        supabase: mockSupabase,
+        selectedOrganisationId: 'org-123',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+        },
+        { timeout: 2000, interval: 10 }
+      );
+
+      // Mock slow refetch
+      sharedMockQuery.single.mockImplementation(
+        () => new Promise(() => {}) // Never resolves
+      );
+
+      rerender({
+        selectedOrganisationId: 'org-456',
+        selectedEventId: 'event-123',
+      });
+
+      // Should show loading during refetch
+      expect(result.current.isLoading).toBe(true);
+    });
+  });
+
+  describe('Cleanup', () => {
+    it('cancels in-flight requests when dependencies change', async () => {
+      let resolveCount = 0;
+
+      sharedMockQuery.single.mockImplementation(() => {
+        resolveCount++;
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            resolve({
+              data: { id: 'app-123', name: 'test-app', is_active: true },
+              error: null,
+            });
+          }, 100);
+        });
+      });
+
+      const { result, rerender } = renderHook(
+        ({ selectedOrganisationId, selectedEventId }) =>
+          useResolvedScope({
+            supabase: mockSupabase,
+            selectedOrganisationId,
+            selectedEventId,
+          }),
+        {
+          initialProps: {
+            selectedOrganisationId: 'org-123',
+            selectedEventId: 'event-123',
+          },
+        }
+      );
+
+      // Rapidly change dependencies
+      rerender({
+        selectedOrganisationId: 'org-456',
+        selectedEventId: 'event-123',
+      });
+
+      rerender({
+        selectedOrganisationId: 'org-789',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.isLoading).toBe(false);
+        },
+        { timeout: 2000 }
+      );
+
+      // Force rerender to pick up ref update
+      rerender({
+        selectedOrganisationId: 'org-789',
+        selectedEventId: 'event-123',
+      });
+
+      await waitFor(
+        () => {
+          expect(result.current.resolvedScope).not.toBeNull();
+          expect(result.current.resolvedScope?.organisationId).toBe('org-789');
+        },
+        { timeout: 2000, interval: 10 }
+      );
+    });
+  });
+});
+