@nest-omni/core 4.1.3-2 → 4.1.3-22

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/examples/basic-usage.d.ts

@@ -1,3 +1,6 @@
+/**
+ * 基础缓存使用示例
+ */
 import { CacheService } from '../index';
 interface User {
     id: string;
@@ -25,6 +28,9 @@ declare class UserRepository {
 declare class PostRepository {
     findByAuthor(authorId: string): Promise<Post[]>;
 }
+/**
+ * 用户服务示例
+ */
 export declare class UserService {
     private cacheService;
     private userRepository;
@@ -39,6 +45,9 @@ export declare class UserService {
     cacheLargeData(id: string): Promise<void>;
     getLargeData(id: string): Promise<any>;
 }
+/**
+ * 文章服务示例 - 展示依赖使用
+ */
 export declare class PostService {
     private cacheService;
     private postRepository;
@@ -47,6 +56,9 @@ export declare class PostService {
     getFeaturedPosts(): Promise<Post[]>;
     private getConfigVersion;
 }
+/**
+ * 缓存统计和监控示例
+ */
 export declare class CacheMonitoringService {
     private cacheService;
     constructor(cacheService: CacheService);
@@ -54,5 +66,8 @@ export declare class CacheMonitoringService {
     resetStats(): void;
     startMonitoring(intervalMs?: number): void;
 }
+/**
+ * 使用示例
+ */
 declare function demonstrateCacheUsage(): Promise<void>;
 export { demonstrateCacheUsage };

package/cache/examples/basic-usage.js

@@ -1,4 +1,7 @@
 "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);
@@ -22,16 +25,18 @@ exports.CacheMonitoringService = exports.PostService = exports.UserService = voi
 exports.demonstrateCacheUsage = demonstrateCacheUsage;
 const common_1 = require("@nestjs/common");
 const index_1 = require("../index");
+// 模拟的仓库类
 class UserRepository {
     findOne(id) {
         return __awaiter(this, void 0, void 0, function* () {
+            // 模拟数据库查询
             console.log(`[DB] 查询用户 ${id}`);
             return {
                 id,
                 name: `User ${id}`,
                 email: `user${id}@example.com`,
                 profile: {
-                    bio: `这是用户 ${id} 的个人简介`.repeat(10),
+                    bio: `这是用户 ${id} 的个人简介`.repeat(10), // 长文本，用于测试压缩
                     avatar: `avatar_${id}.jpg`,
                 },
             };
@@ -80,37 +85,45 @@ class PostRepository {
                 .map((_, i) => ({
                 id: `post_${authorId}_${i}`,
                 title: `文章 ${i}`,
-                content: `这是文章 ${i} 的内容`.repeat(15),
+                content: `这是文章 ${i} 的内容`.repeat(15), // 长内容，用于测试压缩
                 authorId,
                 createdAt: new Date(),
             }));
         });
     }
 }
+/**
+ * 用户服务示例
+ */
 let UserService = class UserService {
     constructor(cacheService, userRepository) {
         this.cacheService = cacheService;
         this.userRepository = userRepository;
     }
+    // 基础缓存使用
     getUser(id) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.cacheService.getOrSet(`user:${id}`, () => this.userRepository.findOne(id), { ttl: 300000 });
         });
     }
+    // 使用装饰器缓存
     getUserProfile(id) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.userRepository.findOne(id);
         });
     }
+    // 条件缓存 - 不缓存管理员用户
     getUserData(id) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.userRepository.findOne(id);
         });
     }
