@od-oneapp/config 2026.2.2001-canary.1

package/typescript/dist/src/server/memory-aware-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-aware-cache.d.ts","sourceRoot":"","sources":["../../../../../core-utils/src/server/memory-aware-cache.ts"],"names":[],"mappings":"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"}

package/typescript/dist/src/server/memory-aware-cache.js

@@ -0,0 +1,655 @@
+import { scheduler } from 'node:timers/promises';
+import { logDebug, logError } from '@repo/shared/logs';
+import { LRUCache } from 'lru-cache';
+import { globalAdvancedMemoryMonitor } from './advanced-memory-monitor';
+import { ErrorPatterns } from './error-handling';
+import { enhancedClone, isStructuredCloneAvailable } from './structured-clone';
+import { ok, runTool } from './tool-helpers';
+export class MemoryAwareCache {
+    cache;
+    options;
+    memoryUsage = 0;
+    compressionStats = {
+        totalCompressed: 0,
+        totalSavings: 0,
+        compressionRatio: 1.0,
+    };
+    analytics = {
+        hits: 0,
+        misses: 0,
+        evictions: 0,
+        compressions: 0,
+        decompressions: 0,
+        memoryPressureEvictions: 0,
+        weakRefCollections: 0,
+    };
+    cleanupInterval = null;
+    lastMemoryCheck = 0;
+    memoryCheckInterval = 30000;
+    compressionStream = null;
+    constructor(options = {}) {
+        this.options = {
+            maxSize: options.maxSize ?? 1000,
+            maxMemoryMB: options.maxMemoryMB ?? 100,
+            ttl: options.ttl || 30 * 60 * 1000,
+            enableAnalytics: options.enableAnalytics !== false,
+            useWeakRefs: options.useWeakRefs !== false,
+            useStructuredClone: options.useStructuredClone !== false && isStructuredCloneAvailable(),
+            deepCopy: options.deepCopy !== false,
+            memoryPressureThreshold: options.memoryPressureThreshold ?? 75,
+            autoEvictOnPressure: options.autoEvictOnPressure !== false,
+            enableLeakDetection: options.enableLeakDetection !== false,
+            compressionThreshold: options.compressionThreshold ?? 10240,
+            persistenceEnabled: options.persistenceEnabled ?? false,
+        };
+        void this.initializeCompression();
+        this.setupCache();
+        this.startPeriodicCleanup();
+    }
+    async initializeCompression() {
+        try {
+            const { createGzip, createGunzip } = await import('node:zlib');
+            this.compressionStream = { createGzip, createGunzip };
+        }
+        catch {
+            logDebug('Compression not available');
+        }
+    }
+    setupCache() {
+        this.cache = new LRUCache({
+            max: this.options.maxSize,
+            ttl: this.options.ttl,
+            sizeCalculation: (value) => value.size,
+            maxSize: this.options.maxMemoryMB * 1024 * 1024,
+            dispose: (value, key, reason) => {
+                this.handleDisposal(value, key, reason);
+            },
+            updateAgeOnGet: true,
+            updateAgeOnHas: true,
+        });
+    }
+    startPeriodicCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            void this.performPeriodicMaintenance().catch(error => {
+                logError('[MemoryAwareCache] Periodic maintenance error', { error });
+            });
+        }, this.memoryCheckInterval);
+        this.cleanupInterval.unref();
+    }
+    async performPeriodicMaintenance() {
+        await this.cleanupDeadWeakRefs();
+        if (this.options.autoEvictOnPressure) {
+            await this.checkMemoryPressureAndEvict();
+        }
+        await this.optimizeCompression();
+    }
+    async cleanupDeadWeakRefs() {
+        let cleaned = 0;
+        for (const [key, value] of this.cache.entries()) {
+            if (value.weakRef && value.weakRef.deref() === undefined) {
+                this.cache.delete(key);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            this.analytics.weakRefCollections += cleaned;
+            logDebug(`Cleaned ${cleaned} dead WeakRef cache entries`, { cleanedCount: cleaned });
+        }
+    }
+    async checkMemoryPressureAndEvict() {
+        const pressure = globalAdvancedMemoryMonitor.getMemoryPressure();
+        if (pressure.heapUtilization > this.options.memoryPressureThreshold) {
+            const evictionResult = await this.evictBasedOnMemoryPressure(pressure.level);
+            if (evictionResult.evicted) {
+                logDebug(`Memory pressure eviction: ${evictionResult.itemsRemoved} items, ${Math.round(evictionResult.memoryFreed / 1024)}KB freed`, {
+                    itemsRemoved: evictionResult.itemsRemoved,
+                    memoryFreedKB: Math.round(evictionResult.memoryFreed / 1024),
+                });
+            }
+        }
+    }
+    async optimizeCompression() {
+        if (!this.compressionStream)
+            return;
+        let optimized = 0;
+        for (const [_key, value] of this.cache.entries()) {
+            if (!value.compressed && value.size > this.options.compressionThreshold) {
+                const compressed = await this.compressValue(value.data);
+                if (compressed && compressed.size < value.size * 0.8) {
+                    value.data = compressed.data;
+                    value.size = compressed.size;
+                    value.compressed = true;
+                    this.analytics.compressions++;
+                    optimized++;
+                }
+            }
+        }
+        if (optimized > 0) {
+            logDebug(`Optimized compression for ${optimized} cache entries`, {
+                optimizedCount: optimized,
+            });
+        }
+    }
+    async set(key, value, options = {}) {
+        const { ttl, compress = false, trackForLeaks = this.options.enableLeakDetection } = options;
+        const size = this.estimateSize(value);
+        let processedValue = value;
+        let compressed = false;
+        let trackingId;
+        if ((compress || size > this.options.compressionThreshold) && this.compressionStream) {
+            const compressedResult = await this.compressValue(value);
+            if (compressedResult && compressedResult.size < size * 0.9) {
+                processedValue = compressedResult.data;
+                compressed = true;
+                this.analytics.compressions++;
+            }
+        }
+        if (trackForLeaks && typeof value === 'object' && value !== null) {
+            trackingId = globalAdvancedMemoryMonitor.trackObject(value, `cache-${String(key)}`, { cacheKey: key, size }, () => {
+                this.cache.delete(key);
+            });
+        }
+        let weakRef;
+        if (this.options.useWeakRefs && typeof value === 'object' && value !== null) {
+            weakRef = new WeakRef(value);
+        }
+        const cacheValue = {
+            data: this.options.deepCopy ? this.deepCloneValue(processedValue) : processedValue,
+            size: compressed ? this.estimateSize(processedValue) : size,
+            accessCount: 0,
+            lastAccessed: Date.now(),
+            created: Date.now(),
+            compressed,
+            weakRef,
+            trackingId,
+        };
+        if (ttl) {
+            this.cache.set(key, cacheValue, { ttl });
+        }
+        else {
+            this.cache.set(key, cacheValue);
+        }
+        this.memoryUsage += cacheValue.size;
+        if (this.options.enableAnalytics) {
+            this.analytics.hits++;
+        }
+    }
+    async get(key) {
+        const cacheValue = this.cache.get(key);
+        if (!cacheValue) {
+            if (this.options.enableAnalytics) {
+                this.analytics.misses++;
+            }
+            return undefined;
+        }
+        if (cacheValue.weakRef) {
+            const weakValue = cacheValue.weakRef.deref();
+            if (weakValue === undefined) {
+                this.cache.delete(key);
+                this.analytics.weakRefCollections++;
+                return undefined;
+            }
+        }
+        cacheValue.accessCount++;
+        cacheValue.lastAccessed = Date.now();
+        let value = cacheValue.data;
+        if (cacheValue.compressed && this.compressionStream) {
+            const decompressed = await this.decompressValue(value);
+            if (decompressed) {
+                value = decompressed;
+                this.analytics.decompressions++;
+            }
+        }
+        if (this.options.deepCopy) {
+            value = this.deepCloneValue(value);
+        }
+        if (this.options.enableAnalytics) {
+            this.analytics.hits++;
+        }
+        return value;
+    }
+    has(key) {
+        const cacheValue = this.cache.peek(key);
+        if (!cacheValue) {
+            return false;
+        }
+        if (cacheValue.weakRef) {
+            const weakValue = cacheValue.weakRef.deref();
+            if (weakValue === undefined) {
+                this.cache.delete(key);
+                this.analytics.weakRefCollections++;
+                return false;
+            }
+        }
+        return true;
+    }
+    delete(key) {
+        const cacheValue = this.cache.get(key);
+        if (cacheValue) {
+            this.memoryUsage -= cacheValue.size;
+            if (cacheValue.trackingId && this.options.enableLeakDetection) {
+                logDebug(`Cleaning up tracked object: ${cacheValue.trackingId}`, {
+                    trackingId: cacheValue.trackingId,
+                });
+            }
+        }
+        return this.cache.delete(key);
+    }
+    async clear() {
+        if (this.options.enableLeakDetection) {
+            for (const [, value] of this.cache.entries()) {
+                if (value.trackingId) {
+                    logDebug(`Force cleaning tracked object: ${value.trackingId}`, {
+                        trackingId: value.trackingId,
+                    });
+                }
+            }
+        }
+        this.cache.clear();
+        this.memoryUsage = 0;
+        if (global.gc) {
+            await scheduler.wait(10);
+            global.gc();
+        }
+    }
+    async evictBasedOnMemoryPressure(pressureLevel) {
+        let itemsToEvict = 0;
+        const _memoryToFree = 0;
+        switch (pressureLevel) {
+            case 'emergency':
+                itemsToEvict = Math.floor(this.cache.size * 0.8);
+                break;
+            case 'critical':
+                itemsToEvict = Math.floor(this.cache.size * 0.6);
+                break;
+            case 'high':
+                itemsToEvict = Math.floor(this.cache.size * 0.4);
+                break;
+            case 'elevated':
+                itemsToEvict = Math.floor(this.cache.size * 0.2);
+                break;
+            default:
+                itemsToEvict = Math.floor(this.cache.size * 0.1);
+        }
+        if (itemsToEvict === 0) {
+            return {
+                evicted: false,
+                itemsRemoved: 0,
+                memoryFreed: 0,
+                reason: 'No eviction needed',
+            };
+        }
+        const entries = Array.from(this.cache.entries())
+            .map(([key, value]) => ({
+            key,
+            value,
+            priority: this.calculateEvictionPriority(value),
+        }))
+            .sort((a, b) => a.priority - b.priority);
+        let actuallyEvicted = 0;
+        let memoryFreed = 0;
+        for (let i = 0; i < Math.min(itemsToEvict, entries.length); i++) {
+            const entry = entries[i];
+            if (!entry) {
+                continue;
+            }
+            memoryFreed += entry.value.size;
+            if (this.cache.delete(entry.key)) {
+                actuallyEvicted++;
+            }
+        }
+        this.analytics.memoryPressureEvictions += actuallyEvicted;
+        return {
+            evicted: actuallyEvicted > 0,
+            itemsRemoved: actuallyEvicted,
+            memoryFreed,
+            reason: `Memory pressure eviction (${pressureLevel})`,
+        };
+    }
+    calculateEvictionPriority(value) {
+        const now = Date.now();
+        const age = now - value.created;
+        const timeSinceAccess = now - value.lastAccessed;
+        const accessFrequency = value.accessCount / Math.max(age, 1);
+        const recencyScore = Math.min(timeSinceAccess / 3600000, 1);
+        const frequencyScore = 1 - Math.min(accessFrequency * 1000, 1);
+        const ageScore = Math.min(age / 86400000, 1);
+        const sizeScore = Math.min(value.size / (1024 * 1024), 1);
+        return recencyScore * 0.4 + frequencyScore * 0.3 + ageScore * 0.2 + sizeScore * 0.1;
+    }
+    async compressValue(value) {
+        if (!this.compressionStream)
+            return null;
+        try {
+            const serialized = JSON.stringify(value);
+            const buffer = Buffer.from(serialized, 'utf8');
+            const compressed = buffer.toString('base64');
+            return {
+                data: compressed,
+                size: compressed.length,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    async decompressValue(compressedData) {
+        if (!this.compressionStream)
+            return null;
+        try {
+            if (typeof compressedData !== 'string')
+                return null;
+            const buffer = Buffer.from(compressedData, 'base64');
+            const decompressed = buffer.toString('utf8');
+            return JSON.parse(decompressed);
+        }
+        catch {
+            return null;
+        }
+    }
+    deepCloneValue(value) {
+        if (!this.options.deepCopy)
+            return value;
+        const cloneResult = enhancedClone(value, {
+            fallbackToJson: true,
+            trackPerformance: false,
+        });
+        return cloneResult.data;
+    }
+    estimateSize(value) {
+        try {
+            const jsonStr = JSON.stringify(value);
+            return jsonStr.length * 2;
+        }
+        catch {
+            return 64;
+        }
+    }
+    handleDisposal(value, key, reason) {
+        this.memoryUsage -= value.size;
+        if (this.options.enableAnalytics && reason === 'evict') {
+            this.analytics.evictions++;
+        }
+        if (value.trackingId && this.options.enableLeakDetection) {
+            logDebug(`Disposal cleanup for tracked object: ${value.trackingId}`, {
+                trackingId: value.trackingId,
+            });
+        }
+    }
+    getMemoryStats() {
+        let totalWeakRefs = 0;
+        let deadWeakRefs = 0;
+        let largestItem = 0;
+        let totalSize = 0;
+        for (const [, value] of this.cache.entries()) {
+            if (value.weakRef) {
+                totalWeakRefs++;
+                if (value.weakRef.deref() === undefined) {
+                    deadWeakRefs++;
+                }
+            }
+            if (value.size > largestItem) {
+                largestItem = value.size;
+            }
+            totalSize += value.size;
+        }
+        const pressure = globalAdvancedMemoryMonitor.getMemoryPressure();
+        return {
+            totalItems: this.cache.size,
+            estimatedMemoryUsage: totalSize,
+            averageItemSize: this.cache.size > 0 ? totalSize / this.cache.size : 0,
+            largestItem,
+            compressionRatio: this.compressionStats.compressionRatio,
+            weakRefCount: totalWeakRefs,
+            deadWeakRefs,
+            memoryPressureLevel: pressure.level,
+        };
+    }
+    getAnalytics() {
+        const hitRate = this.analytics.hits + this.analytics.misses > 0
+            ? ((this.analytics.hits / (this.analytics.hits + this.analytics.misses)) * 100).toFixed(2)
+            : '0';
+        return {
+            ...this.analytics,
+            hitRate: `${hitRate}%`,
+            currentSize: this.cache.size,
+            maxSize: this.options.maxSize,
+            memoryUsage: this.memoryUsage,
+            maxMemoryMB: this.options.maxMemoryMB,
+            compressionStats: this.compressionStats,
+        };
+    }
+    async forceCleanup() {
+        const beforeSize = this.cache.size;
+        const beforeMemory = this.memoryUsage;
+        await this.cleanupDeadWeakRefs();
+        const deadWeakRefsRemoved = this.analytics.weakRefCollections;
+        const evictionResult = await this.evictBasedOnMemoryPressure('high');
+        const afterSize = this.cache.size;
+        const afterMemory = this.memoryUsage;
+        return {
+            cleaned: evictionResult.evicted,
+            itemsRemoved: beforeSize - afterSize,
+            memoryFreed: beforeMemory - afterMemory,
+            deadWeakRefsRemoved,
+        };
+    }
+    dispose() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        void this.clear();
+        logDebug('Memory-aware cache disposed');
+    }
+}
+export class MemoryAwareCacheRegistry {
+    caches = new Map();
+    create(name, options = {}) {
+        if (this.caches.has(name)) {
+            const existing = this.caches.get(name);
+            if (!existing)
+                throw new Error(`Cache '${name}' not found`);
+            return existing;
+        }
+        const cache = new MemoryAwareCache(options);
+        this.caches.set(name, cache);
+        if (options.enableLeakDetection !== false) {
+            globalAdvancedMemoryMonitor.trackObject(cache, `cache-registry-${name}`, {
+                cacheName: name,
+                options,
+            });
+        }
+        return cache;
+    }
+    get(name) {
+        return this.caches.get(name);
+    }
+    delete(name) {
+        const cache = this.caches.get(name);
+        if (cache) {
+            cache.dispose();
+            return this.caches.delete(name);
+        }
+        return false;
+    }
+    list() {
+        return Array.from(this.caches.keys());
+    }
+    async cleanupAll() {
+        const results = {};
+        for (const [name, cache] of this.caches) {
+            results[name] = await cache.forceCleanup();
+        }
+        return results;
+    }
+    getGlobalStats() {
+        let totalItems = 0;
+        let totalMemoryUsage = 0;
+        for (const [, cache] of this.caches) {
+            const stats = cache.getMemoryStats();
+            totalItems += stats.totalItems;
+            totalMemoryUsage += stats.estimatedMemoryUsage;
+        }
+        const pressure = globalAdvancedMemoryMonitor.getMemoryPressure();
+        return {
+            totalCaches: this.caches.size,
+            totalItems,
+            totalMemoryUsage,
+            averageMemoryPerCache: this.caches.size > 0 ? totalMemoryUsage / this.caches.size : 0,
+            memoryPressureLevel: pressure.level,
+        };
+    }
+    async dispose() {
+        for (const [, cache] of this.caches) {
+            cache.dispose();
+        }
+        this.caches.clear();
+    }
+}
+export const globalMemoryAwareCacheRegistry = new MemoryAwareCacheRegistry();
+export const memoryAwareCacheTool = {
+    name: 'memory_aware_cache',
+    description: 'Advanced memory-aware cache with leak prevention and Node.js 22+ optimizations',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['create', 'get', 'set', 'delete', 'clear', 'stats', 'cleanup', 'forceGC'],
+                description: 'Cache action to perform',
+            },
+            cacheName: {
+                type: 'string',
+                description: 'Name of the cache instance',
+            },
+            key: {
+                type: 'string',
+                description: 'Cache key',
+            },
+            value: {
+                type: 'object',
+                description: 'Cache value',
+            },
+            options: {
+                type: 'object',
+                description: 'Cache configuration options',
+            },
+            cacheOptions: {
+                type: 'object',
+                description: 'Operation-specific options',
+            },
+        },
+        required: ['action', 'cacheName'],
+    },
+    async execute(args) {
+        return runTool('memory_aware_cache', args.action, async () => {
+            const { action, cacheName } = args;
+            switch (action) {
+                case 'create': {
+                    globalMemoryAwareCacheRegistry.create(cacheName, args.options ?? {});
+                    return ok({
+                        success: true,
+                        cacheName,
+                        message: `Memory-aware cache '${cacheName}' created`,
+                    });
+                }
+                case 'get': {
+                    const cache = globalMemoryAwareCacheRegistry.get(cacheName);
+                    if (!cache) {
+                        throw new Error(`Cache '${cacheName}' not found`);
+                    }
+                    const value = await cache.get(args.key);
+                    return ok({
+                        found: value !== undefined,
+                        value,
+                        key: args.key,
+                    });
+                }
+                case 'set': {
+                    const cache = globalMemoryAwareCacheRegistry.get(cacheName);
+                    if (!cache) {
+                        throw new Error(`Cache '${cacheName}' not found`);
+                    }
+                    await cache.set(args.key, args.value, args.cacheOptions ?? {});
+                    return ok({
+                        success: true,
+                        key: args.key,
+                        message: 'Value cached successfully',
+                    });
+                }
+                case 'delete': {
+                    const cache = globalMemoryAwareCacheRegistry.get(cacheName);
+                    if (!cache) {
+                        throw new Error(`Cache '${cacheName}' not found`);
+                    }
+                    const deleted = cache.delete(args.key);
+                    return ok({
+                        deleted,
+                        key: args.key,
+                    });
+                }
+                case 'clear': {
+                    const cache = globalMemoryAwareCacheRegistry.get(cacheName);
+                    if (!cache) {
+                        throw new Error(`Cache '${cacheName}' not found`);
+                    }
+                    await cache.clear();
+                    return ok({
+                        success: true,
+                        message: `Cache '${cacheName}' cleared`,
+                    });
+                }
+                case 'stats': {
+                    if (cacheName === 'global') {
+                        const globalStats = globalMemoryAwareCacheRegistry.getGlobalStats();
+                        return ok(globalStats);
+                    }
+                    const cache = globalMemoryAwareCacheRegistry.get(cacheName);
+                    if (!cache) {
+                        throw new Error(`Cache '${cacheName}' not found`);
+                    }
+                    const memoryStats = cache.getMemoryStats();
+                    const analytics = cache.getAnalytics();
+                    return ok({
+                        memoryStats,
+                        analytics,
+                    });
+                }
+                case 'cleanup': {
+                    if (cacheName === 'all') {
+                        const results = await globalMemoryAwareCacheRegistry.cleanupAll();
+                        return ok({
+                            globalCleanup: true,
+                            results,
+                        });
+                    }
+                    const cache = globalMemoryAwareCacheRegistry.get(cacheName);
+                    if (!cache) {
+                        throw new Error(`Cache '${cacheName}' not found`);
+                    }
+                    const result = await cache.forceCleanup();
+                    return ok(result);
+                }
+                case 'forceGC': {
+                    const gcResult = await globalAdvancedMemoryMonitor.performIntelligentGC({
+                        forceFullGC: true,
+                    });
+                    return ok(gcResult);
+                }
+                default:
+                    throw ErrorPatterns.unknownAction(action, [
+                        'create',
+                        'get',
+                        'set',
+                        'delete',
+                        'clear',
+                        'stats',
+                        'cleanup',
+                        'forceGC',
+                    ]);
+            }
+        });
+    },
+};
+//# sourceMappingURL=memory-aware-cache.js.map