@ductape/sdk 0.0.4 → 0.0.6

package/dist/cache/cache.manager.js

@@ -0,0 +1,900 @@
+"use strict";
+/**
+ * CacheManager - Shared caching utility for all executor services
+ *
+ * Provides a three-tier caching strategy:
+ * - Internal (in-memory): Fastest layer using Map with LRU eviction
+ * - Redis (local/fast): Secondary cache layer for distributed reads
+ * - Remote (persistent): Backing store synced on writes/deletes/cache misses
+ *
+ * Used by: StorageService, DatabaseService, GraphService, VectorService,
+ * QuotaService, FallbackService, AgentsService, SessionsService, BrokersService,
+ * NotificationsService, etc.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = exports.cacheLogger = exports.CacheLogger = void 0;
+const crypto_js_1 = __importDefault(require("crypto-js"));
+const processorApi_service_1 = require("../api/services/processorApi.service");
+const processor_utils_1 = require("../processor/utils/processor.utils");
+/**
+ * Cache logger for detailed operation tracking
+ */
+class CacheLogger {
+    constructor(config = {}) {
+        var _a, _b, _c, _d;
+        this.levelPriority = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3,
+        };
+        this.config = {
+            enabled: (_a = config.enabled) !== null && _a !== void 0 ? _a : false,
+            level: (_b = config.level) !== null && _b !== void 0 ? _b : 'info',
+            timestamps: (_c = config.timestamps) !== null && _c !== void 0 ? _c : true,
+            stackTraces: (_d = config.stackTraces) !== null && _d !== void 0 ? _d : false,
+        };
+    }
+    setConfig(config) {
+        this.config = Object.assign(Object.assign({}, this.config), config);
+    }
+    enable() {
+        this.config.enabled = true;
+    }
+    disable() {
+        this.config.enabled = false;
+    }
+    shouldLog(level) {
+        return this.config.enabled && this.levelPriority[level] >= this.levelPriority[this.config.level];
+    }
+    formatMessage(level, component, message, data) {
+        const parts = [];
+        if (this.config.timestamps) {
+            parts.push(`[${new Date().toISOString()}]`);
+        }
+        parts.push(`[CACHE:${level.toUpperCase()}]`);
+        parts.push(`[${component}]`);
+        parts.push(message);
+        if (data && Object.keys(data).length > 0) {
+            parts.push(JSON.stringify(data, null, 2));
+        }
+        return parts.join(' ');
+    }
+    debug(component, message, data) {
+        if (this.shouldLog('debug')) {
+            console.log(this.formatMessage('debug', component, message, data));
+        }
+    }
+    info(component, message, data) {
+        if (this.shouldLog('info')) {
+            console.log(this.formatMessage('info', component, message, data));
+        }
+    }
+    warn(component, message, data) {
+        if (this.shouldLog('warn')) {
+            console.warn(this.formatMessage('warn', component, message, data));
+        }
+    }
+    error(component, message, error, data) {
+        if (this.shouldLog('error')) {
+            console.error(this.formatMessage('error', component, message, data));
+            if (error && this.config.stackTraces) {
+                console.error(error.stack);
+            }
+        }
+    }
+    /** Log cache operation with timing */
+    operation(op, key, startTime, result, tier, data) {
+        const duration = Date.now() - startTime;
+        this.info('OPERATION', `${op} [${result}] from ${tier}`, Object.assign({ key: key.substring(0, 50) + (key.length > 50 ? '...' : ''), duration: `${duration}ms` }, data));
+    }
+}
+exports.CacheLogger = CacheLogger;
+/** Global cache logger instance */
+exports.cacheLogger = new CacheLogger();
+/**
+ * CacheManager provides shared caching functionality for all executor services
+ *
+ * @example
+ * ```ts
+ * const cacheManager = new CacheManager({
+ *   workspace_id: 'ws-123',
+ *   public_key: 'pk-123',
+ *   user_id: 'user-123',
+ *   token: 'token',
+ *   env_type: 'prd',
+ *   redis_client: redisClient,
+ * });
+ *
+ * // Check cache before operation
+ * const cached = await cacheManager.fetch<MyData>({
+ *   cache_tag: 'my-cache',
+ *   product_tag: 'my-product',
+ *   component_tag: 'my-storage',
+ *   component_type: 'storage',
+ *   input: { fileName: 'test.pdf' },
+ *   privateKey: 'private-key',
+ *   expiry: 3600000, // 1 hour
+ * });
+ *
+ * if (cached.hit) {
+ *   return cached.data;
+ * }
+ *
+ * // Execute operation...
+ * const result = await doOperation();
+ *
+ * // Store in cache (fire-and-forget - no await needed)
+ * cacheManager.store({
+ *   cache_tag: 'my-cache',
+ *   product_tag: 'my-product',
+ *   component_tag: 'my-storage',
+ *   component_type: 'storage',
+ *   input: { fileName: 'test.pdf' },
+ *   privateKey: 'private-key',
+ *   expiry: 3600000,
+ * }, result);
+ * ```
+ */
+class CacheManager {
+    constructor(config) {
+        /** Internal in-memory cache (Tier 1 - fastest) */
+        this.internalCache = new Map();
+        /** Maximum number of entries in internal cache before LRU eviction */
+        this.maxInternalCacheSize = 1000;
+        this.config = config;
+        this.redisClient = config.redis_client || null;
+        this.processorApiService = new processorApi_service_1.ProcessorApiService(config.env_type);
+        exports.cacheLogger.info('INIT', 'CacheManager initialized', {
+            workspace_id: config.workspace_id,
+            env_type: config.env_type,
+            redis_available: !!config.redis_client,
+            max_internal_cache_size: this.maxInternalCacheSize,
+        });
+    }
+    /**
+     * Enable cache logging
+     */
+    enableLogging(config) {
+        exports.cacheLogger.setConfig(Object.assign({ enabled: true }, config));
+        exports.cacheLogger.info('INIT', 'Cache logging enabled', config);
+    }
+    /**
+     * Disable cache logging
+     */
+    disableLogging() {
+        exports.cacheLogger.info('INIT', 'Cache logging disabled');
+        exports.cacheLogger.disable();
+    }
+    /**
+     * Set maximum size for internal cache
+     */
+    setMaxInternalCacheSize(size) {
+        const oldSize = this.maxInternalCacheSize;
+        this.maxInternalCacheSize = size;
+        exports.cacheLogger.info('CONFIG', `Internal cache max size changed`, {
+            old_size: oldSize,
+            new_size: size,
+        });
+    }
+    /**
+     * Clear internal cache
+     */
+    clearInternalCache() {
+        const clearedCount = this.internalCache.size;
+        this.internalCache.clear();
+        exports.cacheLogger.info('CLEAR', `Internal cache cleared`, {
+            entries_cleared: clearedCount,
+        });
+    }
+    /**
+     * Set entry in internal cache with LRU eviction
+     */
+    setInternalCache(key, entry) {
+        // Evict oldest entries if at capacity
+        if (this.internalCache.size >= this.maxInternalCacheSize) {
+            const oldestKey = this.internalCache.keys().next().value;
+            if (oldestKey) {
+                this.internalCache.delete(oldestKey);
+                exports.cacheLogger.debug('LRU_EVICTION', `Evicted oldest entry to make room`, {
+                    evicted_key: oldestKey.substring(0, 40) + '...',
+                    cache_size: this.internalCache.size,
+                    max_size: this.maxInternalCacheSize,
+                });
+            }
+        }
+        this.internalCache.set(key, entry);
+    }
+    /**
+     * Check if internal cache entry is still valid
+     */
+    isValidEntry(entry, expiry) {
+        if (!expiry)
+            return true;
+        return Date.now() < entry.lastUpdated + expiry;
+    }
+    /**
+     * Wrap value with type information for storage (auto-detect type)
+     */
+    wrapValue(data) {
+        if (typeof data === 'string') {
+            return { type: 'string', value: data };
+        }
+        return { type: 'json', value: JSON.stringify(data) };
+    }
+    /**
+     * Unwrap value based on stored type
+     */
+    unwrapValue(wrapper) {
+        if (wrapper.type === 'string') {
+            return wrapper.value;
+        }
+        return JSON.parse(wrapper.value);
+    }
+    /**
+     * Get user access credentials for API calls
+     */
+    getUserAccess() {
+        return {
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            user_id: this.config.user_id,
+            token: this.config.token,
+        };
+    }
+    /**
+     * Generate cache key from cache tag and input (legacy format)
+     */
+    generateKey(cache_tag, input) {
+        const inputStr = typeof input === 'string' ? input : JSON.stringify(input);
+        return `${cache_tag}-${crypto_js_1.default.SHA512(inputStr).toString()}`;
+    }
+    /**
+     * Generate cache key with new format: cache_tag:component_type:operation:sha256(input)
+     * Includes cache_tag for isolation between different cache configurations
+     */
+    generateKeyV2(options) {
+        const { cache_tag, component_type, operation, input } = options;
+        const inputStr = typeof input === 'string' ? input : JSON.stringify(input);
+        const hash = crypto_js_1.default.SHA256(inputStr).toString();
+        return `${cache_tag}:${component_type}:${operation}:${hash}`;
+    }
+    /**
+     * Generate cache key based on options (uses V2 format if operation provided)
+     */
+    generateCacheKey(options) {
+        if (options.operation) {
+            return this.generateKeyV2({
+                cache_tag: options.cache_tag,
+                component_type: options.component_type,
+                operation: options.operation,
+                input: options.input,
+            });
+        }
+        return this.generateKey(options.cache_tag, options.input);
+    }
+    /**
+     * Check if caching is available (Redis client connected)
+     */
+    isAvailable() {
+        return this.redisClient !== null;
+    }
+    /**
+     * Fetch data from cache (Internal first, then Redis, then remote on miss)
+     *
+     * @returns Cache result with hit status, data, and source
+     */
+    async fetch(options) {
+        const { privateKey, expiry, cache_tag, component_type, operation } = options;
+        const key = this.generateCacheKey(options);
+        const startTime = Date.now();
+        exports.cacheLogger.debug('FETCH', `Starting cache fetch`, {
+            cache_tag,
+            component_type,
+            operation,
+            key: key.substring(0, 60) + '...',
+            expiry: expiry ? `${expiry}ms` : 'none',
+            internal_cache_size: this.internalCache.size,
+            redis_available: !!this.redisClient,
+        });
+        try {
+            // TIER 1: Check internal (in-memory) cache first
+            exports.cacheLogger.debug('TIER1:INTERNAL', `Checking internal cache...`);
+            const internalEntry = this.internalCache.get(key);
+            if (internalEntry) {
+                if (this.isValidEntry(internalEntry, expiry)) {
+                    const decryptedData = (0, processor_utils_1.decrypt)(internalEntry.data, privateKey);
+                    const wrapper = JSON.parse(decryptedData);
+                    exports.cacheLogger.operation('FETCH', key, startTime, 'hit', 'TIER1:INTERNAL', {
+                        cache_tag,
+                        component_type,
+                        age: `${Date.now() - internalEntry.lastUpdated}ms`,
+                    });
+                    return {
+                        hit: true,
+                        data: this.unwrapValue(wrapper),
+                        key,
+                        source: 'internal',
+                    };
+                }
+                else {
+                    // Expired - remove from internal cache
+                    exports.cacheLogger.debug('TIER1:INTERNAL', `Entry expired, removing`, {
+                        age: `${Date.now() - internalEntry.lastUpdated}ms`,
+                        expiry: `${expiry}ms`,
+                    });
+                    this.internalCache.delete(key);
+                }
+            }
+            else {
+                exports.cacheLogger.debug('TIER1:INTERNAL', `No entry found`);
+            }
+            // TIER 2: Check Redis cache
+            if (this.redisClient) {
+                exports.cacheLogger.debug('TIER2:REDIS', `Checking Redis cache...`);
+                const redisRecord = await this.redisClient.hgetall(key);
+                if (redisRecord && redisRecord.data && redisRecord.lastUpdated) {
+                    const lastUpdated = Number(redisRecord.lastUpdated);
+                    exports.cacheLogger.debug('TIER2:REDIS', `Found entry in Redis`, {
+                        age: `${Date.now() - lastUpdated}ms`,
+                        data_size: `${redisRecord.data.length} chars`,
+                    });
+                    if (expiry) {
+                        const expiryTime = lastUpdated + expiry;
+                        if (Date.now() > expiryTime) {
+                            // Expired - delete from Redis and continue to remote
+                            exports.cacheLogger.debug('TIER2:REDIS', `Entry expired, deleting`, {
+                                age: `${Date.now() - lastUpdated}ms`,
+                                expiry: `${expiry}ms`,
+                            });
+                            await this.redisClient.del(key);
+                        }
+                        else {
+                            // Valid cache hit from Redis - populate internal cache
+                            this.setInternalCache(key, {
+                                data: redisRecord.data,
+                                lastUpdated,
+                                expiry,
+                            });
+                            const decryptedData = (0, processor_utils_1.decrypt)(redisRecord.data, privateKey);
+                            // Try to parse as wrapper, fallback to direct parse for legacy data
+                            try {
+                                const wrapper = JSON.parse(decryptedData);
+                                if (wrapper.type && wrapper.value !== undefined) {
+                                    exports.cacheLogger.operation('FETCH', key, startTime, 'hit', 'TIER2:REDIS', {
+                                        cache_tag,
+                                        component_type,
+                                        promoted_to_internal: true,
+                                    });
+                                    return {
+                                        hit: true,
+                                        data: this.unwrapValue(wrapper),
+                                        key,
+                                        source: 'redis',
+                                    };
+                                }
+                            }
+                            catch (_a) {
+                                // Legacy format - parse directly
+                            }
+                            exports.cacheLogger.operation('FETCH', key, startTime, 'hit', 'TIER2:REDIS', {
+                                cache_tag,
+                                component_type,
+                                legacy_format: true,
+                                promoted_to_internal: true,
+                            });
+                            return {
+                                hit: true,
+                                data: JSON.parse(decryptedData),
+                                key,
+                                source: 'redis',
+                            };
+                        }
+                    }
+                    else {
+                        // No expiry - valid cache hit, populate internal cache
+                        this.setInternalCache(key, {
+                            data: redisRecord.data,
+                            lastUpdated,
+                            expiry,
+                        });
+                        const decryptedData = (0, processor_utils_1.decrypt)(redisRecord.data, privateKey);
+                        try {
+                            const wrapper = JSON.parse(decryptedData);
+                            if (wrapper.type && wrapper.value !== undefined) {
+                                exports.cacheLogger.operation('FETCH', key, startTime, 'hit', 'TIER2:REDIS', {
+                                    cache_tag,
+                                    component_type,
+                                    no_expiry: true,
+                                    promoted_to_internal: true,
+                                });
+                                return {
+                                    hit: true,
+                                    data: this.unwrapValue(wrapper),
+                                    key,
+                                    source: 'redis',
+                                };
+                            }
+                        }
+                        catch (_b) {
+                            // Legacy format
+                        }
+                        exports.cacheLogger.operation('FETCH', key, startTime, 'hit', 'TIER2:REDIS', {
+                            cache_tag,
+                            component_type,
+                            no_expiry: true,
+                            legacy_format: true,
+                            promoted_to_internal: true,
+                        });
+                        return {
+                            hit: true,
+                            data: JSON.parse(decryptedData),
+                            key,
+                            source: 'redis',
+                        };
+                    }
+                }
+                else {
+                    exports.cacheLogger.debug('TIER2:REDIS', `No entry found in Redis`);
+                }
+            }
+            else {
+                exports.cacheLogger.debug('TIER2:REDIS', `Redis not available, skipping`);
+            }
+            // TIER 3: Check remote cache
+            exports.cacheLogger.debug('TIER3:REMOTE', `Checking remote cache...`);
+            const remoteRecord = await this.processorApiService.fetchRemoteCacheByKey(key, this.getUserAccess());
+            if (remoteRecord) {
+                exports.cacheLogger.debug('TIER3:REMOTE', `Found entry in remote cache`, {
+                    value_size: `${remoteRecord.value.length} chars`,
+                });
+                const timestamp = Date.now();
+                // Populate internal cache
+                this.setInternalCache(key, {
+                    data: remoteRecord.value,
+                    lastUpdated: timestamp,
+                    expiry,
+                });
+                exports.cacheLogger.debug('TIER3:REMOTE', `Promoted to internal cache`);
+                // Populate Redis cache for next time
+                if (this.redisClient) {
+                    await this.redisClient.hset(key, 'data', remoteRecord.value);
+                    await this.redisClient.hset(key, 'lastUpdated', timestamp.toString());
+                    exports.cacheLogger.debug('TIER3:REMOTE', `Promoted to Redis cache`);
+                }
+                const decryptedData = (0, processor_utils_1.decrypt)(remoteRecord.value, privateKey);
+                try {
+                    const wrapper = JSON.parse(decryptedData);
+                    if (wrapper.type && wrapper.value !== undefined) {
+                        exports.cacheLogger.operation('FETCH', key, startTime, 'hit', 'TIER3:REMOTE', {
+                            cache_tag,
+                            component_type,
+                            promoted_to_internal: true,
+                            promoted_to_redis: !!this.redisClient,
+                        });
+                        return {
+                            hit: true,
+                            data: this.unwrapValue(wrapper),
+                            key,
+                            source: 'remote',
+                        };
+                    }
+                }
+                catch (_c) {
+                    // Legacy format
+                }
+                exports.cacheLogger.operation('FETCH', key, startTime, 'hit', 'TIER3:REMOTE', {
+                    cache_tag,
+                    component_type,
+                    legacy_format: true,
+                    promoted_to_internal: true,
+                    promoted_to_redis: !!this.redisClient,
+                });
+                return {
+                    hit: true,
+                    data: JSON.parse(decryptedData),
+                    key,
+                    source: 'remote',
+                };
+            }
+            else {
+                exports.cacheLogger.debug('TIER3:REMOTE', `No entry found in remote cache`);
+            }
+            // Cache miss in all tiers
+            exports.cacheLogger.operation('FETCH', key, startTime, 'miss', 'ALL_TIERS', {
+                cache_tag,
+                component_type,
+                tiers_checked: ['internal', this.redisClient ? 'redis' : null, 'remote'].filter(Boolean),
+            });
+            return { hit: false, key, source: 'miss' };
+        }
+        catch (error) {
+            // On error, return miss and let the operation proceed
+            exports.cacheLogger.error('FETCH', `Cache fetch error`, error, {
+                cache_tag,
+                component_type,
+                key: key.substring(0, 60) + '...',
+            });
+            return { hit: false, key, source: 'miss' };
+        }
+    }
+    /**
+     * Store data in cache (all three tiers: internal, Redis, and remote)
+     */
+    /**
+     * Store data in cache - fire-and-forget pattern.
+     * Internal cache is written synchronously for immediate availability.
+     * Redis and remote cache writes happen asynchronously without blocking.
+     */
+    store(options, data) {
+        const { cache_tag, product_tag, component_tag, component_type, privateKey, expiry, operation, } = options;
+        const key = this.generateCacheKey(options);
+        const timestamp = Date.now();
+        const startTime = Date.now();
+        console.log('[CacheManager] store() called - will write to remote cache', {
+            cache_tag,
+            product_tag,
+            component_tag,
+            component_type,
+            operation,
+            key: key.substring(0, 60) + '...',
+            has_privateKey: !!privateKey,
+        });
+        exports.cacheLogger.info('STORE', `Starting cache store (fire-and-forget)`, {
+            cache_tag,
+            product_tag,
+            component_tag,
+            component_type,
+            operation,
+            key: key.substring(0, 60) + '...',
+            expiry: expiry ? `${expiry}ms` : 'none',
+            data_type: typeof data,
+        });
+        // Wrap value with type information and serialize
+        const wrapper = this.wrapValue(data);
+        const serializedData = JSON.stringify(wrapper);
+        const encryptedData = (0, processor_utils_1.encrypt)(serializedData, privateKey);
+        exports.cacheLogger.debug('STORE', `Data prepared for storage`, {
+            original_size: `${serializedData.length} chars`,
+            encrypted_size: `${encryptedData.length} chars`,
+            value_type: wrapper.type,
+        });
+        // Calculate expiry date if provided
+        let expiresAt;
+        if (expiry) {
+            expiresAt = new Date(timestamp + expiry);
+            exports.cacheLogger.debug('STORE', `Cache will expire at ${expiresAt.toISOString()}`);
+        }
+        // TIER 1: Write to internal cache (synchronous - immediate availability)
+        exports.cacheLogger.debug('TIER1:INTERNAL', `Writing to internal cache...`);
+        this.setInternalCache(key, {
+            data: encryptedData,
+            lastUpdated: timestamp,
+            expiry,
+        });
+        exports.cacheLogger.debug('TIER1:INTERNAL', `Written to internal cache`, {
+            internal_cache_size: this.internalCache.size,
+            max_size: this.maxInternalCacheSize,
+        });
+        // TIER 2 & 3: Write to Redis and remote cache (fire-and-forget)
+        this.storeToExternalTiers(key, encryptedData, timestamp, expiresAt, {
+            cache_tag,
+            product_tag,
+            component_tag,
+            component_type,
+            startTime,
+        }).catch((error) => {
+            // Log error but don't propagate - cache failure shouldn't break anything
+            exports.cacheLogger.error('STORE', `External cache store error`, error, {
+                cache_tag,
+                component_type,
+                key: key.substring(0, 60) + '...',
+            });
+        });
+    }
+    /**
+     * Internal method to store to Redis and remote cache asynchronously
+     */
+    async storeToExternalTiers(key, encryptedData, timestamp, expiresAt, meta) {
+        const { cache_tag, product_tag, component_tag, component_type, startTime } = meta;
+        // TIER 2: Write to Redis cache (if available)
+        if (this.redisClient) {
+            exports.cacheLogger.debug('TIER2:REDIS', `Writing to Redis cache...`);
+            await this.redisClient.hset(key, 'data', encryptedData);
+            await this.redisClient.hset(key, 'lastUpdated', timestamp.toString());
+            exports.cacheLogger.debug('TIER2:REDIS', `Written to Redis cache`);
+        }
+        else {
+            exports.cacheLogger.debug('TIER2:REDIS', `Redis not available, skipping`);
+        }
+        // TIER 3: Write to remote cache (persistent store) - fire-and-forget
+        console.log('[CacheManager] TIER3:REMOTE - Writing to remote cache (fire-and-forget)', {
+            cache_tag,
+            product_tag,
+            component_tag,
+            component_type,
+            key: key.substring(0, 60) + '...',
+            has_expiry: !!expiresAt,
+            expiry: expiresAt === null || expiresAt === void 0 ? void 0 : expiresAt.toISOString(),
+        });
+        exports.cacheLogger.info('TIER3:REMOTE', `Writing to remote cache (fire-and-forget)...`, {
+            cache_tag,
+            product_tag,
+            component_tag,
+            component_type,
+            key: key.substring(0, 60) + '...',
+            has_expiry: !!expiresAt,
+            expiry: expiresAt === null || expiresAt === void 0 ? void 0 : expiresAt.toISOString(),
+        });
+        const remotePayload = {
+            key,
+            value: encryptedData,
+            cache_tag,
+            product_tag,
+            component_tag,
+            component_type,
+            expiry: expiresAt,
+        };
+        // Fire-and-forget: don't await to avoid blocking
+        this.processorApiService.addToRemoteCache(remotePayload, this.getUserAccess()).then(() => {
+            console.log('[CacheManager] TIER3:REMOTE - Successfully written to remote cache', {
+                cache_tag,
+                product_tag,
+                component_tag,
+                component_type,
+                key: key.substring(0, 60) + '...',
+            });
+            exports.cacheLogger.info('TIER3:REMOTE', `Successfully written to remote cache`, {
+                cache_tag,
+                product_tag,
+                component_tag,
+                component_type,
+                key: key.substring(0, 60) + '...',
+            });
+        }).catch((error) => {
+            // Log error but don't propagate - cache failure shouldn't break anything
+            console.error('[CacheManager] TIER3:REMOTE - Remote cache write failed (non-blocking)', {
+                cache_tag,
+                product_tag,
+                component_tag,
+                component_type,
+                key: key.substring(0, 60) + '...',
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            exports.cacheLogger.error('TIER3:REMOTE', `Remote cache write failed (non-blocking)`, error, {
+                cache_tag,
+                product_tag,
+                component_tag,
+                component_type,
+                key: key.substring(0, 60) + '...',
+                error_message: error instanceof Error ? error.message : String(error),
+                error_stack: error instanceof Error ? error.stack : undefined,
+            });
+        });
+        exports.cacheLogger.operation('STORE', key, startTime, 'stored', 'ALL_TIERS', {
+            cache_tag,
+            component_type,
+            tiers_written: ['internal', this.redisClient ? 'redis' : null, 'remote'].filter(Boolean),
+            encrypted_size: `${encryptedData.length} chars`,
+            expires_at: (expiresAt === null || expiresAt === void 0 ? void 0 : expiresAt.toISOString()) || 'never',
+        });
+    }
+    /**
+     * Invalidate/delete data from cache (all three tiers)
+     */
+    async invalidate(cache_tag, input) {
+        const key = this.generateKey(cache_tag, input);
+        const startTime = Date.now();
+        exports.cacheLogger.debug('INVALIDATE', `Starting cache invalidation`, {
+            cache_tag,
+            key: key.substring(0, 60) + '...',
+        });
+        try {
+            // TIER 1: Delete from internal cache
+            const wasInInternal = this.internalCache.has(key);
+            this.internalCache.delete(key);
+            exports.cacheLogger.debug('TIER1:INTERNAL', `Deleted from internal cache`, {
+                was_present: wasInInternal,
+            });
+            // TIER 2: Delete from Redis cache (if available)
+            if (this.redisClient) {
+                const redisDeleted = await this.redisClient.del(key);
+                exports.cacheLogger.debug('TIER2:REDIS', `Deleted from Redis cache`, {
+                    keys_deleted: redisDeleted,
+                });
+            }
+            else {
+                exports.cacheLogger.debug('TIER2:REDIS', `Redis not available, skipping`);
+            }
+            // TIER 3: Delete from remote cache
+            exports.cacheLogger.debug('TIER3:REMOTE', `Deleting from remote cache...`);
+            await this.processorApiService.deleteCacheValue({ key }, this.getUserAccess());
+            exports.cacheLogger.debug('TIER3:REMOTE', `Deleted from remote cache`);
+            exports.cacheLogger.operation('INVALIDATE', key, startTime, 'deleted', 'ALL_TIERS', {
+                cache_tag,
+                tiers_deleted: ['internal', this.redisClient ? 'redis' : null, 'remote'].filter(Boolean),
+            });
+        }
+        catch (error) {
+            // Log error but don't throw
+            exports.cacheLogger.error('INVALIDATE', `Cache invalidate error`, error, {
+                cache_tag,
+                key: key.substring(0, 60) + '...',
+            });
+        }
+    }
+    /**
+     * Invalidate/delete data from cache using options (supports new key format)
+     */
+    async invalidateV2(options) {
+        const key = this.generateCacheKey(options);
+        const startTime = Date.now();
+        const { cache_tag, component_type, operation } = options;
+        exports.cacheLogger.debug('INVALIDATE_V2', `Starting cache invalidation (V2)`, {
+            cache_tag,
+            component_type,
+            operation,
+            key: key.substring(0, 60) + '...',
+        });
+        try {
+            // TIER 1: Delete from internal cache
+            const wasInInternal = this.internalCache.has(key);
+            this.internalCache.delete(key);
+            exports.cacheLogger.debug('TIER1:INTERNAL', `Deleted from internal cache`, {
+                was_present: wasInInternal,
+            });
+            // TIER 2: Delete from Redis cache (if available)
+            if (this.redisClient) {
+                const redisDeleted = await this.redisClient.del(key);
+                exports.cacheLogger.debug('TIER2:REDIS', `Deleted from Redis cache`, {
+                    keys_deleted: redisDeleted,
+                });
+            }
+            else {
+                exports.cacheLogger.debug('TIER2:REDIS', `Redis not available, skipping`);
+            }
+            // TIER 3: Delete from remote cache
+            exports.cacheLogger.debug('TIER3:REMOTE', `Deleting from remote cache...`);
+            await this.processorApiService.deleteCacheValue({ key }, this.getUserAccess());
+            exports.cacheLogger.debug('TIER3:REMOTE', `Deleted from remote cache`);
+            exports.cacheLogger.operation('INVALIDATE_V2', key, startTime, 'deleted', 'ALL_TIERS', {
+                cache_tag,
+                component_type,
+                tiers_deleted: ['internal', this.redisClient ? 'redis' : null, 'remote'].filter(Boolean),
+            });
+        }
+        catch (error) {
+            // Log error but don't throw
+            exports.cacheLogger.error('INVALIDATE_V2', `Cache invalidateV2 error`, error, {
+                cache_tag,
+                component_type,
+                key: key.substring(0, 60) + '...',
+            });
+        }
+    }
+    /**
+     * Helper method to wrap an async operation with caching
+     *
+     * @example
+     * ```ts
+     * const result = await cacheManager.withCache(
+     *   {
+     *     cache_tag: 'my-cache',
+     *     product_tag: 'my-product',
+     *     component_tag: 'my-storage',
+     *     component_type: 'storage',
+     *     input: { fileName: 'test.pdf' },
+     *     privateKey: 'private-key',
+     *     expiry: 3600000,
+     *   },
+     *   async () => {
+     *     // Execute the actual operation
+     *     return await downloadFile('test.pdf');
+     *   }
+     * );
+     * ```
+     */
+    async withCache(options, operation) {
+        const { cache_tag, component_type } = options;
+        const startTime = Date.now();
+        exports.cacheLogger.debug('WITH_CACHE', `Starting withCache operation`, {
+            cache_tag,
+            component_type,
+        });
+        // Try to fetch from cache
+        const cached = await this.fetch(options);
+        if (cached.hit && cached.data !== undefined) {
+            exports.cacheLogger.info('WITH_CACHE', `Cache hit - returning cached data`, {
+                cache_tag,
+                component_type,
+                source: cached.source,
+                total_duration: `${Date.now() - startTime}ms`,
+            });
+            return {
+                data: cached.data,
+                cached: true,
+                source: cached.source,
+            };
+        }
+        // Cache miss - execute the operation
+        exports.cacheLogger.debug('WITH_CACHE', `Cache miss - executing operation...`, {
+            cache_tag,
+            component_type,
+        });
+        const operationStart = Date.now();
+        const data = await operation();
+        const operationDuration = Date.now() - operationStart;
+        exports.cacheLogger.debug('WITH_CACHE', `Operation completed, storing result`, {
+            cache_tag,
+            component_type,
+            operation_duration: `${operationDuration}ms`,
+        });
+        // Store result in cache
+        await this.store(options, data);
+        exports.cacheLogger.info('WITH_CACHE', `Cache miss - fresh data retrieved and cached`, {
+            cache_tag,
+            component_type,
+            operation_duration: `${operationDuration}ms`,
+            total_duration: `${Date.now() - startTime}ms`,
+        });
+        return {
+            data,
+            cached: false,
+            source: 'fresh',
+        };
+    }
+    /**
+     * Get internal cache stats for debugging/monitoring
+     */
+    getInternalCacheStats() {
+        const stats = {
+            size: this.internalCache.size,
+            maxSize: this.maxInternalCacheSize,
+            utilizationPercent: Math.round((this.internalCache.size / this.maxInternalCacheSize) * 100),
+            redisAvailable: !!this.redisClient,
+        };
+        exports.cacheLogger.debug('STATS', `Cache stats requested`, stats);
+        return stats;
+    }
+    /**
+     * Get detailed cache statistics including entry ages
+     */
+    getDetailedStats() {
+        const now = Date.now();
+        let oldestAge = null;
+        let newestAge = null;
+        for (const entry of this.internalCache.values()) {
+            const age = now - entry.lastUpdated;
+            if (oldestAge === null || age > oldestAge)
+                oldestAge = age;
+            if (newestAge === null || age < newestAge)
+                newestAge = age;
+        }
+        const stats = {
+            internal: {
+                size: this.internalCache.size,
+                maxSize: this.maxInternalCacheSize,
+                utilizationPercent: Math.round((this.internalCache.size / this.maxInternalCacheSize) * 100),
+                oldestEntryAge: oldestAge,
+                newestEntryAge: newestAge,
+            },
+            redis: { available: !!this.redisClient },
+            remote: { available: true }, // Always available
+        };
+        exports.cacheLogger.info('DETAILED_STATS', `Detailed cache stats`, {
+            internal_size: stats.internal.size,
+            internal_utilization: `${stats.internal.utilizationPercent}%`,
+            oldest_entry: oldestAge ? `${Math.round(oldestAge / 1000)}s ago` : 'none',
+            newest_entry: newestAge ? `${Math.round(newestAge / 1000)}s ago` : 'none',
+            redis_available: stats.redis.available,
+        });
+        return stats;
+    }
+}
+exports.CacheManager = CacheManager;
+exports.default = CacheManager;
+//# sourceMappingURL=cache.manager.js.map