@jmruthers/pace-core 0.5.189 → 0.5.191

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());
 
@@ -358,7 +400,7 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      const data = await result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 });
+      const data = await result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 });
 
       expect(data).toEqual([{ id: 1, name: 'Updated', organisation_id: 'org-123' }]);
     });
@@ -379,7 +421,7 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await expect(result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 })).rejects.toThrow('Update failed');
+      await expect(result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 })).rejects.toThrow('Update failed');
     });
 
     it('should return empty array when no data updated', async () => {
@@ -398,7 +440,7 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      const data = await result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 });
+      const data = await result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 });
 
       expect(data).toEqual([]);
     });
@@ -419,9 +461,9 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await result.current.secureDelete('event', { id: 1 });
+      await result.current.secureDelete('core_events', { id: 1 });
 
-      expect(mockSupabase.from).toHaveBeenCalledWith('event');
+      expect(mockSupabase.from).toHaveBeenCalledWith('core_events');
     });
 
     it('should handle delete errors', async () => {
@@ -438,7 +480,8 @@ describe('useSecureDataAccess', () => {
 
       const { result } = renderHook(() => useSecureDataAccess());
 
-      await expect(result.current.secureDelete('event', { id: 1 })).rejects.toThrow('Delete failed');
+      // The implementation throws the error, so the promise should reject
+      await expect(result.current.secureDelete('core_events', { id: 1 })).rejects.toThrow('Delete failed');
     });
   });
 
@@ -563,12 +606,12 @@ describe('useSecureDataAccess', () => {
       const { result } = renderHook(() => useSecureDataAccess());
 
       // Verify the actual behavior: secure update works correctly
-      const updateResult = await result.current.secureUpdate('event', { name: 'Updated' }, { id: 1 });
+      const updateResult = await result.current.secureUpdate('core_events', { name: 'Updated' }, { id: 1 });
 
       // Test the actual functionality: update executes and returns results
       expect(updateResult).toEqual([{ id: 1, name: 'Updated' }]);
       // Verify security: organisation filter is applied
-      expect(mockSupabase.from).toHaveBeenCalledWith('event');
+      expect(mockSupabase.from).toHaveBeenCalledWith('core_events');
       // Verify the operation completed successfully (organisation filter is applied internally)
 
       consoleSpy.mockRestore();

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;
     }
 
@@ -210,7 +210,7 @@ export function usePublicEvent(
               
               // Fallback: Direct table access with public RLS policy
             const tableResponse2 = await (supabase as any)
-              .from('event')
+              .from('core_events')
               .select(`
                 event_id,
                 event_name,
@@ -247,11 +247,11 @@ export function usePublicEvent(
               return;
             }
 
-            // Get event logo from file_references
+            // Get event logo from core_file_references
             const logoResponse = await (supabase as any)
-              .from('file_references')
+              .from('core_file_references')
               .select('file_path')
-              .eq('table_name', 'event')
+              .eq('table_name', 'core_events')
               .eq('record_id', tableData.event_id)
               .eq('is_public', true)
               .eq('file_metadata->>category', 'event_logos')
@@ -286,7 +286,7 @@ export function usePublicEvent(
         logger.warn('usePublicEvent', 'RPC call failed, falling back to direct table access:', rpcError);
         
         const tableResponse = await (supabase as any)
-          .from('event')
+          .from('core_events')
           .select(`
             event_id,
             event_name,
@@ -323,11 +323,11 @@ export function usePublicEvent(
           return;
         }
 
-        // Get event logo from file_references
+        // Get event logo from core_file_references
         const logoResponse = await (supabase as any)
-          .from('file_references')
+          .from('core_file_references')
           .select('file_path')
-          .eq('table_name', 'event')
+          .eq('table_name', 'core_events')
           .eq('record_id', tableData.event_id)
           .eq('is_public', true)
           .eq('file_metadata->>category', 'event_logos')