xypriss 1.0.1 → 1.1.2

package/dist/esm/mods/security/src/components/cache/UFSIMC.js

@@ -0,0 +1,1107 @@
+import * as crypto from 'crypto';
+import { promisify } from 'util';
+import zlib from 'zlib';
+import { EventEmitter } from 'events';
+import { SecureRandom } from '../../core/random/random-core.js';
+import '../../core/random/random-types.js';
+import '../../core/random/random-sources.js';
+import 'nehonix-uri-processor';
+import '../../utils/memory/index.js';
+import '../../types.js';
+import { CONFIG } from './config/cache.config.js';
+import { FastLRU } from './FastLRU.js';
+import { Logger } from '../../../../../shared/logger/Logger.js';
+
+/**
+ * Ultra-Fast Secure In-Memory Cache System (UFSIMC)
+ * Enhanced version with extreme performance optimizations, advanced security, and user-friendly features
+ */
+/**
+ * Ultra-Fast Secure In-Memory Cache (UFSIMC)
+ * Extends SIMC with extreme performance optimizations and advanced features
+ */
+class UFSIMC extends EventEmitter {
+    constructor(maxEntries = CONFIG.MAX_ENTRIES, logger) {
+        super();
+        this.keyHashMap = new Map(); // Original key -> hashed key mapping
+        this.tagIndex = new Map(); // Tag -> keys mapping
+        this.priorityQueues = new Array(11)
+            .fill(null)
+            .map(() => new Set());
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0,
+            totalSize: 0,
+            entryCount: 0,
+            hitRate: 0,
+            memoryUsage: {
+                used: 0,
+                limit: CONFIG.MAX_CACHE_SIZE_MB * 1024 * 1024,
+                percentage: 0,
+            },
+            totalAccesses: 0,
+            size: 0,
+            capacity: CONFIG.MAX_ENTRIES,
+            averageAccessTime: 0,
+            compressionRatio: 0,
+            encryptionOverhead: 0,
+            hotKeys: [],
+            coldKeys: [],
+            tagStats: new Map(),
+        };
+        this.encryptionKey = Buffer.alloc(0);
+        // Performance optimizations
+        this.encryptionPool = [];
+        this.accessTimes = [];
+        // Security enhancements
+        this.accessPatterns = new Map();
+        this.rateLimiter = new Map();
+        this.integrityCheck = true;
+        this.anomalyThreshold = 1000;
+        this.logger =
+            logger ||
+                new Logger({
+                    enabled: true,
+                    level: "info",
+                    components: {
+                        server: true,
+                        cache: true,
+                        cluster: true,
+                        performance: true,
+                        fileWatcher: true,
+                        plugins: true,
+                        security: true,
+                        monitoring: true,
+                        routes: true,
+                        userApp: true,
+                        typescript: true,
+                        console: true,
+                        other: true,
+                        router: true,
+                        middleware: true,
+                    },
+                });
+        this.lru = new FastLRU(maxEntries);
+        this.initializeEncryption();
+        this.startMaintenanceTasks();
+        this.warmUpPools();
+        this.startPerformanceMonitoring();
+    }
+    /**
+     * Warm up cipher pools for better performance
+     */
+    warmUpPools() {
+        // Pre-create cipher instances
+        for (let i = 0; i < 10; i++) {
+            try {
+                const iv = crypto.randomBytes(16);
+                this.encryptionPool.push(crypto.createCipheriv(CONFIG.ALGORITHM, this.encryptionKey, iv));
+            }
+            catch (error) {
+                // Pool will be created on-demand
+            }
+        }
+    }
+    /**
+     * Start performance monitoring
+     */
+    startPerformanceMonitoring() {
+        this.performanceTimer = setInterval(() => {
+            this.updatePerformanceMetrics();
+            this.optimizeHotness();
+        }, 5000); // Every 5 seconds
+        this.hotnessDecayTimer = setInterval(() => {
+            this.decayHotness();
+        }, 60000); // Every minute
+    }
+    /**
+     * Enhanced encryption initialization with key derivation
+     */
+    initializeEncryption() {
+        try {
+            if (process.env.ENC_SECRET_KEY) {
+                this.encryptionKey = Buffer.from(process.env.ENC_SECRET_KEY, CONFIG.ENCODING);
+            }
+            else if (process.env.ENC_SECRET_SEED &&
+                process.env.ENC_SECRET_SALT) {
+                this.encryptionKey = crypto.pbkdf2Sync(process.env.ENC_SECRET_SEED, process.env.ENC_SECRET_SALT, CONFIG.KEY_ITERATIONS, CONFIG.KEY_LENGTH, "sha256");
+            }
+            else {
+                const warningMsg = "UFSIMC-WARNING: Using generated key. For production, set ENV variables: ENC_SECRET_KEY or (ENC_SECRET_SEED and ENC_SECRET_SALT)";
+                this.logger.warn("security", warningMsg);
+                this.encryptionKey = SecureRandom.getRandomBytes(CONFIG.KEY_LENGTH).getBuffer();
+            }
+            this.emit("key_rotation", {
+                timestamp: Date.now(),
+                reason: "initialization",
+            });
+        }
+        catch (error) {
+            this.logger.error("security", "Failed to initialize encryption:", error);
+            throw new Error("Cache initialization failed");
+        }
+    }
+    /**
+     * Ultra-fast key validation and hashing
+     */
+    validateAndHashKey(key) {
+        if (!key || typeof key !== "string") {
+            throw new Error("Cache key must be a non-empty string");
+        }
+        if (key.length > CONFIG.MAX_KEY_LENGTH) {
+            throw new Error(`Cache key too long (max ${CONFIG.MAX_KEY_LENGTH} chars)`);
+        }
+        // Use cached hash if available
+        let hashedKey = this.keyHashMap.get(key);
+        if (!hashedKey) {
+            const salt = process.env.ENC_SECRET_SALT || "default-salt";
+            hashedKey = crypto
+                .pbkdf2Sync(key, salt, 1000, 32, "sha256")
+                .toString(CONFIG.ENCODING);
+            this.keyHashMap.set(key, hashedKey);
+        }
+        return hashedKey;
+    }
+    /**
+     * High-performance compression with adaptive algorithms
+     */
+    async smartCompress(data) {
+        if (data.length < CONFIG.COMPRESSION_THRESHOLD_BYTES) {
+            return { data, compressed: false, ratio: 1 };
+        }
+        try {
+            const originalSize = data.length;
+            // Try different compression based on data characteristics
+            let compressed;
+            if (data.includes("{") || data.includes("[")) {
+                // JSON-like data - use deflate
+                compressed = await promisify(zlib.deflate)(Buffer.from(data, "utf8"));
+            }
+            else {
+                // Text data - use gzip
+                compressed = await promisify(zlib.gzip)(Buffer.from(data, "utf8"));
+            }
+            const compressedString = compressed.toString(CONFIG.ENCODING);
+            const ratio = originalSize / compressedString.length;
+            if (ratio > 1.1) {
+                // At least 10% compression
+                return { data: compressedString, compressed: true, ratio };
+            }
+        }
+        catch (error) {
+            this.logger.warn("cache", "Compression failed:", error);
+        }
+        return { data, compressed: false, ratio: 1 };
+    }
+    /**
+     * Smart decompression
+     */
+    async smartDecompress(data, compressed) {
+        if (!compressed)
+            return data;
+        try {
+            const buffer = Buffer.from(data, CONFIG.ENCODING);
+            // Try gzip first, then deflate
+            try {
+                const decompressed = await promisify(zlib.gunzip)(buffer);
+                return decompressed.toString("utf8");
+            }
+            catch {
+                const decompressed = await promisify(zlib.inflate)(buffer);
+                return decompressed.toString("utf8");
+            }
+        }
+        catch (error) {
+            this.logger.error("cache", "Decompression failed:", error);
+            throw new Error("Data decompression failed");
+        }
+    }
+    /**
+     * High-performance encryption with pooling
+     */
+    fastEncrypt(data) {
+        try {
+            const iv = crypto.randomBytes(16);
+            const cipher = crypto.createCipheriv(CONFIG.ALGORITHM, this.encryptionKey, iv);
+            let encrypted = cipher.update(data, "utf8", CONFIG.ENCODING);
+            encrypted += cipher.final(CONFIG.ENCODING);
+            const authTag = cipher.getAuthTag().toString(CONFIG.ENCODING);
+            return {
+                encrypted,
+                iv: iv.toString(CONFIG.ENCODING),
+                authTag,
+            };
+        }
+        catch (error) {
+            this.emit("encryption_failure", {
+                error: error.message,
+                timestamp: Date.now(),
+            });
+            throw new Error("Encryption failed");
+        }
+    }
+    /**
+     * High-performance decryption
+     */
+    fastDecrypt(encrypted, iv, authTag) {
+        try {
+            const ivBuffer = Buffer.from(iv, CONFIG.ENCODING);
+            const authTagBuffer = Buffer.from(authTag, CONFIG.ENCODING);
+            const decipher = crypto.createDecipheriv(CONFIG.ALGORITHM, this.encryptionKey, ivBuffer);
+            decipher.setAuthTag(authTagBuffer);
+            let decrypted = decipher.update(encrypted, CONFIG.ENCODING, "utf8");
+            decrypted += decipher.final("utf8");
+            return decrypted;
+        }
+        catch (error) {
+            throw new Error("Decryption failed - data may be corrupted");
+        }
+    }
+    /**
+     * Calculate data checksum for integrity
+     */
+    calculateChecksum(data) {
+        return crypto
+            .createHash("sha256")
+            .update(data)
+            .digest("hex")
+            .substring(0, 16);
+    }
+    /**
+     * Rate limiting check
+     */
+    checkRateLimit(key) {
+        const now = Date.now();
+        const limit = this.rateLimiter.get(key);
+        if (!limit || now > limit.resetTime) {
+            this.rateLimiter.set(key, { count: 1, resetTime: now + 60000 }); // 1 minute window
+            return true;
+        }
+        if (limit.count >= 10000) {
+            // 10k requests per minute max
+            return false;
+        }
+        limit.count++;
+        return true;
+    }
+    /**
+     * Ultra-fast SET operation with advanced features
+     */
+    async set(key, value, options = {}) {
+        const startTime = process.hrtime.bigint();
+        try {
+            // Rate limiting
+            if (!this.checkRateLimit(key)) {
+                throw new Error("Rate limit exceeded");
+            }
+            const hashedKey = this.validateAndHashKey(key);
+            const serialized = JSON.stringify(value);
+            // Size validation
+            if (serialized.length > CONFIG.MAX_VALUE_SIZE_MB * 1024 * 1024) {
+                throw new Error(`Value too large (max ${CONFIG.MAX_VALUE_SIZE_MB}MB)`);
+            }
+            // Smart compression
+            const { data: processedData, compressed } = options.skipCompression
+                ? { data: serialized, compressed: false }
+                : await this.smartCompress(serialized);
+            // Conditional encryption
+            let encrypted, iv, authTag, checksum;
+            if (options.skipEncryption) {
+                encrypted = processedData;
+                iv = "";
+                authTag = "";
+            }
+            else {
+                const encResult = this.fastEncrypt(processedData);
+                encrypted = encResult.encrypted;
+                iv = encResult.iv;
+                authTag = encResult.authTag;
+            }
+            checksum = this.integrityCheck
+                ? this.calculateChecksum(serialized)
+                : "";
+            const now = Date.now();
+            const ttl = options.ttl || CONFIG.CACHE_EXPIRY_MS;
+            const priority = Math.max(1, Math.min(10, options.priority || 5));
+            const entry = {
+                data: encrypted,
+                iv,
+                authTag,
+                timestamp: now,
+                expiresAt: now + ttl,
+                accessCount: 0,
+                lastAccessed: now,
+                compressed,
+                size: encrypted.length + iv.length + authTag.length + 200,
+                version: 1,
+                hotness: 0,
+                priority,
+                tags: new Set(options.tags || []),
+                metadata: options.metadata || {},
+                checksum,
+            };
+            // Handle eviction with callback
+            const evictedEntry = this.lru.put(hashedKey, entry);
+            if (evictedEntry && options.onEvict) {
+                try {
+                    const evictedData = await this.decryptAndDecompress(evictedEntry);
+                    // Find the original key for the evicted entry
+                    const originalKey = this.findOriginalKey(hashedKey);
+                    if (originalKey) {
+                        options.onEvict(originalKey, JSON.parse(evictedData));
+                    }
+                }
+                catch (error) {
+                    this.logger.warn("cache", "Eviction callback failed:", error);
+                }
+            }
+            // Update indexes - ensure priority is within valid range
+            if (priority >= 0 && priority < this.priorityQueues.length) {
+                this.priorityQueues[priority].add(hashedKey);
+            }
+            if (options.tags) {
+                options.tags.forEach((tag) => {
+                    if (!this.tagIndex.has(tag)) {
+                        this.tagIndex.set(tag, new Set());
+                    }
+                    this.tagIndex.get(tag).add(hashedKey);
+                });
+            }
+            // Update stats
+            this.updateStatsAfterSet(entry.size, evictedEntry ? 1 : 0);
+            this.recordAccessTime(startTime);
+            return true;
+        }
+        catch (error) {
+            this.logger.error("cache", "Ultra cache set error:", error);
+            return false;
+        }
+    }
+    /**
+     * Ultra-fast GET operation with hotness tracking
+     */
+    async get(key) {
+        const startTime = process.hrtime.bigint();
+        try {
+            const hashedKey = this.validateAndHashKey(key);
+            const node = this.lru.getNode(hashedKey);
+            if (!node?.entry) {
+                this.stats.misses++;
+                this.recordAccessTime(startTime);
+                return null;
+            }
+            const entry = node.entry;
+            const now = Date.now();
+            // Check expiration
+            if (now > entry.expiresAt) {
+                this.lru.delete(hashedKey);
+                this.cleanupIndexes(hashedKey, entry);
+                this.stats.misses++;
+                this.stats.entryCount--;
+                this.recordAccessTime(startTime);
+                return null;
+            }
+            // Update access patterns and hotness
+            entry.accessCount++;
+            entry.lastAccessed = now;
+            entry.hotness = Math.min(100, entry.hotness + 1);
+            // Security monitoring
+            this.trackAccess(hashedKey);
+            // Decrypt and decompress
+            const decryptedData = await this.decryptAndDecompress(entry);
+            // Integrity check - compare against original serialized data
+            if (this.integrityCheck && entry.checksum) {
+                const currentChecksum = this.calculateChecksum(decryptedData);
+                if (currentChecksum !== entry.checksum) {
+                    this.emit("integrity_violation", { key, timestamp: now });
+                    throw new Error("Data integrity check failed");
+                }
+            }
+            this.stats.hits++;
+            this.recordAccessTime(startTime);
+            return JSON.parse(decryptedData);
+        }
+        catch (error) {
+            this.logger.error("cache", "Ultra cache get error:", error);
+            this.stats.misses++;
+            this.recordAccessTime(startTime);
+            return null;
+        }
+    }
+    /**
+     * Helper method for decryption and decompression
+     */
+    async decryptAndDecompress(entry) {
+        let decrypted;
+        if (entry.iv && entry.authTag) {
+            decrypted = this.fastDecrypt(entry.data, entry.iv, entry.authTag);
+        }
+        else {
+            decrypted = entry.data; // Unencrypted data
+        }
+        return await this.smartDecompress(decrypted, entry.compressed);
+    }
+    /**
+     * Batch GET operation for multiple keys
+     */
+    async getMultiple(keys) {
+        const results = new Map();
+        // Process in parallel batches
+        const batchSize = 50;
+        for (let i = 0; i < keys.length; i += batchSize) {
+            const batch = keys.slice(i, i + batchSize);
+            const promises = batch.map(async (key) => {
+                const value = await this.get(key);
+                return { key, value };
+            });
+            const batchResults = await Promise.all(promises);
+            batchResults.forEach(({ key, value }) => {
+                results.set(key, value);
+            });
+        }
+        return results;
+    }
+    /**
+     * Set multiple key-value pairs
+     */
+    async setMultiple(entries) {
+        const promises = entries.map(({ key, value, options }) => this.set(key, value, options));
+        return Promise.all(promises);
+    }
+    /**
+     * Delete by tag
+     */
+    async deleteByTag(tag) {
+        const keys = this.tagIndex.get(tag);
+        if (!keys)
+            return 0;
+        let deleted = 0;
+        for (const hashedKey of keys) {
+            if (this.lru.delete(hashedKey)) {
+                deleted++;
+            }
+        }
+        this.tagIndex.delete(tag);
+        this.stats.entryCount -= deleted;
+        return deleted;
+    }
+    /**
+     * Get keys by tag
+     */
+    getKeysByTag(tag) {
+        const hashedKeys = this.tagIndex.get(tag);
+        if (!hashedKeys)
+            return [];
+        const originalKeys = [];
+        for (const [originalKey, hashedKey] of this.keyHashMap.entries()) {
+            if (hashedKeys.has(hashedKey)) {
+                originalKeys.push(originalKey);
+            }
+        }
+        return originalKeys;
+    }
+    /**
+     * Advanced cache statistics
+     */
+    get getUltraStats() {
+        this.updatePerformanceMetrics();
+        return { ...this.stats };
+    }
+    /**
+     * Export cache data for backup
+     */
+    async exportData() {
+        const data = {};
+        const keys = this.lru.getKeys();
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (node?.entry) {
+                try {
+                    const decrypted = await this.decryptAndDecompress(node.entry);
+                    const originalKey = this.findOriginalKey(hashedKey);
+                    if (originalKey) {
+                        data[originalKey] = {
+                            value: JSON.parse(decrypted),
+                            metadata: node.entry
+                                .metadata,
+                            tags: Array.from(node.entry.tags),
+                            expiresAt: node.entry
+                                .expiresAt,
+                        };
+                    }
+                }
+                catch (error) {
+                    this.logger.warn("cache", `Failed to export key ${hashedKey}:`, error);
+                }
+            }
+        }
+        return data;
+    }
+    /**
+     * Import cache data from backup
+     */
+    async importData(data) {
+        try {
+            for (const [key, info] of Object.entries(data)) {
+                const { value, metadata, tags, expiresAt } = info;
+                const ttl = Math.max(0, expiresAt - Date.now());
+                if (ttl > 0) {
+                    await this.set(key, value, {
+                        ttl,
+                        metadata,
+                        tags,
+                    });
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error("cache", "Import failed:", error);
+            return false;
+        }
+    }
+    /**
+     * Performance and maintenance methods
+     */
+    updatePerformanceMetrics() {
+        // Calculate average access time
+        if (this.accessTimes.length > 0) {
+            this.stats.averageAccessTime =
+                this.accessTimes.reduce((a, b) => a + b, 0) /
+                    this.accessTimes.length;
+            this.accessTimes = this.accessTimes.slice(-1000); // Keep last 1000 measurements
+        }
+        // Update memory stats
+        this.stats.entryCount = this.lru.getSize();
+        this.stats.memoryUsage.used = this.stats.totalSize;
+        this.stats.memoryUsage.percentage =
+            (this.stats.totalSize / this.stats.memoryUsage.limit) * 100;
+        this.stats.hitRate =
+            this.stats.hits / Math.max(1, this.stats.hits + this.stats.misses);
+        // Update hot/cold keys
+        this.updateHotColdKeys();
+    }
+    updateHotColdKeys() {
+        const keys = this.lru.getKeys();
+        const keyHotness = [];
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (node?.entry) {
+                const entry = node.entry;
+                const originalKey = this.findOriginalKey(hashedKey);
+                if (originalKey) {
+                    keyHotness.push({
+                        key: originalKey,
+                        hotness: entry.hotness,
+                    });
+                }
+            }
+        }
+        keyHotness.sort((a, b) => b.hotness - a.hotness);
+        this.stats.hotKeys = keyHotness.slice(0, 10).map((k) => k.key);
+        this.stats.coldKeys = keyHotness.slice(-10).map((k) => k.key);
+    }
+    optimizeHotness() {
+        // Move hot items to higher priority
+        const keys = this.lru.getKeys();
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (node?.entry) {
+                const entry = node.entry;
+                if (entry.hotness > 50 && entry.priority < 8) {
+                    entry.priority = Math.min(10, entry.priority + 1);
+                }
+            }
+        }
+    }
+    decayHotness() {
+        // Gradually reduce hotness to identify truly hot vs temporarily hot items
+        const keys = this.lru.getKeys();
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (node?.entry) {
+                const entry = node.entry;
+                entry.hotness = Math.max(0, entry.hotness * 0.9);
+            }
+        }
+    }
+    recordAccessTime(startTime) {
+        const endTime = process.hrtime.bigint();
+        const durationNs = Number(endTime - startTime);
+        const durationMs = durationNs / 1000000;
+        this.accessTimes.push(durationMs);
+    }
+    updateStatsAfterSet(size, evictions) {
+        this.stats.totalSize += size;
+        this.stats.entryCount++;
+        this.stats.evictions += evictions;
+    }
+    trackAccess(key) {
+        const now = Date.now();
+        if (!this.accessPatterns.has(key)) {
+            this.accessPatterns.set(key, []);
+        }
+        const accesses = this.accessPatterns.get(key);
+        accesses.push(now);
+        // Keep only recent accesses
+        const oneHourAgo = now - 60 * 60 * 1000;
+        const recentAccesses = accesses.filter((time) => time > oneHourAgo);
+        this.accessPatterns.set(key, recentAccesses);
+        // Detect anomalies
+        if (recentAccesses.length > this.anomalyThreshold) {
+            this.emit("suspicious_access", {
+                key,
+                count: recentAccesses.length,
+                timestamp: now,
+            });
+        }
+    }
+    cleanupIndexes(hashedKey, entry) {
+        // Remove from priority queues - ensure priority is within valid range
+        if (entry.priority >= 0 &&
+            entry.priority < this.priorityQueues.length) {
+            this.priorityQueues[entry.priority].delete(hashedKey);
+        }
+        // Remove from tag indexes
+        for (const tag of entry.tags) {
+            const tagKeys = this.tagIndex.get(tag);
+            if (tagKeys) {
+                tagKeys.delete(hashedKey);
+                if (tagKeys.size === 0) {
+                    this.tagIndex.delete(tag);
+                }
+            }
+        }
+    }
+    findOriginalKey(hashedKey) {
+        for (const [originalKey, hash] of this.keyHashMap.entries()) {
+            if (hash === hashedKey) {
+                return originalKey;
+            }
+        }
+        return undefined;
+    }
+    startMaintenanceTasks() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, CONFIG.CLEANUP_INTERVAL_MS);
+        this.keyRotationTimer = setInterval(() => {
+            this.rotateEncryptionKey();
+        }, CONFIG.KEY_ROTATION_MS);
+        this.securityTimer = setInterval(() => {
+            this.performSecurityChecks();
+        }, CONFIG.SECURITY_CHECK_INTERVAL_MS);
+    }
+    cleanup() {
+        const now = Date.now();
+        const keys = this.lru.getKeys();
+        let cleaned = 0;
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (node?.entry &&
+                now > node.entry.expiresAt) {
+                const entry = node.entry;
+                this.lru.delete(hashedKey);
+                this.cleanupIndexes(hashedKey, entry);
+                this.stats.totalSize -= entry.size;
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            this.stats.entryCount -= cleaned;
+            this.emit("cleanup_completed", { cleaned, timestamp: now });
+        }
+    }
+    async rotateEncryptionKey() {
+        try {
+            const newKey = crypto.randomBytes(CONFIG.KEY_LENGTH);
+            const oldKey = this.encryptionKey;
+            const keys = this.lru.getKeys();
+            let processed = 0;
+            for (const hashedKey of keys) {
+                const node = this.lru.getNode(hashedKey);
+                if (!node?.entry)
+                    continue;
+                const entry = node.entry;
+                // Skip unencrypted entries
+                if (!entry.iv || !entry.authTag)
+                    continue;
+                try {
+                    // Decrypt with old key
+                    this.encryptionKey = oldKey;
+                    const decrypted = this.fastDecrypt(entry.data, entry.iv, entry.authTag);
+                    // Re-encrypt with new key
+                    this.encryptionKey = newKey;
+                    const { encrypted, iv, authTag } = this.fastEncrypt(decrypted);
+                    // Update entry
+                    entry.data = encrypted;
+                    entry.iv = iv;
+                    entry.authTag = authTag;
+                    processed++;
+                }
+                catch (error) {
+                    this.logger.error("security", `Failed to re-encrypt entry ${hashedKey}:`, error);
+                    // Remove corrupted entry
+                    this.lru.delete(hashedKey);
+                    this.cleanupIndexes(hashedKey, entry);
+                    this.stats.totalSize -= entry.size;
+                    this.stats.entryCount--;
+                }
+            }
+            this.encryptionKey = newKey;
+            this.emit("key_rotation", {
+                timestamp: Date.now(),
+                reason: "scheduled",
+                entriesProcessed: processed,
+            });
+        }
+        catch (error) {
+            this.logger.error("security", "Key rotation failed:", error);
+        }
+    }
+    performSecurityChecks() {
+        // Memory pressure check
+        if (this.stats.memoryUsage.percentage > 90) {
+            this.emit("memory_pressure", {
+                usage: this.stats.memoryUsage,
+                timestamp: Date.now(),
+            });
+            // Emergency cleanup
+            this.emergencyCleanup();
+        }
+        // Check for potential DoS attacks
+        if (this.lru.getSize() > CONFIG.MAX_ENTRIES * 0.95) {
+            this.emit("cache_overflow", {
+                entries: this.lru.getSize(),
+                limit: CONFIG.MAX_ENTRIES,
+                timestamp: Date.now(),
+            });
+        }
+        // Analyze access patterns for anomalies
+        this.detectAnomalies();
+    }
+    emergencyCleanup() {
+        const targetSize = this.stats.memoryUsage.limit * 0.6; // Clear to 60%
+        const keys = this.lru.getKeys();
+        let cleaned = 0;
+        // Remove expired entries first
+        this.cleanup();
+        // If still over limit, remove coldest entries
+        if (this.stats.totalSize > targetSize) {
+            for (const hashedKey of keys) {
+                if (this.stats.totalSize <= targetSize)
+                    break;
+                const node = this.lru.getNode(hashedKey);
+                if (node?.entry) {
+                    const entry = node.entry;
+                    if (entry.hotness < 10) {
+                        // Remove cold entries
+                        this.lru.delete(hashedKey);
+                        this.cleanupIndexes(hashedKey, entry);
+                        this.stats.totalSize -= entry.size;
+                        cleaned++;
+                    }
+                }
+            }
+        }
+        this.stats.entryCount -= cleaned;
+        this.stats.evictions += cleaned;
+        this.emit("emergency_cleanup", { cleaned, timestamp: Date.now() });
+    }
+    detectAnomalies() {
+        const now = Date.now();
+        const suspiciousPatterns = [];
+        for (const [key, accesses] of this.accessPatterns.entries()) {
+            if (accesses.length > this.anomalyThreshold) {
+                suspiciousPatterns.push(key);
+            }
+        }
+        if (suspiciousPatterns.length > 0) {
+            this.emit("anomaly_detected", {
+                patterns: suspiciousPatterns,
+                timestamp: now,
+            });
+        }
+    }
+    // ==================Advanced methods (usefull in some case)
+    /**
+     * Get cache health report
+     */
+    getHealthReport() {
+        const issues = [];
+        const recommendations = [];
+        let status = "healthy";
+        const stats = this.getUltraStats;
+        // Check hit rate
+        if (stats.hitRate < 0.5) {
+            issues.push("Low hit rate (< 50%)");
+            recommendations.push("Consider increasing cache size or TTL values");
+            status = "warning";
+        }
+        // Check memory usage
+        if (stats.memoryUsage.percentage > 90) {
+            issues.push("High memory usage (> 90%)");
+            recommendations.push("Increase cache size limit or reduce entry count");
+            status = "critical";
+        }
+        // Check access time
+        if (stats.averageAccessTime > 10) {
+            issues.push("Slow access times (> 10ms)");
+            recommendations.push("Consider optimizing data size or disabling encryption for performance-critical data");
+            if (status === "healthy")
+                status = "warning";
+        }
+        // Check eviction rate
+        const evictionRate = stats.evictions / Math.max(1, stats.entryCount);
+        if (evictionRate > 0.1) {
+            issues.push("High eviction rate (> 10%)");
+            recommendations.push("Increase cache size or adjust TTL values");
+            if (status === "healthy")
+                status = "warning";
+        }
+        return { status, issues, recommendations, metrics: stats };
+    }
+    /**
+     * Optimize cache configuration automatically
+     */
+    autoOptimize() {
+        const stats = this.getUltraStats;
+        // Adjust anomaly threshold based on usage patterns
+        const avgAccesses = Array.from(this.accessPatterns.values()).reduce((sum, accesses) => sum + accesses.length, 0) / Math.max(1, this.accessPatterns.size);
+        this.anomalyThreshold = Math.max(1000, avgAccesses * 10);
+        // Adjust cleanup frequency based on expiration patterns
+        if (stats.memoryUsage.percentage > 70) {
+            // More frequent cleanup
+            if (this.cleanupTimer) {
+                clearInterval(this.cleanupTimer);
+                this.cleanupTimer = setInterval(() => this.cleanup(), CONFIG.CLEANUP_INTERVAL_MS / 2);
+            }
+        }
+        this.emit("auto_optimization", {
+            anomalyThreshold: this.anomalyThreshold,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Prefetch data based on access patterns
+     */
+    async prefetch(predictor) {
+        let prefetched = 0;
+        const keys = this.lru.getKeys();
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (!node?.entry)
+                continue;
+            const entry = node.entry;
+            const originalKey = this.findOriginalKey(hashedKey);
+            if (originalKey && entry.hotness > 20) {
+                try {
+                    const predictedData = await predictor(originalKey, entry.metadata);
+                    if (predictedData) {
+                        const prefetchKey = `${originalKey}_prefetch_${Date.now()}`;
+                        await this.set(prefetchKey, predictedData, {
+                            ttl: entry.expiresAt - Date.now(),
+                            priority: Math.min(10, entry.priority + 1),
+                        });
+                        prefetched++;
+                    }
+                }
+                catch (error) {
+                    this.logger.warn("cache", `Prefetch failed for ${originalKey}:`, error);
+                }
+            }
+        }
+        return prefetched;
+    }
+    /**
+     * Create a cache snapshot for debugging
+     */
+    createSnapshot() {
+        const snapshot = {
+            timestamp: Date.now(),
+            stats: this.getUltraStats,
+            entries: [],
+            hotKeys: this.stats.hotKeys,
+            coldKeys: this.stats.coldKeys,
+            tagStats: Object.fromEntries(this.stats.tagStats),
+        };
+        const keys = this.lru.getKeys().slice(0, 100); // Sample first 100 entries
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (node?.entry) {
+                const entry = node.entry;
+                const originalKey = this.findOriginalKey(hashedKey);
+                snapshot.entries.push({
+                    key: originalKey,
+                    size: entry.size,
+                    accessCount: entry.accessCount,
+                    hotness: entry.hotness,
+                    priority: entry.priority,
+                    tags: Array.from(entry.tags),
+                    compressed: entry.compressed,
+                    encrypted: !!(entry.iv && entry.authTag),
+                    expiresIn: Math.max(0, entry.expiresAt - Date.now()),
+                });
+            }
+        }
+        return snapshot;
+    }
+    /**
+     * Validate cache integrity
+     */
+    async validateIntegrity() {
+        const result = { valid: 0, invalid: 0, errors: [] };
+        const keys = this.lru.getKeys();
+        for (const hashedKey of keys) {
+            const node = this.lru.getNode(hashedKey);
+            if (!node?.entry)
+                continue;
+            const entry = node.entry;
+            const originalKey = this.findOriginalKey(hashedKey);
+            try {
+                // Try to decrypt and decompress
+                await this.decryptAndDecompress(entry);
+                result.valid++;
+            }
+            catch (error) {
+                result.invalid++;
+                result.errors.push(`${originalKey}: ${error}`);
+                // Remove corrupted entry
+                this.lru.delete(hashedKey);
+                this.cleanupIndexes(hashedKey, entry);
+                this.stats.totalSize -= entry.size;
+                this.stats.entryCount--;
+            }
+        }
+        return result;
+    }
+    /**
+     * Enhanced delete with pattern matching
+     */
+    delete(key) {
+        try {
+            const hashedKey = this.validateAndHashKey(key);
+            const node = this.lru.getNode(hashedKey);
+            if (node?.entry) {
+                const entry = node.entry;
+                this.lru.delete(hashedKey);
+                this.cleanupIndexes(hashedKey, entry);
+                this.stats.totalSize -= entry.size;
+                this.stats.entryCount--;
+                this.keyHashMap.delete(key);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            this.logger.error("cache", "Delete error:", error);
+            return false;
+        }
+    }
+    /**
+     * Delete with pattern (supports wildcards)
+     */
+    deletePattern(pattern) {
+        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+        let deleted = 0;
+        for (const [originalKey] of this.keyHashMap.entries()) {
+            if (regex.test(originalKey)) {
+                if (this.delete(originalKey)) {
+                    deleted++;
+                }
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Check if key exists
+     */
+    has(key) {
+        try {
+            const hashedKey = this.validateAndHashKey(key);
+            const node = this.lru.getNode(hashedKey);
+            if (!node?.entry)
+                return false;
+            if (Date.now() > node.entry.expiresAt) {
+                this.delete(key);
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Clear all entries
+     */
+    clear() {
+        this.lru.clear();
+        this.keyHashMap.clear();
+        this.tagIndex.clear();
+        this.accessPatterns.clear();
+        this.rateLimiter.clear();
+        this.priorityQueues.forEach((queue) => queue.clear());
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            evictions: 0,
+            totalSize: 0,
+            entryCount: 0,
+            hitRate: 0,
+            memoryUsage: {
+                used: 0,
+                limit: CONFIG.MAX_CACHE_SIZE_MB * 1024 * 1024,
+                percentage: 0,
+            },
+            totalAccesses: 0,
+            size: 0,
+            capacity: CONFIG.MAX_ENTRIES,
+            averageAccessTime: 0,
+            compressionRatio: 0,
+            encryptionOverhead: 0,
+            hotKeys: [],
+            coldKeys: [],
+            tagStats: new Map(),
+        };
+    }
+    /**
+     * Get cache size
+     */
+    get size() {
+        return {
+            entries: this.lru.getSize(),
+            bytes: this.stats.totalSize,
+        };
+    }
+    /**
+     * Graceful shutdown
+     */
+    async shutdown() {
+        // Clear all timers
+        if (this.cleanupTimer)
+            clearInterval(this.cleanupTimer);
+        if (this.keyRotationTimer)
+            clearInterval(this.keyRotationTimer);
+        if (this.securityTimer)
+            clearInterval(this.securityTimer);
+        if (this.performanceTimer)
+            clearInterval(this.performanceTimer);
+        if (this.hotnessDecayTimer)
+            clearInterval(this.hotnessDecayTimer);
+        // Final cleanup
+        this.cleanup();
+        // Export data if needed (for persistence)
+        this.emit("shutdown", {
+            timestamp: Date.now(),
+            finalStats: this.getUltraStats,
+        });
+        // Clear all data
+        this.clear();
+        this.removeAllListeners();
+    }
+}
+
+export { UFSIMC as UltraFastSecureInMemoryCache, UFSIMC as default };
+//# sourceMappingURL=UFSIMC.js.map