@nest-omni/core 4.1.3-3 → 4.1.3-31

package/cache/entities/typeorm-cache.entity.d.ts

@@ -0,0 +1,71 @@
+/**
+ * TypeORM Cache Entity
+ *
+ * Stores cached data in the database with automatic expiration support.
+ * Used by TypeormCacheProvider for persistent caching.
+ *
+ * Features:
+ * - Namespace isolation for different cache segments
+ * - Automatic expiration handling
+ * - TTL tracking
+ * - Value JSON serialization
+ *
+ * @example
+ * ```typescript
+ * // In your TypeORM configuration:
+ * {
+ *   entities: [TypeormCacheEntity],
+ *   // ... other options
+ * }
+ * ```
+ */
+export declare class TypeormCacheEntity {
+    /**
+     * Composite key: namespace + key
+     * Allows same key in different namespaces
+     */
+    key: string;
+    /**
+     * Namespace for cache isolation
+     * Multiple applications can share the same table
+     */
+    namespace: string;
+    /**
+     * Cached value (JSON serialized)
+     */
+    value: string;
+    /**
+     * Expiration timestamp
+     * NULL means no expiration
+     */
+    expires_at: Date | null;
+    /**
+     * Time to live in seconds
+     * Stored for reference and debugging
+     */
+    ttl: number | null;
+    /**
+     * Creation timestamp
+     */
+    created_at: Date;
+    /**
+     * Last update timestamp
+     */
+    updated_at: Date;
+    /**
+     * Check if entry is expired
+     */
+    isExpired(): boolean;
+    /**
+     * Check if entry is valid (not expired)
+     */
+    isValid(): boolean;
+    /**
+     * Update value and expiration
+     */
+    updateValue(newValue: string, ttl?: number): void;
+    /**
+     * Get remaining time to live in milliseconds
+     */
+    getRemainingTTL(): number;
+}

package/cache/entities/typeorm-cache.entity.js

@@ -0,0 +1,110 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeormCacheEntity = void 0;
+const typeorm_1 = require("typeorm");
+/**
+ * TypeORM Cache Entity
+ *
+ * Stores cached data in the database with automatic expiration support.
+ * Used by TypeormCacheProvider for persistent caching.
+ *
+ * Features:
+ * - Namespace isolation for different cache segments
+ * - Automatic expiration handling
+ * - TTL tracking
+ * - Value JSON serialization
+ *
+ * @example
+ * ```typescript
+ * // In your TypeORM configuration:
+ * {
+ *   entities: [TypeormCacheEntity],
+ *   // ... other options
+ * }
+ * ```
+ */
+let TypeormCacheEntity = class TypeormCacheEntity {
+    /**
+     * Check if entry is expired
+     */
+    isExpired() {
+        if (!this.expires_at) {
+            return false;
+        }
+        return new Date() > this.expires_at;
+    }
+    /**
+     * Check if entry is valid (not expired)
+     */
+    isValid() {
+        return !this.isExpired();
+    }
+    /**
+     * Update value and expiration
+     */
+    updateValue(newValue, ttl) {
+        this.value = newValue;
+        if (ttl && ttl > 0) {
+            this.ttl = Math.floor(ttl / 1000);
+            this.expires_at = new Date(Date.now() + ttl);
+        }
+        else {
+            this.ttl = null;
+            this.expires_at = null;
+        }
+    }
+    /**
+     * Get remaining time to live in milliseconds
+     */
+    getRemainingTTL() {
+        if (!this.expires_at) {
+            return -1; // No expiration
+        }
+        const remaining = this.expires_at.getTime() - Date.now();
+        return Math.max(0, remaining);
+    }
+};
+exports.TypeormCacheEntity = TypeormCacheEntity;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ type: 'varchar', length: 255 }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", String)
+], TypeormCacheEntity.prototype, "key", void 0);
+__decorate([
+    (0, typeorm_1.PrimaryColumn)({ type: 'varchar', length: 255 }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", String)
+], TypeormCacheEntity.prototype, "namespace", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text' }),
+    __metadata("design:type", String)
+], TypeormCacheEntity.prototype, "value", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'datetime', nullable: true }),
+    (0, typeorm_1.Index)(),
+    __metadata("design:type", Date)
+], TypeormCacheEntity.prototype, "expires_at", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'int', nullable: true }),
+    __metadata("design:type", Number)
+], TypeormCacheEntity.prototype, "ttl", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'datetime', name: 'created_at' }),
+    __metadata("design:type", Date)
+], TypeormCacheEntity.prototype, "created_at", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)({ type: 'datetime', name: 'updated_at' }),
+    __metadata("design:type", Date)
+], TypeormCacheEntity.prototype, "updated_at", void 0);
+exports.TypeormCacheEntity = TypeormCacheEntity = __decorate([
+    (0, typeorm_1.Entity)('typeorm_cache')
+], TypeormCacheEntity);

