@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/hooks/usePermissionCache.ts

@@ -54,7 +54,7 @@
  * Consider using useCan() or usePermissions() hooks directly for simpler use cases.
  */
 
-import { useState, useCallback, useMemo, useEffect, useRef } from 'react';
+import { useCallback, useMemo, useEffect, useRef, type MutableRefObject } from 'react';
 import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
 import { useOrganisations } from './useOrganisations';
 import { useEvents } from './useEvents';
@@ -103,6 +103,239 @@ const DEFAULT_CONFIG: CacheConfig = {
   enableAuditTrail: true
 };
 
+/** Params for permission cache helpers. Extracted to keep usePermissionCache under max-lines. */
+interface PermissionCacheParams {
+  cache: MutableRefObject<Map<string, CacheEntry>>;
+  promiseCache: MutableRefObject<Map<string, Promise<boolean>>>;
+  stats: MutableRefObject<{
+    cacheHits: number;
+    cacheMisses: number;
+    totalChecks: number;
+    totalResponseTime: number;
+    lastInvalidation: number;
+  }>;
+  config: CacheConfig;
+  userId: string | undefined;
+  scope: Scope;
+  getCacheKey: (operation: Operation, pageId: string) => string;
+  isCacheValid: (entry: CacheEntry) => boolean;
+  logPermissionCheck: (
+    operation: Operation,
+    pageId: string,
+    result: boolean,
+    cached: boolean,
+    responseTime: number
+  ) => void;
+  triggerCleanup: () => void;
+}
+
+async function checkPermissionWithCache(
+  params: PermissionCacheParams,
+  operation: Operation,
+  pageId: string,
+  ttl?: number
+): Promise<boolean> {
+  if (!operation || !pageId) {
+    logger.warn('PermissionCache', 'Invalid parameters: operation and pageId are required', { operation, pageId });
+    return false;
+  }
+  if (!params.userId || !params.scope.organisationId) {
+    logger.warn('PermissionCache', 'User or organisation context not available - permission check failed', {
+      hasUserId: !!params.userId,
+      hasOrganisationId: !!params.scope.organisationId,
+    });
+    return false;
+  }
+  const startTime = Date.now();
+  const cacheKey = params.getCacheKey(operation, pageId);
+  const entry = params.cache.current.get(cacheKey);
+  if (entry && params.isCacheValid(entry)) {
+    const responseTime = Date.now() - startTime;
+    params.logPermissionCheck(operation, pageId, entry.result, true, responseTime);
+    return entry.result;
+  }
+  const existingPromise = params.promiseCache.current.get(cacheKey);
+  if (existingPromise) return existingPromise;
+
+  const permissionPromise = (async () => {
+    try {
+      const permission: Permission = pageId
+        ? (`${operation}:page.${pageId}` as Permission)
+        : (`${operation}:${pageId || ''}` as Permission);
+      const result = await isPermittedCached({
+        userId: params.userId as UUID,
+        scope: params.scope,
+        permission,
+        pageId: pageId as UUID | undefined,
+      });
+      const hasPermission = result.ok ? result.data : false;
+      const responseTime = Date.now() - startTime;
+      const cacheEntry: CacheEntry = {
+        result: hasPermission,
+        timestamp: Date.now(),
+        ttl: ttl ?? params.config.defaultTTL,
+      };
+      params.cache.current.set(cacheKey, cacheEntry);
+      if (params.cache.current.size > params.config.maxCacheSize) {
+        const entries = Array.from(params.cache.current.entries());
+        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+        const toRemove = entries.slice(0, params.cache.current.size - params.config.maxCacheSize + 1);
+        toRemove.forEach(([key]) => params.cache.current.delete(key));
+      }
+      params.triggerCleanup();
+      params.logPermissionCheck(operation, pageId, hasPermission, false, responseTime);
+      return hasPermission;
+    } catch (error) {
+      logger.error('PermissionCache', `Error checking permission ${operation}:${pageId}`, { operation, pageId, error });
+      return false;
+    } finally {
+      params.promiseCache.current.delete(cacheKey);
+    }
+  })();
+  params.promiseCache.current.set(cacheKey, permissionPromise);
+  return permissionPromise;
+}
+
+async function checkMultiplePermissionsImpl(
+  params: PermissionCacheParams,
+  permissions: Array<[Operation, string]>,
+  ttl?: number
+): Promise<PermissionResult[]> {
+  if (!permissions || !Array.isArray(permissions) || permissions.length === 0) {
+    logger.warn('PermissionCache', 'Invalid permissions array', { permissions });
+    return [];
+  }
+  if (!params.userId || !params.scope.organisationId) {
+    logger.warn('PermissionCache', 'User or organisation context not available - permission checks failed', {
+      hasUserId: !!params.userId,
+      hasOrganisationId: !!params.scope.organisationId,
+    });
+    return permissions.map(([operation, pageId]) => ({
+      operation,
+      pageId,
+      hasPermission: false,
+      cached: false,
+      timestamp: Date.now(),
+    }));
+  }
+  const results: PermissionResult[] = new Array(permissions.length);
+  const startTime = Date.now();
+  const uncachedPermissions: Array<[Operation, string, number]> = [];
+  for (let i = 0; i < permissions.length; i++) {
+    const [operation, pageId] = permissions[i];
+    const cacheKey = params.getCacheKey(operation, pageId);
+    const entry = params.cache.current.get(cacheKey);
+    if (entry && params.isCacheValid(entry)) {
+      results[i] = { operation, pageId, hasPermission: entry.result, cached: true, timestamp: entry.timestamp };
+      params.stats.current.cacheHits++;
+    } else {
+      uncachedPermissions.push([operation, pageId, i]);
+    }
+  }
+  if (uncachedPermissions.length > 0) {
+    for (const [operation, pageId, originalIndex] of uncachedPermissions) {
+      try {
+        const permission: Permission = pageId
+          ? (`${operation}:page.${pageId}` as Permission)
+          : (`${operation}:${pageId || ''}` as Permission);
+        const result = await isPermittedCached({
+          userId: params.userId as UUID,
+          scope: params.scope,
+          permission,
+          pageId: pageId as UUID | undefined,
+        });
+        const hasPermission = result.ok ? result.data : false;
+        const cacheKey = params.getCacheKey(operation, pageId);
+        const cacheEntry: CacheEntry = {
+          result: hasPermission,
+          timestamp: Date.now(),
+          ttl: ttl ?? params.config.defaultTTL,
+        };
+        params.cache.current.set(cacheKey, cacheEntry);
+        if (params.cache.current.size > params.config.maxCacheSize) {
+          const entries = Array.from(params.cache.current.entries());
+          entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
+          const toRemove = entries.slice(0, params.cache.current.size - params.config.maxCacheSize + 1);
+          toRemove.forEach(([key]) => params.cache.current.delete(key));
+        }
+        results[originalIndex] = {
+          operation,
+          pageId,
+          hasPermission,
+          cached: false,
+          timestamp: Date.now(),
+        };
+        params.stats.current.cacheMisses++;
+      } catch (error) {
+        logger.error('PermissionCache', `Error checking permission ${operation}:${pageId}`, { operation, pageId, error });
+        results[originalIndex] = {
+          operation,
+          pageId,
+          hasPermission: false,
+          cached: false,
+          timestamp: Date.now(),
+        };
+      }
+    }
+    params.triggerCleanup();
+  }
+  params.stats.current.totalChecks += permissions.length;
+  params.stats.current.totalResponseTime += Date.now() - startTime;
+  return results;
+}
+
+function invalidateCacheImpl(
+  cache: MutableRefObject<Map<string, CacheEntry>>,
+  promiseCache: MutableRefObject<Map<string, Promise<boolean>>>,
+  stats: PermissionCacheParams['stats'],
+  pattern?: string
+): void {
+  if (pattern) {
+    const regex = new RegExp(pattern);
+    for (const [key] of cache.current.entries()) {
+      if (regex.test(key)) cache.current.delete(key);
+    }
+    for (const [key] of promiseCache.current.entries()) {
+      if (regex.test(key)) promiseCache.current.delete(key);
+    }
+  } else {
+    cache.current.clear();
+    promiseCache.current.clear();
+  }
+  stats.current.lastInvalidation = Date.now();
+}
+
+function getCachedPermissionsImpl(
+  params: PermissionCacheParams,
+  pageId: string
+): Array<{ operation: Operation; hasPermission: boolean }> {
+  const results: Array<{ operation: Operation; hasPermission: boolean }> = [];
+  const operations: Operation[] = ['read', 'create', 'update', 'delete'];
+  for (const operation of operations) {
+    const cacheKey = params.getCacheKey(operation, pageId);
+    const entry = params.cache.current.get(cacheKey);
+    if (entry && params.isCacheValid(entry)) {
+      results.push({ operation, hasPermission: entry.result });
+    }
+  }
+  return results;
+}
+
+function getDebugInfoImpl(
+  cache: MutableRefObject<Map<string, CacheEntry>>,
+  stats: PermissionCacheParams['stats']
+): DebugInfo {
+  const totalChecks = stats.current.totalChecks;
+  return {
+    cacheSize: cache.current.size,
+    cacheHits: stats.current.cacheHits,
+    cacheMisses: stats.current.cacheMisses,
+    totalChecks,
+    averageResponseTime: totalChecks > 0 ? stats.current.totalResponseTime / totalChecks : 0,
+    lastInvalidation: stats.current.lastInvalidation,
+  };
+}
+
 /**
  * Hook for centralized permission caching.
  * Provides intelligent caching with automatic invalidation for permission checks.
@@ -146,7 +379,7 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
   try {
     const eventsContext = useEvents();
     selectedEvent = eventsContext.selectedEvent;
-  } catch (error) {
+  } catch (_error) {
     // Event provider not available - continue without event context
   }
   
@@ -169,11 +402,9 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
 
   // Trigger cleanup when new permissions are checked
   const triggerCleanup = useCallback(() => {
-    let cleaned = 0;
     for (const [key, entry] of cache.current.entries()) {
       if (!isCacheValid(entry)) {
         cache.current.delete(key);
-        cleaned++;
       }
     }
   }, [isCacheValid]);
@@ -213,277 +444,49 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
     }
   }, [mergedConfig.enableAuditTrail, user?.id]);
 
-  // Check single permission
-  const checkPermission = useCallback(async (
-    operation: Operation, 
-    pageId: string, 
-    ttl?: number
-  ): Promise<boolean> => {
-    // Validate parameters
-    if (!operation || !pageId) {
-      logger.warn('PermissionCache', 'Invalid parameters: operation and pageId are required', { operation, pageId });
-      return false;
-    }
-
-    if (!user?.id || !scope.organisationId) {
-      logger.warn('PermissionCache', 'User or organisation context not available - permission check failed', { 
-        hasUserId: !!user?.id, 
-        hasOrganisationId: !!scope.organisationId 
-      });
-      return false;
-    }
-
-    const startTime = Date.now();
-    const cacheKey = getCacheKey(operation, pageId);
-    const entry = cache.current.get(cacheKey);
-    
-    // Check cache first
-    if (entry && isCacheValid(entry)) {
-      const responseTime = Date.now() - startTime;
-      logPermissionCheck(operation, pageId, entry.result, true, responseTime);
-      return entry.result;
-    }
-
-    // Check if there's already a pending promise for this permission
-    const existingPromise = promiseCache.current.get(cacheKey);
-    if (existingPromise) {
-      return existingPromise;
-    }
-
-    // Create new promise for this permission check
-    const permissionPromise = (async () => {
-      try {
-        // Build permission string: operation:page.pageId
-        const permission: Permission = pageId 
-          ? `${operation}:page.${pageId}` as Permission
-          : `${operation}:${pageId || ''}` as Permission;
-        
-        const result = await isPermittedCached({
-          userId: user.id as UUID,
-          scope,
-          permission,
-          pageId: pageId as UUID | undefined
-        });
-        const responseTime = Date.now() - startTime;
-        
-        // Cache the result
-        const cacheEntry: CacheEntry = {
-          result,
-          timestamp: Date.now(),
-          ttl: ttl || mergedConfig.defaultTTL
-        };
-        
-        cache.current.set(cacheKey, cacheEntry);
-        
-        // Enforce max cache size
-        if (cache.current.size > mergedConfig.maxCacheSize) {
-          const entries = Array.from(cache.current.entries());
-          entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-          const toRemove = entries.slice(0, cache.current.size - mergedConfig.maxCacheSize + 1);
-          toRemove.forEach(([key]) => cache.current.delete(key));
-        }
-        
-        // Trigger cleanup of expired entries
-        triggerCleanup();
-        
-        logPermissionCheck(operation, pageId, result, false, responseTime);
-        return result;
-      } catch (error) {
-        logger.error('PermissionCache', `Error checking permission ${operation}:${pageId}`, { operation, pageId, error });
-        return false;
-      } finally {
-        // Remove the promise from cache after completion
-        promiseCache.current.delete(cacheKey);
-      }
-    })();
-
-    // Store the promise in cache
-    promiseCache.current.set(cacheKey, permissionPromise);
-    
-    return permissionPromise;
-  }, [user?.id, scope, getCacheKey, isCacheValid, logPermissionCheck, mergedConfig.defaultTTL, mergedConfig.maxCacheSize, triggerCleanup]);
+  const cacheParams = useMemo(
+    (): PermissionCacheParams => ({
+      cache,
+      promiseCache,
+      stats,
+      config: mergedConfig,
+      userId: user?.id,
+      scope,
+      getCacheKey,
+      isCacheValid,
+      logPermissionCheck,
+      triggerCleanup,
+    }),
+    [
+      mergedConfig,
+      user?.id,
+      scope,
+      getCacheKey,
+      isCacheValid,
+      logPermissionCheck,
+      triggerCleanup,
+    ]
+  );
 
-  // Check multiple permissions efficiently
-  const checkMultiplePermissions = useCallback(async (
-    permissions: Array<[Operation, string]>,
-    ttl?: number
-  ): Promise<PermissionResult[]> => {
-    // Validate parameters
-    if (!permissions || !Array.isArray(permissions) || permissions.length === 0) {
-      logger.warn('PermissionCache', 'Invalid permissions array', { permissions });
-      return [];
-    }
-
-    if (!user?.id || !scope.organisationId) {
-      logger.warn('PermissionCache', 'User or organisation context not available - permission checks failed', {
-        hasUserId: !!user?.id,
-        hasOrganisationId: !!scope.organisationId
-      });
-      return permissions.map(([operation, pageId]) => ({
-        operation,
-        pageId,
-        hasPermission: false,
-        cached: false,
-        timestamp: Date.now()
-      }));
-    }
-
-    // Pre-size results array to maintain order and length
-    const results: PermissionResult[] = new Array(permissions.length);
-    const startTime = Date.now();
-    
-    // Check cache for all permissions first
-    const uncachedPermissions: Array<[Operation, string, number]> = [];
-    
-    for (let i = 0; i < permissions.length; i++) {
-      const [operation, pageId] = permissions[i];
-      const cacheKey = getCacheKey(operation, pageId);
-      const entry = cache.current.get(cacheKey);
-      
-      if (entry && isCacheValid(entry)) {
-        // Use index assignment to maintain order
-        results[i] = {
-          operation,
-          pageId,
-          hasPermission: entry.result,
-          cached: true,
-          timestamp: entry.timestamp
-        };
-        stats.current.cacheHits++;
-      } else {
-        uncachedPermissions.push([operation, pageId, i]);
-      }
-    }
-    
-    // Check uncached permissions
-    if (uncachedPermissions.length > 0) {
-      const batchStartTime = Date.now();
-      
-      // For now, check them individually (could be optimized with batch RPC)
-      for (const [operation, pageId, originalIndex] of uncachedPermissions) {
-        try {
-          // Build permission string: operation:page.pageId
-          const permission: Permission = pageId 
-            ? `${operation}:page.${pageId}` as Permission
-            : `${operation}:${pageId || ''}` as Permission;
-          
-          const result = await isPermittedCached({
-            userId: user.id as UUID,
-            scope,
-            permission,
-            pageId: pageId as UUID | undefined
-          });
-          const cacheKey = getCacheKey(operation, pageId);
-          
-          // Cache the result
-          const cacheEntry: CacheEntry = {
-            result,
-            timestamp: Date.now(),
-            ttl: ttl || mergedConfig.defaultTTL
-          };
-          
-          cache.current.set(cacheKey, cacheEntry);
-          
-          // Enforce max cache size
-          if (cache.current.size > mergedConfig.maxCacheSize) {
-            const entries = Array.from(cache.current.entries());
-            entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-            const toRemove = entries.slice(0, cache.current.size - mergedConfig.maxCacheSize + 1);
-            toRemove.forEach(([key]) => cache.current.delete(key));
-          }
-          
-          results[originalIndex] = {
-            operation,
-            pageId,
-            hasPermission: result,
-            cached: false,
-            timestamp: Date.now()
-          };
-          
-          stats.current.cacheMisses++;
-        } catch (error) {
-          logger.error('PermissionCache', `Error checking permission ${operation}:${pageId}`, { operation, pageId, error });
-          results[originalIndex] = {
-            operation,
-            pageId,
-            hasPermission: false,
-            cached: false,
-            timestamp: Date.now()
-          };
-        }
-      }
-      
-      // Trigger cleanup of expired entries
-      triggerCleanup();
-      
-      const batchResponseTime = Date.now() - batchStartTime;
-      logPermissionCheck('read', `${uncachedPermissions.length} permissions`, true, false, batchResponseTime);
-    }
-    
-    stats.current.totalChecks += permissions.length;
-    stats.current.totalResponseTime += Date.now() - startTime;
-    
-    return results;
-  }, [user?.id, scope, getCacheKey, isCacheValid, logPermissionCheck, mergedConfig.defaultTTL, mergedConfig.maxCacheSize, triggerCleanup]);
-
-  // Get cached permissions for a page
-  const getCachedPermissions = useCallback((pageId: string): Array<{ operation: Operation; hasPermission: boolean }> => {
-    const results: Array<{ operation: Operation; hasPermission: boolean }> = [];
-    const operations: Operation[] = ['read', 'create', 'update', 'delete'];
-    
-    for (const operation of operations) {
-      const cacheKey = getCacheKey(operation, pageId);
-      const entry = cache.current.get(cacheKey);
-      
-      if (entry && isCacheValid(entry)) {
-        results.push({ operation, hasPermission: entry.result });
-      }
-    }
-    
-    return results;
-  }, [getCacheKey, isCacheValid]);
-
-  // Invalidate cache
-  const invalidateCache = useCallback((pattern?: string) => {
-    if (pattern) {
-      // Invalidate specific pattern
-      const regex = new RegExp(pattern);
-      for (const [key] of cache.current.entries()) {
-        if (regex.test(key)) {
-          cache.current.delete(key);
-        }
-      }
-      // Also clear promise cache for matching patterns
-      for (const [key] of promiseCache.current.entries()) {
-        if (regex.test(key)) {
-          promiseCache.current.delete(key);
-        }
-      }
-    } else {
-      // Invalidate all
-      cache.current.clear();
-      promiseCache.current.clear();
-    }
-    
-    stats.current.lastInvalidation = Date.now();
-  }, []);
-
-  // Get debug information
-  const getDebugInfo = useCallback((): DebugInfo => {
-    const totalChecks = stats.current.totalChecks;
-    const averageResponseTime = totalChecks > 0 
-      ? stats.current.totalResponseTime / totalChecks 
-      : 0;
-    
-    return {
-      cacheSize: cache.current.size,
-      cacheHits: stats.current.cacheHits,
-      cacheMisses: stats.current.cacheMisses,
-      totalChecks,
-      averageResponseTime,
-      lastInvalidation: stats.current.lastInvalidation
-    };
-  }, []);
+  const checkPermission = useCallback(
+    (operation: Operation, pageId: string, ttl?: number) =>
+      checkPermissionWithCache(cacheParams, operation, pageId, ttl),
+    [cacheParams]
+  );
+  const checkMultiplePermissions = useCallback(
+    (permissions: Array<[Operation, string]>, ttl?: number) =>
+      checkMultiplePermissionsImpl(cacheParams, permissions, ttl),
+    [cacheParams]
+  );
+  const getCachedPermissions = useCallback(
+    (pageId: string) => getCachedPermissionsImpl(cacheParams, pageId),
+    [cacheParams]
+  );
+  const invalidateCache = useCallback(
+    (pattern?: string) => invalidateCacheImpl(cache, promiseCache, stats, pattern),
+    []
+  );
+  const getDebugInfo = useCallback(() => getDebugInfoImpl(cache, stats), []);
 
   // Get audit trail
   const getAuditTrail = useCallback(() => {
@@ -493,11 +496,9 @@ export function usePermissionCache(config: Partial<CacheConfig> = {}) {
   // Clean up expired cache entries periodically
   useEffect(() => {
     const cleanup = () => {
-      let cleaned = 0;
       for (const [key, entry] of cache.current.entries()) {
         if (!isCacheValid(entry)) {
           cache.current.delete(key);
-          cleaned++;
         }
       }
     };