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

package/nodes/event-topic.html

@@ -10,7 +10,7 @@
         defaults: {
             name: { value: "" },
             cache: { value: "", type: "event-cache", required: true },
-            pattern: { value: "*" },
+            topic: { value: "" },
             outputFormat: { value: "value" },
             outputOnStart: { value: false }
         },
@@ -18,7 +18,7 @@
         outputs: 1,
         icon: "font-awesome/fa-filter",
         label: function() {
-            return this.name || this.pattern || "event topic";
+            return this.name || this.topic || "event topic";
         },
         paletteLabel: "event topic",
         labelStyle: function() { return (this.name ? "node_label_italic" : "") + " event-calc-white-text"; },
@@ -30,18 +30,18 @@
                 const cacheId = $("#node-input-cache").val();
                 if (cacheId) {
                     $.getJSON("event-cache/" + cacheId + "/topics", function(topics) {
-                        $("#node-input-pattern").autocomplete("option", "source", topics || []);
+                        $("#node-input-topic").autocomplete("option", "source", topics || []);
                     });
                 }
             }
 
-            // Setup autocomplete on pattern input
-            $("#node-input-pattern").autocomplete({
+            // Setup autocomplete on topic input
+            $("#node-input-topic").autocomplete({
                 source: [],
                 minLength: 0,
                 delay: 0
             }).on("focus", function() {
-                if (!$(this).val() || $(this).val() === "*") {
+                if (!$(this).val()) {
                     $(this).autocomplete("search", "");
                 }
             });
@@ -65,19 +65,14 @@
         <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>
+        <label for="node-input-topic"><i class="fa fa-bookmark"></i> Topic</label>
+        <input type="text" id="node-input-topic" placeholder="sensors/room1/temp">
     </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">
@@ -88,32 +83,31 @@
 </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>
+    <p>Subscribes to a topic and outputs when that topic updates 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>Topic</dt>
+        <dd>The exact topic to subscribe to</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>
+        <dd>If checked, outputs the current cached value 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>
+        <dt class="optional">topic + payload="subscribe"</dt>
+        <dd>Dynamically change the subscription to a new topic</dd>
+        <dt class="optional">payload = "refresh"</dt>
+        <dd>Output the current cached value</dd>
     </dl>
 
     <h3>Outputs</h3>
@@ -125,12 +119,4 @@
         <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

@@ -1,12 +1,12 @@
 /**
- * event-topic - Subscription node for topic patterns
+ * event-topic - Subscription node for exact topics
  *
  * 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
+ * - Subscribes to cache for a specific topic
+ * - Outputs when the topic updates
+ * - Multiple output formats: value only or full entry
+ * - Optional output of existing value on start
+ * - Dynamic topic change via input message
  */
 module.exports = function(RED) {
     function EventTopicNode(config) {
@@ -14,7 +14,8 @@ module.exports = function(RED) {
         const node = this;
 
         node.cacheConfig = RED.nodes.getNode(config.cache);
-        node.pattern = config.pattern || '#';
+        // Support both old 'pattern' and new 'topic' config
+        node.topic = config.topic || config.pattern || '';
         node.outputFormat = config.outputFormat || 'value';
         node.outputOnStart = config.outputOnStart || false;
 
@@ -25,6 +26,11 @@ module.exports = function(RED) {
             return;
         }
 
+        if (!node.topic) {
+            node.status({ fill: "yellow", shape: "ring", text: "no topic" });
+            return;
+        }
+
         /**
          * Build output message based on configured format
          */
@@ -45,21 +51,6 @@ module.exports = function(RED) {
                             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,
@@ -69,10 +60,10 @@ module.exports = function(RED) {
         }
 
         /**
-         * Subscribe to the current pattern
+         * Subscribe to the current topic
          */
         function subscribe() {
-            subscriptionId = node.cacheConfig.subscribe(node.pattern, (topic, entry) => {
+            subscriptionId = node.cacheConfig.subscribe(node.topic, (topic, entry) => {
                 const msg = buildOutputMessage(topic, entry);
                 node.send(msg);
 
@@ -84,43 +75,45 @@ module.exports = function(RED) {
 
         // Initial subscription
         subscribe();
-        node.status({ fill: "green", shape: "dot", text: node.pattern });
+        const displayTopic = node.topic.length > 20 ? node.topic.substring(0, 17) + '...' : node.topic;
+        node.status({ fill: "green", shape: "dot", text: displayTopic });
 
-        // Output existing values on start if configured
+        // Output existing value 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);
+                const entry = node.cacheConfig.getValue(node.topic);
+                if (entry) {
+                    const msg = buildOutputMessage(node.topic, entry);
                     node.send(msg);
                 }
             });
         }
 
-        // Handle input messages for dynamic pattern change
+        // Handle input messages for dynamic topic 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 (msg.topic && typeof msg.topic === 'string' && msg.payload === 'subscribe') {
+                // Unsubscribe from old topic
                 if (subscriptionId && node.cacheConfig) {
                     node.cacheConfig.unsubscribe(subscriptionId);
                 }
 
-                // Update pattern and resubscribe
-                node.pattern = msg.pattern;
+                // Update topic and resubscribe
+                node.topic = msg.topic;
                 subscribe();
 
-                node.status({ fill: "blue", shape: "dot", text: node.pattern });
+                const dt = node.topic.length > 20 ? node.topic.substring(0, 17) + '...' : node.topic;
+                node.status({ fill: "blue", shape: "dot", text: dt });
             }
 
-            // 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);
+            // Allow manual trigger to output current value
+            if (msg.payload === 'refresh') {
+                const entry = node.cacheConfig.getValue(node.topic);
+                if (entry) {
+                    const outMsg = buildOutputMessage(node.topic, entry);
                     send(outMsg);
                 }
             }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-red-contrib-event-calc",
-  "version": "0.1.2",
-  "description": "Node-RED nodes for event caching and calculations with topic wildcard patterns",
+  "version": "2.0.1",
+  "description": "Node-RED nodes for event caching and calculations",
   "author": {
     "name": "Holger Amort"
   },
@@ -9,19 +9,18 @@
     "node-red",
     "events",
     "cache",
-    "wildcards",
     "reactive",
     "calculation",
     "streaming"
   ],
-  "license": "MIT",
-  "homepage": "https://github.com/ErnstHolger/node-red#readme",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://github.com/ErnstHolger/node-red-contrib-event-calc#readme",
   "bugs": {
-    "url": "https://github.com/ErnstHolger/node-red/issues"
+    "url": "https://github.com/ErnstHolger/node-red-contrib-event-calc/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ErnstHolger/node-red.git"
+    "url": "git+https://github.com/ErnstHolger/node-red-contrib-event-calc.git"
   },
   "node-red": {
     "version": ">=2.0.0",
@@ -29,14 +28,29 @@
       "event-cache": "nodes/event-cache.js",
       "event-in": "nodes/event-in.js",
       "event-topic": "nodes/event-topic.js",
-      "event-calc": "nodes/event-calc.js"
+      "event-calc": "nodes/event-calc.js",
+      "event-json": "nodes/event-json.js",
+      "event-simulator": "nodes/event-simulator.js",
+      "event-chart": "nodes/event-chart.js"
     }
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "scripts": {
-    "publish:dry": "npm publish --dry-run"
+    "deploy": "npm link",
+    "deploy:patch": "npm version patch --no-git-tag-version && npm link",
+    "deploy:minor": "npm version minor --no-git-tag-version && npm link",
+    "deploy:major": "npm version major --no-git-tag-version && npm link",
+    "publish:dry": "npm publish --dry-run",
+    "publish:patch": "npm version patch && npm publish && start https://flows.nodered.org/add/node",
+    "publish:minor": "npm version minor && npm publish && start https://flows.nodered.org/add/node",
+    "publish:major": "npm version major && npm publish && start https://flows.nodered.org/add/node",
+    "test": "playwright test",
+    "test:ui": "playwright test --ui",
+    "test:headed": "playwright test --headed"
   },
-  "dependencies": {}
+  "devDependencies": {
+    "@playwright/test": "^1.57.0"
+  }
 }

package/playwright.config.js

@@ -0,0 +1,22 @@
+// @ts-check
+const { defineConfig } = require('@playwright/test');
+
+module.exports = defineConfig({
+  testDir: './tests',
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: 1,
+  reporter: 'html',
+  use: {
+    baseURL: 'http://localhost:1880',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { browserName: 'chromium' },
+    },
+  ],
+});

package/tests/external-trigger.spec.js

@@ -0,0 +1,141 @@
+// @ts-check
+const { test, expect } = require('@playwright/test');
+
+test.describe('Event Calc - External Trigger Feature', () => {
+  test.beforeEach(async ({ page }) => {
+    // Navigate to Node-RED editor
+    await page.goto('/');
+    // Wait for Node-RED to load
+    await page.waitForSelector('#red-ui-palette', { timeout: 30000 });
+  });
+
+  test('should show External Trigger checkbox in event-calc node configuration', async ({ page }) => {
+    // Search for the event-calc node in the palette
+    const paletteSearch = page.locator('#red-ui-palette-search input');
+    await paletteSearch.fill('event calc');
+
+    // Wait for search results
+    await page.waitForTimeout(500);
+
+    // Find the event-calc node in the palette
+    const eventCalcNode = page.locator('.red-ui-palette-node[data-palette-type="event-calc"]');
+    await expect(eventCalcNode).toBeVisible();
+
+    // Drag the node to the workspace
+    const workspace = page.locator('#red-ui-workspace-chart');
+    await eventCalcNode.dragTo(workspace);
+
+    // Double-click on the newly created node to open the editor
+    // First find the node in the workspace
+    const nodeInWorkspace = page.locator('.red-ui-flow-node-group').last();
+    await nodeInWorkspace.dblclick();
+
+    // Wait for the edit dialog to open
+    await page.waitForSelector('.red-ui-editor', { timeout: 5000 });
+
+    // Verify the External Trigger checkbox exists
+    const externalTriggerCheckbox = page.locator('#node-input-externalTrigger');
+    await expect(externalTriggerCheckbox).toBeVisible();
+
+    // Verify it's unchecked by default
+    await expect(externalTriggerCheckbox).not.toBeChecked();
+
+    // Check the checkbox
+    await externalTriggerCheckbox.check();
+    await expect(externalTriggerCheckbox).toBeChecked();
+
+    // Verify the label is correct
+    const label = page.locator('label[for="node-input-externalTrigger"]');
+    await expect(label).toContainText('External Trigger');
+    await expect(label).toContainText('calculate on any input message');
+  });
+
+  test('should toggle External Trigger checkbox', async ({ page }) => {
+    // Search for the event-calc node
+    const paletteSearch = page.locator('#red-ui-palette-search input');
+    await paletteSearch.fill('event calc');
+    await page.waitForTimeout(500);
+
+    // Find and drag the node
+    const eventCalcNode = page.locator('.red-ui-palette-node[data-palette-type="event-calc"]');
+    const workspace = page.locator('#red-ui-workspace-chart');
+    await eventCalcNode.dragTo(workspace);
+
+    // Open the node editor
+    const nodeInWorkspace = page.locator('.red-ui-flow-node-group').last();
+    await nodeInWorkspace.dblclick();
+    await page.waitForSelector('.red-ui-editor', { timeout: 5000 });
+
+    const externalTriggerCheckbox = page.locator('#node-input-externalTrigger');
+
+    // Toggle on
+    await externalTriggerCheckbox.check();
+    await expect(externalTriggerCheckbox).toBeChecked();
+
+    // Toggle off
+    await externalTriggerCheckbox.uncheck();
+    await expect(externalTriggerCheckbox).not.toBeChecked();
+
+    // Toggle on again
+    await externalTriggerCheckbox.check();
+    await expect(externalTriggerCheckbox).toBeChecked();
+  });
+
+  test('should persist External Trigger setting after save', async ({ page }) => {
+    // Search for event-cache node first (required config)
+    const paletteSearch = page.locator('#red-ui-palette-search input');
+    await paletteSearch.fill('event cache');
+    await page.waitForTimeout(500);
+
+    // Add event-cache config node if needed
+    const eventCacheNode = page.locator('.red-ui-palette-node[data-palette-type="event-cache"]');
+    if (await eventCacheNode.isVisible()) {
+      const workspace = page.locator('#red-ui-workspace-chart');
+      await eventCacheNode.dragTo(workspace);
+
+      // Configure the cache node
+      const cacheNodeInWorkspace = page.locator('.red-ui-flow-node-group').last();
+      await cacheNodeInWorkspace.dblclick();
+      await page.waitForSelector('.red-ui-editor', { timeout: 5000 });
+
+      // Set a name for the cache
+      const nameInput = page.locator('#node-input-name');
+      await nameInput.fill('Test Cache');
+
+      // Save the cache node
+      const doneButton = page.locator('.red-ui-tray-footer button').filter({ hasText: 'Done' });
+      await doneButton.click();
+      await page.waitForTimeout(500);
+    }
+
+    // Now add the event-calc node
+    await paletteSearch.clear();
+    await paletteSearch.fill('event calc');
+    await page.waitForTimeout(500);
+
+    const eventCalcNode = page.locator('.red-ui-palette-node[data-palette-type="event-calc"]');
+    const workspace = page.locator('#red-ui-workspace-chart');
+    await eventCalcNode.dragTo(workspace);
+
+    // Open the node editor
+    const calcNodeInWorkspace = page.locator('.red-ui-flow-node-group').last();
+    await calcNodeInWorkspace.dblclick();
+    await page.waitForSelector('.red-ui-editor', { timeout: 5000 });
+
+    // Check the External Trigger checkbox
+    const externalTriggerCheckbox = page.locator('#node-input-externalTrigger');
+    await externalTriggerCheckbox.check();
+
+    // Save the node configuration
+    const doneButton = page.locator('.red-ui-tray-footer button').filter({ hasText: 'Done' });
+    await doneButton.click();
+    await page.waitForTimeout(500);
+
+    // Reopen the node editor
+    await calcNodeInWorkspace.dblclick();
+    await page.waitForSelector('.red-ui-editor', { timeout: 5000 });
+
+    // Verify the checkbox is still checked
+    await expect(externalTriggerCheckbox).toBeChecked();
+  });
+});