@hazeljs/cache 0.2.0-beta.1

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @hazeljs/cache - Caching module for HazelJS
+ */
+export { CacheModule, type CacheModuleOptions } from './cache.module';
+export { CacheService, CacheManager } from './cache.service';
+export { Cache, CacheKey, CacheTTL, CacheTags, CacheEvict, getCacheMetadata, hasCacheMetadata, getCacheEvictMetadata, } from './decorators/cache.decorator';
+export { type CacheOptions, type CacheStrategy, type TTLStrategy, type CacheEntry, type CacheStats, type ICacheStore, type CacheWarmingOptions, type CacheInvalidationEvent, } from './cache.types';
+export { MemoryCacheStore } from './strategies/memory.strategy';
+export { RedisCacheStore } from './strategies/redis.strategy';
+export { MultiTierCacheStore } from './strategies/multi-tier.strategy';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,GAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @hazeljs/cache - Caching module for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTierCacheStore = exports.RedisCacheStore = exports.MemoryCacheStore = exports.getCacheEvictMetadata = exports.hasCacheMetadata = exports.getCacheMetadata = exports.CacheEvict = exports.CacheTags = exports.CacheTTL = exports.CacheKey = exports.Cache = exports.CacheManager = exports.CacheService = exports.CacheModule = void 0;
+var cache_module_1 = require("./cache.module");
+Object.defineProperty(exports, "CacheModule", { enumerable: true, get: function () { return cache_module_1.CacheModule; } });
+var cache_service_1 = require("./cache.service");
+Object.defineProperty(exports, "CacheService", { enumerable: true, get: function () { return cache_service_1.CacheService; } });
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return cache_service_1.CacheManager; } });
+var cache_decorator_1 = require("./decorators/cache.decorator");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_decorator_1.Cache; } });
+Object.defineProperty(exports, "CacheKey", { enumerable: true, get: function () { return cache_decorator_1.CacheKey; } });
+Object.defineProperty(exports, "CacheTTL", { enumerable: true, get: function () { return cache_decorator_1.CacheTTL; } });
+Object.defineProperty(exports, "CacheTags", { enumerable: true, get: function () { return cache_decorator_1.CacheTags; } });
+Object.defineProperty(exports, "CacheEvict", { enumerable: true, get: function () { return cache_decorator_1.CacheEvict; } });
+Object.defineProperty(exports, "getCacheMetadata", { enumerable: true, get: function () { return cache_decorator_1.getCacheMetadata; } });
+Object.defineProperty(exports, "hasCacheMetadata", { enumerable: true, get: function () { return cache_decorator_1.hasCacheMetadata; } });
+Object.defineProperty(exports, "getCacheEvictMetadata", { enumerable: true, get: function () { return cache_decorator_1.getCacheEvictMetadata; } });
+var memory_strategy_1 = require("./strategies/memory.strategy");
+Object.defineProperty(exports, "MemoryCacheStore", { enumerable: true, get: function () { return memory_strategy_1.MemoryCacheStore; } });
+var redis_strategy_1 = require("./strategies/redis.strategy");
+Object.defineProperty(exports, "RedisCacheStore", { enumerable: true, get: function () { return redis_strategy_1.RedisCacheStore; } });
+var multi_tier_strategy_1 = require("./strategies/multi-tier.strategy");
+Object.defineProperty(exports, "MultiTierCacheStore", { enumerable: true, get: function () { return multi_tier_strategy_1.MultiTierCacheStore; } });

package/dist/src/strategies/memory.strategy.d.ts

