@hazeljs/cache 0.2.0-beta.1 → 0.2.0-beta.15

package/dist/strategies/redis.strategy.js

@@ -1,185 +0,0 @@
-"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;