@mxf-dev/core 1.0.0

package/dist/services/ValidationCacheService.js

@@ -0,0 +1,864 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+/**
+ * ValidationCacheService - Phase 5 Proactive Validation System
+ *
+ * Multi-level caching service for validation results with memory, Redis, and MongoDB tiers.
+ * Provides performance-optimized caching with TTL management and cache invalidation.
+ */
+import { Subject } from 'rxjs';
+import { Logger } from '../utils/Logger.js';
+import { createHash } from 'crypto';
+/**
+ * Validation Cache Service with multi-level caching
+ */
+export class ValidationCacheService {
+    logger;
+    // Configuration
+    config;
+    // Memory cache
+    memoryCache = new Map();
+    accessOrder = new Map(); // for LRU
+    accessFrequency = new Map(); // for LFU
+    memoryCacheSize = 0;
+    // Cache statistics
+    stats = {
+        memory: { enabled: true, entries: 0, size: 0, hits: 0, misses: 0, evictions: 0, avgResponseTime: 0, errorRate: 0, totalResponseTime: 0, totalRequests: 0 },
+        redis: { enabled: false, entries: 0, size: 0, hits: 0, misses: 0, evictions: 0, avgResponseTime: 0, errorRate: 0, totalResponseTime: 0, totalRequests: 0 },
+        mongo: { enabled: false, entries: 0, size: 0, hits: 0, misses: 0, evictions: 0, avgResponseTime: 0, errorRate: 0, totalResponseTime: 0, totalRequests: 0 }
+    };
+    // Events
+    cacheEvents$ = new Subject();
+    // Redis client (placeholder - would be actual Redis client)
+    redisClient = null;
+    // MongoDB connection (placeholder - would be actual MongoDB connection)
+    mongoCollection = null;
+    // Background tasks
+    cleanupInterval = null;
+    static instance;
+    constructor() {
+        this.logger = new Logger('info', 'ValidationCacheService', 'server');
+        this.config = this.getDefaultConfig();
+        this.initializeCacheLevels();
+        this.startBackgroundTasks();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!ValidationCacheService.instance) {
+            ValidationCacheService.instance = new ValidationCacheService();
+        }
+        return ValidationCacheService.instance;
+    }
+    // =============================================================================
+    // CORE CACHE OPERATIONS
+    // =============================================================================
+    /**
+     * Get validation result from cache
+     */
+    async getValidationResult(agentId, channelId, toolName, parameters) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        const key = this.generateCacheKey(agentId, channelId, toolName, parameters);
+        const startTime = Date.now();
+        try {
+            // Try memory cache first
+            if (this.config.enableMemoryCache) {
+                const memoryResult = await this.getFromMemoryCache(key);
+                if (memoryResult.success) {
+                    this.emitCacheEvent({
+                        timestamp: Date.now(),
+                        type: 'HIT',
+                        level: 'MEMORY',
+                        key,
+                        responseTime: Date.now() - startTime
+                    });
+                    return memoryResult.data || null;
+                }
+            }
+            // Try Redis cache
+            if (this.config.enableRedisCache && this.redisClient) {
+                const redisResult = await this.getFromRedisCache(key);
+                if (redisResult.success) {
+                    // Write back to memory cache for faster future access
+                    if (this.config.enableMemoryCache) {
+                        await this.setToMemoryCache(key, redisResult.data, {
+                            agentId,
+                            channelId,
+                            toolName,
+                            parametersHash: this.hashParameters(parameters),
+                            validationLevel: redisResult.data?.riskAssessment?.recommendedValidationLevel || 'UNKNOWN'
+                        });
+                    }
+                    this.emitCacheEvent({
+                        timestamp: Date.now(),
+                        type: 'HIT',
+                        level: 'REDIS',
+                        key,
+                        responseTime: Date.now() - startTime
+                    });
+                    return redisResult.data || null;
+                }
+            }
+            // Try MongoDB cache
+            if (this.config.enableMongoCache && this.mongoCollection) {
+                const mongoResult = await this.getFromMongoCache(key);
+                if (mongoResult.success) {
+                    // Write back to higher cache levels
+                    const metadata = {
+                        agentId,
+                        channelId,
+                        toolName,
+                        parametersHash: this.hashParameters(parameters),
+                        validationLevel: mongoResult.data?.riskAssessment?.recommendedValidationLevel || 'UNKNOWN'
+                    };
+                    if (this.config.enableRedisCache && this.redisClient) {
+                        await this.setToRedisCache(key, mongoResult.data, metadata);
+                    }
+                    if (this.config.enableMemoryCache) {
+                        await this.setToMemoryCache(key, mongoResult.data, metadata);
+                    }
+                    this.emitCacheEvent({
+                        timestamp: Date.now(),
+                        type: 'HIT',
+                        level: 'MONGO',
+                        key,
+                        responseTime: Date.now() - startTime
+                    });
+                    return mongoResult.data || null;
+                }
+            }
+            // Cache miss
+            this.emitCacheEvent({
+                timestamp: Date.now(),
+                type: 'MISS',
+                level: 'MEMORY',
+                key,
+                responseTime: Date.now() - startTime
+            });
+            return null;
+        }
+        catch (error) {
+            this.logger.error(`Cache get operation failed for key ${key}:`, error);
+            this.emitCacheEvent({
+                timestamp: Date.now(),
+                type: 'ERROR',
+                level: 'MEMORY',
+                key,
+                responseTime: Date.now() - startTime,
+                details: { error: error instanceof Error ? error.message : String(error) }
+            });
+            return null;
+        }
+    }
+    /**
+     * Cache validation result
+     */
+    async cacheValidationResult(agentId, channelId, toolName, parameters, validationResult) {
+        if (!this.config.enabled) {
+            return false;
+        }
+        const key = this.generateCacheKey(agentId, channelId, toolName, parameters);
+        const startTime = Date.now();
+        const metadata = {
+            agentId,
+            channelId,
+            toolName,
+            parametersHash: this.hashParameters(parameters),
+            validationLevel: validationResult.riskAssessment.recommendedValidationLevel
+        };
+        try {
+            const writePromises = [];
+            // Write to all enabled cache levels
+            if (this.config.enableMemoryCache) {
+                writePromises.push(this.setToMemoryCache(key, validationResult, metadata));
+            }
+            if (this.config.enableRedisCache && this.redisClient) {
+                writePromises.push(this.setToRedisCache(key, validationResult, metadata));
+            }
+            if (this.config.enableMongoCache && this.mongoCollection) {
+                writePromises.push(this.setToMongoCache(key, validationResult, metadata));
+            }
+            // Execute writes based on configuration
+            if (this.config.performance.parallelWrites) {
+                await Promise.allSettled(writePromises);
+            }
+            else {
+                for (const writePromise of writePromises) {
+                    try {
+                        await writePromise;
+                    }
+                    catch (error) {
+                        this.logger.warn(`Cache write failed:`, error);
+                    }
+                }
+            }
+            this.emitCacheEvent({
+                timestamp: Date.now(),
+                type: 'SET',
+                level: 'MEMORY',
+                key,
+                size: this.estimateSize(validationResult),
+                responseTime: Date.now() - startTime
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Cache set operation failed for key ${key}:`, error);
+            this.emitCacheEvent({
+                timestamp: Date.now(),
+                type: 'ERROR',
+                level: 'MEMORY',
+                key,
+                responseTime: Date.now() - startTime,
+                details: { error: error instanceof Error ? error.message : String(error) }
+            });
+            return false;
+        }
+    }
+    // =============================================================================
+    // MEMORY CACHE IMPLEMENTATION
+    // =============================================================================
+    async getFromMemoryCache(key) {
+        const startTime = Date.now();
+        try {
+            const entry = this.memoryCache.get(key);
+            if (!entry) {
+                this.stats.memory.misses++;
+                return { success: false, fromCache: 'NONE', responseTime: Date.now() - startTime };
+            }
+            // Check expiration
+            if (Date.now() > entry.expiresAt) {
+                this.memoryCache.delete(key);
+                this.memoryCacheSize -= entry.size;
+                this.stats.memory.entries--;
+                this.stats.memory.misses++;
+                this.stats.memory.evictions++;
+                return { success: false, fromCache: 'NONE', responseTime: Date.now() - startTime };
+            }
+            // Update access information
+            entry.accessCount++;
+            entry.lastAccessed = Date.now();
+            this.updateAccessTracking(key);
+            this.stats.memory.hits++;
+            this.updateResponseTimeStats('memory', Date.now() - startTime);
+            return {
+                success: true,
+                data: entry.value,
+                fromCache: 'MEMORY',
+                responseTime: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            this.stats.memory.errorRate++;
+            return {
+                success: false,
+                fromCache: 'NONE',
+                responseTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async setToMemoryCache(key, value, metadata) {
+        const startTime = Date.now();
+        try {
+            const size = this.estimateSize(value);
+            const now = Date.now();
+            // Check size limits and evict if necessary
+            await this.ensureMemoryCacheSpace(size);
+            const entry = {
+                key,
+                value,
+                createdAt: now,
+                expiresAt: now + this.config.memoryCache.defaultTTL,
+                accessCount: 1,
+                lastAccessed: now,
+                size,
+                tags: [metadata.toolName, metadata.agentId, metadata.channelId],
+                metadata
+            };
+            this.memoryCache.set(key, entry);
+            this.memoryCacheSize += size;
+            this.stats.memory.entries++;
+            this.stats.memory.size = this.memoryCacheSize;
+            this.updateAccessTracking(key);
+            return {
+                success: true,
+                fromCache: 'MEMORY',
+                responseTime: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            this.stats.memory.errorRate++;
+            return {
+                success: false,
+                fromCache: 'NONE',
+                responseTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async ensureMemoryCacheSpace(requiredSize) {
+        // Check if we need to make space
+        while ((this.memoryCacheSize + requiredSize > this.config.memoryCache.maxSize) ||
+            (this.memoryCache.size >= this.config.memoryCache.maxEntries)) {
+            const keyToEvict = this.selectEvictionCandidate();
+            if (!keyToEvict)
+                break;
+            const entry = this.memoryCache.get(keyToEvict);
+            if (entry) {
+                this.memoryCache.delete(keyToEvict);
+                this.memoryCacheSize -= entry.size;
+                this.stats.memory.entries--;
+                this.stats.memory.evictions++;
+                this.accessOrder.delete(keyToEvict);
+                this.accessFrequency.delete(keyToEvict);
+                this.emitCacheEvent({
+                    timestamp: Date.now(),
+                    type: 'EVICT',
+                    level: 'MEMORY',
+                    key: keyToEvict,
+                    size: entry.size,
+                    responseTime: 0
+                });
+            }
+        }
+    }
+    selectEvictionCandidate() {
+        if (this.memoryCache.size === 0)
+            return null;
+        switch (this.config.memoryCache.evictionPolicy) {
+            case 'LRU':
+                return this.selectLRUCandidate();
+            case 'LFU':
+                return this.selectLFUCandidate();
+            case 'FIFO':
+                return this.selectFIFOCandidate();
+            default:
+                return Array.from(this.memoryCache.keys())[0];
+        }
+    }
+    selectLRUCandidate() {
+        let oldestKey = null;
+        let oldestTime = Date.now();
+        for (const [key, entry] of this.memoryCache.entries()) {
+            if (entry.lastAccessed < oldestTime) {
+                oldestTime = entry.lastAccessed;
+                oldestKey = key;
+            }
+        }
+        return oldestKey;
+    }
+    selectLFUCandidate() {
+        let leastUsedKey = null;
+        let leastUsedCount = Infinity;
+        for (const [key, entry] of this.memoryCache.entries()) {
+            if (entry.accessCount < leastUsedCount) {
+                leastUsedCount = entry.accessCount;
+                leastUsedKey = key;
+            }
+        }
+        return leastUsedKey;
+    }
+    selectFIFOCandidate() {
+        let oldestKey = null;
+        let oldestTime = Date.now();
+        for (const [key, entry] of this.memoryCache.entries()) {
+            if (entry.createdAt < oldestTime) {
+                oldestTime = entry.createdAt;
+                oldestKey = key;
+            }
+        }
+        return oldestKey;
+    }
+    updateAccessTracking(key) {
+        const now = Date.now();
+        this.accessOrder.set(key, now);
+        const currentFreq = this.accessFrequency.get(key) || 0;
+        this.accessFrequency.set(key, currentFreq + 1);
+    }
+    // =============================================================================
+    // REDIS CACHE IMPLEMENTATION (PLACEHOLDER)
+    // =============================================================================
+    async getFromRedisCache(key) {
+        const startTime = Date.now();
+        try {
+            if (!this.redisClient) {
+                return { success: false, fromCache: 'NONE', responseTime: 0 };
+            }
+            // Placeholder for Redis implementation
+            // const result = await this.redisClient.get(this.config.redisCache.keyPrefix + key);
+            // if (result) {
+            //     const data = this.config.redisCache.compression 
+            //         ? this.decompress(result)
+            //         : JSON.parse(result);
+            //     return { success: true, data, fromCache: 'REDIS', responseTime: Date.now() - startTime };
+            // }
+            this.stats.redis.misses++;
+            return { success: false, fromCache: 'NONE', responseTime: Date.now() - startTime };
+        }
+        catch (error) {
+            this.stats.redis.errorRate++;
+            return {
+                success: false,
+                fromCache: 'NONE',
+                responseTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async setToRedisCache(key, value, metadata) {
+        const startTime = Date.now();
+        try {
+            if (!this.redisClient) {
+                return { success: false, fromCache: 'NONE', responseTime: 0 };
+            }
+            // Placeholder for Redis implementation
+            // const serialized = this.config.redisCache.compression 
+            //     ? this.compress(JSON.stringify(value))
+            //     : JSON.stringify(value);
+            // 
+            // await this.redisClient.setex(
+            //     this.config.redisCache.keyPrefix + key,
+            //     this.config.redisCache.defaultTTL,
+            //     serialized
+            // );
+            this.stats.redis.entries++;
+            return {
+                success: true,
+                fromCache: 'REDIS',
+                responseTime: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            this.stats.redis.errorRate++;
+            return {
+                success: false,
+                fromCache: 'NONE',
+                responseTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    // =============================================================================
+    // MONGODB CACHE IMPLEMENTATION (PLACEHOLDER)
+    // =============================================================================
+    async getFromMongoCache(key) {
+        const startTime = Date.now();
+        try {
+            if (!this.mongoCollection) {
+                return { success: false, fromCache: 'NONE', responseTime: 0 };
+            }
+            // Placeholder for MongoDB implementation
+            // const document = await this.mongoCollection.findOne({
+            //     key,
+            //     expiresAt: { $gt: new Date() }
+            // });
+            // 
+            // if (document) {
+            //     this.stats.mongo.hits++;
+            //     return {
+            //         success: true,
+            //         data: document.value,
+            //         fromCache: 'MONGO',
+            //         responseTime: Date.now() - startTime
+            //     };
+            // }
+            this.stats.mongo.misses++;
+            return { success: false, fromCache: 'NONE', responseTime: Date.now() - startTime };
+        }
+        catch (error) {
+            this.stats.mongo.errorRate++;
+            return {
+                success: false,
+                fromCache: 'NONE',
+                responseTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async setToMongoCache(key, value, metadata) {
+        const startTime = Date.now();
+        try {
+            if (!this.mongoCollection) {
+                return { success: false, fromCache: 'NONE', responseTime: 0 };
+            }
+            // Placeholder for MongoDB implementation
+            // const document = {
+            //     key,
+            //     value,
+            //     metadata,
+            //     createdAt: new Date(),
+            //     expiresAt: new Date(Date.now() + this.config.mongoCache.defaultTTL),
+            //     size: this.estimateSize(value)
+            // };
+            // 
+            // await this.mongoCollection.replaceOne(
+            //     { key },
+            //     document,
+            //     { upsert: true }
+            // );
+            this.stats.mongo.entries++;
+            return {
+                success: true,
+                fromCache: 'MONGO',
+                responseTime: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            this.stats.mongo.errorRate++;
+            return {
+                success: false,
+                fromCache: 'NONE',
+                responseTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    // =============================================================================
+    // CACHE INVALIDATION
+    // =============================================================================
+    /**
+     * Invalidate cache entries based on criteria
+     */
+    async invalidateCache(request) {
+        const result = {
+            invalidated: 0,
+            levels: { memory: 0, redis: 0, mongo: 0 }
+        };
+        try {
+            // Invalidate memory cache
+            if (this.config.enableMemoryCache) {
+                result.levels.memory = await this.invalidateMemoryCache(request);
+                result.invalidated += result.levels.memory;
+            }
+            // Invalidate Redis cache
+            if (this.config.enableRedisCache && this.redisClient) {
+                result.levels.redis = await this.invalidateRedisCache(request);
+                result.invalidated += result.levels.redis;
+            }
+            // Invalidate MongoDB cache
+            if (this.config.enableMongoCache && this.mongoCollection) {
+                result.levels.mongo = await this.invalidateMongoCache(request);
+                result.invalidated += result.levels.mongo;
+            }
+            if (result.invalidated > 0) {
+            }
+        }
+        catch (error) {
+            this.logger.error('Cache invalidation failed:', error);
+        }
+        return result;
+    }
+    async invalidateMemoryCache(request) {
+        let invalidated = 0;
+        for (const [key, entry] of this.memoryCache.entries()) {
+            if (this.shouldInvalidateEntry(key, entry, request)) {
+                this.memoryCache.delete(key);
+                this.memoryCacheSize -= entry.size;
+                this.stats.memory.entries--;
+                this.accessOrder.delete(key);
+                this.accessFrequency.delete(key);
+                invalidated++;
+                this.emitCacheEvent({
+                    timestamp: Date.now(),
+                    type: 'DELETE',
+                    level: 'MEMORY',
+                    key,
+                    responseTime: 0
+                });
+            }
+        }
+        return invalidated;
+    }
+    async invalidateRedisCache(request) {
+        // Placeholder for Redis invalidation
+        // Would implement pattern-based key deletion
+        return 0;
+    }
+    async invalidateMongoCache(request) {
+        // Placeholder for MongoDB invalidation
+        // Would implement query-based document deletion
+        return 0;
+    }
+    shouldInvalidateEntry(key, entry, request) {
+        // Check pattern matching
+        if (request.pattern && !this.matchesPattern(key, request.pattern)) {
+            return false;
+        }
+        // Check tag matching
+        if (request.tags && !request.tags.some(tag => entry.tags.includes(tag))) {
+            return false;
+        }
+        // Check tool name
+        if (request.toolName && entry.metadata.toolName !== request.toolName) {
+            return false;
+        }
+        // Check agent ID
+        if (request.agentId && entry.metadata.agentId !== request.agentId) {
+            return false;
+        }
+        // Check channel ID
+        if (request.channelId && entry.metadata.channelId !== request.channelId) {
+            return false;
+        }
+        // Check age
+        if (request.olderThan && entry.createdAt > request.olderThan) {
+            return false;
+        }
+        return true;
+    }
+    matchesPattern(key, pattern) {
+        // Simple pattern matching - could be enhanced with proper glob patterns
+        return key.includes(pattern.replace('*', ''));
+    }
+    // =============================================================================
+    // HELPER METHODS
+    // =============================================================================
+    generateCacheKey(agentId, channelId, toolName, parameters) {
+        const parametersHash = this.hashParameters(parameters);
+        return `validation:${agentId}:${channelId}:${toolName}:${parametersHash}`;
+    }
+    hashParameters(parameters) {
+        const normalized = JSON.stringify(parameters, Object.keys(parameters).sort());
+        return createHash('sha256').update(normalized).digest('hex').substring(0, 16);
+    }
+    estimateSize(value) {
+        // Rough size estimation in bytes
+        return JSON.stringify(value).length * 2; // Assume 2 bytes per character (UTF-16)
+    }
+    updateResponseTimeStats(level, responseTime) {
+        const levelStats = this.stats[level];
+        levelStats.totalRequests++;
+        levelStats.totalResponseTime += responseTime;
+        levelStats.avgResponseTime = levelStats.totalResponseTime / levelStats.totalRequests;
+    }
+    initializeCacheLevels() {
+        // Initialize Redis client if enabled
+        if (this.config.redisCache.enabled) {
+            try {
+                // Placeholder for Redis client initialization
+                // this.redisClient = new Redis(redisConfig);
+                this.stats.redis.enabled = false; // Will be true when implemented
+            }
+            catch (error) {
+                this.logger.warn('Failed to initialize Redis cache:', error);
+                this.config.enableRedisCache = false;
+            }
+        }
+        // Initialize MongoDB collection if enabled
+        if (this.config.mongoCache.enabled) {
+            try {
+                // Placeholder for MongoDB initialization
+                // this.mongoCollection = db.collection(this.config.mongoCache.collection);
+                this.stats.mongo.enabled = false; // Will be true when implemented
+            }
+            catch (error) {
+                this.logger.warn('Failed to initialize MongoDB cache:', error);
+                this.config.enableMongoCache = false;
+            }
+        }
+    }
+    startBackgroundTasks() {
+        // Memory cache cleanup
+        if (this.config.memoryCache.cleanupInterval > 0) {
+            this.cleanupInterval = setInterval(() => {
+                this.cleanupExpiredMemoryEntries();
+            }, this.config.memoryCache.cleanupInterval);
+        }
+        // MongoDB background cleanup
+        if (this.config.mongoCache.backgroundCleanup) {
+            setInterval(() => {
+                this.cleanupMongoCache().catch(error => {
+                    this.logger.warn('MongoDB cache cleanup failed:', error);
+                });
+            }, 60 * 60 * 1000); // Every hour
+        }
+        // Statistics reporting
+        setInterval(() => {
+            this.reportCacheStatistics();
+        }, 5 * 60 * 1000); // Every 5 minutes
+    }
+    cleanupExpiredMemoryEntries() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, entry] of this.memoryCache.entries()) {
+            if (now > entry.expiresAt) {
+                this.memoryCache.delete(key);
+                this.memoryCacheSize -= entry.size;
+                this.stats.memory.entries--;
+                this.accessOrder.delete(key);
+                this.accessFrequency.delete(key);
+                cleaned++;
+                this.emitCacheEvent({
+                    timestamp: now,
+                    type: 'EVICT',
+                    level: 'MEMORY',
+                    key,
+                    responseTime: 0
+                });
+            }
+        }
+        if (cleaned > 0) {
+        }
+    }
+    async cleanupMongoCache() {
+        // Placeholder for MongoDB cleanup
+        // await this.mongoCollection.deleteMany({ expiresAt: { $lt: new Date() } });
+    }
+    reportCacheStatistics() {
+        const totalRequests = this.stats.memory.hits + this.stats.memory.misses +
+            this.stats.redis.hits + this.stats.redis.misses +
+            this.stats.mongo.hits + this.stats.mongo.misses;
+        if (totalRequests === 0)
+            return;
+        const totalHits = this.stats.memory.hits + this.stats.redis.hits + this.stats.mongo.hits;
+        const overallHitRate = totalHits / totalRequests;
+    }
+    emitCacheEvent(event) {
+        this.cacheEvents$.next(event);
+    }
+    getDefaultConfig() {
+        return {
+            enabled: true,
+            enableMemoryCache: true,
+            enableRedisCache: false, // Disabled until Redis client is implemented
+            enableMongoCache: false, // Disabled until MongoDB client is implemented
+            memoryCache: {
+                maxEntries: 10000,
+                maxSize: 50 * 1024 * 1024, // 50MB
+                defaultTTL: 5 * 60 * 1000, // 5 minutes
+                evictionPolicy: 'LRU',
+                cleanupInterval: 60 * 1000 // 1 minute
+            },
+            redisCache: {
+                enabled: false,
+                keyPrefix: 'mxf:validation:',
+                defaultTTL: 300, // 5 minutes in seconds
+                maxRetries: 3,
+                retryDelay: 1000,
+                compression: true
+            },
+            mongoCache: {
+                enabled: false,
+                collection: 'validation_cache',
+                defaultTTL: 24 * 60 * 60 * 1000, // 24 hours
+                indexKeys: ['key', 'metadata.toolName', 'metadata.agentId', 'expiresAt'],
+                maxDocuments: 1000000,
+                backgroundCleanup: true
+            },
+            performance: {
+                maxCacheTime: 10, // 10ms max cache operation time
+                parallelWrites: true,
+                writeThrough: false,
+                readThrough: true
+            }
+        };
+    }
+    // =============================================================================
+    // PUBLIC API
+    // =============================================================================
+    /**
+     * Get cache events observable
+     */
+    get cacheEvents() {
+        return this.cacheEvents$.asObservable();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const totalRequests = this.stats.memory.hits + this.stats.memory.misses +
+            this.stats.redis.hits + this.stats.redis.misses +
+            this.stats.mongo.hits + this.stats.mongo.misses;
+        const totalHits = this.stats.memory.hits + this.stats.redis.hits + this.stats.mongo.hits;
+        return {
+            totalEntries: this.stats.memory.entries + this.stats.redis.entries + this.stats.mongo.entries,
+            totalSize: this.stats.memory.size + this.stats.redis.size + this.stats.mongo.size,
+            hitRate: totalRequests > 0 ? totalHits / totalRequests : 0,
+            missRate: totalRequests > 0 ? 1 - (totalHits / totalRequests) : 0,
+            evictionRate: totalRequests > 0 ?
+                (this.stats.memory.evictions + this.stats.redis.evictions + this.stats.mongo.evictions) / totalRequests : 0,
+            avgAccessTime: totalRequests > 0 ?
+                (this.stats.memory.avgResponseTime + this.stats.redis.avgResponseTime + this.stats.mongo.avgResponseTime) / 3 : 0,
+            memoryStats: { ...this.stats.memory },
+            redisStats: { ...this.stats.redis },
+            mongoStats: { ...this.stats.mongo }
+        };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Clear all caches
+     */
+    async clearAllCaches() {
+        // Clear memory cache
+        this.memoryCache.clear();
+        this.accessOrder.clear();
+        this.accessFrequency.clear();
+        this.memoryCacheSize = 0;
+        this.stats.memory.entries = 0;
+        this.stats.memory.size = 0;
+        // Clear Redis cache (placeholder)
+        if (this.redisClient) {
+            // await this.redisClient.flushdb();
+        }
+        // Clear MongoDB cache (placeholder)
+        if (this.mongoCollection) {
+            // await this.mongoCollection.deleteMany({});
+        }
+    }
+    /**
+     * Get memory cache size info
+     */
+    getMemoryCacheInfo() {
+        return {
+            entries: this.memoryCache.size,
+            size: this.memoryCacheSize,
+            maxSize: this.config.memoryCache.maxSize,
+            utilization: this.memoryCacheSize / this.config.memoryCache.maxSize
+        };
+    }
+    /**
+     * Shutdown cache service
+     */
+    shutdown() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        if (this.redisClient) {
+            // this.redisClient.disconnect();
+        }
+    }
+}
+//# sourceMappingURL=ValidationCacheService.js.map