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

package/cache/examples/quick-start.js

@@ -0,0 +1,341 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModule = exports.ExampleAppModule = exports.AppModule = void 0;
+const common_1 = require("@nestjs/common");
+const index_1 = require("../index");
+let AppModule = class AppModule {
+};
+exports.AppModule = AppModule;
+exports.ExampleAppModule = AppModule;
+exports.ExampleAppModule = exports.AppModule = AppModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            index_1.CacheModule.forRoot({
+                memoryTtl: 300000,
+            }),
+        ],
+    })
+], AppModule);
+let UserService = class UserService {
+    constructor(cacheService) {
+        this.cacheService = cacheService;
+    }
+    getUserDirect(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.cacheService.getOrSet(`user:${id}`, () => __awaiter(this, void 0, void 0, function* () {
+                yield new Promise((resolve) => setTimeout(resolve, 50));
+                return { id, name: `User ${id}`, email: `user${id}@example.com` };
+            }), {
+                ttl: 300000,
+                dependencies: [new index_1.TagDependency(['user-data'])],
+            });
+        });
+    }
+    getUserWithDecorator(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 50));
+            return { id, name: `User ${id}`, email: `user${id}@example.com` };
+        });
+    }
+    getUserProfile(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.getUserWithDecorator(id);
+            return Object.assign(Object.assign({}, user), { profile: {
+                    bio: `Bio for ${user.name}`,
+                    avatar: `https://avatar.com/${id}.jpg`,
+                    settings: { theme: 'dark' },
+                } });
+        });
+    }
+    getUserFull(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.getUserWithDecorator(id);
+            const profile = yield this.getUserProfile(id);
+            return Object.assign(Object.assign({}, user), { profile, permissions: ['read', 'write'], lastLogin: new Date() });
+        });
+    }
+    getUserList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 100));
+            return [
+                { id: '1', name: 'John Doe', email: 'john@example.com' },
+                { id: '2', name: 'Jane Smith', email: 'jane@example.com' },
+                { id: '3', name: 'Bob Johnson', email: 'bob@example.com' },
+            ];
+        });
+    }
+    searchUsers(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const users = yield this.getUserList();
+            return users.filter((user) => user.name.toLowerCase().includes(query.toLowerCase()) ||
+                user.email.toLowerCase().includes(query.toLowerCase()));
+        });
+    }
+    updateUser(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 50));
+            const existing = yield this.getUserWithDecorator(id);
+            return Object.assign(Object.assign(Object.assign({}, existing), data), { updatedAt: new Date() });
+        });
+    }
+    deleteUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new Promise((resolve) => setTimeout(resolve, 20));
+            return true;
+        });
+    }
+    clearAllUserCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    batchGetUsers(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keys = ids.map((id) => `user:${id}:decorated`);
+            const cached = yield this.cacheService.mget(keys);
+            const uncachedIds = ids.filter((id, index) => !cached[index]);
+            if (uncachedIds.length > 0) {
+                const uncachedUsers = yield Promise.all(uncachedIds.map((id) => this.getUserWithDecorator(id)));
+                const items = uncachedIds.map((id, index) => ({
+                    key: `user:${id}:decorated`,
+                    value: uncachedUsers[index],
+                }));
+                yield this.cacheService.mset(items, { ttl: 300000 });
+            }
+            return cached.filter(Boolean);
+        });
+    }
+    getCacheStats() {
+        return this.cacheService.getStats();
+    }
+};
+__decorate([
+    (0, index_1.Cacheable)({
+        key: (id) => `user:${id}:decorated`,
+        ttl: 300000,
+        layers: [index_1.CacheLayer.MEMORY, index_1.CacheLayer.REDIS],
+        dependencies: [
+            new index_1.TagDependency(['user-data']),
+            new index_1.CallbackDependency(() => __awaiter(void 0, void 0, void 0, function* () {
+                return 'user-version-1';
+            })),
+        ],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "getUserWithDecorator", null);
+__decorate([
+    (0, index_1.Cacheable)({
+        key: (id) => `user:${id}:profile`,
+        condition: (id) => id !== 'admin',
+        dependencies: [new index_1.TagDependency(['user-profile'])],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "getUserProfile", null);
+__decorate([
+    (0, index_1.Cacheable)({
+        key: (id) => `user:${id}:full`,
+        dependencies: [
+            new index_1.DbDependency('SELECT updated_at FROM users WHERE id = ?', (id) => [id]),
+        ],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "getUserFull", null);
+__decorate([
+    (0, index_1.Cacheable)({
+        key: 'users:list',
+        ttl: 600000,
+        dependencies: [new index_1.TagDependency(['user-list', 'all-users'])],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "getUserList", null);
+__decorate([
+    (0, index_1.Cacheable)({
+        key: (query) => `users:search:${query.toLowerCase()}`,
+        condition: (query) => query.length >= 2,
+        ttl: 1800000,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "searchUsers", null);
+__decorate([
+    (0, index_1.CachePut)({
+        key: (id) => `user:${id}:decorated`,
+        dependencies: [new index_1.TagDependency(['user-data'])],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "updateUser", null);
+__decorate([
+    (0, index_1.CacheEvict)({
+        keys: [
+            (id) => `user:${id}`,
+            (id) => `user:${id}:decorated`,
+            (id) => `user:${id}:profile`,
+            (id) => `user:${id}:full`,
+        ],
+        tags: ['user-data'],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "deleteUser", null);
+__decorate([
+    (0, index_1.CacheEvict)({
+        patterns: ['user:*', 'users:*'],
+        tags: ['user-data', 'user-list', 'all-users'],
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UserService.prototype, "clearAllUserCache", null);
+UserService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [index_1.CacheService])
+], UserService);
+let UserController = class UserController {
+    constructor(userService) {
+        this.userService = userService;
+    }
+    getUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.userService.getUserWithDecorator(id);
+        });
+    }
+    getUserProfile(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.userService.getUserProfile(id);
+        });
+    }
+    getUserList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.userService.getUserList();
+        });
+    }
+    searchUsers(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.userService.searchUsers(query);
+        });
+    }
+    updateUser(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.userService.updateUser(id, data);
+        });
+    }
+    deleteUser(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deleted = yield this.userService.deleteUser(id);
+            return { success: deleted };
+        });
+    }
+    clearCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.userService.clearAllUserCache();
+            return { message: 'User cache cleared' };
+        });
+    }
+    getCacheStats() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.userService.getCacheStats();
+        });
+    }
+};
+__decorate([
+    (0, common_1.Get)(':id'),
+    __param(0, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "getUser", null);
+__decorate([
+    (0, common_1.Get)(':id/profile'),
+    __param(0, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "getUserProfile", null);
+__decorate([
+    (0, common_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "getUserList", null);
+__decorate([
+    (0, common_1.Get)('search/:query'),
+    __param(0, (0, common_1.Param)('query')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "searchUsers", null);
+__decorate([
+    (0, common_1.Post)(':id'),
+    __param(0, (0, common_1.Param)('id')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "updateUser", null);
+__decorate([
+    (0, common_1.Post)(':id/delete'),
+    __param(0, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "deleteUser", null);
+__decorate([
+    (0, common_1.Post)('clear-cache'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "clearCache", null);
+__decorate([
+    (0, common_1.Get)('cache/stats'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "getCacheStats", null);
+UserController = __decorate([
+    (0, common_1.Controller)('users'),
+    __metadata("design:paramtypes", [UserService])
+], UserController);
+let UserModuleInternal = class UserModuleInternal {
+};
+UserModuleInternal = __decorate([
+    (0, common_1.Module)({
+        imports: [AppModule],
+        controllers: [UserController],
+        providers: [UserService],
+    })
+], UserModuleInternal);
+class UserModule {
+}
+exports.UserModule = UserModule;

package/cache/index.d.ts

@@ -0,0 +1,14 @@
+export { CacheModule, type CacheModuleOptions, CACHE_SERVICE, } from './cache.module';
+export { CacheService } from './cache.service';
+export { CacheHealthChecker, type CacheHealthResult } from './cache.health';
+export { CacheWarmupService, type CacheWarmupConfig, type CacheWarmupResult, } from './cache.warmup.service';
+export { CacheMetricsService, type CacheMetrics, type CacheOperationRecord, } from './cache-metrics.service';
+export { CacheSerializationService, type CacheSerializationOptions, } from './cache-serialization.service';
+export { Cacheable, CacheEvict, CachePut, getCacheService, setCacheService, } from './decorators';
+export { ClsCacheProvider, MemoryCacheProvider, RedisCacheProvider, BaseCacheProvider, } from './providers';
+export { REDIS_CLIENT } from './providers/redis-cache.provider';
+export type { CacheProvider } from './interfaces/cache-provider.interface';
+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';
+export type { CacheDependency as ICacheDependency, CacheProvider as ICacheProvider, } from './interfaces';

package/cache/index.js

@@ -0,0 +1,41 @@
+"use strict";
+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_SERVICE = exports.CacheModule = void 0;
+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; } });
+var cache_service_1 = require("./cache.service");
+Object.defineProperty(exports, "CacheService", { enumerable: true, get: function () { return cache_service_1.CacheService; } });
+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");
+Object.defineProperty(exports, "CacheWarmupService", { enumerable: true, get: function () { return cache_warmup_service_1.CacheWarmupService; } });
+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; } });
+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; } });
+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, "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; } });
+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; } });
+Object.defineProperty(exports, "DbDependency", { enumerable: true, get: function () { return dependencies_1.DbDependency; } });
+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; } });
+var interfaces_1 = require("./interfaces");
+Object.defineProperty(exports, "CacheLayer", { enumerable: true, get: function () { return interfaces_1.CacheLayer; } });
+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

@@ -0,0 +1,11 @@
+export interface CacheDependency {
+    getKey(): string;
+    getData(): Promise<any>;
+    isChanged(oldData: any): Promise<boolean>;
+    reset?(): Promise<void>;
+}
+export interface DependencyData {
+    key: string;
+    data: any;
+    timestamp: number;
+}

package/cache/interfaces/cache-dependency.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,32 @@
+import type { CacheDependency } from './cache-dependency.interface';
+export declare enum CacheLayer {
+    CLS = "cls",
+    MEMORY = "memory",
+    REDIS = "redis"
+}
+export interface CacheOptions {
+    ttl?: number;
+    layers?: CacheLayer[];
+    prefix?: string;
+    condition?: (...args: any[]) => boolean | Promise<boolean>;
+    dependencies?: CacheDependency[];
+    backfill?: boolean;
+    namespace?: string;
+}
+export interface CacheKeyOptions {
+    key?: string | ((...args: any[]) => string);
+    prefix?: string;
+    includeAllArgs?: boolean;
+}
+export interface CacheableOptions extends CacheOptions, CacheKeyOptions {
+}
+export interface CacheEvictOptions {
+    keys?: Array<string | ((...args: any[]) => string)>;
+    patterns?: string[];
+    tags?: string[];
+    layers?: CacheLayer[];
+    condition?: (...args: any[]) => boolean | Promise<boolean>;
+    timing?: 'before' | 'after';
+}
+export interface CachePutOptions extends CacheOptions, CacheKeyOptions {
+}

package/cache/interfaces/cache-options.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheLayer = void 0;
+var CacheLayer;
+(function (CacheLayer) {
+    CacheLayer["CLS"] = "cls";
+    CacheLayer["MEMORY"] = "memory";
+    CacheLayer["REDIS"] = "redis";
+})(CacheLayer || (exports.CacheLayer = CacheLayer = {}));

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

@@ -0,0 +1,28 @@
+export interface CacheProvider {
+    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>;
+    getName(): string;
+}
+export interface CacheStats {
+    totalGets: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    byLayer: Record<string, {
+        hits: number;
+        misses: number;
+        hitRate: number;
+    }>;
+    totalSets: number;
+    totalDeletes: number;
+    totalClears: number;
+}

package/cache/interfaces/cache-provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cache/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cache-dependency.interface';
+export * from './cache-options.interface';
+export * from './cache-provider.interface';

package/cache/interfaces/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./cache-dependency.interface"), exports);
+__exportStar(require("./cache-options.interface"), exports);
+__exportStar(require("./cache-provider.interface"), exports);

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

@@ -0,0 +1,16 @@
+import type { CacheProvider } from '../interfaces/cache-provider.interface';
+export declare abstract class BaseCacheProvider implements CacheProvider {
+    abstract get<T>(key: string): Promise<T | null>;
+    abstract set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    abstract delete(key: string | string[]): Promise<void>;
+    abstract deletePattern?(pattern: string): Promise<number>;
+    abstract clear(): Promise<void>;
+    abstract has(key: string): Promise<boolean>;
+    abstract getName(): string;
+    mget<T>(keys: string[]): Promise<(T | null)[]>;
+    mset(items: Array<{
+        key: string;
+        value: any;
+    }>, ttl?: number): Promise<void>;
+    protected patternToRegex(pattern: string): RegExp;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCacheProvider = void 0;
+class BaseCacheProvider {
+    mget(keys) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = keys.map((key) => this.get(key));
+            return Promise.all(promises);
+        });
+    }
+    mset(items, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = items.map((item) => this.set(item.key, item.value, ttl));
+            yield Promise.all(promises);
+        });
+    }
+    patternToRegex(pattern) {
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        const regexPattern = escaped.replace(/\*/g, '.*');
+        return new RegExp(`^${regexPattern}$`);
+    }
+}
+exports.BaseCacheProvider = BaseCacheProvider;

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

@@ -0,0 +1,16 @@
+import { BaseCacheProvider } from './base-cache.provider';
+export declare class ClsCacheProvider extends BaseCacheProvider {
+    private static readonly CACHE_PREFIX;
+    private static readonly KEYS_SET;
+    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>;
+    private getFullKey;
+    private addKeyToSet;
+    private removeKeyFromSet;
+    private getAllKeys;
+}