@@ -0,0 +1,73 @@
+import { ICacheStore, CacheStats } from '../cache.types';
+/**
+ * In-memory cache store implementation
+ */
+export declare class MemoryCacheStore implements ICacheStore {
+    private cleanupIntervalMs;
+    private cache;
+    private tagIndex;
+    private stats;
+    private cleanupInterval?;
+    constructor(cleanupIntervalMs?: number);
+    /**
+     * Get a value from cache
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Set a value with tags
+     */
+    setWithTags<T>(key: string, value: T, ttl: number, tags?: string[]): Promise<void>;
+    /**
+     * Delete a value from cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete entries by tag
+     */
+    deleteByTag(tag: string): Promise<void>;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all cache entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all keys matching a pattern
+     */
+    keys(pattern?: string): Promise<string[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Start cleanup interval
+     */
+    private startCleanup;
+    /**
+     * Stop cleanup interval
+     */
+    stopCleanup(): void;
+    /**
+     * Cleanup expired entries
+     */
+    private cleanup;
+    /**
+     * Remove key from tag index
+     */
+    private removeFromTagIndex;
+    /**
+     * Destroy the cache store
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=memory.strategy.d.ts.map

package/dist/src/strategies/memory.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.strategy.d.ts","sourceRoot":"","sources":["../../../src/strategies/memory.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAc,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGrE;;GAEG;AACH,qBAAa,gBAAiB,YAAW,WAAW;IAStC,OAAO,CAAC,iBAAiB;IARrC,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,KAAK,CAGX;IACF,OAAO,CAAC,eAAe,CAAC,CAAiB;gBAErB,iBAAiB,GAAE,MAAc;IAIrD;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IA4B5C;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IActE;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BxF;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASxC;;OAEG;IACG,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc7C;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAY/C;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAoBrC;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,OAAO,CAAC,YAAY;IAMpB;;OAEG;IACH,WAAW,IAAI,IAAI;IAOnB;;OAEG;IACH,OAAO,CAAC,OAAO;IAiBf;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;OAEG;IACH,OAAO,IAAI,IAAI;CAKhB"}

package/dist/src/strategies/memory.strategy.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCacheStore = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * In-memory cache store implementation
+ */
+class MemoryCacheStore {
+    constructor(cleanupIntervalMs = 60000) {
+        this.cleanupIntervalMs = cleanupIntervalMs;
+        this.cache = new Map();
+        this.tagIndex = new Map();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+        };
+        this.startCleanup();
+    }
+    /**
+     * Get a value from cache
+     */
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            core_1.default.debug(`Cache miss: ${key}`);
+            return null;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            this.removeFromTagIndex(key, entry.tags);
+            this.stats.misses++;
+            core_1.default.debug(`Cache expired: ${key}`);
+            return null;
+        }
+        // Update last accessed for sliding TTL
+        if (entry.lastAccessedAt !== undefined) {
+            entry.lastAccessedAt = Date.now();
+        }
+        this.stats.hits++;
+        core_1.default.debug(`Cache hit: ${key}`);
+        return entry.value;
+    }
+    /**
+     * Set a value in cache
+     */
+    async set(key, value, ttl = 3600) {
+        const now = Date.now();
+        const entry = {
+            value,
+            key,
+            cachedAt: now,
+            expiresAt: now + ttl * 1000,
+            lastAccessedAt: now,
+        };
+        this.cache.set(key, entry);
+        core_1.default.debug(`Cache set: ${key} (TTL: ${ttl}s)`);
+    }
+    /**
+     * Set a value with tags
+     */
+    async setWithTags(key, value, ttl, tags) {
+        const now = Date.now();
+        const entry = {
+            value,
+            key,
+            cachedAt: now,
+            expiresAt: now + ttl * 1000,
+            lastAccessedAt: now,
+            tags,
+        };
+        this.cache.set(key, entry);
+        // Update tag index
+        if (tags) {
+            tags.forEach((tag) => {
+                if (!this.tagIndex.has(tag)) {
+                    this.tagIndex.set(tag, new Set());
+                }
+                this.tagIndex.get(tag).add(key);
+            });
+        }
+        core_1.default.debug(`Cache set with tags: ${key} (TTL: ${ttl}s, Tags: ${tags?.join(', ')})`);
+    }
+    /**
+     * Delete a value from cache
+     */
+    async delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.removeFromTagIndex(key, entry.tags);
+        }
+        this.cache.delete(key);
+        core_1.default.debug(`Cache deleted: ${key}`);
+    }
+    /**
+     * Delete entries by tag
+     */
+    async deleteByTag(tag) {
+        const keys = this.tagIndex.get(tag);
+        if (!keys) {
+            return;
+        }
+        for (const key of keys) {
+            await this.delete(key);
+        }
+        this.tagIndex.delete(tag);
+        core_1.default.debug(`Cache invalidated by tag: ${tag} (${keys.size} entries)`);
+    }
+    /**
+     * Check if key exists in cache
+     */
+    async has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            this.removeFromTagIndex(key, entry.tags);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Clear all cache entries
+     */
+    async clear() {
+        this.cache.clear();
+        this.tagIndex.clear();
+        core_1.default.info('Cache cleared');
+    }
+    /**
+     * Get all keys matching a pattern
+     */
+    async keys(pattern) {
+        const allKeys = Array.from(this.cache.keys());
+        if (!pattern) {
+            return allKeys;
+        }
+        // Simple pattern matching (supports * wildcard)
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+        return allKeys.filter((key) => regex.test(key));
+    }
+    /**
+     * Get cache statistics
+     */
+    async getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+        // Calculate approximate memory usage
+        let memoryUsage = 0;
+        for (const entry of this.cache.values()) {
+            const entrySize = JSON.stringify(entry.value).length;
+            memoryUsage += entrySize;
+        }
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            hitRate: Math.round(hitRate * 100) / 100,
+            size: this.cache.size,
+            memoryUsage,
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats.hits = 0;
+        this.stats.misses = 0;
+    }
+    /**
+     * Start cleanup interval
+     */
+    startCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, this.cleanupIntervalMs);
+    }
+    /**
+     * Stop cleanup interval
+     */
+    stopCleanup() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+    }
+    /**
+     * Cleanup expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        let expiredCount = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.expiresAt) {
+                this.cache.delete(key);
+                this.removeFromTagIndex(key, entry.tags);
+                expiredCount++;
+            }
+        }
+        if (expiredCount > 0) {
+            core_1.default.debug(`Cleaned up ${expiredCount} expired cache entries`);
+        }
+    }
+    /**
+     * Remove key from tag index
+     */
+    removeFromTagIndex(key, tags) {
+        if (!tags) {
+            return;
+        }
+        tags.forEach((tag) => {
+            const keys = this.tagIndex.get(tag);
+            if (keys) {
+                keys.delete(key);
+                if (keys.size === 0) {
+                    this.tagIndex.delete(tag);
+                }
+            }
+        });
+    }
+    /**
+     * Destroy the cache store
+     */
+    destroy() {
+        this.stopCleanup();
+        this.cache.clear();
+        this.tagIndex.clear();
+    }
+}
+exports.MemoryCacheStore = MemoryCacheStore;

