node-red-contrib-redis-variable 1.5.1 → 1.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-redis-variable",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "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

@@ -265,6 +265,7 @@ module.exports = function (RED) {
                     retryDelayOnFailover: 100,
                     enableReadyCheck: false,
                     maxRetriesPerRequest: null,
+                    enableOfflineQueue: false,
                     ...additionalOptions
                 };
 
@@ -385,9 +386,23 @@ module.exports = function (RED) {
                 // Create Redis client
                 let client;
                 if (this.cluster) {
-                    // For cluster mode, options should be an array of nodes
-                    const clusterNodes = Array.isArray(connectionOptions) ? connectionOptions : [connectionOptions];
-                    client = new Redis.Cluster(clusterNodes);
+                    // ioredis Cluster: first arg = startup nodes [{ host, port }], second = options with redisOptions
+                    const clusterNodes = [{ host: options.host, port: parseInt(options.port, 10) }];
+                    const clusterOptions = {
+                        enableReadyCheck: false,
+                        lazyConnect: true,
+                        maxRetriesPerRequest: 3,
+                        enableOfflineQueue: false,
+                        redisOptions: {
+                            username: options.username || undefined,
+                            password: options.password || undefined,
+                            db: 0,
+                            connectTimeout: connectionOptions.connectTimeout || 5000,
+                            commandTimeout: connectionOptions.commandTimeout || 3000,
+                            tls: connectionOptions.tls || undefined,
+                        },
+                    };
+                    client = new Redis.Cluster(clusterNodes, clusterOptions);
                 } else {
                     client = new Redis(connectionOptions);
                 }

package/redis-variable.js

@@ -309,6 +309,21 @@ module.exports = function (RED) {
                 send = send || function() { node.send.apply(node, arguments) };
                 done = done || function(err) { if(err) node.error(err, msg); };
 
+                // Ensure we only send and call done once per message
+                let completed = false;
+                const finish = (err) => {
+                    if (completed) return;
+                    completed = true;
+                    if (err) node.error(err.message || err, msg);
+                    done(err);
+                };
+                const sendAndDone = (m) => {
+                    if (completed) return;
+                    completed = true;
+                    send(m);
+                    done();
+                };
+
                 if (!running) {
                     running = true;
                 }
@@ -317,8 +332,7 @@ module.exports = function (RED) {
                 if (!redisConfig) {
                     node.error("Redis configuration not found", msg);
                     msg.payload = { error: "Redis configuration not found" };
-                    send(msg);
-                    done();
+                    sendAndDone(msg);
                     return;
                 }
 
@@ -337,8 +351,7 @@ module.exports = function (RED) {
                 } catch (configError) {
                     node.error(configError.message, msg);
                     msg.payload = { error: configError.message };
-                    send(msg);
-                    done();
+                    sendAndDone(msg);
                     return;
                 }
 
@@ -350,43 +363,55 @@ module.exports = function (RED) {
                             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();
+                            sendAndDone(msg);
                             return;
                         }
                     }
 
-                    // Check if client is connected before proceeding
+                    // Ensure client is connected before running commands
                     if (client.status !== 'ready' && client.status !== 'connect') {
-                        // Try to connect if not connected
-                        if (client.status === 'wait') {
-                            await client.connect();
-                        } else if (client.status === 'disconnect' || client.status === 'end') {
-                            await client.connect();
-                        } else {
-                            // Force disconnect and recreate client for other error states
-                            try {
+                        const CONNECT_WAIT_MS = 15000;
+                        const waitForReady = () => new Promise((resolve, reject) => {
+                            // If connection already established, resolve immediately
+                            if (client.status === 'ready' || client.status === 'connect') {
+                                resolve();
+                                return;
+                            }
+                            const timeout = setTimeout(() => reject(new Error('Connection timeout')), CONNECT_WAIT_MS);
+                            const onReady = () => { clearTimeout(timeout); cleanup(); resolve(); };
+                            const onError = (e) => { clearTimeout(timeout); cleanup(); reject(e); };
+                            const cleanup = () => {
+                                client.removeListener('ready', onReady);
+                                client.removeListener('connect', onReady);
+                                client.removeListener('error', onError);
+                            };
+                            client.once('ready', onReady);
+                            client.once('connect', onReady);
+                            client.once('error', onError);
+                        });
+                        try {
+                            if (client.status === 'connecting') {
+                                // Already connecting: wait for ready, do not call connect() again
+                                await waitForReady();
+                            } else if (typeof client.connect === 'function') {
+                                await client.connect();
+                            }
+                        } catch (connectErr) {
+                            const msg = connectErr.message || String(connectErr);
+                            if (msg.includes('already connecting') || msg.includes('already connected')) {
+                                // Race: another message triggered connect; wait for ready
+                                await waitForReady();
+                            } else {
                                 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}`);
+                                throw new Error(`Failed to connect: ${msg}`);
                             }
                         }
                     }
                 } catch (err) {
                     node.error(err.message, msg);
                     msg.payload = { error: err.message };
-                    send(msg);
-                    done();
+                    sendAndDone(msg);
                     return;
                 }
 
@@ -403,8 +428,33 @@ module.exports = function (RED) {
                     try {
                         switch (node.operation) {
                             case "get":
-                                let getKey = payload.key || payload;
-                                if (!getKey || typeof getKey !== 'string') {
+                                let getKey;
+                                if (typeof payload === 'string' && isJsonString(payload)) {
+                                    try {
+                                        const parsed = JSON.parse(payload);
+                                        getKey = parsed.key !== undefined ? parsed.key : parsed.Key;
+                                    } catch (e) {
+                                        getKey = payload;
+                                    }
+                                } else if (Buffer.isBuffer(payload)) {
+                                    getKey = payload.toString();
+                                } else if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+                                    if (payload.key !== undefined || payload.Key !== undefined) {
+                                        getKey = payload.key !== undefined ? payload.key : payload.Key;
+                                    } else if (payload.payload && typeof payload.payload === 'object') {
+                                        const nested = payload.payload;
+                                        if (nested.key !== undefined || nested.Key !== undefined) {
+                                            getKey = nested.key !== undefined ? nested.key : nested.Key;
+                                        }
+                                    }
+                                } else {
+                                    getKey = payload;
+                                }
+                                if (getKey === undefined || getKey === null) {
+                                    throw new Error("Missing or invalid key for GET operation. Use payload.key or payload as string");
+                                }
+                                getKey = String(getKey).trim();
+                                if (!getKey) {
                                     throw new Error("Missing or invalid key for GET operation. Use payload.key or payload as string");
                                 }
                                 response = await client.get(getKey);
@@ -770,22 +820,19 @@ module.exports = function (RED) {
                                 retryable: false
                             };
                         }
-                        send(msg);
-                        done();
+                        sendAndDone(msg);
                         return;
                     }
 
                     // Update node status on success
                     node.status({ fill: "green", shape: "dot", text: node.operation });
-                    send(msg);
-                    done();
+                    sendAndDone(msg);
 
                 } catch (error) {
                     // Handle general errors (validation, etc.)
                     node.error(error.message, msg);
                     msg.payload = { error: error.message };
-                    send(msg);
-                    done();
+                    sendAndDone(msg);
                 }
             });
         }