+    // 批量获取用户
     getUsersBatch(ids) {
         return __awaiter(this, void 0, void 0, function* () {
             const keys = ids.map((id) => `user:${id}`);
             const cachedUsers = yield this.cacheService.mget(keys);
+            // 找出缓存中没有的用户
             const uncachedIds = [];
             const result = [];
             cachedUsers.forEach((user, index) => {
@@ -121,8 +134,10 @@ let UserService = class UserService {
                     uncachedIds.push(ids[index]);
                 }
             });
+            // 批量查询未缓存的用户
             if (uncachedIds.length > 0) {
                 const newUsers = yield this.userRepository.findMany(uncachedIds);
+                // 批量设置缓存
                 const cacheItems = newUsers.map((user) => ({
                     key: `user:${user.id}`,
                     value: user,
@@ -133,22 +148,26 @@ let UserService = class UserService {
             return result;
         });
     }
+    // 更新用户并缓存
     updateUser(id, data) {
         return __awaiter(this, void 0, void 0, function* () {
             const updatedUser = yield this.userRepository.save(Object.assign({ id }, data));
             return updatedUser;
         });
     }
+    // 删除用户并清除缓存
     deleteUser(id) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.userRepository.delete(id);
         });
     }
+    // 使用标签失效
     invalidateAllProfiles() {
         return __awaiter(this, void 0, void 0, function* () {
             console.log('清除所有用户资料缓存');
         });
     }
+    // 缓存大数据（测试压缩）
     cacheLargeData(id) {
         return __awaiter(this, void 0, void 0, function* () {
             const largeData = {
@@ -173,11 +192,13 @@ let UserService = class UserService {
                     averageRating: (Math.random() * 5).toFixed(2),
                 },
             };
+            // 这个数据会被自动压缩，因为大于 1KB
             yield this.cacheService.set(`user:${id}:large-data`, largeData, {
-                ttl: 3600000,
+                ttl: 3600000, // 1小时
             });
         });
     }
+    // 获取大数据
     getLargeData(id) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.cacheService.get(`user:${id}:large-data`);
@@ -188,7 +209,7 @@ exports.UserService = UserService;
 __decorate([
     (0, index_1.Cacheable)({
         key: (id) => `user:${id}:profile`,
-        ttl: 600000,
+        ttl: 600000, // 10分钟
         dependencies: [new index_1.TagDependency(['user-profile'])],
     }),
     __metadata("design:type", Function),
@@ -235,18 +256,24 @@ exports.UserService = UserService = __decorate([
     __metadata("design:paramtypes", [index_1.CacheService,
         UserRepository])
 ], UserService);
+/**
+ * 文章服务示例 - 展示依赖使用
+ */
 let PostService = class PostService {
     constructor(cacheService, postRepository) {
         this.cacheService = cacheService;
         this.postRepository = postRepository;
     }
+    // 使用数据库依赖 - 当用户表更新时，相关文章缓存会自动失效
     getPostsByAuthor(authorId) {
         return __awaiter(this, void 0, void 0, function* () {
             return yield this.postRepository.findByAuthor(authorId);
         });
     }
+    // 使用回调依赖 - 基于配置版本
     getFeaturedPosts() {
         return __awaiter(this, void 0, void 0, function* () {
+            // 模拟获取推荐文章
             console.log('[DB] 获取推荐文章');
             return Array(10)
                 .fill(null)
@@ -261,6 +288,7 @@ let PostService = class PostService {
     }
     getConfigVersion() {
         return __awaiter(this, void 0, void 0, function* () {
+            // 模拟获取配置版本
             return '1.0.0';
         });
     }
@@ -269,7 +297,7 @@ exports.PostService = PostService;
 __decorate([
     (0, index_1.Cacheable)({
         key: (authorId) => `posts:by-author:${authorId}`,
-        ttl: 600000,
+        ttl: 600000, // 10分钟
         dependencies: [
             new index_1.DbDependency('SELECT updated_at FROM users WHERE id = ?', (authorId) => [authorId]),
         ],
@@ -281,10 +309,11 @@ __decorate([
 __decorate([
     (0, index_1.Cacheable)({
         key: 'posts:featured',
-        ttl: 1800000,
+        ttl: 1800000, // 30分钟
         dependencies: [
             new index_1.CallbackDependency(() => __awaiter(void 0, void 0, void 0, function* () {
-                return yield 'v1.0.0';
+                // 检查配置版本，如果配置改变则失效缓存
+                return yield 'v1.0.0'; // 简化为固定值
             })),
         ],
     }),
@@ -297,10 +326,14 @@ exports.PostService = PostService = __decorate([
     __metadata("design:paramtypes", [index_1.CacheService,
         PostRepository])
 ], PostService);
+/**
+ * 缓存统计和监控示例
+ */
 let CacheMonitoringService = class CacheMonitoringService {
     constructor(cacheService) {
         this.cacheService = cacheService;
     }
+    // 获取缓存统计信息
     getCacheStats() {
         const stats = this.cacheService.getStats();
         console.log('=== 缓存统计信息 ===');
@@ -317,13 +350,16 @@ let CacheMonitoringService = class CacheMonitoringService {
         }
         return stats;
     }
+    // 重置统计
     resetStats() {
         this.cacheService.resetStats();
         console.log('缓存统计已重置');
     }
+    // 定期监控
     startMonitoring(intervalMs = 60000) {
         setInterval(() => {
             const stats = this.getCacheStats();
+            // 如果命中率过低，发出警告
             if (stats.hitRate < 0.7) {
                 console.warn(`⚠️ 缓存命中率过低: ${(stats.hitRate * 100).toFixed(2)}%`);
             }
@@ -336,38 +372,56 @@ exports.CacheMonitoringService = CacheMonitoringService = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [index_1.CacheService])
 ], CacheMonitoringService);
+/**
+ * 使用示例
+ */
 function demonstrateCacheUsage() {
     return __awaiter(this, void 0, void 0, function* () {
-        const userService = new UserService(new index_1.CacheService({}, {}, {}, true, 1024), new UserRepository());
+        // 注意：在实际应用中，这些服务会通过依赖注入获得
+        const userService = new UserService(new index_1.CacheService(
+        // 这些参数在实际应用中会通过模块配置自动注入
+        {}, // CLS Provider
+        {}, // Memory Provider
+        {}, // Redis Provider
+        true, // 启用压缩
+        1024), new UserRepository());
         const postService = new PostService(new index_1.CacheService({}, {}, {}, true, 1024), new PostRepository());
         const monitoringService = new CacheMonitoringService(new index_1.CacheService({}, {}, {}, true, 1024));
         console.log('🚀 开始缓存演示...\n');
         try {
+            // 1. 基础缓存演示
             console.log('1. 基础缓存使用:');
             const user1 = yield userService.getUser('1');
             console.log(`获取用户: ${user1.name}`);
+            // 第二次获取应该从缓存获取
             const user1Cached = yield userService.getUser('1');
             console.log(`从缓存获取用户: ${user1Cached.name}\n`);
+            // 2. 装饰器缓存演示
             console.log('2. 装饰器缓存:');
             const profile = yield userService.getUserProfile('2');
             console.log(`获取用户资料: ${profile.name}`);
             const profileCached = yield userService.getUserProfile('2');
             console.log(`从缓存获取用户资料: ${profileCached.name}\n`);
+            // 3. 批量操作演示
             console.log('3. 批量操作:');
             const users = yield userService.getUsersBatch(['1', '2', '3', '4', '5']);
             console.log(`批量获取 ${users.length} 个用户\n`);
+            // 4. 大数据压缩演示
             console.log('4. 大数据压缩:');
             yield userService.cacheLargeData('1');
             console.log('缓存大数据完成（应该自动压缩）');
             const largeData = yield userService.getLargeData('1');
             console.log(`获取大数据: 用户 ${largeData.user.name}, 文章数 ${largeData.posts.length}\n`);
+            // 5. 依赖系统演示
             console.log('5. 依赖系统:');
             const posts = yield postService.getPostsByAuthor('1');
             console.log(`获取作者文章: ${posts.length} 篇`);
             const featuredPosts = yield postService.getFeaturedPosts();
             console.log(`获取推荐文章: ${featuredPosts.length} 篇\n`);
+            // 6. 缓存统计
             console.log('6. 缓存统计:');
             monitoringService.getCacheStats();
+            // 7. 缓存失效演示
             console.log('\n7. 缓存失效:');
             yield userService.invalidateAllProfiles();
             console.log('已清除所有用户资料缓存');

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,14 +1,32 @@
 "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; } });
 Object.defineProperty(exports, "CACHE_SERVICE", { enumerable: true, get: function () { return cache_module_1.CACHE_SERVICE; } });
+// Constants
 var cache_constants_1 = require("./cache.constants");
 Object.defineProperty(exports, "CACHE_COMPRESSION_ENABLED", { enumerable: true, get: function () { return cache_constants_1.CACHE_COMPRESSION_ENABLED; } });
 Object.defineProperty(exports, "CACHE_COMPRESSION_THRESHOLD", { enumerable: true, get: function () { return cache_constants_1.CACHE_COMPRESSION_THRESHOLD; } });
+// Service
 var cache_service_1 = require("./cache.service");
 Object.defineProperty(exports, "CacheService", { enumerable: true, get: function () { return cache_service_1.CacheService; } });
+// Additional Services
 var cache_health_1 = require("./cache.health");
 Object.defineProperty(exports, "CacheHealthChecker", { enumerable: true, get: function () { return cache_health_1.CacheHealthChecker; } });
 var cache_warmup_service_1 = require("./cache.warmup.service");
@@ -17,19 +35,25 @@ var cache_metrics_service_1 = require("./cache-metrics.service");
 Object.defineProperty(exports, "CacheMetricsService", { enumerable: true, get: function () { return cache_metrics_service_1.CacheMetricsService; } });
 var cache_serialization_service_1 = require("./cache-serialization.service");
 Object.defineProperty(exports, "CacheSerializationService", { enumerable: true, get: function () { return cache_serialization_service_1.CacheSerializationService; } });
+// Decorators
 var decorators_1 = require("./decorators");
 Object.defineProperty(exports, "Cacheable", { enumerable: true, get: function () { return decorators_1.Cacheable; } });
 Object.defineProperty(exports, "CacheEvict", { enumerable: true, get: function () { return decorators_1.CacheEvict; } });
 Object.defineProperty(exports, "CachePut", { enumerable: true, get: function () { return decorators_1.CachePut; } });
 Object.defineProperty(exports, "getCacheService", { enumerable: true, get: function () { return decorators_1.getCacheService; } });
 Object.defineProperty(exports, "setCacheService", { enumerable: true, get: function () { return decorators_1.setCacheService; } });
+// 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; } });
 Object.defineProperty(exports, "ChainDependency", { enumerable: true, get: function () { return dependencies_1.ChainDependency; } });
@@ -37,8 +61,10 @@ Object.defineProperty(exports, "DbDependency", { enumerable: true, get: function
 Object.defineProperty(exports, "FileDependency", { enumerable: true, get: function () { return dependencies_1.FileDependency; } });
 Object.defineProperty(exports, "TagDependency", { enumerable: true, get: function () { return dependencies_1.TagDependency; } });
 Object.defineProperty(exports, "TimeDependency", { enumerable: true, get: function () { return dependencies_1.TimeDependency; } });
+// Interfaces
 var interfaces_1 = require("./interfaces");
 Object.defineProperty(exports, "CacheLayer", { enumerable: true, get: function () { return interfaces_1.CacheLayer; } });
+// Utils (advanced usage)
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "DependencyManager", { enumerable: true, get: function () { return utils_1.DependencyManager; } });
 Object.defineProperty(exports, "KeyGenerator", { enumerable: true, get: function () { return utils_1.KeyGenerator; } });

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

@@ -1,11 +1,64 @@
+/**
+ * Cache dependency interface - similar to Yii2 cache dependency system
+ *
+ * A cache dependency represents a dependency relationship between cached data
+ * and some external state. When the external state changes, the cached data
+ * becomes invalid.
+ *
+ * @example
+ * ```typescript
+ * // Tag-based dependency
+ * new TagDependency(['user-list'])
+ *
+ * // Database-based dependency
+ * new DbDependency('SELECT MAX(updated_at) FROM users WHERE id = ?', [userId])
+ *
+ * // Callback-based dependency
+ * new CallbackDependency(() => ConfigService.get('app.version'))
+ * ```
+ */
 export interface CacheDependency {
+    /**
+     * Get a unique key that identifies this dependency
+     * This key is used to store the dependency state
+     *
+     * @returns Unique dependency key
+     */
     getKey(): string;
+    /**
+     * Get the current state/value of this dependency
+     * This value will be compared with stored state to detect changes
+     *
+     * @returns Current dependency data/state
+     */
     getData(): Promise<any>;
+    /**
+     * Check if the dependency has changed by comparing old data with current data
+     *
+     * @param oldData - Previously stored dependency data
+     * @returns true if dependency has changed, false otherwise
+     */
     isChanged(oldData: any): Promise<boolean>;
+    /**
+     * Reset/clear the dependency state
+     * Used when manually invalidating dependencies
+     */
     reset?(): Promise<void>;
 }
+/**
+ * Serialized dependency data stored alongside cached values
+ */
 export interface DependencyData {
+    /**
+     * Dependency key
+     */
     key: string;
+    /**
+     * Dependency state snapshot at cache time
+     */
     data: any;
+    /**
+     * Timestamp when dependency was captured
+     */
     timestamp: number;
 }