@jmruthers/pace-core 0.5.188 → 0.5.190

package/src/hooks/__tests__/usePreventTabReload.test.ts

@@ -0,0 +1,88 @@
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { usePreventTabReload } from '../usePreventTabReload';
+
+describe('usePreventTabReload', () => {
+  const originalHidden = Object.getOwnPropertyDescriptor(Document.prototype, 'hidden');
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.spyOn(window, 'addEventListener');
+    vi.spyOn(window, 'removeEventListener');
+    vi.spyOn(document, 'addEventListener');
+    vi.spyOn(document, 'removeEventListener');
+
+    // Ensure document.hidden is configurable for visibility tests
+    Object.defineProperty(document, 'hidden', {
+      configurable: true,
+      get: () => false,
+    });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+
+    if (originalHidden) {
+      Object.defineProperty(Document.prototype, 'hidden', originalHidden);
+    }
+  });
+
+  it('registers listeners and schedules grace period on pageshow from bfcache', () => {
+    const setTimeoutSpy = vi.spyOn(global, 'setTimeout');
+
+    const { unmount } = renderHook(() => usePreventTabReload({ gracePeriodMs: 1000 }));
+
+    const pageshowListener = vi.mocked(window.addEventListener).mock.calls.find(
+      call => call[0] === 'pageshow'
+    )?.[1] as (event: any) => void;
+
+    expect(pageshowListener).toBeDefined();
+
+    act(() => {
+      pageshowListener?.({ persisted: true });
+    });
+
+    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 1000);
+
+    act(() => {
+      unmount();
+    });
+
+    expect(window.removeEventListener).toHaveBeenCalledWith('pageshow', pageshowListener);
+  });
+
+  it('handles visibility changes by delaying reloads and cleans up timers', () => {
+    const clearTimeoutSpy = vi.spyOn(global, 'clearTimeout');
+    const setTimeoutSpy = vi.spyOn(global, 'setTimeout');
+
+    const { unmount } = renderHook(() => usePreventTabReload({ gracePeriodMs: 500 }));
+
+    const visibilityListener = vi.mocked(document.addEventListener).mock.calls.find(
+      call => call[0] === 'visibilitychange'
+    )?.[1] as () => void;
+
+    expect(visibilityListener).toBeDefined();
+
+    act(() => {
+      visibilityListener?.();
+    });
+
+    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 500);
+
+    act(() => {
+      unmount();
+    });
+
+    expect(clearTimeoutSpy).toHaveBeenCalled();
+    expect(document.removeEventListener).toHaveBeenCalledWith('visibilitychange', visibilityListener);
+  });
+
+  it('does not attach listeners when disabled', () => {
+    renderHook(() => usePreventTabReload({ enabled: false }));
+
+    expect(window.addEventListener).not.toHaveBeenCalled();
+    expect(document.addEventListener).not.toHaveBeenCalled();
+  });
+});
+

package/src/hooks/__tests__/{usePublicEvent.unit.test.ts → usePublicEvent.test.ts}

@@ -69,7 +69,7 @@ describe('usePublicEvent', () => {
     Object.defineProperty(import.meta, 'env', {
       value: {
         VITE_SUPABASE_URL: 'https://test.supabase.co',
-        VITE_SUPABASE_ANON_KEY: 'test-anon-key'
+        VITE_SUPABASE_PUBLISHABLE_KEY: 'test-publishable-key'
       },
       writable: true
     });
@@ -577,5 +577,32 @@ describe('usePublicEvent', () => {
       expect(result.current.event).toBe(null);
       expect(result.current.error).toEqual(new Error('Event not found'));
     });
+
+    it('warns when Supabase environment variables are missing', async () => {
+      vi.mocked(usePublicPageContext).mockReturnValue({
+        environment: { supabaseUrl: null, supabaseKey: null }
+      } as any);
+
+      Object.defineProperty(import.meta, 'env', {
+        value: {},
+        writable: true
+      });
+
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const { createClient } = await import('@supabase/supabase-js');
+      vi.mocked(createClient).mockClear();
+
+      const { result } = renderHook(() => usePublicEvent('test-event'));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      }, { interval: 10 });
+
+      expect(result.current.error).toBeInstanceOf(Error);
+      expect(result.current.error?.message).toContain('Invalid event code or Supabase client not available');
+      expect(vi.mocked(createClient)).not.toHaveBeenCalled();
+
+      warnSpy.mockRestore();
+    });
   });
 });

