node-red-contrib-event-calc 0.1.1

package/nodes/event-calc.js

@@ -0,0 +1,217 @@
+/**
+ * event-calc - Calculation node for multi-topic expressions
+ *
+ * Features:
+ * - Maps multiple variables to topic patterns
+ * - Evaluates JavaScript expressions when inputs update
+ * - Trigger modes: 'any' (any input updates) or 'all' (all inputs have values)
+ * - Safe expression evaluation using Function constructor
+ * - Dynamic expression update via input message
+ * - Built-in helper functions for common operations
+ */
+module.exports = function(RED) {
+    // Helper functions available in expressions
+    const helpers = {
+        // Math shortcuts
+        min: (...args) => Math.min(...args.flat()),
+        max: (...args) => Math.max(...args.flat()),
+        abs: (x) => Math.abs(x),
+        sqrt: (x) => Math.sqrt(x),
+        pow: (base, exp) => Math.pow(base, exp),
+        log: (x) => Math.log(x),
+        log10: (x) => Math.log10(x),
+        exp: (x) => Math.exp(x),
+        floor: (x) => Math.floor(x),
+        ceil: (x) => Math.ceil(x),
+        sin: (x) => Math.sin(x),
+        cos: (x) => Math.cos(x),
+        tan: (x) => Math.tan(x),
+        PI: Math.PI,
+        E: Math.E,
+
+        // Aggregation
+        sum: (...args) => args.flat().reduce((a, b) => a + b, 0),
+        avg: (...args) => {
+            const flat = args.flat();
+            return flat.length > 0 ? flat.reduce((a, b) => a + b, 0) / flat.length : 0;
+        },
+        count: (...args) => args.flat().length,
+
+        // Utility
+        round: (value, decimals = 0) => {
+            const factor = Math.pow(10, decimals);
+            return Math.round(value * factor) / factor;
+        },
+        clamp: (value, min, max) => Math.min(Math.max(value, min), max),
+        map: (value, inMin, inMax, outMin, outMax) => {
+            return (value - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+        },
+        lerp: (a, b, t) => a + (b - a) * t,
+
+        // Boolean/conditional helpers
+        ifelse: (condition, trueVal, falseVal) => condition ? trueVal : falseVal,
+        between: (value, min, max) => value >= min && value <= max,
+
+        // Delta/change detection (returns difference)
+        delta: (current, previous) => current - previous,
+        pctChange: (current, previous) => previous !== 0 ? ((current - previous) / previous) * 100 : 0
+    };
+    function EventCalcNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.cacheConfig = RED.nodes.getNode(config.cache);
+        node.inputMappings = config.inputMappings || [];
+        node.expression = config.expression || '';
+        node.triggerOn = config.triggerOn || 'any';
+        node.outputTopic = config.outputTopic || 'calc/result';
+
+        const subscriptionIds = [];
+        const latestValues = new Map(); // name -> { topic, value, ts }
+
+        if (!node.cacheConfig) {
+            node.status({ fill: "red", shape: "ring", text: "no cache configured" });
+            return;
+        }
+
+        if (node.inputMappings.length === 0) {
+            node.status({ fill: "yellow", shape: "ring", text: "no inputs defined" });
+            return;
+        }
+
+        if (!node.expression) {
+            node.status({ fill: "yellow", shape: "ring", text: "no expression" });
+            return;
+        }
+
+        /**
+         * Attempt to calculate and output result
+         */
+        function tryCalculate(triggerTopic) {
+            // Check if we should trigger
+            if (node.triggerOn === 'all') {
+                // All inputs must have values
+                for (const input of node.inputMappings) {
+                    if (!latestValues.has(input.name)) {
+                        return; // Not all values available yet
+                    }
+                }
+            }
+
+            // At least one value must exist to calculate
+            if (latestValues.size === 0) {
+                return;
+            }
+
+            // Build context object for expression evaluation
+            const context = {};
+            const inputDetails = {};
+
+            for (const input of node.inputMappings) {
+                const data = latestValues.get(input.name);
+                if (data) {
+                    context[input.name] = data.value;
+                    inputDetails[input.name] = {
+                        topic: data.topic,
+                        value: data.value,
+                        ts: data.ts
+                    };
+                } else {
+                    context[input.name] = undefined;
+                }
+            }
+
+            // Evaluate expression safely
+            try {
+                // Create a function with named parameters from context + helpers
+                const allParams = { ...helpers, ...context };
+                const paramNames = Object.keys(allParams);
+                const paramValues = Object.values(allParams);
+
+                // Build function body with helpers and variables available
+                const fn = new Function(...paramNames, `return ${node.expression};`);
+                const result = fn(...paramValues);
+
+                const msg = {
+                    topic: node.outputTopic,
+                    payload: result,
+                    inputs: inputDetails,
+                    expression: node.expression,
+                    trigger: triggerTopic,
+                    timestamp: Date.now()
+                };
+
+                node.send(msg);
+
+                // Store result back in cache so it can be used by other calculations
+                node.cacheConfig.setValue(node.outputTopic, result, {
+                    source: 'event-calc',
+                    expression: node.expression,
+                    inputs: Object.keys(inputDetails)
+                });
+
+                // Update status with result (truncate if too long)
+                const resultStr = String(result);
+                const displayResult = resultStr.length > 15 ? resultStr.substring(0, 12) + '...' : resultStr;
+                node.status({ fill: "green", shape: "dot", text: `= ${displayResult}` });
+
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: "eval error" });
+                node.error(`Expression evaluation failed: ${err.message}`, { expression: node.expression, context: context });
+            }
+        }
+
+        // Subscribe to each input pattern
+        for (const input of node.inputMappings) {
+            if (!input.name || !input.pattern) {
+                continue;
+            }
+
+            const subId = node.cacheConfig.subscribe(input.pattern, (topic, entry) => {
+                latestValues.set(input.name, {
+                    topic: topic,
+                    value: entry.value,
+                    ts: entry.ts
+                });
+
+                tryCalculate(topic);
+            });
+            subscriptionIds.push(subId);
+        }
+
+        node.status({ fill: "green", shape: "dot", text: "ready" });
+
+        // Handle input messages for dynamic updates
+        node.on('input', function(msg, send, done) {
+            // For Node-RED 0.x compatibility
+            send = send || function() { node.send.apply(node, arguments); };
+            done = done || function(err) { if (err) node.error(err, msg); };
+
+            // Allow expression update via message
+            if (msg.expression && typeof msg.expression === 'string') {
+                node.expression = msg.expression;
+                node.status({ fill: "blue", shape: "dot", text: "expr updated" });
+            }
+
+            // Force recalculation
+            if (msg.payload === 'recalc' || msg.topic === 'recalc') {
+                tryCalculate('manual');
+            }
+
+            done();
+        });
+
+        node.on('close', function(done) {
+            for (const subId of subscriptionIds) {
+                if (node.cacheConfig) {
+                    node.cacheConfig.unsubscribe(subId);
+                }
+            }
+            subscriptionIds.length = 0;
+            latestValues.clear();
+            done();
+        });
+    }
+
+    RED.nodes.registerType("event-calc", EventCalcNode);
+};

