@ductape/sdk 0.1.6 → 0.1.8

package/dist/cache/cache.manager.js

@@ -1,900 +0,0 @@
-"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