@jmruthers/pace-core 0.5.186 → 0.5.188

package/src/hooks/useInactivityTracker.ts

@@ -155,6 +155,7 @@ export function useInactivityTracker({
   const countdownIntervalRef = useRef<NodeJS.Timeout | null>(null);
   const lastActivityRef = useRef<number>(Date.now());
   const channelRef = useRef<BroadcastChannel | null>(null);
+  const throttledResetActivityRef = useRef<((event: Event) => void) | null>(null);
 
   // Clear all timers
   const clearTimers = useCallback(() => {
@@ -294,47 +295,56 @@ export function useInactivityTracker({
       logger.warn('useInactivityTracker', 'Failed to check persisted activity time:', error);
     }
 
-    // Set up throttled activity handler
-    const throttledResetActivity = throttle((event) => {
-      resetActivity();
-    }, 100);
-
-    // Add event listeners
-    const addEventListeners = () => {
+    // Clean up any existing throttled handler and event listeners first
+    if (throttledResetActivityRef.current) {
       ACTIVITY_EVENTS.forEach(event => {
-        document.addEventListener(event, throttledResetActivity, { passive: true });
+        document.removeEventListener(event, throttledResetActivityRef.current!);
       });
-    };
+    }
 
-    // Remove event listeners
-    const removeEventListeners = () => {
-      ACTIVITY_EVENTS.forEach(event => {
-        document.removeEventListener(event, throttledResetActivity);
-      });
-    };
+    // Set up throttled activity handler - store in ref for proper cleanup
+    throttledResetActivityRef.current = throttle((event) => {
+      resetActivity();
+    }, 100);
 
-    // Add listeners
-    addEventListeners();
+    // Add event listeners
+    ACTIVITY_EVENTS.forEach(event => {
+      document.addEventListener(event, throttledResetActivityRef.current!, { passive: true });
+    });
 
     // Start the timer (skip activity callback for initial setup)
     resetActivity(true);
 
     // Cleanup function
     return () => {
-      removeEventListeners();
+      // Remove event listeners using the stored ref
+      if (throttledResetActivityRef.current) {
+        ACTIVITY_EVENTS.forEach(event => {
+          document.removeEventListener(event, throttledResetActivityRef.current!);
+        });
+        throttledResetActivityRef.current = null;
+      }
       clearTimers();
       if (channelRef.current) {
         channelRef.current.close();
         channelRef.current = null;
       }
     };
-  }, [enabled, isTracking, channelName, storageKey, idleTimeoutMs, warnBeforeMs, onIdle, onWarning]);
+  }, [enabled, isTracking, channelName, storageKey, idleTimeoutMs, warnBeforeMs, onIdle, onWarning, onActivity, resetActivity]);
 
   // Stop tracking
   const stopTracking = useCallback(() => {
     setIsTracking(false);
     clearTimers();
     
+    // Remove event listeners
+    if (throttledResetActivityRef.current) {
+      ACTIVITY_EVENTS.forEach(event => {
+        document.removeEventListener(event, throttledResetActivityRef.current!);
+      });
+      throttledResetActivityRef.current = null;
+    }
+    
     if (channelRef.current) {
       channelRef.current.close();
       channelRef.current = null;
@@ -348,8 +358,9 @@ export function useInactivityTracker({
       return cleanup;
     } else {
       stopTracking();
+      return undefined;
     }
-  }, [enabled, idleTimeoutMs, warnBeforeMs]);
+  }, [enabled, idleTimeoutMs, warnBeforeMs, startTracking, stopTracking]);
 
   // Cleanup on unmount
   useEffect(() => {

package/src/hooks/useOrganisationSecurity.test.ts

@@ -26,6 +26,7 @@ vi.mock('./useOrganisations', () => ({
 // Mock the RBAC API
 vi.mock('../rbac/api', () => ({
   isPermitted: vi.fn(),
+  isPermittedCached: vi.fn(),
   isSuperAdmin: vi.fn(),
   getPermissionMap: vi.fn()
 }));
@@ -35,13 +36,14 @@ vi.mock('../rbac/audit', () => ({
   emitAuditEvent: vi.fn()
 }));
 
-import { isPermitted, isSuperAdmin, getPermissionMap } from '../rbac/api';
+import { isPermitted, isPermittedCached, isSuperAdmin, getPermissionMap } from '../rbac/api';
 import { emitAuditEvent } from '../rbac/audit';
 
 describe('useOrganisationSecurity', () => {
   const mockUseUnifiedAuth = vi.mocked(useUnifiedAuth);
   const mockUseOrganisations = vi.mocked(useOrganisations);
   const mockIsPermitted = vi.mocked(isPermitted);
+  const mockIsPermittedCached = vi.mocked(isPermittedCached);
   const mockIsSuperAdmin = vi.mocked(isSuperAdmin);
   const mockGetPermissionMap = vi.mocked(getPermissionMap);
   const mockEmitAuditEvent = vi.mocked(emitAuditEvent);
@@ -99,6 +101,7 @@ describe('useOrganisationSecurity', () => {
     mockUseUnifiedAuth.mockClear();
     mockUseOrganisations.mockClear();
     mockIsPermitted.mockClear();
+    mockIsPermittedCached.mockClear();
     mockIsSuperAdmin.mockClear();
     mockGetPermissionMap.mockClear();
     mockEmitAuditEvent.mockClear();
@@ -508,13 +511,13 @@ describe('useOrganisationSecurity', () => {
         signOut: vi.fn(),
       } as any);
 
-      mockIsPermitted.mockResolvedValue(true);
+      mockIsPermittedCached.mockResolvedValue(true);
 
       const { result } = renderHook(() => useOrganisationSecurity());
 
       const hasPermission = await result.current.hasPermission('read:users');
       expect(hasPermission).toBe(true);
-      expect(mockIsPermitted).toHaveBeenCalledWith({
+      expect(mockIsPermittedCached).toHaveBeenCalledWith({
         userId: 'user-123',
         scope: {
           organisationId: 'org-123',
@@ -527,13 +530,13 @@ describe('useOrganisationSecurity', () => {
 
     it('checks permissions for specific organisation', async () => {
       mockIsSuperAdmin.mockResolvedValue(false);
-      mockIsPermitted.mockResolvedValue(true);
+      mockIsPermittedCached.mockResolvedValue(true);
 
       const { result } = renderHook(() => useOrganisationSecurity());
 
       const hasPermission = await result.current.hasPermission('read:users', 'org-456');
       expect(hasPermission).toBe(true);
-      expect(mockIsPermitted).toHaveBeenCalledWith({
+      expect(mockIsPermittedCached).toHaveBeenCalledWith({
         userId: 'user-123',
         scope: {
           organisationId: 'org-456',
@@ -546,7 +549,7 @@ describe('useOrganisationSecurity', () => {
 
     it('handles permission check errors gracefully', async () => {
       mockIsSuperAdmin.mockResolvedValue(false);
-      mockIsPermitted.mockRejectedValue(new Error('Permission check failed'));
+      mockIsPermittedCached.mockRejectedValue(new Error('Permission check failed'));
 
       const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
@@ -622,7 +625,7 @@ describe('useOrganisationSecurity', () => {
 
     it('handles permission retrieval errors gracefully', async () => {
       mockIsSuperAdmin.mockResolvedValue(false);
-      mockIsPermitted.mockRejectedValue(new Error('Permission retrieval failed'));
+      mockIsPermittedCached.mockRejectedValue(new Error('Permission retrieval failed'));
 
       const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 

package/src/hooks/useOrganisationSecurity.ts

@@ -163,8 +163,8 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
     if (!targetOrgId || !user) return false;
 
     try {
-      // Use the new RBAC system
-      const { isPermitted } = await import('../rbac/api');
+      // Use the new RBAC system with caching
+      const { isPermittedCached } = await import('../rbac/api');
       
       const scope = {
         organisationId: targetOrgId,
@@ -172,7 +172,7 @@ export const useOrganisationSecurity = (): OrganisationSecurityHook => {
         appId: user.user_metadata?.appId || user.app_metadata?.appId,
       };
 
-      return await isPermitted({
+      return await isPermittedCached({
         userId: user.id,
         scope,
         permission: permission as Permission

package/src/hooks/useQueryCache.ts

@@ -0,0 +1,315 @@
+/**
+ * Query Result Caching Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/QueryCache
+ * @since 2.0.0
+ * 
+ * Provides in-memory caching for frequently accessed data to eliminate duplicate queries.
+ * Useful for caching user profiles, app pages, and other relatively static data.
+ */
+
+import { useCallback, useRef, useEffect } from 'react';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { Database } from '../types/database';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useQueryCache');
+
+interface CachedQueryEntry<T> {
+  data: T;
+  expiresAt: number; // Unix timestamp
+  promise?: Promise<T>; // For in-flight requests
+}
+
+/**
+ * In-memory cache for query results
+ * Key format: `table:filterKey:filterValue`
+ */
+const queryCache = new Map<string, CachedQueryEntry<any>>();
+
+// Cleanup interval (every 5 minutes)
+const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+let cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+function runCacheCleanup() {
+  const now = Date.now();
+  const expiredKeys: string[] = [];
+  
+  queryCache.forEach((entry, key) => {
+    if (entry.expiresAt <= now) {
+      expiredKeys.push(key);
+    }
+  });
+  
+  expiredKeys.forEach(key => {
+    queryCache.delete(key);
+    log.debug(`Removed expired query from cache: ${key}`);
+  });
+}
+
+// Initialize cleanup timer once
+if (typeof window !== 'undefined' && !cleanupTimer) {
+  cleanupTimer = setInterval(runCacheCleanup, CLEANUP_INTERVAL_MS);
+  log.debug('Query cache cleanup initialized.');
+}
+
+export interface UseQueryCacheOptions {
+  /** Time to live in seconds (default: 300 = 5 minutes) */
+  ttl?: number;
+  /** Whether to enable caching (default: true) */
+  enabled?: boolean;
+}
+
+export interface UseQueryCacheReturn {
+  /** Get cached query result or fetch if not cached */
+  getCachedQuery: <T>(
+    table: string,
+    filterKey: string,
+    filterValue: string,
+    fetchFn: () => Promise<T>,
+    options?: UseQueryCacheOptions
+  ) => Promise<T>;
+  /** Invalidate a specific cached query */
+  invalidateQuery: (table: string, filterKey: string, filterValue: string) => void;
+  /** Clear all cached queries */
+  clearCache: () => void;
+  /** Get cache statistics */
+  getCacheStats: () => { size: number; keys: string[] };
+}
+
+/**
+ * Hook for query result caching
+ * 
+ * Provides caching for frequently accessed data to eliminate duplicate queries.
+ * Automatically handles cache expiration and cleanup.
+ * 
+ * @param supabase - Supabase client (optional, can be passed in fetchFn)
+ * @returns Query cache utilities
+ * 
+ * @example
+ * ```tsx
+ * const { getCachedQuery } = useQueryCache(supabase);
+ * 
+ * const person = await getCachedQuery(
+ *   'pace_person',
+ *   'user_id',
+ *   userId,
+ *   async () => {
+ *     const { data } = await supabase
+ *       .from('pace_person')
+ *       .select('id, first_name, last_name, email')
+ *       .eq('user_id', userId)
+ *       .single();
+ *     return data;
+ *   },
+ *   { ttl: 300 } // 5 minutes
+ * );
+ * ```
+ */
+export function useQueryCache(supabase?: SupabaseClient<Database>): UseQueryCacheReturn {
+  const getCachedQuery = useCallback(async <T,>(
+    table: string,
+    filterKey: string,
+    filterValue: string,
+    fetchFn: () => Promise<T>,
+    options: UseQueryCacheOptions = {}
+  ): Promise<T> => {
+    const { ttl = 300, enabled = true } = options; // Default 5 minutes
+    const cacheKey = `${table}:${filterKey}:${filterValue}`;
+    const now = Date.now();
+    
+    if (!enabled) {
+      return fetchFn();
+    }
+    
+    // Check cache
+    const cached = queryCache.get(cacheKey);
+    if (cached) {
+      // If data is still valid, return it
+      if (cached.expiresAt > now && cached.data !== undefined) {
+        log.debug(`Cache hit for query: ${cacheKey}`);
+        return cached.data as T;
+      }
+      
+      // If there's an in-flight request, wait for it
+      if (cached.promise) {
+        log.debug(`Waiting for in-flight request: ${cacheKey}`);
+        return cached.promise as Promise<T>;
+      }
+    }
+    
+    // Fetch data
+    log.debug(`Cache miss for query: ${cacheKey}, fetching...`);
+    const fetchPromise = fetchFn();
+    
+    // Store promise for in-flight request deduplication
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + (ttl * 1000),
+      promise: fetchPromise,
+    });
+    
+    try {
+      const data = await fetchPromise;
+      
+      // Update cache with actual data
+      queryCache.set(cacheKey, {
+        data,
+        expiresAt: now + (ttl * 1000),
+      });
+      
+      log.debug(`Cached query result: ${cacheKey}, expires in ${ttl}s`);
+      return data;
+    } catch (error) {
+      // Remove failed request from cache
+      queryCache.delete(cacheKey);
+      log.error(`Query failed for ${cacheKey}:`, error);
+      throw error;
+    }
+  }, []);
+  
+  const invalidateQuery = useCallback((table: string, filterKey: string, filterValue: string) => {
+    const cacheKey = `${table}:${filterKey}:${filterValue}`;
+    queryCache.delete(cacheKey);
+    log.debug(`Invalidated query cache: ${cacheKey}`);
+  }, []);
+  
+  const clearCache = useCallback(() => {
+    queryCache.clear();
+    log.debug('Cleared all query cache entries.');
+  }, []);
+  
+  const getCacheStats = useCallback(() => {
+    return {
+      size: queryCache.size,
+      keys: Array.from(queryCache.keys()),
+    };
+  }, []);
+  
+  return {
+    getCachedQuery,
+    invalidateQuery,
+    clearCache,
+    getCacheStats,
+  };
+}
+
+/**
+ * Pre-configured cache helpers for common queries
+ */
+export const queryCacheHelpers = {
+  /**
+   * Cache pace_person queries by user_id
+   * TTL: 5 minutes
+   */
+  pacePersonByUserId: <T>(
+    supabase: SupabaseClient<Database>,
+    userId: string,
+    fetchFn: () => Promise<T>
+  ): Promise<T> => {
+    const cacheKey = `pace_person:user_id:${userId}`;
+    const now = Date.now();
+    const ttl = 300 * 1000; // 5 minutes
+    
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== undefined) {
+      return Promise.resolve(cached.data as T);
+    }
+    
+    if (cached?.promise) {
+      return cached.promise as Promise<T>;
+    }
+    
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + ttl,
+      promise,
+    });
+    
+    promise.then(data => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    
+    return promise;
+  },
+  
+  /**
+   * Cache pace_member queries by person_id
+   * TTL: 5 minutes
+   */
+  paceMemberByPersonId: <T>(
+    supabase: SupabaseClient<Database>,
+    personId: string,
+    fetchFn: () => Promise<T>
+  ): Promise<T> => {
+    const cacheKey = `pace_member:person_id:${personId}`;
+    const now = Date.now();
+    const ttl = 300 * 1000; // 5 minutes
+    
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== undefined) {
+      return Promise.resolve(cached.data as T);
+    }
+    
+    if (cached?.promise) {
+      return cached.promise as Promise<T>;
+    }
+    
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + ttl,
+      promise,
+    });
+    
+    promise.then(data => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    
+    return promise;
+  },
+  
+  /**
+   * Cache rbac_app_pages queries by app_id
+   * TTL: 15 minutes (app pages are relatively static)
+   */
+  rbacAppPagesByAppId: <T>(
+    supabase: SupabaseClient<Database>,
+    appId: string,
+    fetchFn: () => Promise<T>
+  ): Promise<T> => {
+    const cacheKey = `rbac_app_pages:app_id:${appId}`;
+    const now = Date.now();
+    const ttl = 15 * 60 * 1000; // 15 minutes
+    
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== undefined) {
+      return Promise.resolve(cached.data as T);
+    }
+    
+    if (cached?.promise) {
+      return cached.promise as Promise<T>;
+    }
+    
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + ttl,
+      promise,
+    });
+    
+    promise.then(data => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    
+    return promise;
+  },
+};
+

package/src/index.ts

@@ -76,6 +76,8 @@ export type { CardProps } from './components/Card/Card';
 
 export { Input } from './components/Input/Input';
 export type { InputProps } from './components/Input/Input';
+export { AddressField } from './components/AddressField';
+export type { AddressFieldProps, AddressFieldRef, ParsedAddress, AutocompleteOptions } from './components/AddressField';
 export { Label } from './components/Label/Label';
 export type { LabelProps } from './components/Label/Label';
 

package/src/providers/services/EventServiceProvider.tsx

@@ -50,6 +50,7 @@ export function EventServiceProvider({
   const eventService = eventServiceRef.current;
 
   // Update service dependencies and initialize when dependencies change
+  // Note: eventService is a ref and never changes, so we don't include it in dependencies
   useEffect(() => {
     let isMounted = true;
     
@@ -72,7 +73,9 @@ export function EventServiceProvider({
     return () => {
       isMounted = false;
     };
-  }, [eventService, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // eventService is a ref and never changes, so we exclude it from dependencies
+  }, [supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
 
   // Cleanup service on unmount only
   useEffect(() => {

package/src/rbac/api.test.ts

@@ -45,6 +45,12 @@ vi.mock('./cache', () => ({
   }
 }));
 
+vi.mock('./request-deduplication', () => ({
+  getOrCreateRequest: vi.fn((input, checkFn) => checkFn(input)),
+  clearInFlightRequests: vi.fn(),
+  getInFlightRequestCount: vi.fn(() => 0),
+}));
+
 vi.mock('./config', () => ({
   createRBACConfig: vi.fn(),
   getRBACLogger: vi.fn(() => ({
@@ -120,7 +126,14 @@ describe('RBAC API', () => {
       process.env.NODE_ENV = originalEnv;
 
       expect(mockCreateRBACEngine).toHaveBeenCalledWith(mockSupabase, undefined);
-      expect(mockCreateAuditManager).toHaveBeenCalledWith(mockSupabase);
+      expect(mockCreateAuditManager).toHaveBeenCalledWith(
+        mockSupabase, 
+        true, 
+        expect.objectContaining({
+          batchSize: undefined,
+          batchWindow: undefined,
+        })
+      );
       expect(mockSetGlobalAuditManager).toHaveBeenCalledWith(mockAuditManager);
       expect(mockLogger.info).toHaveBeenCalledWith('RBAC system initialized successfully');
     });
@@ -659,7 +672,7 @@ describe('RBAC API', () => {
         });
 
         expect(result).toBe(true);
-        expect(rbacCache.get).toHaveBeenCalledWith(cacheKey);
+        expect(rbacCache.get).toHaveBeenCalledWith(cacheKey, true);
         expect(mockEngine.isPermitted).not.toHaveBeenCalled();
       });
 
@@ -689,10 +702,12 @@ describe('RBAC API', () => {
             organisationId: 'org-456'
           })
         );
-        expect(rbacCache.set).toHaveBeenCalledWith(
-          expect.any(String),
-          true
-        );
+        // Check that cache.set was called - pageId presence makes it a page-level check
+        expect(rbacCache.set).toHaveBeenCalled();
+        const setCall = rbacCache.set.mock.calls[0];
+        expect(setCall[0]).toBeTruthy(); // cache key
+        expect(setCall[1]).toBe(true); // result
+        // setCall[2] is TTL (optional), setCall[3] is useSessionCache (true for page-level)
       });
     });
 

package/src/rbac/api.ts

@@ -27,6 +27,8 @@ import { rbacCache, RBACCache, CACHE_PATTERNS } from './cache';
 import { createRBACConfig, RBACConfig, getRBACLogger } from './config';
 import { SecurityContext } from './security';
 import { createLogger } from '../utils/core/logger';
+import { enablePerformanceMonitoring } from './performance';
+import { getOrCreateRequest } from './request-deduplication';
 
 const log = createLogger('RBACAPI');
 
@@ -72,10 +74,20 @@ export function setupRBAC(supabase: SupabaseClient<Database>, config?: Partial<R
   // Pass security config to engine
   globalEngine = createRBACEngine(supabase, securityConfig);
   
-  // Setup audit manager
-  const auditManager = createAuditManager(supabase);
+  // Setup audit manager with batching configuration
+  const useBatchedAudit = config?.audit?.batched !== false && (config?.performance?.enableBatchedAuditLogging !== false);
+  const batchConfig = useBatchedAudit ? {
+    batchWindow: config?.audit?.batchWindow,
+    batchSize: config?.audit?.batchSize,
+  } : undefined;
+  const auditManager = createAuditManager(supabase, useBatchedAudit, batchConfig);
   setGlobalAuditManager(auditManager);
   
+  // Setup performance monitoring if enabled
+  if (config?.performance?.enablePerformanceTracking) {
+    enablePerformanceMonitoring();
+  }
+  
   logger.info('RBAC system initialized successfully');
 }
 
@@ -195,13 +207,16 @@ export async function isPermitted(input: PermissionCheck): Promise<boolean> {
 /**
  * Check if user has a specific permission (cached version)
  * 
+ * Uses request deduplication to share in-flight requests across components
+ * and checks cache before making new requests. Uses session cache for page-level checks.
+ * 
  * @param input - Permission check input
  * @returns Promise resolving to permission result
  */
 export async function isPermittedCached(input: PermissionCheck): Promise<boolean> {
   const { userId, scope, permission, pageId } = input;
   
-  // Check cache first
+  // Check cache first (checks both short-term and session cache)
   const cacheKey = RBACCache.generatePermissionKey({
     userId,
     organisationId: scope.organisationId!,
@@ -211,18 +226,24 @@ export async function isPermittedCached(input: PermissionCheck): Promise<boolean
     pageId,
   });
   
-  const cached = rbacCache.get<boolean>(cacheKey);
+  const cached = rbacCache.get<boolean>(cacheKey, true);
   if (cached !== null) {
     return cached;
   }
 
-  // Check permission
-  const result = await isPermitted(input);
-  
-  // Cache result
-  rbacCache.set(cacheKey, result);
-  
-  return result;
+  // Use request deduplication - if same request is in-flight, share the promise
+  return getOrCreateRequest(input, async (checkInput) => {
+    // Check permission
+    const result = await isPermitted(checkInput);
+    
+    // Determine if this is a page-level check (has pageId or permission contains 'page.')
+    const isPageLevelCheck = !!pageId || permission.includes('page.');
+    
+    // Cache result - use session cache for page-level checks
+    rbacCache.set(cacheKey, result, undefined, isPageLevelCheck);
+    
+    return result;
+  });
 }
 
 /**