node-red-contrib-event-calc 0.1.1

package/nodes/event-cache.js

@@ -0,0 +1,327 @@
+/**
+ * event-cache - Config node providing central cache and event bus
+ *
+ * Features:
+ * - Map<topic, {value, ts, metadata}> for caching latest values
+ * - EventEmitter for notifying subscribers on updates
+ * - Wildcard matching (* for one or more chars, ? for exactly one char)
+ * - LRU eviction when maxEntries exceeded
+ * - Reference counting for cleanup
+ */
+module.exports = function(RED) {
+    const EventEmitter = require('events');
+
+    // Shared cache instances per config node ID
+    const cacheInstances = new Map();
+
+    /**
+     * Check if a pattern contains wildcards
+     * @param {string} pattern - Topic pattern
+     * @returns {boolean} - True if pattern contains * or ?
+     */
+    function hasWildcard(pattern) {
+        return pattern && (pattern.includes('*') || pattern.includes('?'));
+    }
+
+    /**
+     * Convert topic pattern to RegExp
+     *
+     * Wildcards:
+     * - '*' (asterisk): Matches one or more characters
+     *   Example: 'sensors/*' matches 'sensors/temp', 'sensors/room1/temp'
+     *
+     * - '?' (question mark): Matches exactly one character
+     *   Example: 'sensor?' matches 'sensor1', 'sensorA' but NOT 'sensor' or 'sensor12'
+     *
+     * @param {string} pattern - Topic pattern with wildcards
+     * @returns {RegExp} - Regular expression for matching
+     */
+    function patternToRegex(pattern) {
+        // Handle empty pattern or just *
+        if (!pattern || pattern === '*') {
+            return /^.+$/;
+        }
+
+        // Escape regex special characters except our wildcards (* and ?)
+        let regexStr = pattern
+            .replace(/[.^$|()[\]{}\\+#/]/g, '\\$&')  // Escape regex special chars (including /)
+            .replace(/\?/g, '.')                      // ? matches exactly one character
+            .replace(/\*/g, '.+');                    // * matches one or more characters
+
+        return new RegExp(`^${regexStr}$`);
+    }
+
+    function EventCacheNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = config.name || 'Event Cache';
+        node.maxEntries = parseInt(config.maxEntries) || 10000;
+        node.ttl = parseInt(config.ttl) || 0; // 0 = no expiry
+
+        // Create or get shared cache instance
+        const cacheKey = node.id;
+        if (!cacheInstances.has(cacheKey)) {
+            cacheInstances.set(cacheKey, {
+                cache: new Map(),
+                emitter: new EventEmitter(),
+                // Optimized subscription storage:
+                // - exactSubscriptions: Map<topic, Map<subId, callback>> for O(1) exact match
+                // - wildcardSubscriptions: Map<subId, {pattern, regex, callback}> for pattern matching
+                exactSubscriptions: new Map(),
+                wildcardSubscriptions: new Map(),
+                users: 0,
+                subscriptionCounter: 0
+            });
+        }
+
+        const instance = cacheInstances.get(cacheKey);
+        instance.users++;
+        instance.emitter.setMaxListeners(100); // Allow many subscribers
+
+        // TTL cleanup interval
+        let ttlInterval = null;
+        if (node.ttl > 0) {
+            ttlInterval = setInterval(() => {
+                const now = Date.now();
+                for (const [topic, entry] of instance.cache) {
+                    if (now - entry.ts > node.ttl) {
+                        instance.cache.delete(topic);
+                    }
+                }
+            }, Math.min(node.ttl, 60000)); // Check at most every minute
+        }
+
+        /**
+         * Set a value in the cache and emit update event
+         * @param {string} topic - The topic key
+         * @param {any} value - The value to store
+         * @param {object} metadata - Optional metadata
+         */
+        node.setValue = function(topic, value, metadata = {}) {
+            const entry = {
+                value: value,
+                ts: Date.now(),
+                metadata: metadata
+            };
+
+            instance.cache.set(topic, entry);
+
+            // Enforce max entries (LRU eviction - remove oldest)
+            if (instance.cache.size > node.maxEntries) {
+                const firstKey = instance.cache.keys().next().value;
+                instance.cache.delete(firstKey);
+            }
+
+            // Emit topic-specific update event
+            instance.emitter.emit('update', topic, entry);
+        };
+
+        /**
+         * Get a value from the cache
+         * @param {string} topic - The topic key
+         * @returns {object|undefined} - The cached entry {value, ts, metadata} or undefined
+         */
+        node.getValue = function(topic) {
+            return instance.cache.get(topic);
+        };
+
+        /**
+         * Get all values matching a pattern
+         * @param {string} pattern - Pattern with * and ? wildcards
+         * @returns {Map} - Map of matching topic -> entry
+         */
+        node.getMatching = function(pattern) {
+            const regex = patternToRegex(pattern);
+            const results = new Map();
+
+            for (const [topic, entry] of instance.cache) {
+                if (regex.test(topic)) {
+                    results.set(topic, entry);
+                }
+            }
+
+            return results;
+        };
+
+        /**
+         * Subscribe to updates matching a pattern
+         * Optimized: exact matches use O(1) lookup, wildcards use pattern matching
+         * @param {string} pattern - Topic pattern with wildcards
+         * @param {Function} callback - Called with (topic, entry) on match
+         * @returns {string} - Subscription ID for unsubscribe
+         */
+        node.subscribe = function(pattern, callback) {
+            const subId = `sub_${++instance.subscriptionCounter}`;
+
+            if (hasWildcard(pattern)) {
+                // Wildcard pattern - store with regex for matching
+                const regex = patternToRegex(pattern);
+                instance.wildcardSubscriptions.set(subId, {
+                    pattern: pattern,
+                    regex: regex,
+                    callback: callback
+                });
+            } else {
+                // Exact match - store in topic-indexed map for O(1) lookup
+                if (!instance.exactSubscriptions.has(pattern)) {
+                    instance.exactSubscriptions.set(pattern, new Map());
+                }
+                instance.exactSubscriptions.get(pattern).set(subId, callback);
+            }
+
+            return subId;
+        };
+
+        /**
+         * Unsubscribe from updates
+         * @param {string} subscriptionId - The subscription ID to remove
+         */
+        node.unsubscribe = function(subscriptionId) {
+            // Try wildcard subscriptions first
+            if (instance.wildcardSubscriptions.delete(subscriptionId)) {
+                return;
+            }
+
+            // Search exact subscriptions
+            for (const [topic, subs] of instance.exactSubscriptions) {
+                if (subs.delete(subscriptionId)) {
+                    // Clean up empty topic maps
+                    if (subs.size === 0) {
+                        instance.exactSubscriptions.delete(topic);
+                    }
+                    return;
+                }
+            }
+        };
+
+        /**
+         * Get all topics in cache
+         * @returns {string[]} - Array of all topic keys
+         */
+        node.getTopics = function() {
+            return Array.from(instance.cache.keys());
+        };
+
+        /**
+         * Get the number of entries in the cache
+         * @returns {number} - Cache size
+         */
+        node.size = function() {
+            return instance.cache.size;
+        };
+
+        /**
+         * Clear all entries from cache
+         */
+        node.clear = function() {
+            instance.cache.clear();
+        };
+
+        // Internal: dispatch updates to matching subscriptions
+        // Optimized: O(1) for exact matches, O(w) for wildcard patterns
+        const updateHandler = (topic, entry) => {
+            // First: O(1) lookup for exact subscriptions
+            const exactSubs = instance.exactSubscriptions.get(topic);
+            if (exactSubs) {
+                for (const [subId, callback] of exactSubs) {
+                    try {
+                        callback(topic, entry);
+                    } catch (err) {
+                        RED.log.error(`[event-cache] Subscription callback error: ${err.message}`);
+                    }
+                }
+            }
+
+            // Second: iterate only wildcard subscriptions (typically fewer)
+            for (const [subId, sub] of instance.wildcardSubscriptions) {
+                if (sub.regex.test(topic)) {
+                    try {
+                        sub.callback(topic, entry);
+                    } catch (err) {
+                        RED.log.error(`[event-cache] Subscription callback error: ${err.message}`);
+                    }
+                }
+            }
+        };
+        instance.emitter.on('update', updateHandler);
+
+        // Cleanup on close
+        node.on('close', function(done) {
+            if (ttlInterval) {
+                clearInterval(ttlInterval);
+            }
+
+            instance.users--;
+            if (instance.users <= 0) {
+                instance.cache.clear();
+                instance.exactSubscriptions.clear();
+                instance.wildcardSubscriptions.clear();
+                instance.emitter.removeAllListeners();
+                cacheInstances.delete(cacheKey);
+            }
+            done();
+        });
+    }
+
+    RED.nodes.registerType("event-cache", EventCacheNode);
+
+    // HTTP Admin endpoint to clear cache
+    RED.httpAdmin.post("/event-cache/:id/clear", function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node && node.clear) {
+            node.clear();
+            res.sendStatus(200);
+        } else {
+            res.sendStatus(404);
+        }
+    });
+
+    // HTTP Admin endpoint to get cache stats
+    RED.httpAdmin.get("/event-cache/:id/stats", function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node) {
+            const instance = cacheInstances.get(node.id);
+            let exactSubCount = 0;
+            if (instance) {
+                for (const subs of instance.exactSubscriptions.values()) {
+                    exactSubCount += subs.size;
+                }
+            }
+            res.json({
+                size: node.size(),
+                topics: node.getTopics(),
+                maxEntries: node.maxEntries,
+                ttl: node.ttl,
+                subscriptions: {
+                    exact: exactSubCount,
+                    wildcard: instance ? instance.wildcardSubscriptions.size : 0,
+                    exactTopics: instance ? instance.exactSubscriptions.size : 0
+                }
+            });
+        } else {
+            res.sendStatus(404);
+        }
+    });
+
+    // HTTP Admin endpoint to get topics only (for autocomplete)
+    RED.httpAdmin.get("/event-cache/:id/topics", function(req, res) {
+        const node = RED.nodes.getNode(req.params.id);
+        if (node) {
+            res.json(node.getTopics());
+        } else {
+            res.json([]);
+        }
+    });
+
+    // HTTP Admin endpoint to get topics from all caches
+    RED.httpAdmin.get("/event-cache/topics/all", function(req, res) {
+        const allTopics = new Set();
+        for (const [cacheKey, instance] of cacheInstances) {
+            for (const topic of instance.cache.keys()) {
+                allTopics.add(topic);
+            }
+        }
+        res.json(Array.from(allTopics).sort());
+    });
+};

