@jmruthers/pace-core 0.2.6 → 0.4.1

package/src/hooks/usePerformanceMonitor.ts

@@ -1,128 +0,0 @@
-
-import { useEffect, useRef, useCallback } from 'react';
-import { performanceBudgetMonitor, PERFORMANCE_BUDGETS } from '../utils/performanceBudgets';
-
-export interface PerformanceMetrics {
-  renderTime: number;
-  componentName: string;
-  timestamp: number;
-}
-
-/**
- * Hook for monitoring component performance with budget validation
- * @param componentName - Name of the component being monitored
- * @param enabled - Whether performance monitoring is enabled
- * @param budgetName - Performance budget to validate against
- */
-export function usePerformanceMonitor(
-  componentName: string, 
-  enabled = process.env.NODE_ENV === 'development',
-  budgetName: string = 'COMPONENT_RENDER'
-) {
-  const renderStartTime = useRef<number>(0);
-  const metrics = useRef<PerformanceMetrics[]>([]);
-
-  // Start performance measurement
-  const startMeasurement = useCallback(() => {
-    if (!enabled) return;
-    renderStartTime.current = performance.now();
-  }, [enabled]);
-
-  // End performance measurement with budget validation
-  const endMeasurement = useCallback(() => {
-    if (!enabled || renderStartTime.current === 0) return;
-    
-    const renderTime = performance.now() - renderStartTime.current;
-    const metric: PerformanceMetrics = {
-      renderTime,
-      componentName,
-      timestamp: Date.now()
-    };
-    
-    metrics.current.push(metric);
-    
-    // Keep only last 10 measurements
-    if (metrics.current.length > 10) {
-      metrics.current = metrics.current.slice(-10);
-    }
-    
-    // Validate against performance budget
-    const measurement = performanceBudgetMonitor.measure(budgetName, renderTime, {
-      componentName,
-      renderCount: metrics.current.length
-    });
-    
-    // Log slow renders in development
-    if (!measurement.passed) {
-      console.warn(
-        `🐌 Performance budget exceeded in ${componentName}: ${renderTime.toFixed(2)}ms ` +
-        `(budget: ${PERFORMANCE_BUDGETS[budgetName]?.threshold}ms)`
-      );
-    }
-    
-    renderStartTime.current = 0;
-  }, [enabled, componentName, budgetName]);
-
-  // Get performance metrics
-  const getMetrics = useCallback(() => {
-    return metrics.current.slice();
-  }, []);
-
-  // Get average render time
-  const getAverageRenderTime = useCallback(() => {
-    if (metrics.current.length === 0) return 0;
-    
-    const total = metrics.current.reduce((sum, metric) => sum + metric.renderTime, 0);
-    return total / metrics.current.length;
-  }, []);
-
-  // Get performance budget status
-  const getBudgetStatus = useCallback(() => {
-    const budget = PERFORMANCE_BUDGETS[budgetName];
-    if (!budget) return null;
-
-    const averageTime = getAverageRenderTime();
-    return {
-      budget: budget.threshold,
-      average: averageTime,
-      passed: averageTime <= budget.threshold,
-      efficiency: budget.threshold > 0 ? (budget.threshold - averageTime) / budget.threshold : 0
-    };
-  }, [budgetName, getAverageRenderTime]);
-
-  // Start measurement on every render
-  useEffect(() => {
-    startMeasurement();
-    return endMeasurement;
-  });
-
-  return {
-    getMetrics,
-    getAverageRenderTime,
-    getBudgetStatus,
-    startMeasurement,
-    endMeasurement
-  };
-}
-
-// Hook for measuring specific operations
-export function useOperationPerformance(operationName: string, budgetName?: string) {
-  const measureOperation = useCallback(async <T>(
-    operation: () => Promise<T> | T,
-    context?: Record<string, any>
-  ): Promise<T> => {
-    const start = performance.now();
-    const result = await operation();
-    const duration = performance.now() - start;
-    
-    const budget = budgetName || 'COMPONENT_RENDER';
-    performanceBudgetMonitor.measure(budget, duration, {
-      operation: operationName,
-      ...context
-    });
-    
-    return result;
-  }, [operationName, budgetName]);
-
-  return { measureOperation };
-}

