@path58/n8n-mcp 0.1.0

package/dist/services/RedisCatalogCache.js

@@ -0,0 +1,680 @@
+/**
+ * Redis Catalog Cache Service
+ *
+ * Implements ICatalogCache using Redis for distributed caching.
+ * Caches all bluelime catalog data (nodes, operations, parameters,
+ * credentials, connection_rules) with structured key namespaces.
+ *
+ * Features:
+ * - Sub-millisecond lookups for cached data
+ * - Graceful fallback to DB if Redis unavailable
+ * - Configurable TTL (default: 24 hours)
+ * - Hit/miss tracking for monitoring
+ *
+ * @module services/RedisCatalogCache
+ */
+import Redis from 'ioredis';
+import { logger } from '@tsvika58/shared-utilities/logging';
+import { loadFullCatalog } from './catalog/loaders.js';
+import { validatorQuery } from '../db/validatorPostgresClient.js';
+/** Default TTL in seconds (24 hours) */
+const DEFAULT_TTL = 86400;
+/** Redis key prefix for all catalog data */
+const PREFIX = 'catalog:';
+/**
+ * Normalize node type to lowercase for consistent lookups.
+ */
+function normalizeNodeType(nodeType) {
+    return nodeType.toLowerCase().trim();
+}
+/**
+ * RedisCatalogCache implements ICatalogCache using Redis as the backing store.
+ * Falls back to database queries when Redis is unavailable.
+ */
+export class RedisCatalogCache {
+    redis = null;
+    isConnected = false;
+    ready = false;
+    config;
+    stats;
+    constructor(config) {
+        this.config = {
+            ttlSeconds: config?.ttlSeconds ?? DEFAULT_TTL,
+            autoRefresh: config?.autoRefresh ?? false,
+            refreshIntervalSeconds: config?.refreshIntervalSeconds ?? 3600,
+            preloadOnInit: config?.preloadOnInit ?? true,
+            redisUrl: config?.redisUrl ?? process.env.REDIS_URL ?? '',
+            fallbackToMemory: config?.fallbackToMemory ?? true,
+        };
+        this.stats = {
+            nodes: 0,
+            operations: 0,
+            parameters: 0,
+            credentials: 0,
+            connections: 0,
+            loadedAt: null,
+            loadDurationMs: 0,
+            hits: 0,
+            misses: 0,
+        };
+    }
+    // ============================================================
+    // Lifecycle Methods
+    // ============================================================
+    async initialize() {
+        await this.connectRedis();
+        if (this.config.preloadOnInit && this.isConnected && this.redis) {
+            // Check if Redis already has cached data (skip redundant Supabase loads)
+            // RAG-2.2.93.13: Check nodes, operations, AND parameters to ensure cache is complete
+            try {
+                const cachedNodeCount = await this.redis.scard(`${PREFIX}nodes:_all`);
+                // Check if operations are cached
+                const opKeys = await this.redis.keys(`${PREFIX}operations:*`);
+                const hasOperations = opKeys.length > 100; // Expect many operation keys
+                // Check if parameters are cached
+                const paramKeys = await this.redis.keys(`${PREFIX}parameters:*`);
+                const hasParameters = paramKeys.length > 100; // Expect many parameter keys
+                if (cachedNodeCount > 0 && hasOperations && hasParameters) {
+                    // Cache already populated - restore stats from Redis
+                    this.stats.nodes = cachedNodeCount;
+                    this.stats.operations = opKeys.length;
+                    this.stats.parameters = paramKeys.length;
+                    this.stats.credentials = await this.redis.scard(`${PREFIX}credentials:_all`);
+                    logger.info('Using existing Redis cache', {
+                        node_count: cachedNodeCount,
+                        op_keys: opKeys.length,
+                        param_keys: paramKeys.length,
+                    });
+                }
+                else {
+                    // Cache incomplete - need to load from Supabase
+                    logger.info('Redis cache incomplete, refreshing...', {
+                        nodes: cachedNodeCount,
+                        op_keys: opKeys.length,
+                        param_keys: paramKeys.length,
+                    });
+                    await this.refresh();
+                }
+            }
+            catch {
+                // Fallback to refresh if cache check fails (e.g., mocked Redis in tests)
+                await this.refresh();
+            }
+        }
+        this.ready = true;
+    }
+    async refresh() {
+        const start = performance.now();
+        try {
+            const catalogData = await loadFullCatalog();
+            await this.populateCache(catalogData);
+            this.stats.loadedAt = new Date().toISOString();
+            this.stats.loadDurationMs = performance.now() - start;
+            return {
+                success: true,
+                stats: await this.getStats(),
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                stats: await this.getStats(),
+                error: errorMsg,
+            };
+        }
+    }
+    async getStats() {
+        return {
+            nodes: this.stats.nodes,
+            operations: this.stats.operations,
+            parameters: this.stats.parameters,
+            credentials: this.stats.credentials,
+            connections: this.stats.connections,
+            loaded_at: this.stats.loadedAt,
+            load_duration_ms: this.stats.loadDurationMs,
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            backend: this.getBackend(),
+        };
+    }
+    isReady() {
+        return this.ready;
+    }
+    async dispose() {
+        if (this.redis) {
+            await this.redis.quit();
+            this.redis = null;
+            this.isConnected = false;
+        }
+        this.ready = false;
+    }
+    // ============================================================
+    // Node Operations
+    // ============================================================
+    async getNode(nodeType) {
+        const key = `${PREFIX}nodes:${normalizeNodeType(nodeType)}`;
+        return this.getCachedOrFallback(key, async () => {
+            const result = await validatorQuery('SELECT * FROM bluelime.nodes WHERE LOWER(node_type) = $1', [normalizeNodeType(nodeType)]);
+            return result.rows[0] ?? null;
+        });
+    }
+    async isTrigger(nodeType) {
+        const node = await this.getNode(nodeType);
+        return node?.is_trigger ?? false;
+    }
+    async isDeprecated(nodeType) {
+        const node = await this.getNode(nodeType);
+        return node?.is_deprecated ?? false;
+    }
+    async getNodesByRole(role) {
+        const key = `${PREFIX}nodes:_roles:${role}`;
+        return this.getSetMembers(key);
+    }
+    async getAllNodeTypes() {
+        // Try Redis first
+        const cachedTypes = await this.getSetMembers(`${PREFIX}nodes:_all`);
+        if (cachedTypes.length > 0) {
+            return cachedTypes;
+        }
+        // Fallback to database query if Redis set is empty
+        try {
+            const result = await validatorQuery('SELECT LOWER(node_type) as node_type FROM bluelime.nodes');
+            return result.rows.map((row) => row.node_type);
+        }
+        catch {
+            return [];
+        }
+    }
+    async hasNode(nodeType) {
+        const key = `${PREFIX}nodes:${normalizeNodeType(nodeType)}`;
+        if (this.isConnected && this.redis) {
+            const exists = await this.redis.exists(key);
+            return exists === 1;
+        }
+        const node = await this.getNode(nodeType);
+        return node !== null;
+    }
+    // ============================================================
+    // Operation and Parameter Methods
+    // ============================================================
+    async getOperations(nodeType) {
+        const key = `${PREFIX}operations:${normalizeNodeType(nodeType)}`;
+        const result = await this.getCachedOrFallback(key, async () => {
+            const dbResult = await validatorQuery(`SELECT o.id, n.node_type, o.display_name AS operation_name,
+                  o.operation AS operation_value, o.description, o.required_parameters
+           FROM bluelime.operations o
+           JOIN bluelime.nodes n ON o.node_id = n.id
+           WHERE LOWER(n.node_type) = $1`, [normalizeNodeType(nodeType)]);
+            return dbResult.rows;
+        });
+        return result ?? [];
+    }
+    async getOperation(nodeType, operationValue) {
+        const operations = await this.getOperations(nodeType);
+        return (operations.find((op) => op.operation_value.toLowerCase() === operationValue.toLowerCase()) ?? null);
+    }
+    /**
+     * RAG-2.2.108.5: Batch fetch operations for multiple node types.
+     * Reduces Redis round-trips from O(n) to O(1) for L5 validation.
+     */
+    async getOperationsBatch(nodeTypes) {
+        const result = new Map();
+        if (nodeTypes.length === 0)
+            return result;
+        // Try batch fetch from Redis first
+        if (this.isConnected && this.redis) {
+            try {
+                const keys = nodeTypes.map((nt) => `${PREFIX}operations:${normalizeNodeType(nt)}`);
+                const values = await this.redis.mget(...keys);
+                const missingTypes = [];
+                for (let i = 0; i < nodeTypes.length; i++) {
+                    const value = values[i];
+                    const normalizedType = normalizeNodeType(nodeTypes[i]);
+                    if (value) {
+                        this.stats.hits++;
+                        result.set(normalizedType, JSON.parse(value));
+                    }
+                    else {
+                        missingTypes.push(nodeTypes[i]);
+                    }
+                }
+                // Fetch missing from DB in single batch query
+                if (missingTypes.length > 0) {
+                    this.stats.misses += missingTypes.length;
+                    logger.debug(`[CACHE] Operations cache miss: ${missingTypes.length} node types`);
+                    // Batch query for all missing operations
+                    const placeholders = missingTypes.map((_, i) => `$${i + 1}`).join(', ');
+                    const normalizedTypes = missingTypes.map((nt) => normalizeNodeType(nt));
+                    const dbResult = await validatorQuery(`SELECT o.id, n.node_type, o.display_name AS operation_name,
+                    o.operation AS operation_value, o.description, o.required_parameters
+             FROM bluelime.operations o
+             JOIN bluelime.nodes n ON o.node_id = n.id
+             WHERE LOWER(n.node_type) IN (${placeholders})`, normalizedTypes);
+                    // Group results by node_type
+                    const byNodeType = new Map();
+                    for (const op of dbResult.rows) {
+                        const normalized = normalizeNodeType(op.node_type);
+                        if (!byNodeType.has(normalized)) {
+                            byNodeType.set(normalized, []);
+                        }
+                        byNodeType.get(normalized).push(op);
+                    }
+                    // Cache and add to result
+                    const pipeline = this.redis.pipeline();
+                    for (const nt of missingTypes) {
+                        const normalized = normalizeNodeType(nt);
+                        const ops = byNodeType.get(normalized) || [];
+                        result.set(normalized, ops);
+                        pipeline.setex(`${PREFIX}operations:${normalized}`, this.config.ttlSeconds, JSON.stringify(ops));
+                    }
+                    await pipeline.exec();
+                }
+                return result;
+            }
+            catch {
+                // Fall through to sequential fallback
+            }
+        }
+        // Fallback: sequential fetches
+        for (const nodeType of nodeTypes) {
+            const ops = await this.getOperations(nodeType);
+            result.set(normalizeNodeType(nodeType), ops);
+        }
+        return result;
+    }
+    async getParameters(operationId) {
+        const key = `${PREFIX}parameters:${operationId}`;
+        const result = await this.getCachedOrFallback(key, async () => {
+            const dbResult = await validatorQuery('SELECT * FROM bluelime.parameters WHERE operation_id = $1', [operationId]);
+            return dbResult.rows;
+        });
+        return result ?? [];
+    }
+    async getParametersBatch(operationIds) {
+        const result = new Map();
+        if (operationIds.length === 0)
+            return result;
+        // Try batch fetch from Redis first
+        if (this.isConnected && this.redis) {
+            try {
+                const keys = operationIds.map((id) => `${PREFIX}parameters:${id}`);
+                const values = await this.redis.mget(...keys);
+                const missingIds = [];
+                for (let i = 0; i < operationIds.length; i++) {
+                    const value = values[i];
+                    if (value) {
+                        this.stats.hits++;
+                        result.set(operationIds[i], JSON.parse(value));
+                    }
+                    else {
+                        missingIds.push(operationIds[i]);
+                    }
+                }
+                // RAG-2.2.93.13: Fetch missing from DB in single batch query (not parallel)
+                // This prevents overwhelming the connection pool with many parallel queries
+                if (missingIds.length > 0) {
+                    this.stats.misses += missingIds.length;
+                    logger.debug(`[CACHE] Parameter cache miss: ${missingIds.length} operation IDs`);
+                    // Single batch query for all missing parameters
+                    const placeholders = missingIds.map((_, i) => `$${i + 1}`).join(', ');
+                    const dbResult = await validatorQuery(`SELECT * FROM bluelime.parameters WHERE operation_id IN (${placeholders})`, missingIds);
+                    // Group results by operation_id
+                    const byOperationId = new Map();
+                    for (const param of dbResult.rows) {
+                        if (!byOperationId.has(param.operation_id)) {
+                            byOperationId.set(param.operation_id, []);
+                        }
+                        byOperationId.get(param.operation_id).push(param);
+                    }
+                    // Cache and add to result
+                    const pipeline = this.redis.pipeline();
+                    for (const id of missingIds) {
+                        const params = byOperationId.get(id) || [];
+                        result.set(id, params);
+                        pipeline.setex(`${PREFIX}parameters:${id}`, this.config.ttlSeconds, JSON.stringify(params));
+                    }
+                    await pipeline.exec();
+                }
+                return result;
+            }
+            catch {
+                // Fall through to sequential fallback
+            }
+        }
+        // Fallback: sequential fetches
+        for (const id of operationIds) {
+            const params = await this.getParameters(id);
+            result.set(id, params);
+        }
+        return result;
+    }
+    async getParametersByOperation(nodeType, operationValue) {
+        const operation = await this.getOperation(nodeType, operationValue);
+        if (!operation)
+            return [];
+        return this.getParameters(operation.id);
+    }
+    // ============================================================
+    // Credential Methods
+    // ============================================================
+    async getCredential(credType) {
+        const key = `${PREFIX}credentials:${credType.toLowerCase()}`;
+        return this.getCachedOrFallback(key, async () => {
+            const result = await validatorQuery('SELECT * FROM bluelime.credentials WHERE LOWER(credential_type) = $1', [credType.toLowerCase()]);
+            return result.rows[0] ?? null;
+        });
+    }
+    async hasCredential(credType) {
+        const cred = await this.getCredential(credType);
+        return cred !== null;
+    }
+    async getAllCredentialTypes() {
+        return this.getSetMembers(`${PREFIX}credentials:_all`);
+    }
+    async getCredentialsForNode(nodeType) {
+        const key = `${PREFIX}node_credentials:${normalizeNodeType(nodeType)}`;
+        return this.getSetMembers(key);
+    }
+    // ============================================================
+    // Connection Methods
+    // ============================================================
+    async getConnection(source, target) {
+        const key = this.getConnectionKey(source, target);
+        return this.getCachedOrFallback(key, async () => {
+            const result = await validatorQuery(`SELECT source_node_type AS source_type, target_node_type AS target_type,
+                occurrence_count, 1.0 AS confidence
+         FROM bluelime.connection_rules
+         WHERE LOWER(source_node_type) = $1 AND LOWER(target_node_type) = $2`, [normalizeNodeType(source), normalizeNodeType(target)]);
+            return result.rows[0] ?? null;
+        });
+    }
+    async hasConnection(source, target) {
+        const conn = await this.getConnection(source, target);
+        return conn !== null;
+    }
+    async getOutgoingConnections(source) {
+        const key = `${PREFIX}connections:out:${normalizeNodeType(source)}`;
+        const result = await this.getCachedOrFallback(key, async () => {
+            const dbResult = await validatorQuery(`SELECT source_node_type AS source_type, target_node_type AS target_type,
+                  occurrence_count, 1.0 AS confidence
+           FROM bluelime.connection_rules WHERE LOWER(source_node_type) = $1`, [normalizeNodeType(source)]);
+            return dbResult.rows;
+        });
+        return result ?? [];
+    }
+    async getIncomingConnections(target) {
+        const key = `${PREFIX}connections:in:${normalizeNodeType(target)}`;
+        const result = await this.getCachedOrFallback(key, async () => {
+            const dbResult = await validatorQuery(`SELECT source_node_type AS source_type, target_node_type AS target_type,
+                  occurrence_count, 1.0 AS confidence
+           FROM bluelime.connection_rules WHERE LOWER(target_node_type) = $1`, [normalizeNodeType(target)]);
+            return dbResult.rows;
+        });
+        return result ?? [];
+    }
+    // ============================================================
+    // Private: Redis Connection
+    // ============================================================
+    async connectRedis() {
+        const redisUrl = this.config.redisUrl ||
+            process.env.REDIS_URL ||
+            'redis://localhost:6379';
+        try {
+            this.redis = new Redis(redisUrl, {
+                enableAutoPipelining: true,
+                maxRetriesPerRequest: 1,
+                connectTimeout: 2000,
+                commandTimeout: 5000,
+                retryStrategy: (times) => {
+                    if (times > 2)
+                        return null;
+                    return Math.min(times * 100, 1000);
+                },
+                enableReadyCheck: true,
+            });
+            await this.waitForConnection();
+            await this.redis.ping();
+            this.isConnected = true;
+        }
+        catch (error) {
+            this.handleConnectionError(error);
+        }
+    }
+    async waitForConnection() {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Redis connection timeout'));
+            }, 5000);
+            this.redis.on('ready', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.redis.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    handleConnectionError(error) {
+        logger.warn('Failed to connect to Redis', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        if (this.redis) {
+            this.redis.quit().catch((err) => {
+                logger.debug('Redis quit failed during connection error cleanup', { error: err.message });
+            });
+        }
+        this.redis = null;
+        this.isConnected = false;
+    }
+    // ============================================================
+    // Private: Cache Population
+    // ============================================================
+    async populateCache(data) {
+        if (!this.isConnected || !this.redis)
+            return;
+        const pipeline = this.redis.pipeline();
+        const ttl = this.config.ttlSeconds;
+        this.populateNodes(pipeline, data.nodes.data, ttl);
+        this.populateOperations(pipeline, data.operations.data, ttl);
+        this.populateParameters(pipeline, data.parameters.data, ttl);
+        this.populateCredentials(pipeline, data.credentials.data, ttl);
+        this.populateConnections(pipeline, data.connections.data, ttl);
+        await pipeline.exec();
+        this.stats.nodes = data.nodes.count;
+        this.stats.operations = data.operations.count;
+        this.stats.parameters = data.parameters.count;
+        this.stats.credentials = data.credentials.count;
+        this.stats.connections = data.connections.count;
+    }
+    populateNodes(pipeline, nodes, ttl) {
+        const triggers = [];
+        const deprecated = [];
+        const roleMap = new Map();
+        const allNodes = [];
+        for (const node of nodes) {
+            const normalizedType = normalizeNodeType(node.node_type);
+            const key = `${PREFIX}nodes:${normalizedType}`;
+            pipeline.setex(key, ttl, JSON.stringify(node));
+            allNodes.push(normalizedType);
+            if (node.is_trigger)
+                triggers.push(normalizedType);
+            if (node.is_deprecated)
+                deprecated.push(normalizedType);
+            const role = node.node_role || 'unknown';
+            if (!roleMap.has(role))
+                roleMap.set(role, []);
+            roleMap.get(role).push(normalizedType);
+        }
+        if (allNodes.length > 0) {
+            pipeline.del(`${PREFIX}nodes:_all`);
+            pipeline.sadd(`${PREFIX}nodes:_all`, ...allNodes);
+        }
+        if (triggers.length > 0) {
+            pipeline.del(`${PREFIX}nodes:_triggers`);
+            pipeline.sadd(`${PREFIX}nodes:_triggers`, ...triggers);
+        }
+        if (deprecated.length > 0) {
+            pipeline.del(`${PREFIX}nodes:_deprecated`);
+            pipeline.sadd(`${PREFIX}nodes:_deprecated`, ...deprecated);
+        }
+        Array.from(roleMap.entries()).forEach(([role, types]) => {
+            const roleKey = `${PREFIX}nodes:_roles:${role}`;
+            pipeline.del(roleKey);
+            pipeline.sadd(roleKey, ...types);
+        });
+    }
+    populateOperations(pipeline, operations, ttl) {
+        const byNode = new Map();
+        for (const op of operations) {
+            const normalized = normalizeNodeType(op.node_type);
+            if (!byNode.has(normalized))
+                byNode.set(normalized, []);
+            byNode.get(normalized).push(op);
+        }
+        Array.from(byNode.entries()).forEach(([nodeType, ops]) => {
+            const key = `${PREFIX}operations:${nodeType}`;
+            pipeline.setex(key, ttl, JSON.stringify(ops));
+        });
+    }
+    populateParameters(pipeline, parameters, ttl) {
+        const byOperation = new Map();
+        for (const param of parameters) {
+            if (!byOperation.has(param.operation_id)) {
+                byOperation.set(param.operation_id, []);
+            }
+            byOperation.get(param.operation_id).push(param);
+        }
+        Array.from(byOperation.entries()).forEach(([opId, params]) => {
+            const key = `${PREFIX}parameters:${opId}`;
+            pipeline.setex(key, ttl, JSON.stringify(params));
+        });
+    }
+    populateCredentials(pipeline, credentials, ttl) {
+        const allCreds = [];
+        for (const cred of credentials) {
+            const normalized = cred.credential_type.toLowerCase();
+            const key = `${PREFIX}credentials:${normalized}`;
+            pipeline.setex(key, ttl, JSON.stringify(cred));
+            allCreds.push(normalized);
+        }
+        if (allCreds.length > 0) {
+            pipeline.del(`${PREFIX}credentials:_all`);
+            pipeline.sadd(`${PREFIX}credentials:_all`, ...allCreds);
+        }
+    }
+    populateConnections(pipeline, connections, ttl) {
+        const outgoing = new Map();
+        const incoming = new Map();
+        for (const conn of connections) {
+            const key = this.getConnectionKey(conn.source_type, conn.target_type);
+            pipeline.setex(key, ttl, JSON.stringify(conn));
+            const srcNorm = normalizeNodeType(conn.source_type);
+            const tgtNorm = normalizeNodeType(conn.target_type);
+            if (!outgoing.has(srcNorm))
+                outgoing.set(srcNorm, []);
+            outgoing.get(srcNorm).push(conn);
+            if (!incoming.has(tgtNorm))
+                incoming.set(tgtNorm, []);
+            incoming.get(tgtNorm).push(conn);
+        }
+        Array.from(outgoing.entries()).forEach(([src, conns]) => {
+            const key = `${PREFIX}connections:out:${src}`;
+            pipeline.setex(key, ttl, JSON.stringify(conns));
+        });
+        Array.from(incoming.entries()).forEach(([tgt, conns]) => {
+            const key = `${PREFIX}connections:in:${tgt}`;
+            pipeline.setex(key, ttl, JSON.stringify(conns));
+        });
+    }
+    // ============================================================
+    // Private: Cache Helpers
+    // ============================================================
+    async getCachedOrFallback(key, fallback) {
+        if (this.isConnected && this.redis) {
+            try {
+                const cached = await this.redis.get(key);
+                if (cached) {
+                    this.stats.hits++;
+                    return JSON.parse(cached);
+                }
+            }
+            catch {
+                // Fall through to DB
+            }
+        }
+        this.stats.misses++;
+        const result = await fallback();
+        if (result && this.isConnected && this.redis) {
+            await this.redis
+                .setex(key, this.config.ttlSeconds, JSON.stringify(result))
+                .catch((err) => {
+                logger.debug('Redis setex failed (non-critical)', { key, error: err.message });
+            });
+        }
+        return result;
+    }
+    async getSetMembers(key) {
+        if (this.isConnected && this.redis) {
+            try {
+                return await this.redis.smembers(key);
+            }
+            catch {
+                return [];
+            }
+        }
+        return [];
+    }
+    getConnectionKey(source, target) {
+        return `${PREFIX}connections:${normalizeNodeType(source)}:${normalizeNodeType(target)}`;
+    }
+    getBackend() {
+        if (this.isConnected && this.redis)
+            return 'redis';
+        return 'none';
+    }
+}
+/** Singleton instance */
+let instance = null;
+/** Promise singleton for initialization (prevents race conditions) */
+let initPromise = null;
+/**
+ * Get or create the singleton RedisCatalogCache instance.
+ */
+export function getRedisCatalogCache(config) {
+    if (!instance) {
+        instance = new RedisCatalogCache(config);
+    }
+    return instance;
+}
+/**
+ * Initialize and return the singleton cache.
+ * Convenience function that creates, initializes, and returns the cache.
+ * Uses promise singleton pattern to prevent race conditions when called concurrently.
+ */
+export function initRedisCatalogCache(config) {
+    if (!initPromise) {
+        initPromise = (async () => {
+            const cache = getRedisCatalogCache(config);
+            if (!cache.isReady()) {
+                await cache.initialize();
+            }
+            return cache;
+        })();
+    }
+    return initPromise;
+}
+/**
+ * Reset the singleton instance (for testing).
+ */
+export function resetRedisCatalogCache() {
+    if (instance) {
+        instance.dispose().catch((err) => {
+            logger.debug('Dispose failed during reset', { error: err.message });
+        });
+        instance = null;
+    }
+    initPromise = null;
+}
+//# sourceMappingURL=RedisCatalogCache.js.map