@nest-omni/core 3.1.1-11 → 3.1.1-13

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);

package/cache/cache.module.d.ts

@@ -0,0 +1,24 @@
+import { DynamicModule, OnModuleInit } from '@nestjs/common';
+import type { DataSource } from 'typeorm';
+import type { Redis } from 'ioredis';
+import { CacheService } from './cache.service';
+export declare const CACHE_SERVICE: unique symbol;
+export interface CacheModuleOptions {
+    isGlobal?: boolean;
+    redisClient?: Redis;
+    dataSource?: DataSource;
+    memoryTtl?: number;
+    memoryNamespace?: string;
+}
+export declare class CacheModule implements OnModuleInit {
+    private readonly cacheService;
+    constructor(cacheService: CacheService);
+    static forRoot(options?: CacheModuleOptions): DynamicModule;
+    static forRootAsync(options: {
+        imports?: any[];
+        inject?: any[];
+        useFactory: (...args: any[]) => Promise<CacheModuleOptions> | CacheModuleOptions;
+        isGlobal?: boolean;
+    }): DynamicModule;
+    onModuleInit(): void;
+}

package/cache/cache.module.js

@@ -0,0 +1,105 @@
+"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 CacheModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheModule = exports.CACHE_SERVICE = void 0;
+const common_1 = require("@nestjs/common");
+const cache_service_1 = require("./cache.service");
+const dependencies_1 = require("./dependencies");
+const decorators_1 = require("./decorators");
+const providers_1 = require("./providers");
+exports.CACHE_SERVICE = Symbol('CACHE_SERVICE');
+let CacheModule = CacheModule_1 = class CacheModule {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+    }
+    static forRoot(options = {}) {
+        const { isGlobal = true, redisClient, dataSource, memoryTtl, memoryNamespace, } = options;
+        if (dataSource) {
+            dependencies_1.DbDependency.setDataSource(dataSource);
+        }
+        return {
+            module: CacheModule_1,
+            global: isGlobal,
+            providers: [
+                providers_1.ClsCacheProvider,
+                {
+                    provide: providers_1.MemoryCacheProvider,
+                    useValue: new providers_1.MemoryCacheProvider({
+                        ttl: memoryTtl,
+                        namespace: memoryNamespace,
+                    }),
+                },
+                ...(redisClient
+                    ? [
+                        {
+                            provide: providers_1.REDIS_CLIENT,
+                            useValue: redisClient,
+                        },
+                    ]
+                    : []),
+                providers_1.RedisCacheProvider,
+                {
+                    provide: exports.CACHE_SERVICE,
+                    useClass: cache_service_1.CacheService,
+                },
+                cache_service_1.CacheService,
+            ],
+            exports: [cache_service_1.CacheService, exports.CACHE_SERVICE],
+        };
+    }
+    static forRootAsync(options) {
+        var _a;
+        return {
+            module: CacheModule_1,
+            global: (_a = options.isGlobal) !== null && _a !== void 0 ? _a : true,
+            imports: options.imports || [],
+            providers: [
+                {
+                    provide: 'CACHE_MODULE_OPTIONS',
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+                providers_1.ClsCacheProvider,
+                {
+                    provide: providers_1.MemoryCacheProvider,
+                    useFactory: (moduleOptions) => {
+                        if (moduleOptions.dataSource) {
+                            dependencies_1.DbDependency.setDataSource(moduleOptions.dataSource);
+                        }
+                        return new providers_1.MemoryCacheProvider({
+                            ttl: moduleOptions.memoryTtl,
+                            namespace: moduleOptions.memoryNamespace,
+                        });
+                    },
+                    inject: ['CACHE_MODULE_OPTIONS'],
+                },
+                {
+                    provide: providers_1.REDIS_CLIENT,
+                    useFactory: (moduleOptions) => moduleOptions.redisClient,
+                    inject: ['CACHE_MODULE_OPTIONS'],
+                },
+                providers_1.RedisCacheProvider,
+                cache_service_1.CacheService,
+            ],
+            exports: [cache_service_1.CacheService],
+        };
+    }
+    onModuleInit() {
+        (0, decorators_1.setCacheService)(this.cacheService);
+    }
+};
+exports.CacheModule = CacheModule;
+exports.CacheModule = CacheModule = CacheModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({}),
+    __metadata("design:paramtypes", [cache_service_1.CacheService])
+], CacheModule);