package/cache/index.d.ts

@@ -6,9 +6,10 @@ export { CacheWarmupService, type CacheWarmupConfig, type CacheWarmupResult, } f
 export { CacheMetricsService, type CacheMetrics, type CacheOperationRecord, } from './cache-metrics.service';
 export { CacheSerializationService, type CacheSerializationOptions, type SerializationResult, type DeserializationResult, } from './cache-serialization.service';
 export { Cacheable, CacheEvict, CachePut, getCacheService, setCacheService, } from './decorators';
-export { ClsCacheProvider, MemoryCacheProvider, RedisCacheProvider, BaseCacheProvider, } from './providers';
+export { ClsCacheProvider, LRUCacheProvider, TypeormCacheProvider, RedisCacheProvider, BaseCacheProvider, } from './providers';
 export { REDIS_CLIENT } from './providers/redis-cache.provider';
 export type { CacheProvider } from './interfaces/cache-provider.interface';
+export * from './entities';
 export { CallbackDependency, ChainDependency, DbDependency, FileDependency, TagDependency, TimeDependency, } from './dependencies';
 export { CacheLayer, type CacheDependency, type CacheEvictOptions, type CacheOptions, type CachePutOptions, type CacheableOptions, type CacheStats, type DependencyData, } from './interfaces';
 export { DependencyManager, KeyGenerator, type CachedValueWithDependencies, } from './utils';

package/cache/index.js

@@ -1,6 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyGenerator = exports.DependencyManager = exports.CacheLayer = exports.TimeDependency = exports.TagDependency = exports.FileDependency = exports.DbDependency = exports.ChainDependency = exports.CallbackDependency = exports.REDIS_CLIENT = exports.BaseCacheProvider = exports.RedisCacheProvider = exports.MemoryCacheProvider = exports.ClsCacheProvider = exports.setCacheService = exports.getCacheService = exports.CachePut = exports.CacheEvict = exports.Cacheable = exports.CacheSerializationService = exports.CacheMetricsService = exports.CacheWarmupService = exports.CacheHealthChecker = exports.CacheService = exports.CACHE_COMPRESSION_THRESHOLD = exports.CACHE_COMPRESSION_ENABLED = exports.CACHE_SERVICE = exports.CacheModule = void 0;
+exports.KeyGenerator = exports.DependencyManager = exports.CacheLayer = exports.TimeDependency = exports.TagDependency = exports.FileDependency = exports.DbDependency = exports.ChainDependency = exports.CallbackDependency = exports.REDIS_CLIENT = exports.BaseCacheProvider = exports.RedisCacheProvider = exports.TypeormCacheProvider = exports.LRUCacheProvider = exports.ClsCacheProvider = exports.setCacheService = exports.getCacheService = exports.CachePut = exports.CacheEvict = exports.Cacheable = exports.CacheSerializationService = exports.CacheMetricsService = exports.CacheWarmupService = exports.CacheHealthChecker = exports.CacheService = exports.CACHE_COMPRESSION_THRESHOLD = exports.CACHE_COMPRESSION_ENABLED = exports.CACHE_SERVICE = exports.CacheModule = void 0;
 // Module
 var cache_module_1 = require("./cache.module");
 Object.defineProperty(exports, "CacheModule", { enumerable: true, get: function () { return cache_module_1.CacheModule; } });