package/nodes/event-in.html

@@ -0,0 +1,66 @@
+<script type="text/javascript">
+    RED.nodes.registerType('event-in', {
+        category: 'event calc',
+        color: '#87CEEB',
+        defaults: {
+            name: { value: "" },
+            cache: { value: "", type: "event-cache", required: true },
+            topicField: { value: "topic" },
+            valueField: { value: "payload" }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-arrow-circle-right",
+        label: function() {
+            return this.name || "event in";
+        },
+        paletteLabel: "event in"
+    });
+</script>
+
+<script type="text/html" data-template-name="event-in">
+    <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-cache"><i class="fa fa-database"></i> Cache</label>
+        <input type="text" id="node-input-cache">
+    </div>
+    <div class="form-row">
+        <label for="node-input-topicField"><i class="fa fa-bookmark"></i> Topic Field</label>
+        <input type="text" id="node-input-topicField" placeholder="topic">
+        <div class="form-tips">Message property containing the topic (e.g., <code>topic</code> for <code>msg.topic</code>)</div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-valueField"><i class="fa fa-cube"></i> Value Field</label>
+        <input type="text" id="node-input-valueField" placeholder="payload">
+        <div class="form-tips">Message property containing the value (e.g., <code>payload</code> for <code>msg.payload</code>)</div>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-in">
+    <p>Receives messages and pushes values to the event cache.</p>
+
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Cache</dt>
+        <dd>The event-cache config node to use</dd>
+        <dt>Topic Field</dt>
+        <dd>Message property containing the topic (default: <code>msg.topic</code>)</dd>
+        <dt>Value Field</dt>
+        <dd>Message property containing the value (default: <code>msg.payload</code>)</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <p>Any message with a topic and value. The topic is used as the cache key.</p>
+
+    <h3>Outputs</h3>
+    <p>The original message is passed through unchanged, allowing this node to be inserted into existing flows.</p>
+
+    <h3>Details</h3>
+    <p>This node extracts a topic and value from incoming messages and stores them in the configured event-cache.
+    Other nodes (event-topic, event-calc) can then subscribe to these cached values.</p>
+
+    <p>Use this node to feed data from any source into the event cache system.</p>
+</script>

package/nodes/event-in.js

@@ -0,0 +1,80 @@
+/**
+ * event-in - Input node that pushes data to the event cache
+ *
+ * Features:
+ * - Receives messages from any upstream Node-RED node
+ * - Configurable topic and value extraction from message
+ * - Pass-through: forwards original message after caching
+ */
+module.exports = function(RED) {
+    function EventInNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.cacheConfig = RED.nodes.getNode(config.cache);
+        node.topicField = config.topicField || 'topic';
+        node.valueField = config.valueField || 'payload';
+
+        if (!node.cacheConfig) {
+            node.status({ fill: "red", shape: "ring", text: "no cache configured" });
+            return;
+        }
+
+        node.status({ fill: "green", shape: "dot", text: "ready" });
+
+        node.on('input', function(msg, send, done) {
+            // For Node-RED 0.x compatibility
+            send = send || function() { node.send.apply(node, arguments); };
+            done = done || function(err) { if (err) node.error(err, msg); };
+
+            try {
+                // Extract topic using RED.util.getMessageProperty
+                let topic;
+                if (node.topicField.startsWith('msg.')) {
+                    topic = RED.util.getMessageProperty(msg, node.topicField.substring(4));
+                } else {
+                    topic = RED.util.getMessageProperty(msg, node.topicField);
+                }
+
+                if (!topic || typeof topic !== 'string') {
+                    node.status({ fill: "yellow", shape: "ring", text: "missing topic" });
+                    done(new Error(`Topic not found at msg.${node.topicField} or not a string`));
+                    return;
+                }
+
+                // Extract value
+                let value;
+                if (node.valueField.startsWith('msg.')) {
+                    value = RED.util.getMessageProperty(msg, node.valueField.substring(4));
+                } else {
+                    value = RED.util.getMessageProperty(msg, node.valueField);
+                }
+
+                // Build metadata from msg properties
+                const metadata = {
+                    _msgid: msg._msgid
+                };
+
+                // Push to cache
+                node.cacheConfig.setValue(topic, value, metadata);
+
+                // Truncate topic for status display
+                const displayTopic = topic.length > 20 ? topic.substring(0, 17) + '...' : topic;
+                node.status({ fill: "green", shape: "dot", text: displayTopic });
+
+                // Pass through the message
+                send(msg);
+                done();
+            } catch (err) {
+                node.status({ fill: "red", shape: "ring", text: "error" });
+                done(err);
+            }
+        });
+
+        node.on('close', function(done) {
+            done();
+        });
+    }
+
+    RED.nodes.registerType("event-in", EventInNode);
+};