package/cache/cache.service.d.ts

@@ -0,0 +1,35 @@
+import type { CacheOptions, CacheStats } from './interfaces';
+import { CacheLayer } from './interfaces';
+import { ClsCacheProvider, MemoryCacheProvider, RedisCacheProvider } from './providers';
+export declare class CacheService {
+    private readonly clsProvider;
+    private readonly memoryProvider;
+    private readonly redisProvider;
+    private readonly logger;
+    private readonly providers;
+    private readonly stats;
+    constructor(clsProvider: ClsCacheProvider, memoryProvider: MemoryCacheProvider, redisProvider: RedisCacheProvider);
+    getOrSet<T>(key: string, factory: () => Promise<T>, options?: CacheOptions): Promise<T>;
+    get<T>(key: string, options?: CacheOptions): Promise<T | null>;
+    set<T>(key: string, value: T, options?: CacheOptions | number): Promise<void>;
+    del(key: string | string[], layers?: CacheLayer[]): Promise<void>;
+    deletePattern(pattern: string, layers?: CacheLayer[]): Promise<void>;
+    clear(layers?: CacheLayer[]): Promise<void>;
+    invalidateTags(tags: string[]): Promise<void>;
+    mget<T>(keys: string[], options?: CacheOptions): Promise<(T | null)[]>;
+    mset(items: Array<{
+        key: string;
+        value: any;
+    }>, options?: CacheOptions): Promise<void>;
+    getStats(): CacheStats;
+    resetStats(): void;
+    private setWithOptions;
+    private resolveLayers;
+    private getDefaultLayers;
+    private buildKey;
+    private backfillUpperLayers;
+    private recordHit;
+    private recordMiss;
+    private updateLayerHitRate;
+    private initializeStats;
+}

package/cache/cache.service.js

