node-red-contrib-event-calc 0.1.2 → 0.1.4

package/nodes/event-cache.js

@@ -3,53 +3,17 @@
  *
  * Features:
  * - Map<topic, {value, ts, metadata}> for caching latest values
+ * - Stored in global context for visibility in sidebar
  * - EventEmitter for notifying subscribers on updates
- * - Wildcard matching (* for one or more chars, ? for exactly one char)
+ * - Exact topic matching for subscriptions
  * - 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}$`);
-    }
+    // Shared instances for event emitters and subscriptions (not stored in context)
+    const sharedInstances = new Map();
 
     function EventCacheNode(config) {
         RED.nodes.createNode(this, config);
@@ -59,36 +23,47 @@ module.exports = function(RED) {
         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(),
+        // Context key for storing cache data (visible in sidebar)
+        const contextKey = `eventCache_${node.name.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+        const globalContext = node.context().global;
+
+        // Create or get shared instance for emitters/subscriptions (not serializable)
+        const instanceKey = node.id;
+        if (!sharedInstances.has(instanceKey)) {
+            sharedInstances.set(instanceKey, {
                 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(),
+                // Subscription storage: Map<topic, Map<subId, callback>> for O(1) exact match
+                subscriptions: new Map(),
                 users: 0,
                 subscriptionCounter: 0
             });
         }
 
-        const instance = cacheInstances.get(cacheKey);
+        const instance = sharedInstances.get(instanceKey);
         instance.users++;
         instance.emitter.setMaxListeners(100); // Allow many subscribers
 
+        // Initialize cache in global context if not exists
+        if (!globalContext.get(contextKey)) {
+            globalContext.set(contextKey, {});
+        }
+
         // 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);
+                const cache = globalContext.get(contextKey) || {};
+                let changed = false;
+                for (const topic of Object.keys(cache)) {
+                    if (now - cache[topic].ts > node.ttl) {
+                        delete cache[topic];
+                        changed = true;
                     }
                 }
+                if (changed) {
+                    globalContext.set(contextKey, cache);
+                }
             }, Math.min(node.ttl, 60000)); // Check at most every minute
         }
 
@@ -105,14 +80,26 @@ module.exports = function(RED) {
                 metadata: metadata
             };
 
-            instance.cache.set(topic, entry);
+            const cache = globalContext.get(contextKey) || {};
+            cache[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);
+            const keys = Object.keys(cache);
+            if (keys.length > node.maxEntries) {
+                // Find oldest entry
+                let oldestKey = keys[0];
+                let oldestTs = cache[oldestKey].ts;
+                for (const key of keys) {
+                    if (cache[key].ts < oldestTs) {
+                        oldestTs = cache[key].ts;
+                        oldestKey = key;
+                    }
+                }
+                delete cache[oldestKey];
             }
 
+            globalContext.set(contextKey, cache);
+
             // Emit topic-specific update event
             instance.emitter.emit('update', topic, entry);
         };
@@ -123,52 +110,23 @@ module.exports = function(RED) {
          * @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;
+            const cache = globalContext.get(contextKey) || {};
+            return cache[topic];
         };
 
         /**
-         * 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
+         * Subscribe to updates for a specific topic
+         * @param {string} topic - The exact topic to subscribe to
+         * @param {Function} callback - Called with (topic, entry) on update
          * @returns {string} - Subscription ID for unsubscribe
          */
-        node.subscribe = function(pattern, callback) {
+        node.subscribe = function(topic, 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);
+            if (!instance.subscriptions.has(topic)) {
+                instance.subscriptions.set(topic, new Map());
             }
+            instance.subscriptions.get(topic).set(subId, callback);
 
             return subId;
         };