package/src/hooks/usePermissionCache.ts

@@ -1,455 +0,0 @@
-/**
- * @file Permission Cache Hook
- * @package @jmruthers/pace-core
- * @module Hooks/PermissionCache
- * @since 0.3.0
- *
- * A centralized permission caching system that provides:
- * - Single source of truth for all permission checks
- * - Intelligent caching with automatic invalidation
- * - Centralized logging and debugging
- * - Performance optimization through batch loading
- * - Type-safe permission management
- *
- * @example
- * ```tsx
- * import { usePermissionCache } from '@jmruthers/pace-core';
- * 
- * function MyComponent() {
- *   const { 
- *     checkPermission, 
- *     checkMultiplePermissions,
- *     getCachedPermissions,
- *     invalidateCache,
- *     debugInfo 
- *   } = usePermissionCache();
- * 
- *   const canEdit = await checkPermission('update', 'meals');
- *   const permissions = await checkMultiplePermissions([
- *     ['read', 'meals'],
- *     ['create', 'meals'],
- *     ['update', 'meals'],
- *     ['delete', 'meals']
- *   ]);
- * }
- * ```
- *
- * @security
- * - Centralized permission validation
- * - Audit logging of all permission checks
- * - Secure cache invalidation
- *
- * @performance
- * - Intelligent caching with TTL
- * - Batch permission loading
- * - Automatic cache invalidation
- * - Memory-efficient storage
- *
- * @dependencies
- * - React 18+ - Hooks and effects
- * - useRBAC hook - Base permission checking
- * - RBAC types - Type definitions
- */
-
-import { useState, useCallback, useMemo, useEffect, useRef } from 'react';
-import { useRBAC } from './useRBAC';
-import type { Operation } from '../rbac/types';
-
-// Cache entry interface
-interface CacheEntry {
-  result: boolean;
-  timestamp: number;
-  ttl: number;
-}
-
-// Permission check result
-interface PermissionResult {
-  operation: Operation;
-  pageId: string;
-  hasPermission: boolean;
-  cached: boolean;
-  timestamp: number;
-}
-
-// Debug information
-interface DebugInfo {
-  cacheSize: number;
-  cacheHits: number;
-  cacheMisses: number;
-  totalChecks: number;
-  averageResponseTime: number;
-  lastInvalidation: number;
-}
-
-// Cache configuration
-interface CacheConfig {
-  defaultTTL: number; // milliseconds
-  maxCacheSize: number;
-  enableLogging: boolean;
-  enableAuditTrail: boolean;
-}
-
-const DEFAULT_CONFIG: CacheConfig = {
-  defaultTTL: 5 * 60 * 1000, // 5 minutes
-  maxCacheSize: 1000,
-  enableLogging: process.env.NODE_ENV === 'development',
-  enableAuditTrail: true
-};
-
-export function usePermissionCache(config: Partial<CacheConfig> = {}) {
-  const mergedConfig = useMemo(() => ({ ...DEFAULT_CONFIG, ...config }), [config]);
-  
-  // Cache storage
-  const cache = useRef<Map<string, CacheEntry>>(new Map());
-  
-  // Promise cache for concurrent calls
-  const promiseCache = useRef<Map<string, Promise<boolean>>>(new Map());
-  
-  // Statistics
-  const stats = useRef({
-    cacheHits: 0,
-    cacheMisses: 0,
-    totalChecks: 0,
-    totalResponseTime: 0,
-    lastInvalidation: Date.now()
-  });
-
-  // Audit trail
-  const auditTrail = useRef<Array<{
-    timestamp: number;
-    operation: Operation;
-    pageId: string;
-    result: boolean;
-    cached: boolean;
-    userId?: string;
-  }>>([]);
-
-  // Get base RBAC hook
-  const { hasPermission: baseHasPermission, user } = useRBAC();
-
-  // Generate cache key
-  const getCacheKey = useCallback((operation: Operation, pageId: string): string => {
-    return `${operation}:${pageId}`;
-  }, []);
-
-  // Check if cache entry is valid
-  const isCacheValid = useCallback((entry: CacheEntry): boolean => {
-    return Date.now() - entry.timestamp < entry.ttl;
-  }, []);
-
-  // 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++;
-      }
-    }
-    
-    if (cleaned > 0 && mergedConfig.enableLogging) {
-      console.log(`[PermissionCache] Cleaned up ${cleaned} expired cache entries`);
-    }
-  }, [isCacheValid, mergedConfig.enableLogging]);
-
-  // Log permission check
-  const logPermissionCheck = useCallback((
-    operation: Operation, 
-    pageId: string, 
-    result: boolean, 
-    cached: boolean,
-    responseTime: number
-  ) => {
-    if (mergedConfig.enableLogging) {
-      console.log(`[PermissionCache] ${operation}:${pageId} = ${result} (${cached ? 'cached' : 'fresh'}) - ${responseTime}ms`);
-    }
-
-    if (mergedConfig.enableAuditTrail) {
-      auditTrail.current.push({
-        timestamp: Date.now(),
-        operation,
-        pageId,
-        result,
-        cached,
-        userId: user?.id
-      });
-
-      // Keep audit trail manageable
-      if (auditTrail.current.length > 500) {
-        auditTrail.current = auditTrail.current.slice(-250);
-      }
-    }
-
-    // Update statistics - ensure minimum response time for accurate tracking
-    const trackedResponseTime = Math.max(responseTime, 1); // Minimum 1ms for tracking
-    stats.current.totalChecks++;
-    stats.current.totalResponseTime += trackedResponseTime;
-    if (cached) {
-      stats.current.cacheHits++;
-    } else {
-      stats.current.cacheMisses++;
-    }
-  }, [mergedConfig.enableLogging, mergedConfig.enableAuditTrail, user?.id]);
-
-  // Check single permission
-  const checkPermission = useCallback(async (
-    operation: Operation, 
-    pageId: string, 
-    ttl?: number
-  ): Promise<boolean> => {
-    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 {
-        const result = await baseHasPermission(operation, pageId);
-        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) {
-        console.error(`[PermissionCache] Error checking permission ${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;
-  }, [baseHasPermission, getCacheKey, isCacheValid, logPermissionCheck, mergedConfig.defaultTTL, mergedConfig.maxCacheSize, triggerCleanup]);
-
-  // Check multiple permissions efficiently
-  const checkMultiplePermissions = useCallback(async (
-    permissions: Array<[Operation, string]>,
-    ttl?: number
-  ): Promise<PermissionResult[]> => {
-    const results: PermissionResult[] = [];
-    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)) {
-        results.push({
-          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 {
-          const result = await baseHasPermission(operation, pageId);
-          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) {
-          console.error(`[PermissionCache] Error checking permission ${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;
-  }, [baseHasPermission, 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();
-    
-    if (mergedConfig.enableLogging) {
-      console.log(`[PermissionCache] Cache invalidated${pattern ? ` for pattern: ${pattern}` : ''}`);
-    }
-  }, [mergedConfig.enableLogging]);
-
-  // 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
-    };
-  }, []);
-
-  // Get audit trail
-  const getAuditTrail = useCallback(() => {
-    return [...auditTrail.current];
-  }, []);
-
-  // 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++;
-        }
-      }
-      
-      if (cleaned > 0 && mergedConfig.enableLogging) {
-        console.log(`[PermissionCache] Cleaned up ${cleaned} expired cache entries`);
-      }
-    };
-    
-    // Only set up interval in non-test environments to prevent memory leaks during testing
-    const interval = typeof process !== 'undefined' && process.env.NODE_ENV !== 'test' 
-      ? setInterval(cleanup, 1000) 
-      : null;
-    
-    return () => {
-      if (interval) {
-        clearInterval(interval);
-      }
-    };
-  }, [isCacheValid, mergedConfig.enableLogging]);
-
-  return {
-    checkPermission,
-    checkMultiplePermissions,
-    getCachedPermissions,
-    invalidateCache,
-    getDebugInfo,
-    getAuditTrail
-  };
-}