@@ -0,0 +1,280 @@
+"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 CacheService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheService = void 0;
+const common_1 = require("@nestjs/common");
+const dependencies_1 = require("./dependencies");
+const interfaces_1 = require("./interfaces");
+const providers_1 = require("./providers");
+const utils_1 = require("./utils");
+let CacheService = CacheService_1 = class CacheService {
+    constructor(clsProvider, memoryProvider, redisProvider) {
+        this.clsProvider = clsProvider;
+        this.memoryProvider = memoryProvider;
+        this.redisProvider = redisProvider;
+        this.logger = new common_1.Logger(CacheService_1.name);
+        this.providers = new Map();
+        this.stats = {
+            totalGets: 0,
+            hits: 0,
+            misses: 0,
+            hitRate: 0,
+            byLayer: {},
+            totalSets: 0,
+            totalDeletes: 0,
+            totalClears: 0,
+        };
+        this.providers.set(interfaces_1.CacheLayer.CLS, clsProvider);
+        this.providers.set(interfaces_1.CacheLayer.MEMORY, memoryProvider);
+        this.providers.set(interfaces_1.CacheLayer.REDIS, redisProvider);
+        this.initializeStats();
+    }
+    getOrSet(key, factory, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cached = yield this.get(key, options);
+            if (cached !== null) {
+                return cached;
+            }
+            const value = yield factory();
+            yield this.set(key, value, options);
+            return value;
+        });
+    }
+    get(key, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stats.totalGets++;
+            const layers = this.resolveLayers(options === null || options === void 0 ? void 0 : options.layers);
+            const fullKey = this.buildKey(key, options === null || options === void 0 ? void 0 : options.namespace);
+            for (let i = 0; i < layers.length; i++) {
+                const layer = layers[i];
+                const provider = this.providers.get(layer);
+                if (!provider) {
+                    continue;
+                }
+                try {
+                    const wrapped = yield provider.get(fullKey);
+                    if (wrapped !== null) {
+                        const value = yield utils_1.DependencyManager.unwrapAndValidate(wrapped, options === null || options === void 0 ? void 0 : options.dependencies);
+                        if (value !== null) {
+                            this.recordHit(layer);
+                            if ((options === null || options === void 0 ? void 0 : options.backfill) !== false && i > 0) {
+                                yield this.backfillUpperLayers(fullKey, wrapped, layers.slice(0, i), options === null || options === void 0 ? void 0 : options.ttl);
+                            }
+                            return value;
+                        }
+                        yield provider.delete(fullKey);
+                    }
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to get from ${layer} cache: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            this.recordMiss();
+            return null;
+        });
+    }
+    set(key, value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof options === 'number') {
+                return this.setWithOptions(key, value, { ttl: options });
+            }
+            else {
+                return this.setWithOptions(key, value, options);
+            }
+        });
+    }
+    del(key, layers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stats.totalDeletes++;
+            const targetLayers = layers || this.getDefaultLayers();
+            const keys = Array.isArray(key) ? key : [key];
+            const promises = targetLayers.map((layer) => __awaiter(this, void 0, void 0, function* () {
+                const provider = this.providers.get(layer);
+                if (!provider) {
+                    return;
+                }
+                try {
+                    yield provider.delete(keys);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to delete from ${layer} cache: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }));
+            yield Promise.all(promises);
+        });
+    }
+    deletePattern(pattern, layers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetLayers = layers || [interfaces_1.CacheLayer.MEMORY, interfaces_1.CacheLayer.REDIS];
+            const promises = targetLayers.map((layer) => __awaiter(this, void 0, void 0, function* () {
+                const provider = this.providers.get(layer);
+                if (!provider || !provider.deletePattern) {
+                    return;
+                }
+                try {
+                    yield provider.deletePattern(pattern);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to delete pattern from ${layer} cache: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }));
+            yield Promise.all(promises);
+        });
+    }
+    clear(layers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stats.totalClears++;
+            const targetLayers = layers || this.getDefaultLayers();
+            const promises = targetLayers.map((layer) => __awaiter(this, void 0, void 0, function* () {
+                const provider = this.providers.get(layer);
+                if (!provider) {
+                    return;
+                }
+                try {
+                    yield provider.clear();
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to clear ${layer} cache: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }));
+            yield Promise.all(promises);
+        });
+    }
+    invalidateTags(tags) {
+        return __awaiter(this, void 0, void 0, function* () {
+            dependencies_1.TagDependency.invalidateTags(tags);
+            this.logger.debug(`Invalidated tags: ${tags.join(', ')}`);
+        });
+    }
+    mget(keys, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = keys.map((key) => this.get(key, options));
+            return Promise.all(promises);
+        });
+    }
+    mset(items, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = items.map((item) => this.set(item.key, item.value, options));
+            yield Promise.all(promises);
+        });
+    }
+    getStats() {
+        return Object.assign(Object.assign({}, this.stats), { hitRate: this.stats.totalGets > 0 ? this.stats.hits / this.stats.totalGets : 0 });
+    }
+    resetStats() {
+        this.stats.totalGets = 0;
+        this.stats.hits = 0;
+        this.stats.misses = 0;
+        this.stats.hitRate = 0;
+        this.stats.totalSets = 0;
+        this.stats.totalDeletes = 0;
+        this.stats.totalClears = 0;
+        this.initializeStats();
+    }
+    setWithOptions(key, value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stats.totalSets++;
+            if ((options === null || options === void 0 ? void 0 : options.condition) && !(yield Promise.resolve(options.condition()))) {
+                return;
+            }
+            const layers = this.resolveLayers(options === null || options === void 0 ? void 0 : options.layers);
+            const fullKey = this.buildKey(key, options === null || options === void 0 ? void 0 : options.namespace);
+            const wrapped = yield utils_1.DependencyManager.wrapWithDependencies(value, options === null || options === void 0 ? void 0 : options.dependencies);
+            const promises = layers.map((layer) => __awaiter(this, void 0, void 0, function* () {
+                const provider = this.providers.get(layer);
+                if (!provider) {
+                    return;
+                }
+                try {
+                    yield provider.set(fullKey, wrapped, options === null || options === void 0 ? void 0 : options.ttl);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to set in ${layer} cache: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }));
+            yield Promise.all(promises);
+        });
+    }
+    resolveLayers(layers) {
+        if (layers && layers.length > 0) {
+            return layers;
+        }
+        return this.getDefaultLayers();
+    }
+    getDefaultLayers() {
+        return [interfaces_1.CacheLayer.CLS, interfaces_1.CacheLayer.MEMORY, interfaces_1.CacheLayer.REDIS];
+    }
+    buildKey(key, namespace) {
+        if (namespace) {
+            return `${namespace}:${key}`;
+        }
+        return key;
+    }
+    backfillUpperLayers(key, value, layers, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = layers.map((layer) => __awaiter(this, void 0, void 0, function* () {
+                const provider = this.providers.get(layer);
+                if (!provider) {
+                    return;
+                }
+                try {
+                    yield provider.set(key, value, ttl);
+                }
+                catch (error) {
+                    this.logger.debug(`Failed to backfill ${layer} cache: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }));
+            yield Promise.all(promises);
+        });
+    }
+    recordHit(layer) {
+        this.stats.hits++;
+        if (!this.stats.byLayer[layer]) {
+            this.stats.byLayer[layer] = { hits: 0, misses: 0, hitRate: 0 };
+        }
+        this.stats.byLayer[layer].hits++;
+        this.updateLayerHitRate(layer);
+    }
+    recordMiss() {
+        this.stats.misses++;
+    }
+    updateLayerHitRate(layer) {
+        const layerStats = this.stats.byLayer[layer];
+        if (layerStats) {
+            const total = layerStats.hits + layerStats.misses;
+            layerStats.hitRate = total > 0 ? layerStats.hits / total : 0;
+        }
+    }
+    initializeStats() {
+        for (const layer of [interfaces_1.CacheLayer.CLS, interfaces_1.CacheLayer.MEMORY, interfaces_1.CacheLayer.REDIS]) {
+            if (!this.stats.byLayer[layer]) {
+                this.stats.byLayer[layer] = { hits: 0, misses: 0, hitRate: 0 };
+            }
+        }
+    }
+};
+exports.CacheService = CacheService;
+exports.CacheService = CacheService = CacheService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [providers_1.ClsCacheProvider,
+        providers_1.MemoryCacheProvider,
+        providers_1.RedisCacheProvider])
+], CacheService);

package/cache/cache.warmup.service.d.ts

@@ -0,0 +1,34 @@
+import { CacheService } from './cache.service';
+export interface CacheWarmupConfig {
+    name: string;
+    dataProvider: () => Promise<any> | any;
+    key: string | ((data: any) => string);
+    ttl?: number;
+    layers?: string[];
+    batchSize?: number;
+    critical?: boolean;
+}
+export interface CacheWarmupResult {
+    name: string;
+    success: boolean;
+    itemCount: number;
+    duration: number;
+    errors: string[];
+}
+export declare class CacheWarmupService {
+    private readonly cacheService;
+    private readonly logger;
+    private warmupConfigs;
+    constructor(cacheService: CacheService);
+    registerWarmup(groupName: string, configs: CacheWarmupConfig[]): void;
+    warmupGroup(groupName: string): Promise<CacheWarmupResult[]>;
+    warmupAll(): Promise<Map<string, CacheWarmupResult[]>>;
+    getWarmupStats(): {
+        totalGroups: number;
+        totalTasks: number;
+        taskDetails: any[];
+    };
+    removeWarmupGroup(groupName: string): boolean;
+    clearWarmupConfigs(): void;
+    private executeWarmupTask;
+}