package/nodes/event-topic.html

@@ -0,0 +1,130 @@
+<script type="text/javascript">
+    RED.nodes.registerType('event-topic', {
+        category: 'event calc',
+        color: '#87CEEB',
+        defaults: {
+            name: { value: "" },
+            cache: { value: "", type: "event-cache", required: true },
+            pattern: { value: "*" },
+            outputFormat: { value: "value" },
+            outputOnStart: { value: false }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-filter",
+        label: function() {
+            return this.name || this.pattern || "event topic";
+        },
+        paletteLabel: "event topic",
+        oneditprepare: function() {
+            const node = this;
+
+            // Fetch topics from cache for autocomplete
+            function fetchTopics() {
+                const cacheId = $("#node-input-cache").val();
+                if (cacheId) {
+                    $.getJSON("event-cache/" + cacheId + "/topics", function(topics) {
+                        $("#node-input-pattern").autocomplete("option", "source", topics || []);
+                    });
+                }
+            }
+
+            // Setup autocomplete on pattern input
+            $("#node-input-pattern").autocomplete({
+                source: [],
+                minLength: 0,
+                delay: 0
+            }).on("focus", function() {
+                if (!$(this).val() || $(this).val() === "*") {
+                    $(this).autocomplete("search", "");
+                }
+            });
+
+            // Refresh topics when cache selection changes
+            $("#node-input-cache").on("change", fetchTopics);
+
+            // Initial fetch
+            setTimeout(fetchTopics, 100);
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="event-topic">
+    <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-cache"><i class="fa fa-database"></i> Cache</label>
+        <input type="text" id="node-input-cache">
+    </div>
+    <div class="form-row">
+        <label for="node-input-pattern"><i class="fa fa-bookmark"></i> Topic Pattern</label>
+        <input type="text" id="node-input-pattern" placeholder="*">
+        <div class="form-tips">
+            Wildcards: <code>?</code> = exactly one character, <code>*</code> = one or more characters.<br>
+            Examples: <code>sensor?</code> matches sensor1, <code>sensors/*</code> matches sensors/temp
+        </div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-outputFormat"><i class="fa fa-sign-out"></i> Output Format</label>
+        <select id="node-input-outputFormat" style="width:70%;">
+            <option value="value">Value only (msg.payload = value)</option>
+            <option value="full">Full entry (msg.payload = {value, ts, metadata})</option>
+            <option value="all">All matching (msg.payload = {topic: value, ...})</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label>&nbsp;</label>
+        <input type="checkbox" id="node-input-outputOnStart" style="display:inline-block; width:auto; vertical-align:top;">
+        <label for="node-input-outputOnStart" style="width:auto;">Output existing cached values on deploy</label>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-topic">
+    <p>Subscribes to a topic pattern and outputs when matching topics update in the cache.</p>
+
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Cache</dt>
+        <dd>The event-cache config node to use</dd>
+        <dt>Topic Pattern</dt>
+        <dd>Pattern with wildcards. <code>?</code> = exactly one character, <code>*</code> = one or more characters.</dd>
+        <dt>Output Format</dt>
+        <dd>
+            <ul>
+                <li><b>Value only</b>: <code>msg.payload</code> contains just the value</li>
+                <li><b>Full entry</b>: <code>msg.payload</code> contains <code>{value, ts, metadata}</code></li>
+                <li><b>All matching</b>: <code>msg.payload</code> contains all cached values matching the pattern</li>
+            </ul>
+        </dd>
+        <dt>Output on deploy</dt>
+        <dd>If checked, outputs all currently cached values matching the pattern when the flow starts</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt class="optional">pattern <span class="property-type">string</span></dt>
+        <dd>Dynamically change the subscription pattern</dd>
+        <dt class="optional">payload/topic = "refresh"</dt>
+        <dd>Output all currently cached values matching the pattern</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>topic <span class="property-type">string</span></dt>
+        <dd>The topic that was updated</dd>
+        <dt>payload <span class="property-type">any</span></dt>
+        <dd>The value (format depends on Output Format setting)</dd>
+        <dt>timestamp <span class="property-type">number</span></dt>
+        <dd>Unix timestamp when the value was cached</dd>
+    </dl>
+
+    <h3>Wildcard Examples</h3>
+    <ul>
+        <li><code>sensor?</code> - matches sensor1, sensorA (exactly one char)</li>
+        <li><code>sensors/*</code> - matches sensors/temp, sensors/room1 (one or more chars after /)</li>
+        <li><code>*/temp</code> - matches room1/temp, sensors/temp</li>
+        <li><code>*</code> - matches any topic with one or more characters</li>
+    </ul>
+</script>

package/nodes/event-topic.js

@@ -0,0 +1,140 @@
+/**
+ * event-topic - Subscription node for topic patterns
+ *
+ * Features:
+ * - Subscribes to cache using MQTT-style topic patterns
+ * - Outputs when matching topics update
+ * - Multiple output formats: value only, full entry, or all matching
+ * - Optional output of existing values on start
+ * - Dynamic pattern change via input message
+ */
+module.exports = function(RED) {
+    function EventTopicNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.cacheConfig = RED.nodes.getNode(config.cache);
+        node.pattern = config.pattern || '#';
+        node.outputFormat = config.outputFormat || 'value';
+        node.outputOnStart = config.outputOnStart || false;
+
+        let subscriptionId = null;
+
+        if (!node.cacheConfig) {
+            node.status({ fill: "red", shape: "ring", text: "no cache configured" });
+            return;
+        }
+
+        /**
+         * Build output message based on configured format
+         */
+        function buildOutputMessage(topic, entry) {
+            switch (node.outputFormat) {
+                case 'value':
+                    return {
+                        topic: topic,
+                        payload: entry.value,
+                        timestamp: entry.ts
+                    };
+                case 'full':
+                    return {
+                        topic: topic,
+                        payload: {
+                            value: entry.value,
+                            ts: entry.ts,
+                            metadata: entry.metadata
+                        }
+                    };
+                case 'all':
+                    const all = node.cacheConfig.getMatching(node.pattern);
+                    const values = {};
+                    for (const [t, e] of all) {
+                        values[t] = e.value;
+                    }
+                    return {
+                        topic: topic,
+                        payload: values,
+                        trigger: {
+                            topic: topic,
+                            value: entry.value
+                        },
+                        timestamp: entry.ts
+                    };
+                default:
+                    return {
+                        topic: topic,
+                        payload: entry.value
+                    };
+            }
+        }
+
+        /**
+         * Subscribe to the current pattern
+         */
+        function subscribe() {
+            subscriptionId = node.cacheConfig.subscribe(node.pattern, (topic, entry) => {
+                const msg = buildOutputMessage(topic, entry);
+                node.send(msg);
+
+                // Truncate topic for status display
+                const displayTopic = topic.length > 20 ? topic.substring(0, 17) + '...' : topic;
+                node.status({ fill: "green", shape: "dot", text: displayTopic });
+            });
+        }
+
+        // Initial subscription
+        subscribe();
+        node.status({ fill: "green", shape: "dot", text: node.pattern });
+
+        // Output existing values on start if configured
+        if (node.outputOnStart) {
+            setImmediate(() => {
+                const matching = node.cacheConfig.getMatching(node.pattern);
+                for (const [topic, entry] of matching) {
+                    const msg = buildOutputMessage(topic, entry);
+                    node.send(msg);
+                }
+            });
+        }
+
+        // Handle input messages for dynamic pattern change
+        node.on('input', function(msg, send, done) {
+            // For Node-RED 0.x compatibility
+            send = send || function() { node.send.apply(node, arguments); };
+            done = done || function(err) { if (err) node.error(err, msg); };
+
+            if (msg.pattern && typeof msg.pattern === 'string') {
+                // Unsubscribe from old pattern
+                if (subscriptionId && node.cacheConfig) {
+                    node.cacheConfig.unsubscribe(subscriptionId);
+                }
+
+                // Update pattern and resubscribe
+                node.pattern = msg.pattern;
+                subscribe();
+
+                node.status({ fill: "blue", shape: "dot", text: node.pattern });
+            }
+
+            // Allow manual trigger to output all current values
+            if (msg.topic === 'refresh' || msg.payload === 'refresh') {
+                const matching = node.cacheConfig.getMatching(node.pattern);
+                for (const [topic, entry] of matching) {
+                    const outMsg = buildOutputMessage(topic, entry);
+                    send(outMsg);
+                }
+            }
+
+            done();
+        });
+
+        node.on('close', function(done) {
+            if (subscriptionId && node.cacheConfig) {
+                node.cacheConfig.unsubscribe(subscriptionId);
+            }
+            done();
+        });
+    }
+
+    RED.nodes.registerType("event-topic", EventTopicNode);
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "node-red-contrib-event-calc",
+  "version": "0.1.1",
+  "description": "Node-RED nodes for event caching and calculations with topic wildcard patterns",
+  "author": {
+    "name": "Holger Amort"
+  },
+  "keywords": [
+    "node-red",
+    "events",
+    "cache",
+    "wildcards",
+    "reactive",
+    "calculation",
+    "streaming"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/ErnstHolger/node-red#readme",
+  "bugs": {
+    "url": "https://github.com/ErnstHolger/node-red/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ErnstHolger/node-red.git"
+  },
+  "node-red": {
+    "version": ">=2.0.0",
+    "nodes": {
+      "event-cache": "nodes/event-cache.js",
+      "event-in": "nodes/event-in.js",
+      "event-topic": "nodes/event-topic.js",
+      "event-calc": "nodes/event-calc.js"
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "publish:dry": "npm publish --dry-run"
+  },
+  "dependencies": {}
+}