node-red-contrib-redis-variable 1.0.0

package/redis-variable-config.js

@@ -0,0 +1,363 @@
+const Redis = require("ioredis");
+
+module.exports = function (RED) {
+    let connections = {};
+    let usedConn = {};
+
+    /**
+     * Helper function to get value from different contexts
+     * @param {Object} node - Node instance
+     * @param {string} value - Value to get
+     * @param {string} type - Type of value (str, flow, global, env)
+     * @param {Object} msg - Message object
+     * @returns {string} Retrieved value
+     */
+    function getValueFromContext(node, value, type, msg) {
+        if (value === null || value === undefined) return null;
+
+        try {
+            let result;
+            switch (type) {
+                case 'flow':
+                    const flowContext = node.context().flow;
+                    if (!flowContext) {
+                        return null;
+                    }
+                    result = getNestedValue(flowContext, value);
+                    break;
+                case 'global':
+                    const globalContext = node.context().global;
+                    if (!globalContext) {
+                        return null;
+                    }
+                    result = getNestedValue(globalContext, value);
+                    break;
+                case 'env':
+                    result = process.env[value];
+                    break;
+                case 'msg':
+                    result = RED.util.getMessageProperty(msg, value);
+                    break;
+                default:
+                    result = value;
+            }
+
+            return result !== undefined ? result : null;
+        } catch (err) {
+            throw new Error(`Failed to get value for type: ${type}, value: ${value}. Error: ${err.message}`);
+        }
+    }
+
+    // Helper function to get nested values like "redis_config.host"
+    function getNestedValue(context, path) {
+        if (!context) return undefined;
+        
+        if (path.includes('.')) {
+            const parts = path.split('.');
+            let result = context.get(parts[0]);
+            for (let i = 1; i < parts.length; i++) {
+                if (result && typeof result === 'object') {
+                    result = result[parts[i]];
+                } else {
+                    return undefined;
+                }
+            }
+            return result;
+        } else {
+            return context.get(path);
+        }
+    }
+
+    function RedisConfigNode(config) {
+        RED.nodes.createNode(this, config);
+        this.name = config.name || "Redis Config";
+        this.cluster = config.cluster || false;
+        
+        // Connection configuration
+        this.hostType = config.hostType || 'str';
+        this.host = config.host || 'localhost';
+        this.hostContext = config.hostContext;
+        this.port = config.port || 6379;
+        this.portType = config.portType || 'str';
+        this.portContext = config.portContext;
+        
+        // Authentication
+        this.passwordType = config.passwordType || 'str';
+        this.password = config.password;
+        this.passwordContext = config.passwordContext;
+        this.username = config.username;
+        this.usernameType = config.usernameType || 'str';
+        this.usernameContext = config.usernameContext;
+        
+        // SSL/TLS Configuration
+        this.enableTLS = config.enableTLS || false;
+        this.tlsRejectUnauthorized = config.tlsRejectUnauthorized !== false; // Default to true
+        this.tlsCertType = config.tlsCertType || 'str';
+        this.tlsCertContext = config.tlsCertContext;
+        this.tlsKeyType = config.tlsKeyType || 'str';
+        this.tlsKeyContext = config.tlsKeyContext;
+        this.tlsCaType = config.tlsCaType || 'str';
+        this.tlsCaContext = config.tlsCaContext;
+        
+        // Database and other options
+        this.database = config.database || 0;
+        this.databaseType = config.databaseType || 'str';
+        this.databaseContext = config.databaseContext;
+        
+        // Advanced options
+        this.optionsType = config.optionsType || 'json';
+        this.options = config.options || '{}';
+        this.optionsContext = config.optionsContext;
+
+        // Get credentials for string passwords
+        const credentials = this.credentials || {};
+
+        // Helper method to parse credential values
+        this.parseCredentialValue = function(value, type, msg, executingNode) {
+            if (!value && value !== 0) {
+                return null;
+            }
+            
+            try {
+                let result;
+                switch (type) {
+                    case 'str':
+                        result = value;
+                        break;
+                    case 'flow':
+                        result = getValueFromContext(executingNode || this, value, 'flow', msg);
+                        break;
+                    case 'global':
+                        result = getValueFromContext(executingNode || this, value, 'global', msg);
+                        break;
+                    case 'env':
+                        result = process.env[value] || null;
+                        break;
+                    case 'json':
+                        try {
+                            result = JSON.parse(value);
+                        } catch (e) {
+                            result = value;
+                        }
+                        break;
+                    case 'num':
+                        result = Number(value);
+                        break;
+                    default:
+                        result = value;
+                }
+                return result;
+            } catch (error) {
+                if (executingNode) {
+                    executingNode.error(`Error parsing credential value: ${error.message}`);
+                }
+                return null;
+            }
+        };
+
+        // Get Redis connection options
+        this.getConnectionOptions = function(msg, executingNode) {
+            try {
+                // Parse host
+                let host = this.parseCredentialValue(
+                    this.hostType === 'str' ? this.host : this.hostContext, 
+                    this.hostType, 
+                    msg, 
+                    executingNode
+                ) || 'localhost';
+
+                // Parse port
+                let port = this.parseCredentialValue(
+                    this.portType === 'str' ? this.port : this.portContext,
+                    this.portType,
+                    msg,
+                    executingNode
+                ) || 6379;
+
+                // Parse database
+                let database = this.parseCredentialValue(
+                    this.databaseType === 'str' ? this.database : this.databaseContext,
+                    this.databaseType,
+                    msg,
+                    executingNode
+                ) || 0;
+
+                // Parse password
+                let password = null;
+                if (this.passwordType === 'str') {
+                    password = this.credentials?.password;
+                } else {
+                    password = this.parseCredentialValue(this.passwordContext, this.passwordType, msg, executingNode);
+                }
+
+                // Parse username
+                let username = null;
+                if (this.usernameType === 'str') {
+                    username = this.credentials?.username;
+                } else {
+                    username = this.parseCredentialValue(this.usernameContext, this.usernameType, msg, executingNode);
+                }
+
+                // Parse additional options
+                let additionalOptions = {};
+                if (this.optionsType === 'json') {
+                    try {
+                        additionalOptions = JSON.parse(this.options || '{}');
+                    } catch (e) {
+                        additionalOptions = {};
+                    }
+                } else {
+                    additionalOptions = this.parseCredentialValue(this.optionsContext, this.optionsType, msg, executingNode) || {};
+                }
+
+                // Build connection options
+                const connectionOptions = {
+                    host: host,
+                    port: parseInt(port),
+                    db: parseInt(database),
+                    retryDelayOnFailover: 100,
+                    enableReadyCheck: false,
+                    maxRetriesPerRequest: null,
+                    ...additionalOptions
+                };
+
+                // Add authentication if provided
+                if (password) {
+                    connectionOptions.password = password;
+                }
+                if (username) {
+                    connectionOptions.username = username;
+                }
+
+                // Add SSL/TLS configuration if enabled
+                if (this.enableTLS) {
+                    connectionOptions.tls = {
+                        rejectUnauthorized: this.tlsRejectUnauthorized
+                    };
+
+                    // Parse TLS Certificate
+                    let tlsCert = null;
+                    if (this.tlsCertType === 'str') {
+                        tlsCert = this.credentials?.tlsCert;
+                    } else {
+                        tlsCert = this.parseCredentialValue(this.tlsCertContext, this.tlsCertType, msg, executingNode);
+                    }
+
+                    // Parse TLS Key
+                    let tlsKey = null;
+                    if (this.tlsKeyType === 'str') {
+                        tlsKey = this.credentials?.tlsKey;
+                    } else {
+                        tlsKey = this.parseCredentialValue(this.tlsKeyContext, this.tlsKeyType, msg, executingNode);
+                    }
+
+                    // Parse TLS CA
+                    let tlsCa = null;
+                    if (this.tlsCaType === 'str') {
+                        tlsCa = this.credentials?.tlsCa;
+                    } else {
+                        tlsCa = this.parseCredentialValue(this.tlsCaContext, this.tlsCaType, msg, executingNode);
+                    }
+
+                    // Add TLS options if provided
+                    if (tlsCert && tlsKey) {
+                        connectionOptions.tls.cert = tlsCert;
+                        connectionOptions.tls.key = tlsKey;
+                    }
+
+                    if (tlsCa) {
+                        connectionOptions.tls.ca = tlsCa;
+                    }
+
+                    // If using custom CA or self-signed certificates, might need to disable rejection
+                    if (!this.tlsRejectUnauthorized) {
+                        connectionOptions.tls.rejectUnauthorized = false;
+                    }
+                }
+
+                return connectionOptions;
+
+            } catch (error) {
+                if (executingNode) {
+                    executingNode.error(`Failed to get Redis connection options: ${error.message}`);
+                }
+                throw error;
+            }
+        };
+
+        // Get Redis client
+        this.getClient = function(msg, executingNode, nodeId) {
+            try {
+                const id = nodeId || this.id;
+                
+                // Return existing connection if available
+                if (connections[id]) {
+                    usedConn[id]++;
+                    return connections[id];
+                }
+
+                const options = this.getConnectionOptions(msg, executingNode);
+
+                // 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];
+                    client = new Redis.Cluster(clusterNodes);
+                } else {
+                    client = new Redis(options);
+                }
+
+                // Handle connection errors
+                client.on("error", (e) => {
+                    if (executingNode) {
+                        executingNode.error(`Redis connection error: ${e.message}`, {});
+                    } else {
+                        this.error(`Redis connection error: ${e.message}`, {});
+                    }
+                });
+
+                // Store connection
+                connections[id] = client;
+                if (usedConn[id] === undefined) {
+                    usedConn[id] = 1;
+                } else {
+                    usedConn[id]++;
+                }
+
+                return client;
+
+            } catch (error) {
+                if (executingNode) {
+                    executingNode.error(`Failed to create Redis client: ${error.message}`);
+                }
+                throw error;
+            }
+        };
+
+        // Disconnect method
+        this.disconnect = function(nodeId) {
+            const id = nodeId || this.id;
+            if (usedConn[id] !== undefined) {
+                usedConn[id]--;
+            }
+            if (connections[id] && usedConn[id] <= 0) {
+                connections[id].disconnect();
+                delete connections[id];
+                delete usedConn[id];
+            }
+        };
+
+        // Clean up on node close
+        this.on('close', function() {
+            this.disconnect();
+        });
+    }
+
+    RED.nodes.registerType("redis-variable-config", RedisConfigNode, {
+        credentials: {
+            password: { type: "password" },
+            username: { type: "text" }
+        }
+    });
+}; 

