node-red-contrib-redis-variable 1.2.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-redis-variable",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "A comprehensive Node-RED node for Redis operations with universal payload-based configuration, automatic JSON handling, SSL/TLS support, and advanced pattern matching with pagination",
   "keywords": [
     "node-red",

package/redis-variable-config.js

@@ -157,6 +157,51 @@ module.exports = function (RED) {
             }
         };
 
+        // Check if configuration exists in context
+        this.hasValidConfiguration = function(msg, executingNode) {
+            try {
+                // If using string configuration for host and port, it's always valid
+                if (this.hostType === 'str' && this.portType === 'str') {
+                    return true;
+                }
+                
+                // For context-based configuration, check if the required values exist
+                let hasHost = false;
+                let hasPort = false;
+                
+                // Check host configuration
+                if (this.hostType === 'str') {
+                    hasHost = !!(this.host);
+                } else {
+                    const contextHost = this.parseCredentialValue(this.hostContext, this.hostType, msg, executingNode);
+                    hasHost = !!(contextHost);
+                }
+                
+                // Check port configuration
+                if (this.portType === 'str') {
+                    hasPort = !!(this.port);
+                } else {
+                    const contextPort = this.parseCredentialValue(this.portContext, this.portType, msg, executingNode);
+                    hasPort = !!(contextPort);
+                }
+                
+                // We need at least host and port to have a valid configuration
+                const result = hasHost && hasPort;
+                
+                if (executingNode && process.env.NODE_RED_DEBUG) {
+                    executingNode.log(`Configuration check - hasHost: ${hasHost}, hasPort: ${hasPort}, result: ${result}`);
+                }
+                
+                return result;
+                
+            } catch (error) {
+                if (executingNode) {
+                    executingNode.error(`Error checking configuration: ${error.message}`);
+                }
+                return false;
+            }
+        };
+
         // Get Redis connection options
         this.getConnectionOptions = function(msg, executingNode) {
             try {
@@ -301,35 +346,97 @@ module.exports = function (RED) {
                     return connections[id];
                 }
 
+                // Check if configuration is available before attempting connection
+                if (!this.hasValidConfiguration(msg, executingNode)) {
+                    if (executingNode) {
+                        // Only warn once per node to avoid spam
+                        if (!executingNode._configWarningShown) {
+                            executingNode.warn("Redis configuration not available in context. Skipping connection attempt.");
+                            executingNode._configWarningShown = true;
+                            
+                            // Reset warning flag after 30 seconds
+                            setTimeout(() => {
+                                if (executingNode) {
+                                    executingNode._configWarningShown = false;
+                                }
+                            }, 30000);
+                        }
+                    }
+                    return null;
+                }
+
                 const options = this.getConnectionOptions(msg, executingNode);
 
+                // Add connection limits to prevent infinite retry loops
+                const connectionOptions = {
+                    ...options,
+                    maxRetriesPerRequest: 1, // Limit retries per request
+                    retryDelayOnFailover: 100,
+                    enableReadyCheck: false,
+                    lazyConnect: true, // Don't connect immediately
+                    connectTimeout: 5000, // 5 second timeout
+                    commandTimeout: 3000, // 3 second command timeout
+                    // Disable automatic reconnection to prevent error loops
+                    retryDelayOnClusterDown: 0,
+                    retryDelayOnFailover: 0,
+                    maxRetriesPerRequest: 0
+                };
+
                 // Create Redis client
                 let client;
                 if (this.cluster) {
                     // For cluster mode, options should be an array of nodes
-                    const clusterNodes = Array.isArray(options) ? options : [options];
+                    const clusterNodes = Array.isArray(connectionOptions) ? connectionOptions : [connectionOptions];
                     client = new Redis.Cluster(clusterNodes);
                 } else {
-                    client = new Redis(options);
+                    client = new Redis(connectionOptions);
                 }
 
+                // Track error state to prevent spam
+                let errorReported = false;
+                let lastErrorTime = 0;
+                const ERROR_REPORT_INTERVAL = 30000; // Report errors only once per 30 seconds
+
                 // Handle connection errors
                 client.on("error", (e) => {
-                    let errorMsg = `Redis connection error: ${e.message}`;
+                    const now = Date.now();
                     
-                    // Add specific diagnostics for common SSL issues
-                    if (e.message.includes("Protocol error") || e.message.includes("\\u0015")) {
-                        errorMsg += "\nThis usually indicates an SSL/TLS configuration issue. Try:";
-                        errorMsg += "\n1. Disable SSL/TLS if your Redis server doesn't support it";
-                        errorMsg += "\n2. Use port 6380 for Redis SSL instead of 6379";
-                        errorMsg += "\n3. Check if your Redis server is configured for SSL";
-                        errorMsg += "\n4. Enable 'Debug: Force No SSL' option for testing";
+                    // Only report errors once per interval to prevent spam
+                    if (!errorReported || (now - lastErrorTime) > ERROR_REPORT_INTERVAL) {
+                        let errorMsg = `Redis connection error: ${e.message}`;
+                        
+                        // Add specific diagnostics for common SSL issues
+                        if (e.message.includes("Protocol error") || e.message.includes("\\u0015")) {
+                            errorMsg += "\nThis usually indicates an SSL/TLS configuration issue. Try:";
+                            errorMsg += "\n1. Disable SSL/TLS if your Redis server doesn't support it";
+                            errorMsg += "\n2. Use port 6380 for Redis SSL instead of 6379";
+                            errorMsg += "\n3. Check if your Redis server is configured for SSL";
+                            errorMsg += "\n4. Enable 'Debug: Force No SSL' option for testing";
+                        }
+                        
+                        if (executingNode) {
+                            executingNode.error(errorMsg, {});
+                        } else {
+                            this.error(errorMsg, {});
+                        }
+                        
+                        errorReported = true;
+                        lastErrorTime = now;
                     }
-                    
+                });
+
+                // Handle successful connection
+                client.on("connect", () => {
+                    errorReported = false;
                     if (executingNode) {
-                        executingNode.error(errorMsg, {});
-                    } else {
-                        this.error(errorMsg, {});
+                        executingNode.status({ fill: "green", shape: "dot", text: "connected" });
+                    }
+                });
+
+                // Handle disconnection
+                client.on("disconnect", () => {
+                    if (executingNode) {
+                        executingNode.status({ fill: "red", shape: "ring", text: "disconnected" });
                     }
                 });
 
@@ -364,6 +471,20 @@ module.exports = function (RED) {
             }
         };
 
+        // Force disconnect method for error recovery
+        this.forceDisconnect = function(nodeId) {
+            const id = nodeId || this.id;
+            if (connections[id]) {
+                try {
+                    connections[id].disconnect();
+                } catch (e) {
+                    // Ignore disconnect errors
+                }
+                delete connections[id];
+                delete usedConn[id];
+            }
+        };
+
         // Clean up on node close
         this.on('close', function() {
             this.disconnect();

package/redis-variable.js

@@ -280,7 +280,37 @@ module.exports = function (RED) {
                     if (!client) {
                         client = redisConfig.getClient(msg, node, node.id);
                         if (!client) {
-                            throw new Error("Failed to initialize Redis client");
+                            node.warn("Redis configuration not available. Operation skipped.");
+                            node.status({ fill: "yellow", shape: "ring", text: "no config" });
+                            msg.payload = { error: "Redis configuration not available" };
+                            send(msg);
+                            done();
+                            return;
+                        }
+                    }
+                    
+                    // Check if client is connected before proceeding
+                    if (client.status !== 'ready' && client.status !== 'connect') {
+                        // Try to connect if not connected
+                        if (client.status === 'disconnect' || client.status === 'end') {
+                            await client.connect();
+                        } else {
+                            // Force disconnect and recreate client for other error states
+                            try {
+                                redisConfig.forceDisconnect(node.id);
+                                client = null;
+                                client = redisConfig.getClient(msg, node, node.id);
+                                if (!client) {
+                                    node.warn("Redis configuration not available during reconnection. Operation skipped.");
+                                    node.status({ fill: "yellow", shape: "ring", text: "no config" });
+                                    msg.payload = { error: "Redis configuration not available" };
+                                    send(msg);
+                                    done();
+                                    return;
+                                }
+                            } catch (reconnectError) {
+                                throw new Error(`Failed to reconnect: ${reconnectError.message}`);
+                            }
                         }
                     }
                 } catch (err) {
@@ -300,330 +330,378 @@ module.exports = function (RED) {
                         throw new Error("Missing payload");
                     }
 
-                    switch (node.operation) {
-                        case "get":
-                            let getKey = payload.key || payload;
-                            if (!getKey || typeof getKey !== 'string') {
-                                throw new Error("Missing or invalid key for GET operation. Use payload.key or payload as string");
-                            }
-                            response = await client.get(getKey);
-                            msg.payload = smartParse(response);
-                            break;
+                    // Wrap all Redis operations in try-catch to handle connection errors gracefully
+                    try {
+                        switch (node.operation) {
+                            case "get":
+                                let getKey = payload.key || payload;
+                                if (!getKey || typeof getKey !== 'string') {
+                                    throw new Error("Missing or invalid key for GET operation. Use payload.key or payload as string");
+                                }
+                                response = await client.get(getKey);
+                                msg.payload = smartParse(response);
+                                break;
 
-                        case "set":
-                            if (!payload.key) {
-                                throw new Error("Missing key for SET operation. Use payload.key");
-                            }
-                            let setValue = payload.value !== undefined ? payload.value : payload.data;
-                            if (setValue === undefined) {
-                                throw new Error("Missing value for SET operation. Use payload.value or payload.data");
-                            }
-                            setValue = smartSerialize(setValue);
-                            
-                            // Support TTL
-                            if (payload.ttl && payload.ttl > 0) {
-                                response = await client.setex(payload.key, payload.ttl, setValue);
-                            } else {
-                                response = await client.set(payload.key, setValue);
-                            }
-                            msg.payload = { success: true, result: response, ttl: payload.ttl || null };
-                            break;
+                            case "set":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for SET operation. Use payload.key");
+                                }
+                                let setValue = payload.value !== undefined ? payload.value : payload.data;
+                                if (setValue === undefined) {
+                                    throw new Error("Missing value for SET operation. Use payload.value or payload.data");
+                                }
+                                setValue = smartSerialize(setValue);
+                                
+                                // Support TTL
+                                if (payload.ttl && payload.ttl > 0) {
+                                    response = await client.setex(payload.key, payload.ttl, setValue);
+                                } else {
+                                    response = await client.set(payload.key, setValue);
+                                }
+                                msg.payload = { success: true, result: response, ttl: payload.ttl || null };
+                                break;
 
-                        case "del":
-                            let delKeys = payload.keys || payload.key || payload;
-                            if (!delKeys) {
-                                throw new Error("Missing keys for DEL operation. Use payload.keys (array) or payload.key");
-                            }
-                            let keysToDelete = Array.isArray(delKeys) ? delKeys : [delKeys];
-                            response = await client.del(...keysToDelete);
-                            msg.payload = { success: true, deleted: response, keys: keysToDelete };
-                            break;
-
-                        case "exists":
-                            let existsKeys = payload.keys || payload.key || payload;
-                            if (!existsKeys) {
-                                throw new Error("Missing keys for EXISTS operation. Use payload.keys (array) or payload.key");
-                            }
-                            let keysToCheck = Array.isArray(existsKeys) ? existsKeys : [existsKeys];
-                            response = await client.exists(...keysToCheck);
-                            msg.payload = { exists: response > 0, count: response, keys: keysToCheck };
-                            break;
-
-                        case "match":
-                            let pattern = payload.pattern || payload;
-                            if (!pattern || typeof pattern !== 'string') {
-                                throw new Error("Missing pattern for MATCH operation. Use payload.pattern or payload as string");
-                            }
-                            
-                            let count = payload.count || 100; // Default scan count
-                            let startCursor = payload.cursor || payload.skip || 0; // Support cursor/skip for pagination
-                            let allKeys = [];
-                            let cursor = startCursor;
-                            let maxIterations = 1000; // Prevent infinite loops
-                            let iterations = 0;
-                            
-                            // If skip is specified, we need to scan through keys without collecting them
-                            if (payload.skip && payload.skip > 0) {
-                                let skipped = 0;
+                            case "del":
+                                let delKeys = payload.keys || payload.key || payload;
+                                if (!delKeys) {
+                                    throw new Error("Missing keys for DEL operation. Use payload.keys (array) or payload.key");
+                                }
+                                let keysToDelete = Array.isArray(delKeys) ? delKeys : [delKeys];
+                                response = await client.del(...keysToDelete);
+                                msg.payload = { success: true, deleted: response, keys: keysToDelete };
+                                break;
+
+                            case "exists":
+                                let existsKeys = payload.keys || payload.key || payload;
+                                if (!existsKeys) {
+                                    throw new Error("Missing keys for EXISTS operation. Use payload.keys (array) or payload.key");
+                                }
+                                let keysToCheck = Array.isArray(existsKeys) ? existsKeys : [existsKeys];
+                                response = await client.exists(...keysToCheck);
+                                msg.payload = { exists: response > 0, count: response, keys: keysToCheck };
+                                break;
+
+                            case "match":
+                                let pattern = payload.pattern || payload;
+                                if (!pattern || typeof pattern !== 'string') {
+                                    throw new Error("Missing pattern for MATCH operation. Use payload.pattern or payload as string");
+                                }
+                                
+                                let count = payload.count || 100; // Default scan count
+                                let startCursor = payload.cursor || payload.skip || 0; // Support cursor/skip for pagination
+                                let allKeys = [];
+                                let cursor = startCursor;
+                                let maxIterations = 1000; // Prevent infinite loops
+                                let iterations = 0;
+                                
+                                // If skip is specified, we need to scan through keys without collecting them
+                                if (payload.skip && payload.skip > 0) {
+                                    let skipped = 0;
+                                    do {
+                                        if (iterations++ > maxIterations) {
+                                            throw new Error("Maximum scan iterations exceeded. Check your pattern or reduce skip value.");
+                                        }
+                                        const scanResult = await client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
+                                        cursor = scanResult[0];
+                                        skipped += scanResult[1].length;
+                                        
+                                        if (skipped >= payload.skip) {
+                                            // We've skipped enough, start collecting from this point
+                                            const excessSkipped = skipped - payload.skip;
+                                            if (excessSkipped > 0) {
+                                                // Add keys from current batch, excluding the excess
+                                                allKeys = scanResult[1].slice(excessSkipped);
+                                            }
+                                            break;
+                                        }
+                                    } while (cursor !== 0 && cursor !== '0');
+                                }
+                                
+                                // Continue scanning to collect keys up to the limit
                                 do {
                                     if (iterations++ > maxIterations) {
-                                        throw new Error("Maximum scan iterations exceeded. Check your pattern or reduce skip value.");
+                                        throw new Error("Maximum scan iterations exceeded. Check your pattern or reduce count value.");
                                     }
                                     const scanResult = await client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
                                     cursor = scanResult[0];
-                                    skipped += scanResult[1].length;
+                                    allKeys = allKeys.concat(scanResult[1]);
                                     
-                                    if (skipped >= payload.skip) {
-                                        // We've skipped enough, start collecting from this point
-                                        const excessSkipped = skipped - payload.skip;
-                                        if (excessSkipped > 0) {
-                                            // Add keys from current batch, excluding the excess
-                                            allKeys = scanResult[1].slice(excessSkipped);
-                                        }
+                                    // Break early if we've found enough keys
+                                    if (allKeys.length >= count) {
+                                        allKeys = allKeys.slice(0, count); // Trim to exact count
                                         break;
                                     }
                                 } while (cursor !== 0 && cursor !== '0');
-                            }
-                            
-                            // Continue scanning to collect keys up to the limit
-                            do {
-                                if (iterations++ > maxIterations) {
-                                    throw new Error("Maximum scan iterations exceeded. Check your pattern or reduce count value.");
-                                }
-                                const scanResult = await client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
-                                cursor = scanResult[0];
-                                allKeys = allKeys.concat(scanResult[1]);
                                 
-                                // Break early if we've found enough keys
-                                if (allKeys.length >= count) {
-                                    allKeys = allKeys.slice(0, count); // Trim to exact count
-                                    break;
+                                msg.payload = { 
+                                    pattern: pattern,
+                                    keys: allKeys,
+                                    count: allKeys.length,
+                                    limit: count,
+                                    cursor: cursor, // Return next cursor for pagination
+                                    startCursor: startCursor,
+                                    scanned: true,
+                                    truncated: allKeys.length === count,
+                                    iterations: iterations
+                                };
+                                break;
+
+                            // TTL Operations
+                            case "ttl":
+                                let ttlKey = payload.key || payload;
+                                if (!ttlKey || typeof ttlKey !== 'string') {
+                                    throw new Error("Missing key for TTL operation. Use payload.key or payload as string");
                                 }
-                            } while (cursor !== 0 && cursor !== '0');
-                            
-                            msg.payload = { 
-                                pattern: pattern,
-                                keys: allKeys,
-                                count: allKeys.length,
-                                limit: count,
-                                cursor: cursor, // Return next cursor for pagination
-                                startCursor: startCursor,
-                                scanned: true,
-                                truncated: allKeys.length === count,
-                                iterations: iterations
-                            };
-                            break;
+                                response = await client.ttl(ttlKey);
+                                msg.payload = { 
+                                    key: ttlKey,
+                                    ttl: response,
+                                    status: response === -1 ? "no expiration" : response === -2 ? "key not found" : "expires in " + response + " seconds"
+                                };
+                                break;
+
+                            case "expire":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for EXPIRE operation. Use payload.key");
+                                }
+                                let expireSeconds = payload.ttl || payload.seconds || payload.value || 3600;
+                                response = await client.expire(payload.key, expireSeconds);
+                                msg.payload = { 
+                                    success: response === 1,
+                                    key: payload.key,
+                                    ttl: expireSeconds,
+                                    message: response === 1 ? "Expiration set" : "Key not found"
+                                };
+                                break;
+
+                            case "persist":
+                                let persistKey = payload.key || payload;
+                                if (!persistKey || typeof persistKey !== 'string') {
+                                    throw new Error("Missing key for PERSIST operation. Use payload.key or payload as string");
+                                }
+                                response = await client.persist(persistKey);
+                                msg.payload = { 
+                                    success: response === 1,
+                                    key: persistKey,
+                                    message: response === 1 ? "Expiration removed" : "Key not found or no expiration"
+                                };
+                                break;
+
+                            // Counter Operations
+                            case "incr":
+                                let incrKey = payload.key || payload;
+                                if (!incrKey || typeof incrKey !== 'string') {
+                                    throw new Error("Missing key for INCR operation. Use payload.key or payload as string");
+                                }
+                                response = await client.incr(incrKey);
+                                msg.payload = { key: incrKey, value: response };
+                                break;
+
+                            case "decr":
+                                let decrKey = payload.key || payload;
+                                if (!decrKey || typeof decrKey !== 'string') {
+                                    throw new Error("Missing key for DECR operation. Use payload.key or payload as string");
+                                }
+                                response = await client.decr(decrKey);
+                                msg.payload = { key: decrKey, value: response };
+                                break;
 
-                        // TTL Operations
-                        case "ttl":
-                            let ttlKey = payload.key || payload;
-                            if (!ttlKey || typeof ttlKey !== 'string') {
-                                throw new Error("Missing key for TTL operation. Use payload.key or payload as string");
-                            }
-                            response = await client.ttl(ttlKey);
-                            msg.payload = { 
-                                key: ttlKey,
-                                ttl: response,
-                                status: response === -1 ? "no expiration" : response === -2 ? "key not found" : "expires in " + response + " seconds"
-                            };
-                            break;
+                            case "incrby":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for INCRBY operation. Use payload.key");
+                                }
+                                let incrAmount = payload.amount || payload.value || payload.increment || 1;
+                                response = await client.incrby(payload.key, incrAmount);
+                                msg.payload = { key: payload.key, value: response, increment: incrAmount };
+                                break;
+
+                            case "decrby":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for DECRBY operation. Use payload.key");
+                                }
+                                let decrAmount = payload.amount || payload.value || payload.decrement || 1;
+                                response = await client.decrby(payload.key, decrAmount);
+                                msg.payload = { key: payload.key, value: response, decrement: decrAmount };
+                                break;
+
+                            // List Operations
+                            case "lpush":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for LPUSH operation. Use payload.key");
+                                }
+                                let lpushValue = payload.value !== undefined ? payload.value : payload.data;
+                                if (lpushValue === undefined) {
+                                    throw new Error("Missing value for LPUSH operation. Use payload.value or payload.data");
+                                }
+                                lpushValue = smartSerialize(lpushValue);
+                                response = await client.lpush(payload.key, lpushValue);
+                                msg.payload = { success: true, result: response, key: payload.key };
+                                break;
+
+                            case "rpush":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for RPUSH operation. Use payload.key");
+                                }
+                                let rpushValue = payload.value !== undefined ? payload.value : payload.data;
+                                if (rpushValue === undefined) {
+                                    throw new Error("Missing value for RPUSH operation. Use payload.value or payload.data");
+                                }
+                                rpushValue = smartSerialize(rpushValue);
+                                response = await client.rpush(payload.key, rpushValue);
+                                msg.payload = { success: true, result: response, key: payload.key };
+                                break;
+
+                            case "lpop":
+                                let lpopKey = payload.key || payload;
+                                if (!lpopKey || typeof lpopKey !== 'string') {
+                                    throw new Error("Missing key for LPOP operation. Use payload.key or payload as string");
+                                }
+                                response = await client.lpop(lpopKey);
+                                msg.payload = smartParse(response);
+                                break;
+
+                            case "rpop":
+                                let rpopKey = payload.key || payload;
+                                if (!rpopKey || typeof rpopKey !== 'string') {
+                                    throw new Error("Missing key for RPOP operation. Use payload.key or payload as string");
+                                }
+                                response = await client.rpop(rpopKey);
+                                msg.payload = smartParse(response);
+                                break;
+
+                            case "lrange":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for LRANGE operation. Use payload.key");
+                                }
+                                let start = payload.start || payload.from || 0;
+                                let stop = payload.stop || payload.to || -1;
+                                response = await client.lrange(payload.key, start, stop);
+                                msg.payload = response.map(item => smartParse(item));
+                                break;
+
+                            case "llen":
+                                let llenKey = payload.key || payload;
+                                if (!llenKey || typeof llenKey !== 'string') {
+                                    throw new Error("Missing key for LLEN operation. Use payload.key or payload as string");
+                                }
+                                response = await client.llen(llenKey);
+                                msg.payload = { key: llenKey, length: response };
+                                break;
+
+                            // Hash Operations
+                            case "hset":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for HSET operation. Use payload.key");
+                                }
+                                let hsetField = payload.field || payload.name;
+                                let hsetValue = payload.value !== undefined ? payload.value : payload.data;
+                                if (!hsetField || hsetValue === undefined) {
+                                    throw new Error("Missing field or value for HSET operation. Use payload.field and payload.value");
+                                }
+                                hsetValue = smartSerialize(hsetValue);
+                                response = await client.hset(payload.key, hsetField, hsetValue);
+                                msg.payload = { success: true, result: response, key: payload.key, field: hsetField };
+                                break;
+
+                            case "hget":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for HGET operation. Use payload.key");
+                                }
+                                let hgetField = payload.field || payload.name;
+                                if (!hgetField) {
+                                    throw new Error("Missing field for HGET operation. Use payload.field");
+                                }
+                                response = await client.hget(payload.key, hgetField);
+                                msg.payload = smartParse(response);
+                                break;
+
+                            case "hgetall":
+                                let hgetallKey = payload.key || payload;
+                                if (!hgetallKey || typeof hgetallKey !== 'string') {
+                                    throw new Error("Missing key for HGETALL operation. Use payload.key or payload as string");
+                                }
+                                response = await client.hgetall(hgetallKey);
+                                // Parse all values in the hash
+                                const parsedHash = {};
+                                for (const [field, value] of Object.entries(response)) {
+                                    parsedHash[field] = smartParse(value);
+                                }
+                                msg.payload = parsedHash;
+                                break;
+
+                            case "hdel":
+                                if (!payload.key) {
+                                    throw new Error("Missing key for HDEL operation. Use payload.key");
+                                }
+                                let hdelFields = payload.fields || payload.field || payload.names;
+                                if (!hdelFields) {
+                                    throw new Error("Missing fields for HDEL operation. Use payload.fields (array) or payload.field");
+                                }
+                                let fieldsToDelete = Array.isArray(hdelFields) ? hdelFields : [hdelFields];
+                                response = await client.hdel(payload.key, ...fieldsToDelete);
+                                msg.payload = { success: true, deleted: response, key: payload.key, fields: fieldsToDelete };
+                                break;
+
+                            // Pub/Sub Operations
+                            case "publish":
+                                if (!payload.channel) {
+                                    throw new Error("Missing channel for PUBLISH operation. Use payload.channel");
+                                }
+                                let publishMessage = payload.message !== undefined ? payload.message : payload.data;
+                                if (publishMessage === undefined) {
+                                    throw new Error("Missing message for PUBLISH operation. Use payload.message or payload.data");
+                                }
+                                publishMessage = smartSerialize(publishMessage);
+                                response = await client.publish(payload.channel, publishMessage);
+                                msg.payload = { success: true, subscribers: response, channel: payload.channel };
+                                break;
 
-                        case "expire":
-                            if (!payload.key) {
-                                throw new Error("Missing key for EXPIRE operation. Use payload.key");
+                            default:
+                                throw new Error(`Unknown operation: ${node.operation}`);
+                        }
+                    } catch (redisError) {
+                        // Handle Redis-specific errors (connection, command errors, etc.)
+                        if (redisError.message.includes('ECONNREFUSED') || 
+                            redisError.message.includes('ENOTFOUND') ||
+                            redisError.message.includes('ETIMEDOUT')) {
+                            // Connection-related errors - force disconnect to prevent dead connections
+                            if (client) {
+                                try {
+                                    redisConfig.forceDisconnect(node.id);
+                                    client = null;
+                                } catch (e) {
+                                    // Ignore disconnect errors
+                                }
                             }
-                            let expireSeconds = payload.ttl || payload.seconds || payload.value || 3600;
-                            response = await client.expire(payload.key, expireSeconds);
+                            
                             msg.payload = { 
-                                success: response === 1,
-                                key: payload.key,
-                                ttl: expireSeconds,
-                                message: response === 1 ? "Expiration set" : "Key not found"
+                                error: `Redis connection failed: ${redisError.message}`,
+                                operation: node.operation,
+                                retryable: true
                             };
-                            break;
-
-                        case "persist":
-                            let persistKey = payload.key || payload;
-                            if (!persistKey || typeof persistKey !== 'string') {
-                                throw new Error("Missing key for PERSIST operation. Use payload.key or payload as string");
-                            }
-                            response = await client.persist(persistKey);
+                            node.status({ fill: "red", shape: "ring", text: "connection failed" });
+                        } else {
+                            // Other Redis errors (command errors, etc.)
                             msg.payload = { 
-                                success: response === 1,
-                                key: persistKey,
-                                message: response === 1 ? "Expiration removed" : "Key not found or no expiration"
+                                error: `Redis operation failed: ${redisError.message}`,
+                                operation: node.operation,
+                                retryable: false
                             };
-                            break;
-
-                        // Counter Operations
-                        case "incr":
-                            let incrKey = payload.key || payload;
-                            if (!incrKey || typeof incrKey !== 'string') {
-                                throw new Error("Missing key for INCR operation. Use payload.key or payload as string");
-                            }
-                            response = await client.incr(incrKey);
-                            msg.payload = { key: incrKey, value: response };
-                            break;
-
-                        case "decr":
-                            let decrKey = payload.key || payload;
-                            if (!decrKey || typeof decrKey !== 'string') {
-                                throw new Error("Missing key for DECR operation. Use payload.key or payload as string");
-                            }
-                            response = await client.decr(decrKey);
-                            msg.payload = { key: decrKey, value: response };
-                            break;
-
-                        case "incrby":
-                            if (!payload.key) {
-                                throw new Error("Missing key for INCRBY operation. Use payload.key");
-                            }
-                            let incrAmount = payload.amount || payload.value || payload.increment || 1;
-                            response = await client.incrby(payload.key, incrAmount);
-                            msg.payload = { key: payload.key, value: response, increment: incrAmount };
-                            break;
-
-                        case "decrby":
-                            if (!payload.key) {
-                                throw new Error("Missing key for DECRBY operation. Use payload.key");
-                            }
-                            let decrAmount = payload.amount || payload.value || payload.decrement || 1;
-                            response = await client.decrby(payload.key, decrAmount);
-                            msg.payload = { key: payload.key, value: response, decrement: decrAmount };
-                            break;
-
-                        // List Operations
-                        case "lpush":
-                        case "rpush":
-                            if (!payload.key) {
-                                throw new Error(`Missing key for ${node.operation.toUpperCase()} operation. Use payload.key`);
-                            }
-                            let pushValue = payload.value !== undefined ? payload.value : payload.data;
-                            if (pushValue === undefined) {
-                                throw new Error(`Missing value for ${node.operation.toUpperCase()} operation. Use payload.value or payload.data`);
-                            }
-                            pushValue = smartSerialize(pushValue);
-                            response = await client[node.operation](payload.key, pushValue);
-                            msg.payload = { success: true, key: payload.key, length: response, operation: node.operation };
-                            break;
-
-                        case "lpop":
-                        case "rpop":
-                            let popKey = payload.key || payload;
-                            if (!popKey || typeof popKey !== 'string') {
-                                throw new Error(`Missing key for ${node.operation.toUpperCase()} operation. Use payload.key or payload as string`);
-                            }
-                            response = await client[node.operation](popKey);
-                            msg.payload = smartParse(response);
-                            break;
-
-                        case "llen":
-                            let llenKey = payload.key || payload;
-                            if (!llenKey || typeof llenKey !== 'string') {
-                                throw new Error("Missing key for LLEN operation. Use payload.key or payload as string");
-                            }
-                            response = await client.llen(llenKey);
-                            msg.payload = { key: llenKey, length: response };
-                            break;
-
-                        case "lrange":
-                            if (!payload.key) {
-                                throw new Error("Missing key for LRANGE operation. Use payload.key");
-                            }
-                            let start = payload.start !== undefined ? payload.start : 0;
-                            let stop = payload.stop !== undefined ? payload.stop : -1;
-                            response = await client.lrange(payload.key, start, stop);
-                            // Auto-parse each item in the array
-                            response = response.map(item => smartParse(item));
-                            msg.payload = { key: payload.key, range: { start, stop }, values: response, count: response.length };
-                            break;
-
-                        // Hash Operations
-                        case "hset":
-                            if (!payload.key) {
-                                throw new Error("Missing key for HSET operation. Use payload.key");
-                            }
-                            if (payload.field && payload.value !== undefined) {
-                                // Single field
-                                let hashValue = smartSerialize(payload.value);
-                                response = await client.hset(payload.key, payload.field, hashValue);
-                                msg.payload = { success: true, key: payload.key, field: payload.field, created: response === 1 };
-                            } else if (payload.fields && typeof payload.fields === 'object') {
-                                // Multiple fields from payload.fields
-                                const fields = {};
-                                for (const [key, value] of Object.entries(payload.fields)) {
-                                    fields[key] = smartSerialize(value);
-                                }
-                                response = await client.hset(payload.key, fields);
-                                msg.payload = { success: true, key: payload.key, fields: Object.keys(fields), created: response };
-                            } else {
-                                throw new Error("HSET requires field and value (payload.field, payload.value) or multiple fields (payload.fields)");
-                            }
-                            break;
-
-                        case "hget":
-                            if (!payload.key) {
-                                throw new Error("Missing key for HGET operation. Use payload.key");
-                            }
-                            let field = payload.field;
-                            if (!field) {
-                                throw new Error("Missing field for HGET operation. Use payload.field");
-                            }
-                            response = await client.hget(payload.key, field);
-                            msg.payload = smartParse(response);
-                            break;
-
-                        case "hgetall":
-                            let hgetallKey = payload.key || payload;
-                            if (!hgetallKey || typeof hgetallKey !== 'string') {
-                                throw new Error("Missing key for HGETALL operation. Use payload.key or payload as string");
-                            }
-                            response = await client.hgetall(hgetallKey);
-                            // Auto-parse each field value
-                            const parsed = {};
-                            for (const [key, value] of Object.entries(response)) {
-                                parsed[key] = smartParse(value);
-                            }
-                            msg.payload = parsed;
-                            break;
-
-                        case "hdel":
-                            if (!payload.key) {
-                                throw new Error("Missing key for HDEL operation. Use payload.key");
-                            }
-                            let fieldsToDelete = payload.fields || payload.field;
-                            if (!fieldsToDelete) {
-                                throw new Error("Missing fields for HDEL operation. Use payload.fields (array) or payload.field");
-                            }
-                            fieldsToDelete = Array.isArray(fieldsToDelete) ? fieldsToDelete : [fieldsToDelete];
-                            response = await client.hdel(payload.key, ...fieldsToDelete);
-                            msg.payload = { success: true, key: payload.key, deleted: response, fields: fieldsToDelete };
-                            break;
-
-                        case "publish":
-                            let channel = payload.channel || payload.key;
-                            if (!channel) {
-                                throw new Error("Missing channel for PUBLISH operation. Use payload.channel or payload.key");
-                            }
-                            let pubValue = payload.message || payload.value || payload.data;
-                            if (pubValue === undefined) {
-                                throw new Error("Missing message for PUBLISH operation. Use payload.message, payload.value, or payload.data");
-                            }
-                            pubValue = smartSerialize(pubValue);
-                            response = await client.publish(channel, pubValue);
-                            msg.payload = { success: true, channel: channel, subscribers: response, message: pubValue };
-                            break;
-
-                        default:
-                            throw new Error(`Unsupported operation: ${node.operation}`);
+                        }
+                        send(msg);
+                        done();
+                        return;
                     }
 
+                    // Update node status on success
+                    node.status({ fill: "green", shape: "dot", text: node.operation });
                     send(msg);
                     done();
 
-                } catch (err) {
-                    node.error(err.message, msg);
-                    msg.payload = { error: err.message };
+                } catch (error) {
+                    // Handle general errors (validation, etc.)
+                    node.error(error.message, msg);
+                    msg.payload = { error: error.message };
                     send(msg);
                     done();
                 }