ts-prorm-orm 1.1.0

package/dist/cache/redis-cluster-cache.js

@@ -0,0 +1,557 @@
+"use strict";
+/**
+ * Redis Cluster Cache Backend
+ *
+ * Implements CacheBackend using ioredis cluster with L1 (in-memory) and L2 (Redis cluster) caching.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClusterCache = void 0;
+exports.createRedisClusterCache = createRedisClusterCache;
+const ioredis_1 = __importStar(require("ioredis"));
+const cache_manager_1 = require("./cache-manager");
+/**
+ * LRU Map implementation for L1 cache
+ */
+class LRUCache {
+    constructor(maxSize = 1000, ttl = 60000) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+        this.ttl = ttl;
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value === undefined) {
+            return undefined;
+        }
+        // Move to end (most recently used)
+        this.cache.delete(key);
+        this.cache.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        // If key exists, delete it first to update order
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        // If at capacity, remove oldest (first) entry
+        if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, value);
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    keys() {
+        return Array.from(this.cache.keys());
+    }
+    size() {
+        return this.cache.size;
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+}
+/**
+ * Redis Cluster Cache implementation with L1/L2 support
+ */
+class RedisClusterCache extends cache_manager_1.AbstractCacheManager {
+    // Use 'options' from parent class, cast for extended options
+    get clusterOptions() {
+        return this.options;
+    }
+    constructor(options = {}) {
+        super(options);
+        this.redisCluster = null;
+        this.redisReplicas = [];
+        this.connected = false;
+        this.l1Cache = new LRUCache(options.l1?.maxEntries ?? 1000, (options.l1?.ttl ?? 60) * 1000);
+        this.initializeCluster();
+    }
+    /**
+     * Initialize Redis cluster connection
+     */
+    initializeCluster() {
+        const opts = this.clusterOptions;
+        if (!opts.clusterNodes || opts.clusterNodes.length === 0) {
+            console.warn('RedisClusterCache: No cluster nodes provided, running in L1-only mode');
+            return;
+        }
+        const clusterNodes = opts.clusterNodes.map(node => ({
+            host: node.host,
+            port: node.port,
+            password: node.password,
+            tls: node.tls,
+        }));
+        const clusterOptions = {
+            maxRedirections: 3,
+            enableReadyCheck: true,
+            enableOfflineQueue: true,
+            lazyConnect: false,
+            redisOptions: {
+                password: this.options.clusterOptions?.password,
+                tls: this.options.clusterOptions?.tls ? {} : undefined,
+                connectTimeout: this.options.connectTimeout ?? 10000,
+                commandTimeout: this.options.commandTimeout ?? 5000,
+                db: this.options.db ?? 0,
+            },
+        };
+        // Add retry strategy
+        const toClusterRetryStrategy = (fn) => (times) => {
+            const result = fn(times);
+            return result instanceof Error ? null : result;
+        };
+        if (this.options.retryStrategy) {
+            clusterOptions.clusterRetryStrategy = toClusterRetryStrategy(this.options.retryStrategy);
+        }
+        else {
+            clusterOptions.clusterRetryStrategy = (times) => {
+                if (times > 10) {
+                    return null; // Stop retrying
+                }
+                return Math.min(times * 200, 3000); // Max 3 seconds
+            };
+        }
+        this.redisCluster = new ioredis_1.Cluster(clusterNodes, clusterOptions);
+        this.redisCluster.on('connect', () => {
+            this.connected = true;
+            console.log('RedisClusterCache: Connected to cluster');
+        });
+        this.redisCluster.on('error', (err) => {
+            console.error('RedisClusterCache: Cluster error', err.message);
+            this.connected = false;
+        });
+        this.redisCluster.on('close', () => {
+            this.connected = false;
+        });
+        // Initialize read replicas if enabled
+        if (this.options.readFromReplicas && this.options.clusterOptions?.enableReadFromReplicas) {
+            this.initializeReplicas();
+        }
+    }
+    /**
+     * Initialize read replicas for read-from-replicas functionality
+     */
+    initializeReplicas() {
+        if (!this.options.clusterOptions?.replicaNodes || this.options.clusterOptions.replicaNodes.length === 0) {
+            return;
+        }
+        for (const node of this.options.clusterOptions.replicaNodes) {
+            const redis = new ioredis_1.default({
+                host: node.host,
+                port: node.port,
+                password: node.password,
+                tls: node.tls ? {} : undefined,
+                db: this.options.db ?? 0,
+                connectTimeout: this.options.connectTimeout ?? 10000,
+                commandTimeout: this.options.commandTimeout ?? 5000,
+                lazyConnect: false,
+            });
+            redis.on('error', (err) => {
+                console.error('RedisClusterCache: Replica error', err.message);
+            });
+            this.redisReplicas.push(redis);
+        }
+    }
+    /**
+     * Get a value from cache, checking L1 first then L2
+     */
+    async get(key) {
+        const fullKey = this.buildKey(key);
+        // Try L1 cache first
+        if (this.options.l1?.enabled !== false) {
+            const l1Value = this.l1Cache.get(fullKey);
+            if (l1Value !== undefined) {
+                this.stats.hits++;
+                this.stats.l1Hits++;
+                return l1Value;
+            }
+        }
+        // If L2 is disabled, return null
+        if (this.options.l2?.enabled === false) {
+            this.stats.misses++;
+            return null;
+        }
+        // Try L2 (Redis cluster)
+        try {
+            const redis = this.getRedisClient();
+            if (redis) {
+                const l2Value = await redis.get(fullKey);
+                if (l2Value !== null) {
+                    this.stats.hits++;
+                    this.stats.l2Hits++;
+                    // Update L1 cache
+                    if (this.options.l1?.enabled !== false) {
+                        this.l1Cache.set(fullKey, l2Value);
+                    }
+                    return l2Value;
+                }
+            }
+        }
+        catch (error) {
+            console.error('RedisClusterCache: Error getting from L2', error);
+        }
+        this.stats.misses++;
+        return null;
+    }
+    /**
+     * Set a value in cache (both L1 and L2)
+     */
+    async set(key, value, ttl) {
+        const fullKey = this.buildKey(key);
+        const l2Ttl = ttl ?? this.options.l2?.defaultTtl ?? 3600;
+        // Always set in L1
+        if (this.options.l1?.enabled !== false) {
+            this.l1Cache.set(fullKey, value);
+        }
+        // Set in L2 if enabled
+        if (this.options.l2?.enabled !== false) {
+            try {
+                const redis = this.getRedisClient();
+                if (redis) {
+                    await redis.setex(fullKey, l2Ttl, value);
+                    return true;
+                }
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error setting in L2', error);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Delete a key from cache (both L1 and L2)
+     */
+    async del(key) {
+        const fullKey = this.buildKey(key);
+        // Delete from L1
+        if (this.options.l1?.enabled !== false) {
+            this.l1Cache.delete(fullKey);
+        }
+        // Delete from L2 if enabled
+        if (this.options.l2?.enabled !== false) {
+            try {
+                const redis = this.getRedisClient();
+                if (redis) {
+                    await redis.del(fullKey);
+                    return true;
+                }
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error deleting from L2', error);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if a key exists in cache
+     */
+    async exists(key) {
+        const fullKey = this.buildKey(key);
+        // Check L1 first
+        if (this.options.l1?.enabled !== false) {
+            if (this.l1Cache.has(fullKey)) {
+                return true;
+            }
+        }
+        // Check L2 if enabled
+        if (this.options.l2?.enabled !== false) {
+            try {
+                const redis = this.getRedisClient();
+                if (redis) {
+                    const result = await redis.exists(fullKey);
+                    return result === 1;
+                }
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error checking existence in L2', error);
+            }
+        }
+        return false;
+    }
+    /**
+     * Invalidate all keys matching a pattern
+     */
+    async invalidatePattern(pattern) {
+        const fullPattern = this.buildKey(pattern);
+        let invalidated = 0;
+        // Clear matching keys from L1
+        if (this.options.l1?.enabled !== false) {
+            const l1Keys = this.l1Cache.keys();
+            const regex = this.patternToRegex(fullPattern);
+            for (const key of l1Keys) {
+                if (regex.test(key)) {
+                    this.l1Cache.delete(key);
+                    invalidated++;
+                }
+            }
+        }
+        // Clear matching keys from L2 if enabled
+        if (this.options.l2?.enabled !== false) {
+            try {
+                const redis = this.getRedisClient();
+                if (redis) {
+                    const keys = await redis.keys(fullPattern);
+                    if (keys.length > 0) {
+                        await redis.del(...keys);
+                        invalidated += keys.length;
+                    }
+                }
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error invalidating pattern in L2', error);
+            }
+        }
+        return invalidated;
+    }
+    /**
+     * Clear all cache entries
+     */
+    async clear() {
+        // Clear L1
+        if (this.options.l1?.enabled !== false) {
+            this.l1Cache.clear();
+        }
+        // Clear L2 if enabled
+        if (this.options.l2?.enabled !== false) {
+            try {
+                const redis = this.getRedisClient();
+                if (redis) {
+                    const keys = await redis.keys(this.buildKey('*'));
+                    if (keys.length > 0) {
+                        await redis.del(...keys);
+                    }
+                }
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error clearing L2', error);
+                return false;
+            }
+        }
+        this.resetStats();
+        return true;
+    }
+    /**
+     * Get multiple keys at once
+     */
+    async mget(keys) {
+        const fullKeys = keys.map(k => this.buildKey(k));
+        const results = new Array(keys.length);
+        // Separate keys into L1 and L2
+        const l1Results = new Map();
+        const l2Keys = [];
+        if (this.options.l1?.enabled !== false) {
+            for (let i = 0; i < fullKeys.length; i++) {
+                const value = this.l1Cache.get(fullKeys[i]);
+                if (value !== undefined) {
+                    results[i] = value;
+                    this.stats.hits++;
+                    this.stats.l1Hits++;
+                }
+                else {
+                    l2Keys.push(fullKeys[i]);
+                }
+            }
+        }
+        else {
+            l2Keys.push(...fullKeys);
+        }
+        // Get remaining from L2
+        if (l2Keys.length > 0 && this.options.l2?.enabled !== false) {
+            try {
+                const redis = this.getRedisClient();
+                if (redis) {
+                    const l2Results = await redis.mget(...l2Keys);
+                    for (let i = 0; i < l2Keys.length; i++) {
+                        const fullKey = l2Keys[i];
+                        const originalIndex = fullKeys.indexOf(fullKey);
+                        if (l2Results[i] !== null) {
+                            results[originalIndex] = l2Results[i];
+                            this.stats.hits++;
+                            this.stats.l2Hits++;
+                            // Update L1 cache
+                            if (this.options.l1?.enabled !== false) {
+                                this.l1Cache.set(fullKey, l2Results[i]);
+                            }
+                        }
+                        else {
+                            this.stats.misses++;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error in mget L2', error);
+            }
+        }
+        return results;
+    }
+    /**
+     * Set multiple keys at once
+     */
+    async mset(entries) {
+        // Set in L1
+        if (this.options.l1?.enabled !== false) {
+            for (const entry of entries) {
+                this.l1Cache.set(this.buildKey(entry.key), entry.value);
+            }
+        }
+        // Set in L2 if enabled
+        if (this.options.l2?.enabled !== false) {
+            try {
+                const redis = this.getRedisClient();
+                if (redis) {
+                    const pipeline = redis.pipeline();
+                    for (const entry of entries) {
+                        const fullKey = this.buildKey(entry.key);
+                        const l2Ttl = entry.ttl ?? this.options.l2?.defaultTtl ?? 3600;
+                        pipeline.setex(fullKey, l2Ttl, entry.value);
+                    }
+                    await pipeline.exec();
+                    return true;
+                }
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error in mset L2', error);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Get the appropriate Redis client (master or replica)
+     */
+    getRedisClient() {
+        if (!this.redisCluster) {
+            return null;
+        }
+        // Use replica if enabled and available
+        if (this.options.readFromReplicas && this.redisReplicas.length > 0) {
+            const randomIndex = Math.floor(Math.random() * this.redisReplicas.length);
+            return this.redisReplicas[randomIndex];
+        }
+        return this.redisCluster;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return {
+            ...super.getStats(),
+            keys: this.l1Cache.size(),
+        };
+    }
+    /**
+     * Close all Redis connections
+     */
+    async disconnect() {
+        // Close replica connections
+        for (const replica of this.redisReplicas) {
+            try {
+                await replica.quit();
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error closing replica', error);
+            }
+        }
+        this.redisReplicas = [];
+        // Close cluster connection
+        if (this.redisCluster) {
+            try {
+                await this.redisCluster.quit();
+            }
+            catch (error) {
+                console.error('RedisClusterCache: Error closing cluster', error);
+            }
+            this.redisCluster = null;
+        }
+        this.connected = false;
+        console.log('RedisClusterCache: Disconnected');
+    }
+    /**
+     * Check if cache backend is connected
+     */
+    isConnected() {
+        return this.connected && this.redisCluster !== null;
+    }
+    /**
+     * Get the underlying Redis cluster instance
+     */
+    getRedisCluster() {
+        return this.redisCluster;
+    }
+    /**
+     * Get all replica connections
+     */
+    getReplicas() {
+        return this.redisReplicas;
+    }
+    /**
+     * Manually invalidate L1 cache (useful for testing)
+     */
+    clearL1() {
+        this.l1Cache.clear();
+    }
+    /**
+     * Convert glob pattern to regex
+     */
+    patternToRegex(pattern) {
+        const escaped = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${escaped}$`);
+    }
+}
+exports.RedisClusterCache = RedisClusterCache;
+/**
+ * Create a RedisClusterCache instance with simplified options
+ */
+function createRedisClusterCache(nodes, options = {}) {
+    return new RedisClusterCache({
+        ...options,
+        clusterNodes: nodes,
+    });
+}
+exports.default = RedisClusterCache;