package/redis-variable.html

@@ -0,0 +1,284 @@
+<script type="text/javascript">
+    RED.nodes.registerType("redis-variable", {
+        category: "Redis",
+        color: "#D8BFD8",
+        defaults: {
+            name: { value: "" },
+            redisConfig: { value: "", type: "redis-variable-config" },
+            operation: { value: "get" }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-database",
+        label: function() {
+            return this.name || "Redis (" + (this.operation || "get") + ")";
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="redis-variable">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-redisConfig"><i class="fa fa-cog"></i> Redis Config</label>
+        <input type="text" id="node-input-redisConfig">
+    </div>
+    <div class="form-row">
+        <label for="node-input-operation"><i class="fa fa-tasks"></i> Operation</label>
+        <select id="node-input-operation">
+            <optgroup label="Basic Operations">
+                <option value="get">GET - Get value</option>
+                <option value="set">SET - Set value</option>
+                <option value="del">DEL - Delete key</option>
+                <option value="exists">EXISTS - Check if key exists</option>
+            </optgroup>
+            <optgroup label="TTL Operations">
+                <option value="ttl">TTL - Get time to live</option>
+                <option value="expire">EXPIRE - Set expiration</option>
+                <option value="persist">PERSIST - Remove expiration</option>
+            </optgroup>
+            <optgroup label="Counter Operations">
+                <option value="incr">INCR - Increment by 1</option>
+                <option value="decr">DECR - Decrement by 1</option>
+                <option value="incrby">INCRBY - Increment by N</option>
+                <option value="decrby">DECRBY - Decrement by N</option>
+            </optgroup>
+            <optgroup label="List Operations">
+                <option value="lpush">LPUSH - Push to left</option>
+                <option value="rpush">RPUSH - Push to right</option>
+                <option value="lpop">LPOP - Pop from left</option>
+                <option value="rpop">RPOP - Pop from right</option>
+                <option value="llen">LLEN - List length</option>
+                <option value="lrange">LRANGE - Get range</option>
+            </optgroup>
+            <optgroup label="Hash Operations">
+                <option value="hset">HSET - Set hash field</option>
+                <option value="hget">HGET - Get hash field</option>
+                <option value="hgetall">HGETALL - Get all fields</option>
+                <option value="hdel">HDEL - Delete hash field</option>
+            </optgroup>
+            <optgroup label="Pub/Sub Operations">
+                <option value="publish">PUBLISH - Publish message</option>
+            </optgroup>
+        </select>
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="redis-variable">
+    <p>Redis node for comprehensive operations with universal payload-based configuration.</p>
+    
+    <h3>Configuration</h3>
+    <p>Select or create a Redis configuration that contains your connection settings.</p>
+    
+    <h3>Operations</h3>
+    
+    <h4>Basic Operations</h4>
+    <ul>
+        <li><b>GET</b>: Retrieve value by key</li>
+        <li><b>SET</b>: Store value with key (supports TTL)</li>
+        <li><b>DEL</b>: Delete key(s)</li>
+        <li><b>EXISTS</b>: Check if key(s) exist</li>
+    </ul>
+    
+    <h4>TTL Operations</h4>
+    <ul>
+        <li><b>TTL</b>: Get remaining time to live in seconds</li>
+        <li><b>EXPIRE</b>: Set expiration time for existing key</li>
+        <li><b>PERSIST</b>: Remove expiration from key</li>
+    </ul>
+    
+    <h4>Counter Operations</h4>
+    <ul>
+        <li><b>INCR</b>: Increment value by 1</li>
+        <li><b>DECR</b>: Decrement value by 1</li>
+        <li><b>INCRBY</b>: Increment value by N</li>
+        <li><b>DECRBY</b>: Decrement value by N</li>
+    </ul>
+    
+    <h4>List Operations</h4>
+    <ul>
+        <li><b>LPUSH</b>: Add element to beginning of list</li>
+        <li><b>RPUSH</b>: Add element to end of list</li>
+        <li><b>LPOP</b>: Remove and return first element</li>
+        <li><b>RPOP</b>: Remove and return last element</li>
+        <li><b>LLEN</b>: Get list length</li>
+        <li><b>LRANGE</b>: Get range of elements</li>
+    </ul>
+    
+    <h4>Hash Operations</h4>
+    <ul>
+        <li><b>HSET</b>: Set hash field value</li>
+        <li><b>HGET</b>: Get hash field value</li>
+        <li><b>HGETALL</b>: Get all hash fields</li>
+        <li><b>HDEL</b>: Delete hash field(s)</li>
+    </ul>
+    
+    <h4>Pub/Sub Operations</h4>
+    <ul>
+        <li><b>PUBLISH</b>: Publish message to channel</li>
+    </ul>
+    
+    <h3>Universal Payload Format</h3>
+    <p>All parameters are passed via <code>msg.payload</code>. The payload can be a string (for simple operations) or an object with specific properties.</p>
+    
+    <h3>Examples</h3>
+    
+    <h4>Basic Operations</h4>
+    <pre>// GET - simple format
+{
+  "payload": "user:123"
+}
+
+// GET - object format
+{
+  "payload": {"key": "user:123"}
+}
+
+// SET with value
+{
+  "payload": {
+    "key": "user:123",
+    "value": "John Doe"
+  }
+}
+
+// SET with TTL (expires in 1 hour)
+{
+  "payload": {
+    "key": "session:abc123",
+    "value": {"userId": 42, "role": "admin"},
+    "ttl": 3600
+  }
+}
+
+// DELETE multiple keys
+{
+  "payload": {
+    "keys": ["cache:page1", "cache:page2", "temp:data"]
+  }
+}</pre>
+    
+    <h4>TTL Operations</h4>
+    <pre>// Check TTL
+{
+  "payload": "session:abc123"
+}
+
+// Set expiration
+{
+  "payload": {
+    "key": "temp:data",
+    "ttl": 1800
+  }
+}
+
+// Remove expiration
+{
+  "payload": "permanent:key"
+}</pre>
+    
+    <h4>Counter Operations</h4>
+    <pre>// Increment by 1
+{
+  "payload": "page:views"
+}
+
+// Increment by amount
+{
+  "payload": {
+    "key": "score:player1",
+    "amount": 100
+  }
+}</pre>
+    
+    <h4>List Operations</h4>
+    <pre>// Add to list
+{
+  "payload": {
+    "key": "queue:tasks",
+    "value": {"task": "process_order", "id": 123}
+  }
+}
+
+// Get range
+{
+  "payload": {
+    "key": "queue:tasks",
+    "start": 0,
+    "stop": 9
+  }
+}
+
+// Pop from list
+{
+  "payload": "queue:tasks"
+}</pre>
+    
+    <h4>Hash Operations</h4>
+    <pre>// Set single field
+{
+  "payload": {
+    "key": "user:123",
+    "field": "email",
+    "value": "user@example.com"
+  }
+}
+
+// Set multiple fields
+{
+  "payload": {
+    "key": "user:123",
+    "fields": {
+      "name": "John Doe",
+      "age": 30,
+      "city": "New York"
+    }
+  }
+}
+
+// Get field
+{
+  "payload": {
+    "key": "user:123",
+    "field": "email"
+  }
+}
+
+// Get all fields
+{
+  "payload": "user:123"
+}</pre>
+    
+    <h4>Pub/Sub Operations</h4>
+    <pre>// Publish message
+{
+  "payload": {
+    "channel": "notifications",
+    "message": {
+      "type": "alert",
+      "text": "System maintenance"
+    }
+  }
+}</pre>
+    
+    <h3>Automatic JSON Handling</h3>
+    <p>The node automatically detects and handles JSON data:</p>
+    <ul>
+        <li><b>When storing</b>: JavaScript objects are automatically serialized to JSON strings</li>
+        <li><b>When retrieving</b>: Valid JSON strings are automatically parsed back to objects</li>
+        <li><b>Simple values</b>: Strings, numbers, and other simple types are handled as-is</li>
+        <li>Applies to all operations that handle values (GET, SET, lists, hashes, pub/sub)</li>
+    </ul>
+    
+    <h3>Output Examples</h3>
+    <ul>
+        <li><b>GET</b>: Returns the stored value (auto-parsed if JSON)</li>
+        <li><b>SET</b>: <code>{ success: true, result: "OK", ttl: 3600 }</code></li>
+        <li><b>TTL</b>: <code>{ key: "mykey", ttl: 3600, status: "expires in 3600 seconds" }</code></li>
+        <li><b>INCR</b>: <code>{ key: "counter", value: 42 }</code></li>
+        <li><b>LPUSH</b>: <code>{ success: true, key: "list", length: 5, operation: "lpush" }</code></li>
+        <li><b>HGETALL</b>: <code>{ name: "John", age: 30, email: "john@example.com" }</code> (auto-parsed)</li>
+    </ul>
+</script>