package/nodes/event-calc.html

@@ -0,0 +1,307 @@
+<script type="text/javascript">
+    RED.nodes.registerType('event-calc', {
+        category: 'event calc',
+        color: '#87CEEB',
+        defaults: {
+            name: { value: "" },
+            cache: { value: "", type: "event-cache", required: true },
+            inputMappings: { value: [] },
+            expression: { value: "" },
+            triggerOn: { value: "any" },
+            outputTopic: { value: "calc/result" }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-calculator",
+        label: function() {
+            return this.name || this.expression || "event calc";
+        },
+        paletteLabel: "event calc",
+        oneditprepare: function() {
+            const node = this;
+            let cachedTopics = [];
+
+            // Fetch topics from cache for autocomplete
+            function fetchTopics() {
+                const cacheId = $("#node-input-cache").val();
+                if (cacheId) {
+                    $.getJSON("event-cache/" + cacheId + "/topics", function(topics) {
+                        cachedTopics = topics || [];
+                        // Update existing autocomplete instances
+                        $(".input-pattern").each(function() {
+                            $(this).autocomplete("option", "source", cachedTopics);
+                        });
+                    });
+                }
+            }
+
+            // Refresh topics when cache selection changes
+            $("#node-input-cache").on("change", fetchTopics);
+
+            // Initial fetch
+            setTimeout(fetchTopics, 100);
+
+            // Function picker - insert selected function at cursor
+            $("#node-function-picker").on("change", function() {
+                const func = $(this).val();
+                if (func) {
+                    const exprInput = document.getElementById("node-input-expression");
+                    const start = exprInput.selectionStart;
+                    const end = exprInput.selectionEnd;
+                    const text = exprInput.value;
+
+                    // Insert function at cursor position
+                    exprInput.value = text.substring(0, start) + func + text.substring(end);
+
+                    // Position cursor inside the first parenthesis
+                    const parenPos = func.indexOf('(');
+                    if (parenPos !== -1) {
+                        exprInput.selectionStart = exprInput.selectionEnd = start + parenPos + 1;
+                    } else {
+                        exprInput.selectionStart = exprInput.selectionEnd = start + func.length;
+                    }
+                    exprInput.focus();
+
+                    // Reset dropdown
+                    $(this).val("");
+                }
+            });
+
+            // Input mappings editable list
+            const inputList = $("#node-input-inputMappings-list").css({
+                'min-height': '150px',
+                'min-width': '450px'
+            }).editableList({
+                addItem: function(container, i, data) {
+                    const row = $('<div/>', { style: "display:flex; align-items:center; gap:5px;" }).appendTo(container);
+
+                    $('<input/>', {
+                        type: "text",
+                        placeholder: "var (e.g. 'a')",
+                        class: "input-name"
+                    })
+                    .css({ width: "25%", flex: "0 0 auto" })
+                    .val(data.name || "")
+                    .appendTo(row);
+
+                    $('<span/>', { style: "flex: 0 0 auto;" }).text(" = ").appendTo(row);
+
+                    const patternInput = $('<input/>', {
+                        type: "text",
+                        placeholder: "topic (type to search cached topics)",
+                        class: "input-pattern"
+                    })
+                    .css({ flex: "1 1 auto" })
+                    .val(data.pattern || "")
+                    .appendTo(row);
+
+                    // Add autocomplete to pattern input
+                    patternInput.autocomplete({
+                        source: cachedTopics,
+                        minLength: 0,
+                        delay: 0
+                    }).on("focus", function() {
+                        // Show all options on focus if empty
+                        if (!$(this).val()) {
+                            $(this).autocomplete("search", "");
+                        }
+                    });
+                },
+                removable: true,
+                sortable: true,
+                addButton: true
+            });
+
+            // Load existing inputs
+            if (node.inputMappings && node.inputMappings.length > 0) {
+                node.inputMappings.forEach(function(input) {
+                    inputList.editableList('addItem', input);
+                });
+            } else {
+                // Add two default empty inputs
+                inputList.editableList('addItem', { name: 'a', pattern: '' });
+                inputList.editableList('addItem', { name: 'b', pattern: '' });
+            }
+        },
+        oneditsave: function() {
+            const node = this;
+            node.inputMappings = [];
+
+            $("#node-input-inputMappings-list").editableList('items').each(function() {
+                const name = $(this).find(".input-name").val().trim();
+                const pattern = $(this).find(".input-pattern").val().trim();
+                if (name && pattern) {
+                    node.inputMappings.push({ name: name, pattern: pattern });
+                }
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="event-calc">
+    <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 style="width:100%;"><i class="fa fa-sign-in"></i> Input Variables</label>
+        <ol id="node-input-inputMappings-list"></ol>
+        <div class="form-tips">
+            Map variable names to topic patterns. Wildcards: <code>?</code> = one char, <code>*</code> = one or more chars
+        </div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-expression"><i class="fa fa-code"></i> Expression</label>
+        <div style="display:flex; gap:5px;">
+            <input type="text" id="node-input-expression" placeholder="e.g. a + b, avg(a, b), round(a, 2)" style="flex:1;">
+            <select id="node-function-picker" style="width:120px;">
+                <option value="">+ Function</option>
+                <optgroup label="Math">
+                    <option value="min(, )">min(a, b)</option>
+                    <option value="max(, )">max(a, b)</option>
+                    <option value="abs()">abs(x)</option>
+                    <option value="sqrt()">sqrt(x)</option>
+                    <option value="pow(, )">pow(base, exp)</option>
+                    <option value="log()">log(x)</option>
+                    <option value="log10()">log10(x)</option>
+                    <option value="floor()">floor(x)</option>
+                    <option value="ceil()">ceil(x)</option>
+                    <option value="sin()">sin(x)</option>
+                    <option value="cos()">cos(x)</option>
+                    <option value="PI">PI</option>
+                </optgroup>
+                <optgroup label="Aggregation">
+                    <option value="sum(, )">sum(a, b, ...)</option>
+                    <option value="avg(, )">avg(a, b, ...)</option>
+                    <option value="count(, )">count(a, b, ...)</option>
+                </optgroup>
+                <optgroup label="Utility">
+                    <option value="round(, 2)">round(val, dec)</option>
+                    <option value="clamp(, 0, 100)">clamp(val, min, max)</option>
+                    <option value="map(, 0, 100, 0, 1)">map(val, in1, in2, out1, out2)</option>
+                    <option value="lerp(, , 0.5)">lerp(a, b, t)</option>
+                    <option value="ifelse( > , '', '')">ifelse(cond, true, false)</option>
+                    <option value="between(, , )">between(val, min, max)</option>
+                    <option value="delta(, )">delta(curr, prev)</option>
+                    <option value="pctChange(, )">pctChange(curr, prev)</option>
+                </optgroup>
+            </select>
+        </div>
+        <div class="form-tips">
+            JavaScript expression. Select a function to insert it at cursor position.
+        </div>
+    </div>
+    <div class="form-row">
+        <label for="node-input-triggerOn"><i class="fa fa-bolt"></i> Trigger</label>
+        <select id="node-input-triggerOn" style="width:70%;">
+            <option value="any">Any input updates</option>
+            <option value="all">Only when all inputs have values</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-outputTopic"><i class="fa fa-bookmark"></i> Output Topic</label>
+        <input type="text" id="node-input-outputTopic" placeholder="calc/result">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="event-calc">
+    <p>Subscribes to multiple topics and evaluates an expression when values update.</p>
+
+    <h3>Properties</h3>
+    <dl class="message-properties">
+        <dt>Input Variables</dt>
+        <dd>Map variable names to topic patterns. Each variable receives the latest value from matching topics.</dd>
+        <dt>Expression</dt>
+        <dd>JavaScript expression using the variable names, e.g. <code>a + b</code>, <code>Math.max(a, b)</code>, <code>(a - b) / a * 100</code></dd>
+        <dt>Trigger</dt>
+        <dd>
+            <ul>
+                <li><b>Any input updates</b>: Recalculate whenever any subscribed topic updates</li>
+                <li><b>Only when all inputs have values</b>: Wait until all inputs have received at least one value</li>
+            </ul>
+        </dd>
+        <dt>Output Topic</dt>
+        <dd>Topic to set on output messages</dd>
+    </dl>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt class="optional">expression <span class="property-type">string</span></dt>
+        <dd>Dynamically update the expression</dd>
+        <dt class="optional">payload/topic = "recalc"</dt>
+        <dd>Force recalculation with current values</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">any</span></dt>
+        <dd>The result of the expression</dd>
+        <dt>topic <span class="property-type">string</span></dt>
+        <dd>The configured output topic</dd>
+        <dt>inputs <span class="property-type">object</span></dt>
+        <dd>Details of all input values used in the calculation</dd>
+        <dt>expression <span class="property-type">string</span></dt>
+        <dd>The expression that was evaluated</dd>
+        <dt>trigger <span class="property-type">string</span></dt>
+        <dd>The topic that triggered this calculation</dd>
+    </dl>
+
+    <h3>Built-in Functions</h3>
+    <p>The following functions are available in expressions:</p>
+
+    <h4>Math</h4>
+    <ul>
+        <li><code>min(a, b, ...)</code> - Minimum value</li>
+        <li><code>max(a, b, ...)</code> - Maximum value</li>
+        <li><code>abs(x)</code> - Absolute value</li>
+        <li><code>sqrt(x)</code> - Square root</li>
+        <li><code>pow(base, exp)</code> - Power</li>
+        <li><code>log(x)</code>, <code>log10(x)</code> - Logarithms</li>
+        <li><code>exp(x)</code> - e^x</li>
+        <li><code>floor(x)</code>, <code>ceil(x)</code> - Rounding</li>
+        <li><code>sin(x)</code>, <code>cos(x)</code>, <code>tan(x)</code> - Trigonometry</li>
+        <li><code>PI</code>, <code>E</code> - Constants</li>
+    </ul>
+
+    <h4>Aggregation</h4>
+    <ul>
+        <li><code>sum(a, b, ...)</code> - Sum of values</li>
+        <li><code>avg(a, b, ...)</code> - Average of values</li>
+        <li><code>count(a, b, ...)</code> - Count of values</li>
+    </ul>
+
+    <h4>Utility</h4>
+    <ul>
+        <li><code>round(value, decimals)</code> - Round to N decimals</li>
+        <li><code>clamp(value, min, max)</code> - Constrain to range</li>
+        <li><code>map(value, inMin, inMax, outMin, outMax)</code> - Scale value</li>
+        <li><code>lerp(a, b, t)</code> - Linear interpolation</li>
+        <li><code>ifelse(cond, trueVal, falseVal)</code> - Conditional</li>
+        <li><code>between(value, min, max)</code> - Range check</li>
+        <li><code>delta(current, previous)</code> - Difference</li>
+        <li><code>pctChange(current, previous)</code> - Percentage change</li>
+    </ul>
+
+    <h3>Expression Examples</h3>
+    <ul>
+        <li><code>a + b</code> - Sum of two values</li>
+        <li><code>avg(a, b)</code> - Average of two values</li>
+        <li><code>max(a, b, c)</code> - Maximum of three values</li>
+        <li><code>sqrt(a * a + b * b)</code> - Pythagorean calculation</li>
+        <li><code>round(a, 2)</code> - Round to 2 decimals</li>
+        <li><code>clamp(a, 0, 100)</code> - Constrain to 0-100</li>
+        <li><code>map(a, 0, 1023, 0, 100)</code> - Scale ADC to percentage</li>
+        <li><code>ifelse(a > b, 'high', 'low')</code> - Conditional</li>
+        <li><code>pctChange(a, b)</code> - Percent change from b to a</li>
+    </ul>
+
+    <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/temp</li>
+    </ul>
+</script>