@@ -31,11 +45,14 @@ Object.defineProperty(exports, "setCacheService", { enumerable: true, get: funct
 // Providers
 var providers_1 = require("./providers");
 Object.defineProperty(exports, "ClsCacheProvider", { enumerable: true, get: function () { return providers_1.ClsCacheProvider; } });
-Object.defineProperty(exports, "MemoryCacheProvider", { enumerable: true, get: function () { return providers_1.MemoryCacheProvider; } });
+Object.defineProperty(exports, "LRUCacheProvider", { enumerable: true, get: function () { return providers_1.LRUCacheProvider; } });
+Object.defineProperty(exports, "TypeormCacheProvider", { enumerable: true, get: function () { return providers_1.TypeormCacheProvider; } });
 Object.defineProperty(exports, "RedisCacheProvider", { enumerable: true, get: function () { return providers_1.RedisCacheProvider; } });
 Object.defineProperty(exports, "BaseCacheProvider", { enumerable: true, get: function () { return providers_1.BaseCacheProvider; } });
 var redis_cache_provider_1 = require("./providers/redis-cache.provider");
 Object.defineProperty(exports, "REDIS_CLIENT", { enumerable: true, get: function () { return redis_cache_provider_1.REDIS_CLIENT; } });
+// Entities
+__exportStar(require("./entities"), exports);
 // Dependencies
 var dependencies_1 = require("./dependencies");
 Object.defineProperty(exports, "CallbackDependency", { enumerable: true, get: function () { return dependencies_1.CallbackDependency; } });

package/cache/interfaces/cache-options.interface.d.ts

@@ -35,6 +35,14 @@ export interface CacheOptions {
      * @returns true to cache, false to skip
      */
     condition?: (...args: any[]) => boolean | Promise<boolean>;
+    /**
+     * Unless condition - skip caching when this condition is true
+     * Can be a function (safe) or a string expression (use with caution)
+     * @param result - Method return value
+     * @param args - Method arguments
+     * @returns true to skip caching, false to cache normally
+     */
+    unless?: ((result: any, args: any[]) => boolean) | string;
     /**
      * Cache dependencies - cache will be invalidated when dependencies change
      * Similar to Yii2 cache dependency system

package/cache/providers/index.d.ts

@@ -1,4 +1,5 @@
 export * from './base-cache.provider';
 export * from './cls-cache.provider';
-export * from './memory-cache.provider';
+export * from './lrucache.provider';
+export * from './typeorm-cache.provider';
 export { REDIS_CLIENT, RedisCacheProvider } from './redis-cache.provider';

package/cache/providers/index.js

@@ -17,7 +17,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCacheProvider = exports.REDIS_CLIENT = void 0;
 __exportStar(require("./base-cache.provider"), exports);
 __exportStar(require("./cls-cache.provider"), exports);
-__exportStar(require("./memory-cache.provider"), exports);
+__exportStar(require("./lrucache.provider"), exports);
+__exportStar(require("./typeorm-cache.provider"), exports);
 var redis_cache_provider_1 = require("./redis-cache.provider");
 Object.defineProperty(exports, "REDIS_CLIENT", { enumerable: true, get: function () { return redis_cache_provider_1.REDIS_CLIENT; } });
 Object.defineProperty(exports, "RedisCacheProvider", { enumerable: true, get: function () { return redis_cache_provider_1.RedisCacheProvider; } });

package/cache/providers/lrucache.provider.d.ts

@@ -0,0 +1,77 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { BaseCacheProvider } from './base-cache.provider';
+/**
+ * LRU Memory Cache Provider
+ *
+ * High-performance in-memory LRU (Least Recently Used) cache provider.
+ * This is an L2 cache layer with fast access and automatic eviction.
+ *
+ * Features:
+ * - O(1) get/set operations
+ * - Automatic LRU eviction when cache is full
+ * - Optional TTL (Time To Live) support
+ * - Namespace isolation
+ * - Cache statistics (size, hit rate, usage percentage)
+ *
+ * Use Cases:
+ * - Session data caching
+ * - Frequently accessed configuration
+ * - API response caching
+ * - Temporary data storage
+ *
+ * @example
+ * ```typescript
+ * const provider = new LRUCacheProvider({
+ *   maxSize: 1000,
+ *   ttl: 60000, // optional TTL
+ *   namespace: 'my-cache',
+ * });
+ * ```
+ */
+export declare class LRUCacheProvider extends BaseCacheProvider implements OnModuleDestroy {
+    private readonly logger;
+    private cache;
+    private namespace;
+    private defaultTtl?;
+    constructor(options?: {
+        maxSize?: number;
+        ttl?: number;
+        namespace?: string;
+    });
+    getName(): string;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string | string[]): Promise<void>;
+    deletePattern(pattern: string): Promise<number>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    mget<T>(keys: string[]): Promise<(T | null)[]>;
+    mset(items: Array<{
+        key: string;
+        value: any;
+    }>, ttl?: number): Promise<void>;
+    /**
+     * Get cache size
+     */
+    getSize(): number;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        provider: string;
+        namespace: string;
+        size: any;
+        maxSize: any;
+        calculatedSize: any;
+        usagePercentage: number;
+    };
+    /**
+     * Clean up expired items
+     */
+    cleanup(): number;
+    /**
+     * Destroy the provider
+     */
+    onModuleDestroy(): void;
+    private getFullKey;
+}

package/cache/providers/lrucache.provider.js

@@ -0,0 +1,228 @@
+"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 LRUCacheProvider_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCacheProvider = void 0;
+const common_1 = require("@nestjs/common");
+const base_cache_provider_1 = require("./base-cache.provider");
+// Dynamic import to handle ESM/CommonJS interop
+const LRUCacheClass = require('lru-cache').LRUCache;
+/**
+ * LRU Memory Cache Provider
+ *
+ * High-performance in-memory LRU (Least Recently Used) cache provider.
+ * This is an L2 cache layer with fast access and automatic eviction.
+ *
+ * Features:
+ * - O(1) get/set operations
+ * - Automatic LRU eviction when cache is full
+ * - Optional TTL (Time To Live) support
+ * - Namespace isolation
+ * - Cache statistics (size, hit rate, usage percentage)
+ *
+ * Use Cases:
+ * - Session data caching
+ * - Frequently accessed configuration
+ * - API response caching
+ * - Temporary data storage
+ *
+ * @example
+ * ```typescript
+ * const provider = new LRUCacheProvider({
+ *   maxSize: 1000,
+ *   ttl: 60000, // optional TTL
+ *   namespace: 'my-cache',
+ * });
+ * ```
+ */
+let LRUCacheProvider = LRUCacheProvider_1 = class LRUCacheProvider extends base_cache_provider_1.BaseCacheProvider {
+    constructor(options) {
+        super();
+        this.logger = new common_1.Logger(LRUCacheProvider_1.name);
+        const { maxSize = 500, ttl, namespace = 'cache:lru' } = options || {};
+        this.namespace = namespace;
+        this.defaultTtl = ttl;
+        this.cache = new LRUCacheClass({
+            max: maxSize,
+            ttl: ttl,
+            updateAgeOnGet: true,
+            updateAgeOnHas: true,
+        });
+    }
+    getName() {
+        return 'LRUMemory';
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const fullKey = this.getFullKey(key);
+                const value = this.cache.get(fullKey);
+                return value !== undefined ? value : null;
+            }
+            catch (error) {
+                this.logger.warn(`Failed to get key ${key}: ${error instanceof Error ? error.message : String(error)}`);
+                return null;
+            }
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const fullKey = this.getFullKey(key);
+                const effectiveTtl = ttl !== null && ttl !== void 0 ? ttl : this.defaultTtl;
+                this.cache.set(fullKey, value, { ttl: effectiveTtl });
+            }
+            catch (error) {
+                throw new Error(`LRUCacheProvider: Failed to set key ${key}: ${error}`);
+            }
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (Array.isArray(key)) {
+                    key.forEach((k) => {
+                        const fullKey = this.getFullKey(k);
+                        this.cache.delete(fullKey);
+                    });
+                }
+                else {
+                    const fullKey = this.getFullKey(key);
+                    this.cache.delete(fullKey);
+                }
+            }
+            catch (error) {
+                throw new Error(`LRUCacheProvider: Failed to delete keys: ${error}`);
+            }
+        });
+    }
+    deletePattern(pattern) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const regex = this.patternToRegex(pattern);
+                const keys = Array.from(this.cache.keys());
+                let deleted = 0;
+                for (const key of keys) {
+                    if (regex.test(String(key))) {
+                        this.cache.delete(key);
+                        deleted++;
+                    }
+                }
+                return deleted;
+            }
+            catch (error) {
+                throw new Error(`LRUCacheProvider: Failed to delete pattern ${pattern}: ${error}`);
+            }
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.cache.clear();
+            }
+            catch (error) {
+                throw new Error(`LRUCacheProvider: Failed to clear cache: ${error}`);
+            }
+        });
+    }
+    has(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const fullKey = this.getFullKey(key);
+                return this.cache.has(fullKey);
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+    mget(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return keys.map((key) => {
+                    const fullKey = this.getFullKey(key);
+                    const value = this.cache.get(fullKey);
+                    return value !== undefined ? value : null;
+                });
+            }
+            catch (error) {
+                this.logger.warn(`Failed to mget: ${error instanceof Error ? error.message : String(error)}`);
+                return keys.map(() => null);
+            }
+        });
+    }
+    mset(items, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const effectiveTtl = ttl !== null && ttl !== void 0 ? ttl : this.defaultTtl;
+                items.forEach((item) => {
+                    const fullKey = this.getFullKey(item.key);
+                    this.cache.set(fullKey, item.value, { ttl: effectiveTtl });
+                });
+            }
+            catch (error) {
+                throw new Error(`LRUCacheProvider: Failed to mset: ${error}`);
+            }
+        });
+    }
+    /**
+     * Get cache size
+     */
+    getSize() {
+        return this.cache.size;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return {
+            provider: 'LRUMemory',
+            namespace: this.namespace,
+            size: this.cache.size,
+            maxSize: this.cache.max,
+            calculatedSize: this.cache.calculatedSize,
+            usagePercentage: this.cache.max
+                ? (this.cache.size / this.cache.max) * 100
+                : 0,
+        };
+    }
+    /**
+     * Clean up expired items
+     */
+    cleanup() {
+        const beforeSize = this.cache.size;
+        this.cache.purgeStale();
+        return beforeSize - this.cache.size;
+    }
+    /**
+     * Destroy the provider
+     */
+    onModuleDestroy() {
+        this.cache.clear();
+    }
+    getFullKey(key) {
+        return `${this.namespace}:${key}`;
+    }
+};
+exports.LRUCacheProvider = LRUCacheProvider;
+exports.LRUCacheProvider = LRUCacheProvider = LRUCacheProvider_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [Object])
+], LRUCacheProvider);