package/src/hooks/__tests__/useQueryCache.test.ts

@@ -0,0 +1,144 @@
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { useQueryCache, queryCacheHelpers } from '../useQueryCache';
+
+vi.mock('../../utils/core/logger', () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    error: vi.fn(),
+  }),
+}));
+
+describe('useQueryCache', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  const supabase = {} as SupabaseClient<any>;
+
+  it('caches query results and returns cached data', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({ id: 1 });
+    const { result } = renderHook(() => useQueryCache(supabase));
+
+    const first = await result.current.getCachedQuery('table', 'id', '1', fetchFn, { ttl: 5 });
+    const second = await result.current.getCachedQuery('table', 'id', '1', fetchFn, { ttl: 5 });
+
+    expect(first).toEqual({ id: 1 });
+    expect(second).toEqual(first);
+    expect(fetchFn).toHaveBeenCalledTimes(1);
+
+    act(() => {
+      result.current.clearCache();
+    });
+  });
+
+  it('invalidates cache entries explicitly', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({ id: 2 });
+    const { result } = renderHook(() => useQueryCache());
+
+    await result.current.getCachedQuery('table', 'id', '2', fetchFn);
+    act(() => {
+      result.current.invalidateQuery('table', 'id', '2');
+    });
+    await result.current.getCachedQuery('table', 'id', '2', fetchFn);
+
+    expect(fetchFn).toHaveBeenCalledTimes(2);
+
+    act(() => {
+      result.current.clearCache();
+    });
+  });
+
+  it('expires cache entries after ttl', async () => {
+    const fetchFn = vi.fn().mockResolvedValue('value');
+    const { result } = renderHook(() => useQueryCache());
+
+    await result.current.getCachedQuery('table', 'key', 'val', fetchFn, { ttl: 1 });
+
+    vi.setSystemTime(2000); // advance past ttl
+    await result.current.getCachedQuery('table', 'key', 'val', fetchFn, { ttl: 1 });
+
+    expect(fetchFn).toHaveBeenCalledTimes(2);
+
+    act(() => {
+      result.current.clearCache();
+    });
+  });
+
+  it('deduplicates in-flight requests', async () => {
+    let resolveFn: (value: string) => void;
+    const fetchPromise = new Promise<string>(resolve => {
+      resolveFn = resolve;
+    });
+    const fetchFn = vi.fn(() => fetchPromise);
+    const { result } = renderHook(() => useQueryCache());
+
+    const firstPromise = result.current.getCachedQuery('table', 'id', '3', fetchFn);
+    const secondPromise = result.current.getCachedQuery('table', 'id', '3', fetchFn);
+
+    expect(fetchFn).toHaveBeenCalledTimes(1);
+
+    resolveFn!('done');
+
+    await expect(firstPromise).resolves.toBe('done');
+    await expect(secondPromise).resolves.toBe('done');
+
+    act(() => {
+      result.current.clearCache();
+    });
+  });
+
+  it('bypasses cache when disabled', async () => {
+    const fetchFn = vi.fn().mockResolvedValue('fresh');
+    const { result } = renderHook(() => useQueryCache());
+
+    await result.current.getCachedQuery('table', 'id', '4', fetchFn, { enabled: false });
+    await result.current.getCachedQuery('table', 'id', '4', fetchFn, { enabled: false });
+
+    expect(fetchFn).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('queryCacheHelpers', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it('caches helper queries and reuses promises for in-flight requests', async () => {
+    let resolveFn: (value: string) => void;
+    const promise = new Promise<string>(resolve => {
+      resolveFn = resolve;
+    });
+    const fetchFn = vi.fn(() => promise);
+    const supabase = {} as SupabaseClient<any>;
+
+    const firstPromise = queryCacheHelpers.pacePersonByUserId(supabase, 'user', fetchFn);
+    const secondPromise = queryCacheHelpers.pacePersonByUserId(supabase, 'user', fetchFn);
+
+    expect(fetchFn).toHaveBeenCalledTimes(1);
+
+    resolveFn!('person');
+
+    await expect(firstPromise).resolves.toBe('person');
+    await expect(secondPromise).resolves.toBe('person');
+
+    // Subsequent call should return cached data immediately
+    const cached = await queryCacheHelpers.pacePersonByUserId(supabase, 'user', fetchFn);
+    expect(cached).toBe('person');
+    expect(fetchFn).toHaveBeenCalledTimes(1);
+  });
+});
+

package/src/hooks/__tests__/useSecureDataAccess.unit.test.tsx

@@ -4,6 +4,8 @@ import { useSecureDataAccess } from '../useSecureDataAccess';
 import { useUnifiedAuth } from '../../providers';
 import { useOrganisations } from '../../hooks/useOrganisations';
 import { testDataGenerators } from '../../__tests__/helpers/test-utils';
+import { useResolvedScope } from '../../rbac/hooks/useResolvedScope';
+import { useSuperAdminBypass } from '../../rbac/hooks/useSuperAdminBypass';
 
 // Mock dependencies
 vi.mock('../../providers', () => ({
@@ -22,10 +24,20 @@ vi.mock('../../utils/context/organisationContext', () => ({
   setOrganisationContext: vi.fn().mockResolvedValue(undefined),
 }));
 
+vi.mock('../../rbac/hooks/useResolvedScope', () => ({
+  useResolvedScope: vi.fn(),
+}));
+
+vi.mock('../../rbac/hooks/useSuperAdminBypass', () => ({
+  useSuperAdminBypass: vi.fn(),
+}));
+
 const mockUseUnifiedAuth = {
   user: null,
   session: null,
-  supabase: null
+  supabase: null,
+  selectedOrganisation: null,
+  selectedEvent: null,
 };
 
 const mockUseOrganisations = vi.fn(() => ({
@@ -54,7 +66,8 @@ const createAuthenticatedContext = (supabase = { auth: {} }, org = { id: 'org-12
     ...mockUseUnifiedAuth,
     user: mockUser,
     session: mockSession,
-    supabase
+    supabase,
+    selectedOrganisation: org,
   } as any);
   
   // Create a fresh mock with ensureOrganisationContext that returns the org
@@ -76,6 +89,17 @@ const createAuthenticatedContext = (supabase = { auth: {} }, org = { id: 'org-12
   };
   
   vi.mocked(useOrganisations).mockReturnValue(mockOrgs as any);
+  
+  // Mock resolved scope with organisationId
+  vi.mocked(useResolvedScope).mockReturnValue({
+    resolvedScope: {
+      organisationId: org.id,
+      eventId: undefined,
+      appId: undefined,
+    },
+    isLoading: false,
+    error: null,
+  });
 };
 
 describe('useSecureDataAccess', () => {
@@ -84,6 +108,16 @@ describe('useSecureDataAccess', () => {
     vi.mocked(useUnifiedAuth).mockReturnValue(mockUseUnifiedAuth as any);
     // Set up useOrganisations to return the default mock (which throws for org context)
     vi.mocked(useOrganisations).mockReturnValue(mockUseOrganisations() as any);
+    // Default mock for useResolvedScope - returns null scope (no context)
+    vi.mocked(useResolvedScope).mockReturnValue({
+      resolvedScope: null,
+      isLoading: false,
+      error: null,
+    });
+    // Default mock for useSuperAdminBypass - not super admin
+    vi.mocked(useSuperAdminBypass).mockReturnValue({
+      isSuperAdmin: false,
+    });
   });
 
   describe('validateContext', () => {
@@ -129,21 +163,23 @@ describe('useSecureDataAccess', () => {
         user: mockUser,
         session: mockSession,
         supabase: mockSupabase,
+        selectedOrganisation: { id: 'org-123' },
       } as any);
       
-      const mockOrg = { id: 'org-123' };
-      const ensureOrgContextMock = vi.fn(() => mockOrg);
-      
-      const mockOrgs = {
-        ...mockUseOrganisations(),
-        ensureOrganisationContext: ensureOrgContextMock,
-      };
-      vi.mocked(useOrganisations).mockReturnValue(mockOrgs as any);
+      // Mock useResolvedScope to return resolved scope with organisationId
+      vi.mocked(useResolvedScope).mockReturnValue({
+        resolvedScope: {
+          organisationId: 'org-123',
+          eventId: undefined,
+          appId: undefined,
+        },
+        isLoading: false,
+        error: null,
+      });
 
       const { result } = renderHook(() => useSecureDataAccess());
 
       expect(() => result.current.validateContext()).not.toThrow();
-      expect(ensureOrgContextMock).toHaveBeenCalled();
     });
   });
 
@@ -158,13 +194,19 @@ describe('useSecureDataAccess', () => {
         user: mockUser,
         session: mockSession,
         supabase: mockSupabase,
+        selectedOrganisation: { id: 'org-123' },
       } as any);
       
-      const mockOrgs = {
-        ...mockUseOrganisations(),
-        ensureOrganisationContext: vi.fn().mockReturnValue({ id: 'org-123' }),
-      };
-      vi.mocked(useOrganisations).mockReturnValue(mockOrgs as any);
+      // Mock resolved scope with organisationId
+      vi.mocked(useResolvedScope).mockReturnValue({
+        resolvedScope: {
+          organisationId: 'org-123',
+          eventId: undefined,
+          appId: undefined,
+        },
+        isLoading: false,
+        error: null,
+      });
 
       const { result } = renderHook(() => useSecureDataAccess());
 

package/src/hooks/index.ts

@@ -50,7 +50,7 @@ export { useComponentPerformance } from './useComponentPerformance';
 export { useAppConfig } from './useAppConfig';
 export type { UseAppConfigReturn } from './useAppConfig';
 export { usePerformanceMonitor } from './usePerformanceMonitor';
-export { useQueryCache, queryCacheHelpers } from './useQueryCache';
+export { useQueryCache, queryCacheHelpers, cleanupQueryCache } from './useQueryCache';
 export type { UseQueryCacheReturn, UseQueryCacheOptions } from './useQueryCache';
 
 // DataTable performance hook

package/src/hooks/public/usePublicEvent.ts

@@ -120,7 +120,7 @@ export function usePublicEvent(
     // Fallback to direct environment variable access if not in PublicPageProvider
     environment = {
       supabaseUrl: (import.meta as any).env?.VITE_SUPABASE_URL || (import.meta as any).env?.NEXT_PUBLIC_SUPABASE_URL || null,
-      supabaseKey: (import.meta as any).env?.VITE_SUPABASE_ANON_KEY || (import.meta as any).env?.NEXT_PUBLIC_SUPABASE_ANON_KEY || null
+      supabaseKey: (import.meta as any).env?.VITE_SUPABASE_PUBLISHABLE_KEY || (import.meta as any).env?.NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY || null
     };
   }
   
@@ -129,7 +129,7 @@ export function usePublicEvent(
     if (typeof window === 'undefined') return null;
     
     if (!environment.supabaseUrl || !environment.supabaseKey) {
-      logger.warn('usePublicEvent', 'Missing Supabase environment variables. Please ensure VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY are set in your environment. Use publishable key if anon key is disabled.');
+      logger.warn('usePublicEvent', 'Missing Supabase environment variables. Please ensure VITE_SUPABASE_URL and VITE_SUPABASE_PUBLISHABLE_KEY are set in your environment.');
       return null;
     }