@@ -178,17 +136,11 @@ module.exports = function(RED) {
          * @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) {
+            for (const [topic, subs] of instance.subscriptions) {
                 if (subs.delete(subscriptionId)) {
                     // Clean up empty topic maps
                     if (subs.size === 0) {
-                        instance.exactSubscriptions.delete(topic);
+                        instance.subscriptions.delete(topic);
                     }
                     return;
                 }
@@ -200,7 +152,8 @@ module.exports = function(RED) {
          * @returns {string[]} - Array of all topic keys
          */
         node.getTopics = function() {
-            return Array.from(instance.cache.keys());
+            const cache = globalContext.get(contextKey) || {};
+            return Object.keys(cache);
         };
 
         /**
@@ -208,23 +161,22 @@ module.exports = function(RED) {
          * @returns {number} - Cache size
          */
         node.size = function() {
-            return instance.cache.size;
+            const cache = globalContext.get(contextKey) || {};
+            return Object.keys(cache).length;
         };
 
         /**
          * Clear all entries from cache
          */
         node.clear = function() {
-            instance.cache.clear();
+            globalContext.set(contextKey, {});
         };
 
-        // Internal: dispatch updates to matching subscriptions
-        // Optimized: O(1) for exact matches, O(w) for wildcard patterns
+        // Internal: dispatch updates to matching subscriptions (O(1) lookup)
         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) {
+            const subs = instance.subscriptions.get(topic);
+            if (subs) {
+                for (const [subId, callback] of subs) {
                     try {
                         callback(topic, entry);
                     } catch (err) {
@@ -232,17 +184,6 @@ module.exports = function(RED) {
                     }
                 }
             }
-
-            // 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);
 
@@ -254,11 +195,10 @@ module.exports = function(RED) {
 
             instance.users--;
             if (instance.users <= 0) {
-                instance.cache.clear();
-                instance.exactSubscriptions.clear();
-                instance.wildcardSubscriptions.clear();
+                // Don't clear the context cache - let it persist
+                instance.subscriptions.clear();
                 instance.emitter.removeAllListeners();
-                cacheInstances.delete(cacheKey);
+                sharedInstances.delete(instanceKey);
             }
             done();
         });
@@ -281,11 +221,11 @@ module.exports = function(RED) {
     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;
+            const instance = sharedInstances.get(node.id);
+            let subCount = 0;
             if (instance) {
-                for (const subs of instance.exactSubscriptions.values()) {
-                    exactSubCount += subs.size;
+                for (const subs of instance.subscriptions.values()) {
+                    subCount += subs.size;
                 }
             }
             res.json({
@@ -294,9 +234,8 @@ module.exports = function(RED) {
                 maxEntries: node.maxEntries,
                 ttl: node.ttl,
                 subscriptions: {
-                    exact: exactSubCount,
-                    wildcard: instance ? instance.wildcardSubscriptions.size : 0,
-                    exactTopics: instance ? instance.exactSubscriptions.size : 0
+                    count: subCount,
+                    topics: instance ? instance.subscriptions.size : 0
                 }
             });
         } else {
@@ -317,11 +256,17 @@ module.exports = function(RED) {
     // 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);
+        // Get all event-cache nodes and collect their topics
+        RED.nodes.eachNode(function(n) {
+            if (n.type === 'event-cache') {
+                const cacheNode = RED.nodes.getNode(n.id);
+                if (cacheNode && cacheNode.getTopics) {
+                    for (const topic of cacheNode.getTopics()) {
+                        allTopics.add(topic);
+                    }
+                }
             }
-        }
+        });
         res.json(Array.from(allTopics).sort());
     });
 };

package/nodes/event-calc.html

@@ -16,7 +16,8 @@
             outputTopic: { value: "calc/result" }
         },
         inputs: 1,
-        outputs: 1,
+        outputs: 2,
+        outputLabels: ["result", "error"],
         icon: "font-awesome/fa-calculator",
         label: function() {
             return this.name || this.expression || "event calc";
@@ -34,7 +35,7 @@
                     $.getJSON("event-cache/" + cacheId + "/topics", function(topics) {
                         cachedTopics = topics || [];
                         // Update existing autocomplete instances
-                        $(".input-pattern").each(function() {
+                        $(".input-topic").each(function() {
                             $(this).autocomplete("option", "source", cachedTopics);
                         });
                     });
@@ -92,17 +93,17 @@
 
                     $('<span/>', { style: "flex: 0 0 auto;" }).text(" = ").appendTo(row);
 
-                    const patternInput = $('<input/>', {
+                    const topicInput = $('<input/>', {
                         type: "text",
                         placeholder: "topic (type to search cached topics)",
-                        class: "input-pattern"
+                        class: "input-topic"
                     })
                     .css({ flex: "1 1 auto" })
-                    .val(data.pattern || "")
+                    .val(data.topic || data.pattern || "")
                     .appendTo(row);
 
-                    // Add autocomplete to pattern input
-                    patternInput.autocomplete({
+                    // Add autocomplete to topic input
+                    topicInput.autocomplete({
                         source: cachedTopics,
                         minLength: 0,
                         delay: 0
@@ -135,9 +136,9 @@
 
             $("#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 });
+                const topic = $(this).find(".input-topic").val().trim();
+                if (name && topic) {
+                    node.inputMappings.push({ name: name, topic: topic });
                 }
             });
         }
@@ -157,7 +158,7 @@
         <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
+            Map variable names to topics.
         </div>
     </div>
     <div class="form-row">
@@ -220,7 +221,7 @@
     <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>
+        <dd>Map variable names to 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>
@@ -231,7 +232,7 @@
             </ul>
         </dd>
         <dt>Output Topic</dt>
-        <dd>Topic to set on output messages</dd>
+        <dd>Topic for output messages.</dd>
     </dl>
 
     <h3>Inputs</h3>
@@ -243,19 +244,40 @@
     </dl>
 
     <h3>Outputs</h3>
+    <p>The node has two outputs:</p>
+    <ol>
+        <li><b>Result</b> - Successful calculation results</li>
+        <li><b>Error</b> - Errors (NaN results, evaluation failures)</li>
+    </ol>
+
+    <h4>Output 1 (Result)</h4>
     <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>
+        <dd>The output topic</dd>
+        <dt>topics <span class="property-type">object</span></dt>
+        <dd>Mapping of variable names to topics</dd>
+        <dt>timestamps <span class="property-type">object</span></dt>
+        <dd>Mapping of variable names to their cached timestamps</dd>
         <dt>inputs <span class="property-type">object</span></dt>
-        <dd>Details of all input values used in the calculation</dd>
+        <dd>Full details of all input values</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>
 
+    <h4>Output 2 (Error)</h4>
+    <dl class="message-properties">
+        <dt>payload.error <span class="property-type">string</span></dt>
+        <dd>Error message (e.g., "Expression resulted in NaN")</dd>
+        <dt>payload.missingInputs <span class="property-type">array</span></dt>
+        <dd>List of input variables that were undefined</dd>
+        <dt>payload.expression <span class="property-type">string</span></dt>
+        <dd>The expression that failed</dd>
+    </dl>
+
     <h3>Built-in Functions</h3>
     <p>The following functions are available in expressions:</p>
 
@@ -304,10 +326,4 @@
         <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>