package/dist/src/strategies/multi-tier.strategy.d.ts

@@ -0,0 +1,69 @@
+import { ICacheStore, CacheStats } from '../cache.types';
+/**
+ * Multi-tier cache store implementation
+ * Uses memory cache as L1 and Redis as L2
+ */
+export declare class MultiTierCacheStore implements ICacheStore {
+    private l1Cache;
+    private l2Cache;
+    constructor(options?: {
+        redis?: {
+            host?: string;
+            port?: number;
+            password?: string;
+        };
+    });
+    /**
+     * Get a value from cache (L1 first, then L2)
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache (both L1 and L2)
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Set a value with tags
+     */
+    setWithTags<T>(key: string, value: T, ttl: number, tags?: string[]): Promise<void>;
+    /**
+     * Delete a value from cache (both L1 and L2)
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete entries by tag
+     */
+    deleteByTag(tag: string): Promise<void>;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all cache entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all keys matching a pattern
+     */
+    keys(pattern?: string): Promise<string[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Get L1 cache statistics
+     */
+    getL1Stats(): Promise<CacheStats>;
+    /**
+     * Get L2 cache statistics
+     */
+    getL2Stats(): Promise<CacheStats>;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Destroy the cache store
+     */
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=multi-tier.strategy.d.ts.map

package/dist/src/strategies/multi-tier.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-tier.strategy.d.ts","sourceRoot":"","sources":["../../../src/strategies/multi-tier.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAKzD;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAAkB;gBAErB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;IAMrF;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAqB5C;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUtE;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWxF;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxC;;OAEG;IACG,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM7C;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAW/C;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAqBrC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAIvC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAIvC;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}

package/dist/src/strategies/multi-tier.strategy.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTierCacheStore = void 0;
+const memory_strategy_1 = require("./memory.strategy");
+const redis_strategy_1 = require("./redis.strategy");
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * Multi-tier cache store implementation
+ * Uses memory cache as L1 and Redis as L2
+ */
+class MultiTierCacheStore {
+    constructor(options) {
+        this.l1Cache = new memory_strategy_1.MemoryCacheStore();
+        this.l2Cache = new redis_strategy_1.RedisCacheStore(options?.redis);
+        core_1.default.info('Multi-tier cache store initialized (L1: Memory, L2: Redis)');
+    }
+    /**
+     * Get a value from cache (L1 first, then L2)
+     */
+    async get(key) {
+        // Try L1 cache first
+        let value = await this.l1Cache.get(key);
+        if (value !== null) {
+            core_1.default.debug(`Multi-tier cache hit (L1): ${key}`);
+            return value;
+        }
+        // Try L2 cache
+        value = await this.l2Cache.get(key);
+        if (value !== null) {
+            core_1.default.debug(`Multi-tier cache hit (L2): ${key}`);
+            // Promote to L1
+            await this.l1Cache.set(key, value, 300); // 5 minutes in L1
+            return value;
+        }
+        core_1.default.debug(`Multi-tier cache miss: ${key}`);
+        return null;
+    }
+    /**
+     * Set a value in cache (both L1 and L2)
+     */
+    async set(key, value, ttl = 3600) {
+        // Set in both caches
+        await Promise.all([
+            this.l1Cache.set(key, value, Math.min(ttl, 300)), // Max 5 minutes in L1
+            this.l2Cache.set(key, value, ttl),
+        ]);
+        core_1.default.debug(`Multi-tier cache set: ${key} (TTL: ${ttl}s)`);
+    }
+    /**
+     * Set a value with tags
+     */
+    async setWithTags(key, value, ttl, tags) {
+        await Promise.all([
+            this.l1Cache.setWithTags(key, value, Math.min(ttl, 300), tags),
+            this.l2Cache.setWithTags(key, value, ttl, tags),
+        ]);
+        core_1.default.debug(`Multi-tier cache set with tags: ${key} (TTL: ${ttl}s, Tags: ${tags?.join(', ')})`);
+    }
+    /**
+     * Delete a value from cache (both L1 and L2)
+     */
+    async delete(key) {
+        await Promise.all([this.l1Cache.delete(key), this.l2Cache.delete(key)]);
+        core_1.default.debug(`Multi-tier cache deleted: ${key}`);
+    }
+    /**
+     * Delete entries by tag
+     */
+    async deleteByTag(tag) {
+        await Promise.all([this.l1Cache.deleteByTag(tag), this.l2Cache.deleteByTag(tag)]);
+        core_1.default.debug(`Multi-tier cache invalidated by tag: ${tag}`);
+    }
+    /**
+     * Check if key exists in cache
+     */
+    async has(key) {
+        const inL1 = await this.l1Cache.has(key);
+        if (inL1) {
+            return true;
+        }
+        return await this.l2Cache.has(key);
+    }
+    /**
+     * Clear all cache entries
+     */
+    async clear() {
+        await Promise.all([this.l1Cache.clear(), this.l2Cache.clear()]);
+        core_1.default.info('Multi-tier cache cleared');
+    }
+    /**
+     * Get all keys matching a pattern
+     */
+    async keys(pattern) {
+        // Get keys from both caches and merge
+        const [l1Keys, l2Keys] = await Promise.all([
+            this.l1Cache.keys(pattern),
+            this.l2Cache.keys(pattern),
+        ]);
+        // Merge and deduplicate
+        return Array.from(new Set([...l1Keys, ...l2Keys]));
+    }
+    /**
+     * Get cache statistics
+     */
+    async getStats() {
+        const [l1Stats, l2Stats] = await Promise.all([
+            this.l1Cache.getStats(),
+            this.l2Cache.getStats(),
+        ]);
+        // Combine stats
+        const totalHits = l1Stats.hits + l2Stats.hits;
+        const totalMisses = l1Stats.misses + l2Stats.misses;
+        const total = totalHits + totalMisses;
+        const hitRate = total > 0 ? (totalHits / total) * 100 : 0;
+        return {
+            hits: totalHits,
+            misses: totalMisses,
+            hitRate: Math.round(hitRate * 100) / 100,
+            size: l1Stats.size + l2Stats.size,
+            memoryUsage: l1Stats.memoryUsage,
+        };
+    }
+    /**
+     * Get L1 cache statistics
+     */
+    async getL1Stats() {
+        return await this.l1Cache.getStats();
+    }
+    /**
+     * Get L2 cache statistics
+     */
+    async getL2Stats() {
+        return await this.l2Cache.getStats();
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.l1Cache.resetStats();
+        this.l2Cache.resetStats();
+    }
+    /**
+     * Destroy the cache store
+     */
+    async destroy() {
+        this.l1Cache.destroy();
+        await this.l2Cache.disconnect();
+        core_1.default.info('Multi-tier cache destroyed');
+    }
+}
+exports.MultiTierCacheStore = MultiTierCacheStore;

package/dist/src/strategies/redis.strategy.d.ts

@@ -0,0 +1,61 @@
+import { ICacheStore, CacheStats } from '../cache.types';
+/**
+ * Redis cache store implementation
+ * Note: This is a mock implementation. In production, you would use a real Redis client like ioredis
+ */
+export declare class RedisCacheStore implements ICacheStore {
+    private options?;
+    private mockStore;
+    private tagIndex;
+    private stats;
+    constructor(options?: {
+        host?: string;
+        port?: number;
+        password?: string;
+    } | undefined);
+    /**
+     * Get a value from cache
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Set a value with tags
+     */
+    setWithTags<T>(key: string, value: T, ttl: number, tags?: string[]): Promise<void>;
+    /**
+     * Delete a value from cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete entries by tag
+     */
+    deleteByTag(tag: string): Promise<void>;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all cache entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all keys matching a pattern
+     */
+    keys(pattern?: string): Promise<string[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Disconnect from Redis
+     */
+    disconnect(): Promise<void>;
+}
+//# sourceMappingURL=redis.strategy.d.ts.map

package/dist/src/strategies/redis.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.strategy.d.ts","sourceRoot":"","sources":["../../../src/strategies/redis.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGzD;;;GAGG;AACH,qBAAa,eAAgB,YAAW,WAAW;IAQrC,OAAO,CAAC,OAAO,CAAC;IAP5B,OAAO,CAAC,SAAS,CAAgE;IACjF,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,KAAK,CAGX;gBAEkB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,YAAA;IAMjF;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IA4B5C;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAWtE;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBxF;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQxC;;OAEG;IACG,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7C;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAkBxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAe/C;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAgBrC;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CAQlC"}