@nest-omni/core 3.1.1-9 → 3.1.1

package/cache/cache-metrics.service.js

@@ -0,0 +1,298 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CacheMetricsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheMetricsService = void 0;
+const common_1 = require("@nestjs/common");
+const events_1 = require("events");
+let CacheMetricsService = CacheMetricsService_1 = class CacheMetricsService extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.logger = new common_1.Logger(CacheMetricsService_1.name);
+        this.operations = [];
+        this.maxOperations = 10000;
+        this.maxAge = 3600000;
+        setInterval(() => this.cleanupOldRecords(), 60000);
+    }
+    recordOperation(type, layer, hit, latency, error, key) {
+        const record = {
+            type,
+            layer,
+            hit,
+            latency,
+            error,
+            key,
+            timestamp: new Date(),
+        };
+        this.operations.push(record);
+        if (this.operations.length > this.maxOperations) {
+            this.operations.splice(0, this.operations.length - this.maxOperations);
+        }
+        this.emit('operation', record);
+        if (error) {
+            this.logger.warn(`Cache operation error: ${type} on ${layer} - ${error}`);
+        }
+    }
+    getMetrics(timeWindowMs = 300000) {
+        const endTime = new Date();
+        const startTime = new Date(endTime.getTime() - timeWindowMs);
+        const recentOperations = this.operations.filter((op) => op.timestamp >= startTime && op.timestamp <= endTime);
+        if (recentOperations.length === 0) {
+            return this.createEmptyMetrics(startTime, endTime);
+        }
+        const hits = recentOperations.filter((op) => op.hit).length;
+        const misses = recentOperations.filter((op) => !op.hit).length;
+        const errors = recentOperations.filter((op) => op.error).length;
+        const latencies = recentOperations
+            .map((op) => op.latency)
+            .sort((a, b) => a - b);
+        const gets = recentOperations.filter((op) => op.type === 'get').length;
+        const sets = recentOperations.filter((op) => op.type === 'set').length;
+        const deletes = recentOperations.filter((op) => op.type === 'delete').length;
+        const clears = recentOperations.filter((op) => op.type === 'clear').length;
+        const layerOperations = {
+            cls: recentOperations.filter((op) => op.layer === 'cls'),
+            memory: recentOperations.filter((op) => op.layer === 'memory'),
+            redis: recentOperations.filter((op) => op.layer === 'redis'),
+        };
+        const layerMetrics = {
+            cls: this.calculateLayerMetrics(layerOperations.cls),
+            memory: this.calculateLayerMetrics(layerOperations.memory),
+            redis: this.calculateLayerMetrics(layerOperations.redis),
+        };
+        return {
+            totalOperations: recentOperations.length,
+            hits,
+            misses,
+            hitRate: recentOperations.length > 0 ? hits / recentOperations.length : 0,
+            avgLatency: this.average(latencies),
+            minLatency: latencies.length > 0 ? latencies[0] : 0,
+            maxLatency: latencies.length > 0 ? latencies[latencies.length - 1] : 0,
+            p95Latency: this.percentile(latencies, 0.95),
+            p99Latency: this.percentile(latencies, 0.99),
+            gets,
+            sets,
+            deletes,
+            clears,
+            totalKeys: this.getUniqueKeyCount(recentOperations),
+            totalSize: this.estimateTotalSize(recentOperations),
+            errors,
+            errorRate: recentOperations.length > 0 ? errors / recentOperations.length : 0,
+            layerMetrics,
+            timeWindow: {
+                start: startTime,
+                end: endTime,
+                duration: timeWindowMs,
+            },
+        };
+    }
+    getSnapshot() {
+        const now = new Date();
+        const oneMinuteAgo = new Date(now.getTime() - 60000);
+        const recentOperations = this.operations.filter((op) => op.timestamp >= oneMinuteAgo);
+        if (recentOperations.length === 0) {
+            return {
+                totalOperations: 0,
+                hits: 0,
+                misses: 0,
+                hitRate: 0,
+                avgLatency: 0,
+                errors: 0,
+                errorRate: 0,
+            };
+        }
+        const hits = recentOperations.filter((op) => op.hit).length;
+        const errors = recentOperations.filter((op) => op.error).length;
+        const latencies = recentOperations.map((op) => op.latency);
+        return {
+            totalOperations: recentOperations.length,
+            hits,
+            misses: recentOperations.length - hits,
+            hitRate: hits / recentOperations.length,
+            avgLatency: this.average(latencies),
+            minLatency: Math.min(...latencies),
+            maxLatency: Math.max(...latencies),
+            errors,
+            errorRate: errors / recentOperations.length,
+        };
+    }
+    getSlowOperations(limit = 10) {
+        return this.operations
+            .filter((op) => op.error === undefined)
+            .sort((a, b) => b.latency - a.latency)
+            .slice(0, limit);
+    }
+    getMostAccessedKeys(limit = 10) {
+        const keyStats = new Map();
+        this.operations.forEach((op) => {
+            if (op.key) {
+                const stats = keyStats.get(op.key) || { count: 0, totalLatency: 0 };
+                stats.count++;
+                stats.totalLatency += op.latency;
+                keyStats.set(op.key, stats);
+            }
+        });
+        return Array.from(keyStats.entries())
+            .map(([key, stats]) => ({
+            key,
+            count: stats.count,
+            avgLatency: stats.totalLatency / stats.count,
+        }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, limit);
+    }
+    getErrorBreakdown() {
+        const errorStats = new Map();
+        this.operations.forEach((op) => {
+            if (op.error) {
+                const stats = errorStats.get(op.error) || {
+                    count: 0,
+                    lastOccurrence: op.timestamp,
+                };
+                stats.count++;
+                stats.lastOccurrence =
+                    op.timestamp > stats.lastOccurrence
+                        ? op.timestamp
+                        : stats.lastOccurrence;
+                errorStats.set(op.error, stats);
+            }
+        });
+        return Array.from(errorStats.entries())
+            .map(([error, stats]) => ({
+            error,
+            count: stats.count,
+            lastOccurrence: stats.lastOccurrence,
+        }))
+            .sort((a, b) => b.count - a.count);
+    }
+    resetMetrics() {
+        this.operations.length = 0;
+        this.logger.log('Cache metrics reset');
+        this.emit('reset');
+    }
+    exportMetrics(format = 'json') {
+        const metrics = this.getMetrics();
+        if (format === 'prometheus') {
+            return this.toPrometheusFormat(metrics);
+        }
+        return JSON.stringify(metrics, null, 2);
+    }
+    cleanupOldRecords() {
+        const cutoff = new Date(Date.now() - this.maxAge);
+        const initialLength = this.operations.length;
+        for (let i = this.operations.length - 1; i >= 0; i--) {
+            if (this.operations[i].timestamp < cutoff) {
+                this.operations.splice(0, i + 1);
+                break;
+            }
+        }
+        const removed = initialLength - this.operations.length;
+        if (removed > 0) {
+            this.logger.debug(`Cleaned up ${removed} old cache operation records`);
+        }
+    }
+    createEmptyMetrics(start, end) {
+        return {
+            totalOperations: 0,
+            hits: 0,
+            misses: 0,
+            hitRate: 0,
+            avgLatency: 0,
+            minLatency: 0,
+            maxLatency: 0,
+            p95Latency: 0,
+            p99Latency: 0,
+            gets: 0,
+            sets: 0,
+            deletes: 0,
+            clears: 0,
+            totalKeys: 0,
+            totalSize: 0,
+            errors: 0,
+            errorRate: 0,
+            layerMetrics: {
+                cls: { hits: 0, misses: 0, avgLatency: 0 },
+                memory: { hits: 0, misses: 0, avgLatency: 0, size: 0 },
+                redis: { hits: 0, misses: 0, avgLatency: 0 },
+            },
+            timeWindow: {
+                start,
+                end,
+                duration: end.getTime() - start.getTime(),
+            },
+        };
+    }
+    calculateLayerMetrics(operations) {
+        const hits = operations.filter((op) => op.hit).length;
+        const misses = operations.filter((op) => !op.hit).length;
+        const latencies = operations.map((op) => op.latency);
+        return {
+            hits,
+            misses,
+            avgLatency: latencies.length > 0 ? this.average(latencies) : 0,
+            size: operations.length,
+        };
+    }
+    average(numbers) {
+        return numbers.length > 0
+            ? numbers.reduce((sum, num) => sum + num, 0) / numbers.length
+            : 0;
+    }
+    percentile(sortedNumbers, p) {
+        if (sortedNumbers.length === 0)
+            return 0;
+        const index = Math.ceil(sortedNumbers.length * p) - 1;
+        return sortedNumbers[Math.max(0, Math.min(index, sortedNumbers.length - 1))];
+    }
+    getUniqueKeyCount(operations) {
+        const keys = new Set();
+        operations.forEach((op) => {
+            if (op.key)
+                keys.add(op.key);
+        });
+        return keys.size;
+    }
+    estimateTotalSize(operations) {
+        const avgValueSize = 120;
+        return this.getUniqueKeyCount(operations) * avgValueSize;
+    }
+    toPrometheusFormat(metrics) {
+        const labels = {
+            layer: 'cls|memory|redis',
+        };
+        let output = '';
+        output += `# HELP cache_hit_rate Cache hit rate\n`;
+        output += `# TYPE cache_hit_rate gauge\n`;
+        output += `cache_hit_rate ${metrics.hitRate}\n`;
+        output += `# HELP cache_operations_total Total cache operations\n`;
+        output += `# TYPE cache_operations_total counter\n`;
+        output += `cache_operations_total{type="get"} ${metrics.gets}\n`;
+        output += `cache_operations_total{type="set"} ${metrics.sets}\n`;
+        output += `cache_operations_total{type="delete"} ${metrics.deletes}\n`;
+        output += `cache_operations_total{type="clear"} ${metrics.clears}\n`;
+        output += `# HELP cache_latency_ms Cache operation latency\n`;
+        output += `# TYPE cache_latency_ms histogram\n`;
+        output += `cache_latency_ms{quantile="0.5"} ${metrics.avgLatency}\n`;
+        output += `cache_latency_ms{quantile="0.95"} ${metrics.p95Latency}\n`;
+        output += `cache_latency_ms{quantile="0.99"} ${metrics.p99Latency}\n`;
+        Object.entries(metrics.layerMetrics).forEach(([layer, layerMetrics]) => {
+            output += `cache_layer_hits_total{layer="${layer}"} ${layerMetrics.hits}\n`;
+            output += `cache_layer_misses_total{layer="${layer}"} ${layerMetrics.misses}\n`;
+            output += `cache_layer_latency_ms{layer="${layer}"} ${layerMetrics.avgLatency}\n`;
+        });
+        return output;
+    }
+};
+exports.CacheMetricsService = CacheMetricsService;
+exports.CacheMetricsService = CacheMetricsService = CacheMetricsService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], CacheMetricsService);