package/cache/providers/redis-cache.provider.d.ts

@@ -14,6 +14,7 @@ export declare const REDIS_CLIENT: unique symbol;
  */
 export declare class RedisCacheProvider extends BaseCacheProvider {
     private readonly redis?;
+    private readonly logger;
     private readonly keyPrefix;
     constructor(redis?: Redis);
     getName(): string;

package/cache/providers/redis-cache.provider.js

@@ -20,6 +20,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var RedisCacheProvider_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisCacheProvider = exports.REDIS_CLIENT = void 0;
 const common_1 = require("@nestjs/common");
@@ -36,13 +37,14 @@ exports.REDIS_CLIENT = Symbol('REDIS_CLIENT');
  *
  * Slowest but most persistent and widely shared cache layer.
  */
-let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.BaseCacheProvider {
+let RedisCacheProvider = RedisCacheProvider_1 = class RedisCacheProvider extends base_cache_provider_1.BaseCacheProvider {
     constructor(redis) {
         super();
         this.redis = redis;
+        this.logger = new common_1.Logger(RedisCacheProvider_1.name);
         this.keyPrefix = 'cache:';
         if (!redis) {
-            console.warn('RedisCacheProvider: Redis client not injected. Redis caching will be disabled.');
+            this.logger.warn('Redis client not injected. Redis caching will be disabled.');
         }
     }
     getName() {
@@ -62,7 +64,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
                 return JSON.parse(value);
             }
             catch (error) {
-                console.warn(`RedisCacheProvider: Failed to get key ${key}: ${error instanceof Error ? error.message : String(error)}`);
+                this.logger.warn(`Failed to get key ${key}: ${error instanceof Error ? error.message : String(error)}`);
                 return null;
             }
         });
@@ -126,7 +128,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
                 return deletedCount;
             }
             catch (error) {
-                console.warn(`RedisCacheProvider: deletePattern failed: ${error instanceof Error ? error.message : String(error)}`);
+                this.logger.warn(`deletePattern failed: ${error instanceof Error ? error.message : String(error)}`);
                 return 0;
             }
         });
@@ -184,7 +186,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
                 });
             }
             catch (error) {
-                console.warn(`RedisCacheProvider: mget failed: ${error instanceof Error ? error.message : String(error)}`);
+                this.logger.warn(`mget failed: ${error instanceof Error ? error.message : String(error)}`);
                 return keys.map(() => null);
             }
         });
@@ -236,7 +238,7 @@ let RedisCacheProvider = class RedisCacheProvider extends base_cache_provider_1.
     }
 };
 exports.RedisCacheProvider = RedisCacheProvider;
-exports.RedisCacheProvider = RedisCacheProvider = __decorate([
+exports.RedisCacheProvider = RedisCacheProvider = RedisCacheProvider_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Optional)()),
     __param(0, (0, common_1.Inject)(exports.REDIS_CLIENT)),