@hazeljs/cache 0.2.0-beta.1

package/dist/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/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/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"}

package/dist/strategies/redis.strategy.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCacheStore = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * Redis cache store implementation
+ * Note: This is a mock implementation. In production, you would use a real Redis client like ioredis
+ */
+class RedisCacheStore {
+    constructor(options) {
+        this.options = options;
+        this.mockStore = new Map();
+        this.tagIndex = new Map();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+        };
+        core_1.default.info('Redis cache store initialized (mock mode)');
+        // In production, initialize real Redis client here
+        // this.client = new Redis(options);
+    }
+    /**
+     * Get a value from cache
+     */
+    async get(key) {
+        const entry = this.mockStore.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            core_1.default.debug(`Redis cache miss: ${key}`);
+            return null;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.mockStore.delete(key);
+            this.stats.misses++;
+            core_1.default.debug(`Redis cache expired: ${key}`);
+            return null;
+        }
+        this.stats.hits++;
+        core_1.default.debug(`Redis cache hit: ${key}`);
+        try {
+            return JSON.parse(entry.value);
+        }
+        catch (error) {
+            core_1.default.error(`Failed to parse cached value for key ${key}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Set a value in cache
+     */
+    async set(key, value, ttl = 3600) {
+        const serialized = JSON.stringify(value);
+        const expiresAt = Date.now() + ttl * 1000;
+        this.mockStore.set(key, { value: serialized, expiresAt });
+        core_1.default.debug(`Redis cache set: ${key} (TTL: ${ttl}s)`);
+        // In production:
+        // await this.client.setex(key, ttl, serialized);
+    }
+    /**
+     * Set a value with tags
+     */
+    async setWithTags(key, value, ttl, tags) {
+        await this.set(key, value, ttl);
+        // Update tag index
+        if (tags) {
+            for (const tag of tags) {
+                if (!this.tagIndex.has(tag)) {
+                    this.tagIndex.set(tag, new Set());
+                }
+                this.tagIndex.get(tag).add(key);
+                // In production, use Redis sets:
+                // await this.client.sadd(`tag:${tag}`, key);
+            }
+        }
+        core_1.default.debug(`Redis cache set with tags: ${key} (TTL: ${ttl}s, Tags: ${tags?.join(', ')})`);
+    }
+    /**
+     * Delete a value from cache
+     */
+    async delete(key) {
+        this.mockStore.delete(key);
+        core_1.default.debug(`Redis cache deleted: ${key}`);
+        // In production:
+        // await this.client.del(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(`Redis cache invalidated by tag: ${tag} (${keys.size} entries)`);
+        // In production:
+        // const keys = await this.client.smembers(`tag:${tag}`);
+        // if (keys.length > 0) {
+        //   await this.client.del(...keys);
+        //   await this.client.del(`tag:${tag}`);
+        // }
+    }
+    /**
+     * Check if key exists in cache
+     */
+    async has(key) {
+        const entry = this.mockStore.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.mockStore.delete(key);
+            return false;
+        }
+        return true;
+        // In production:
+        // return (await this.client.exists(key)) === 1;
+    }
+    /**
+     * Clear all cache entries
+     */
+    async clear() {
+        this.mockStore.clear();
+        this.tagIndex.clear();
+        core_1.default.info('Redis cache cleared');
+        // In production:
+        // await this.client.flushdb();
+    }
+    /**
+     * Get all keys matching a pattern
+     */
+    async keys(pattern) {
+        const allKeys = Array.from(this.mockStore.keys());
+        if (!pattern) {
+            return allKeys;
+        }
+        // Simple pattern matching
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+        return allKeys.filter((key) => regex.test(key));
+        // In production:
+        // return await this.client.keys(pattern || '*');
+    }
+    /**
+     * Get cache statistics
+     */
+    async getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            hitRate: Math.round(hitRate * 100) / 100,
+            size: this.mockStore.size,
+        };
+        // In production:
+        // const info = await this.client.info('stats');
+        // Parse info and return stats
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats.hits = 0;
+        this.stats.misses = 0;
+    }
+    /**
+     * Disconnect from Redis
+     */
+    async disconnect() {
+        this.mockStore.clear();
+        this.tagIndex.clear();
+        core_1.default.info('Redis cache disconnected');
+        // In production:
+        // await this.client.quit();
+    }
+}
+exports.RedisCacheStore = RedisCacheStore;