@hazeljs/cache 0.2.0-beta.1

package/dist/src/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;

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