package/cache/cache-serialization.service.d.ts

@@ -0,0 +1,22 @@
+export interface CacheSerializationOptions {
+    compress?: boolean;
+    compressThreshold?: number;
+}
+export interface SerializationResult {
+    data: Buffer;
+    compressed: boolean;
+    originalSize: number;
+    serializedSize: number;
+}
+export interface DeserializationResult<T> {
+    data: T;
+    wasCompressed: boolean;
+}
+export declare class CacheSerializationService {
+    private readonly logger;
+    serialize<T>(value: T, options?: CacheSerializationOptions): Promise<SerializationResult>;
+    deserialize<T>(buffer: Buffer): Promise<DeserializationResult<T>>;
+    private serializeWithDates;
+    private preProcessDates;
+    private deserializeWithDates;
+}

package/cache/cache-serialization.service.js

@@ -0,0 +1,122 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var CacheSerializationService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheSerializationService = void 0;
+const common_1 = require("@nestjs/common");
+const zlib_1 = require("zlib");
+const util_1 = require("util");
+const gzipAsync = (0, util_1.promisify)(zlib_1.gzip);
+const gunzipAsync = (0, util_1.promisify)(zlib_1.gunzip);
+let CacheSerializationService = CacheSerializationService_1 = class CacheSerializationService {
+    constructor() {
+        this.logger = new common_1.Logger(CacheSerializationService_1.name);
+    }
+    serialize(value_1) {
+        return __awaiter(this, arguments, void 0, function* (value, options = {}) {
+            const { compress = false, compressThreshold = 1024 } = options;
+            try {
+                const serialized = this.serializeWithDates(value);
+                const originalSize = Buffer.byteLength(serialized, 'utf8');
+                let data;
+                let wasCompressed = false;
+                if (compress && originalSize >= compressThreshold) {
+                    try {
+                        data = yield gzipAsync(Buffer.from(serialized, 'utf8'));
+                        wasCompressed = true;
+                    }
+                    catch (error) {
+                        this.logger.warn('Compression failed, using uncompressed data:', error);
+                        data = Buffer.from(serialized, 'utf8');
+                    }
+                }
+                else {
+                    data = Buffer.from(serialized, 'utf8');
+                }
+                return {
+                    data,
+                    compressed: wasCompressed,
+                    originalSize,
+                    serializedSize: data.length,
+                };
+            }
+            catch (error) {
+                this.logger.error('Serialization failed:', error);
+                throw new Error(`Failed to serialize cache value: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    deserialize(buffer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let dataString;
+                let wasCompressed = false;
+                if (buffer.length >= 2 && buffer[0] === 0x1f && buffer[1] === 0x8b) {
+                    dataString = (yield gunzipAsync(buffer)).toString('utf8');
+                    wasCompressed = true;
+                }
+                else {
+                    dataString = buffer.toString('utf8');
+                }
+                const data = this.deserializeWithDates(dataString);
+                return {
+                    data,
+                    wasCompressed,
+                };
+            }
+            catch (error) {
+                this.logger.error('Deserialization failed:', error);
+                throw new Error(`Failed to deserialize cache value: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    serializeWithDates(value) {
+        const processed = this.preProcessDates(value);
+        return JSON.stringify(processed);
+    }
+    preProcessDates(obj) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (obj instanceof Date) {
+            return { __type: 'Date', value: obj.toISOString() };
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.preProcessDates(item));
+        }
+        if (typeof obj === 'object') {
+            const processed = {};
+            for (const [key, value] of Object.entries(obj)) {
+                processed[key] = this.preProcessDates(value);
+            }
+            return processed;
+        }
+        return obj;
+    }
+    deserializeWithDates(dataString) {
+        return JSON.parse(dataString, (key, val) => {
+            if (val && typeof val === 'object' && val.__type === 'Date') {
+                return new Date(val.value);
+            }
+            return val;
+        });
+    }
+};
+exports.CacheSerializationService = CacheSerializationService;
+exports.CacheSerializationService = CacheSerializationService = CacheSerializationService_1 = __decorate([
+    (0, common_1.Injectable)()
+], CacheSerializationService);

package/cache/cache.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CACHE_COMPRESSION_ENABLED: unique symbol;
+export declare const CACHE_COMPRESSION_THRESHOLD: unique symbol;

package/cache/cache.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CACHE_COMPRESSION_THRESHOLD = exports.CACHE_COMPRESSION_ENABLED = void 0;
+exports.CACHE_COMPRESSION_ENABLED = Symbol('CACHE_COMPRESSION_ENABLED');
+exports.CACHE_COMPRESSION_THRESHOLD = Symbol('CACHE_COMPRESSION_THRESHOLD');

package/cache/cache.health.d.ts

@@ -0,0 +1,35 @@
+import { CacheService } from './cache.service';
+export interface CacheHealthResult {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    layers: {
+        cls: {
+            available: boolean;
+            latency?: number;
+            error?: string;
+        };
+        memory: {
+            available: boolean;
+            latency?: number;
+            size?: number;
+            error?: string;
+        };
+        redis: {
+            available: boolean;
+            latency?: number;
+            error?: string;
+        };
+    };
+    timestamp: Date;
+    overallLatency: number;
+}
+export declare class CacheHealthChecker {
+    private readonly cacheService;
+    private readonly logger;
+    constructor(cacheService: CacheService);
+    checkHealth(): Promise<CacheHealthResult>;
+    getDetailedStats(): Promise<any>;
+    private checkClsHealth;
+    private checkMemoryHealth;
+    private checkRedisHealth;
+    private generateRecommendations;
+}

package/cache/cache.health.js

@@ -0,0 +1,193 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var CacheHealthChecker_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheHealthChecker = void 0;
+const common_1 = require("@nestjs/common");
+const cache_service_1 = require("./cache.service");
+const cache_options_interface_1 = require("./interfaces/cache-options.interface");
+let CacheHealthChecker = CacheHealthChecker_1 = class CacheHealthChecker {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+        this.logger = new common_1.Logger(CacheHealthChecker_1.name);
+    }
+    checkHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            const results = {
+                cls: yield this.checkClsHealth(),
+                memory: yield this.checkMemoryHealth(),
+                redis: yield this.checkRedisHealth(),
+            };
+            const overallLatency = Date.now() - startTime;
+            const layerStatuses = Object.values(results);
+            const healthyCount = layerStatuses.filter((layer) => layer.available).length;
+            const totalCount = layerStatuses.length;
+            let status;
+            if (healthyCount === totalCount) {
+                status = 'healthy';
+            }
+            else if (healthyCount > 0) {
+                status = 'degraded';
+            }
+            else {
+                status = 'unhealthy';
+            }
+            return {
+                status,
+                layers: results,
+                timestamp: new Date(),
+                overallLatency,
+            };
+        });
+    }
+    getDetailedStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stats = this.cacheService.getStats();
+            const health = yield this.checkHealth();
+            return {
+                statistics: stats,
+                health,
+                recommendations: this.generateRecommendations(health, stats),
+            };
+        });
+    }
+    checkClsHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            try {
+                yield this.cacheService.set('health:cls:test', 'test-value', {
+                    layers: [cache_options_interface_1.CacheLayer.CLS],
+                });
+                const result = yield this.cacheService.get('health:cls:test', {
+                    layers: [cache_options_interface_1.CacheLayer.CLS],
+                });
+                const latency = Date.now() - startTime;
+                if (result === 'test-value') {
+                    return { available: true, latency };
+                }
+                else {
+                    return {
+                        available: false,
+                        latency,
+                        error: 'CLS cache not returning expected value',
+                    };
+                }
+            }
+            catch (error) {
+                const latency = Date.now() - startTime;
+                return {
+                    available: false,
+                    latency,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+    }
+    checkMemoryHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            try {
+                yield this.cacheService.set('health:memory:test', 'test-value', {
+                    layers: [cache_options_interface_1.CacheLayer.MEMORY],
+                });
+                const result = yield this.cacheService.get('health:memory:test', {
+                    layers: [cache_options_interface_1.CacheLayer.MEMORY],
+                });
+                const latency = Date.now() - startTime;
+                if (result === 'test-value') {
+                    const stats = this.cacheService.getStats();
+                    return { available: true, latency, size: stats.totalSets };
+                }
+                else {
+                    return {
+                        available: false,
+                        latency,
+                        error: 'Memory cache not returning expected value',
+                    };
+                }
+            }
+            catch (error) {
+                const latency = Date.now() - startTime;
+                return {
+                    available: false,
+                    latency,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+    }
+    checkRedisHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            try {
+                yield this.cacheService.set('health:redis:test', 'test-value', {
+                    layers: [cache_options_interface_1.CacheLayer.REDIS],
+                });
+                const result = yield this.cacheService.get('health:redis:test', {
+                    layers: [cache_options_interface_1.CacheLayer.REDIS],
+                });
+                const latency = Date.now() - startTime;
+                if (result === 'test-value') {
+                    return { available: true, latency };
+                }
+                else {
+                    return {
+                        available: false,
+                        latency,
+                        error: 'Redis not returning expected value',
+                    };
+                }
+            }
+            catch (error) {
+                const latency = Date.now() - startTime;
+                return {
+                    available: false,
+                    latency,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+    }
+    generateRecommendations(health, stats) {
+        const recommendations = [];
+        if (!health.layers.redis.available) {
+            recommendations.push('Redis is unavailable. Check Redis connection and configuration.');
+        }
+        if (!health.layers.memory.available) {
+            recommendations.push('Memory cache is unavailable. This may indicate memory pressure.');
+        }
+        if (health.overallLatency > 100) {
+            recommendations.push('Cache latency is high. Consider optimizing cache operations or increasing resources.');
+        }
+        if (stats.hitRate < 0.5) {
+            recommendations.push('Cache hit rate is low. Review cache TTL and key patterns.');
+        }
+        if (stats.totalSets > 10000 && stats.hits / stats.totalGets < 0.8) {
+            recommendations.push('High cache churn detected. Consider longer TTL or cache warming.');
+        }
+        return recommendations;
+    }
+};
+exports.CacheHealthChecker = CacheHealthChecker;
+exports.CacheHealthChecker = CacheHealthChecker = CacheHealthChecker_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [cache_service_1.CacheService])
+], CacheHealthChecker);