node-red-contrib-uos-nats 1.0.7 → 1.1.0

package/lib/payloads.js

@@ -19,7 +19,7 @@ import { ReadVariablesQueryResponseT } from './fbs/weidmueller/ucontrol/hub/read
 import { ReadVariablesQueryRequestT } from './fbs/weidmueller/ucontrol/hub/read-variables-query-request.js';
 import { ReadVariablesQueryRequest } from './fbs/weidmueller/ucontrol/hub/read-variables-query-request.js';
 import { ReadProviderDefinitionQueryRequest } from './fbs/weidmueller/ucontrol/hub/read-provider-definition-query-request.js';
-import { WriteVariablesCommandT } from './fbs/weidmueller/ucontrol/hub/write-variables-command.js';
+import { WriteVariablesCommandT, WriteVariablesCommand } from './fbs/weidmueller/ucontrol/hub/write-variables-command.js';
 import { StateChangedEvent } from './fbs/weidmueller/ucontrol/hub/state-changed-event.js';
 import { State } from './fbs/weidmueller/ucontrol/hub/state.js';
 
@@ -206,6 +206,12 @@ export function encodeWriteVariablesCommand(variables, fingerprint = BigInt(0))
     return builder.asUint8Array();
 }
 
+export function decodeWriteVariablesCommand(buffer) {
+    const bb = new flatbuffers.ByteBuffer(buffer);
+    const cmd = WriteVariablesCommand.getRootAsWriteVariablesCommand(bb);
+    return decodeVariableList(cmd.variables());
+}
+
 export function decodeVariableList(list) {
     if (!list)
         return [];

package/nodes/datahub-output.html

@@ -6,10 +6,12 @@
       name: { value: '' },
       connection: { type: 'uos-config', required: true },
       providerId: { value: '', required: false },
-      heartbeatInterval: { value: 300, required: true, validate: RED.validators.number() } // Default 5 mins
+      heartbeatInterval: { value: 300, required: true, validate: RED.validators.number() }, // Default 5 mins
+      enableWrites: { value: false }
     },
     inputs: 1,
-    outputs: 1,
+    outputs: 2,
+    outputLabels: ["Input Passthrough", "External Write Command"],
     icon: "datahub-provider.svg",
     oneditprepare: function () {
       const node = this;
@@ -119,6 +121,11 @@
     <input type="number" id="node-input-heartbeatInterval" placeholder="300" style="width:100px;">
     <span style="color:#777; font-size:0.9em; margin-left:10px;">(Default: 300s / 5min)</span>
   </div>
+  <div class="form-row">
+    <label for="node-input-enableWrites"><i class="fa fa-pencil"></i> Access</label>
+    <input type="checkbox" id="node-input-enableWrites" style="width:auto; vertical-align:top;">
+    <span style="margin-left:5px;">Allow external writes (Bidirectional)</span>
+  </div>
 </script>
 
 <script type="text/html" data-help-name="datahub-output">
@@ -130,8 +137,15 @@
     <dd>The unique ID for this provider.</dd>
     <dd><b>Auto Mode:</b> Shows the <em>Client Name</em> from your Config. Uses this name automatically.</dd>
     <dt>Keep-Alive (s)</dt>
-    <dd>Interval in seconds to refresh the provider definition. Default: <b>300s (5 min)</b>. Lower values increase traffic but might be needed for very strict networks.</dd>
+    <dd>Interval in seconds to refresh the provider definition. Default: <b>300s (5 min)</b>.</dd>
+    <dt>Allow external writes</dt>
+    <dd>If checked, variables are published as <code>READ_WRITE</code>. External changes are emitted on the <b>2nd Output</b>.</dd>
   </dl>
+  <h3>Outputs</h3>
+  <ol>
+    <li><b>Input Passthrough:</b> The original message sent to the node.</li>
+    <li><b>External Write Command:</b> Emits a message when another system writes to a variable. <code>msg.var</code> contains the key, <code>msg.value</code> the new value.</li>
+  </ol>
   <p>Send a JSON object as <code>msg.payload</code>. Nested objects are flattened using dot-notation to create <strong>subcategories</strong> automatically:</p>
 <pre>{
   "machine": {

package/nodes/datahub-output.js

@@ -96,7 +96,7 @@ module.exports = function (RED) {
         id: nextId += 1,
         key: normalized,
         dataType,
-        access: 'READ_ONLY',
+        access: config.enableWrites ? 'READ_WRITE' : 'READ_ONLY',
       };
       defMap.set(normalized, def);
       definitions.push(def);
@@ -146,38 +146,21 @@ module.exports = function (RED) {
 
     const sendValuesUpdate = async () => {
       if (!nc || nc.isClosed()) {
-        console.log('[DataHub Output] Heartbeat skipped: NATS closed or missing.');
-        // Add event listeners for connection status changes
-        // Note: `connection` is defined in the outer scope, not `this.connection`
-        connection.on('reconnected', () => {
-          console.log('[DataHub Output] Reconnected. Re-publishing definition...');
-          this.status({ fill: 'green', shape: 'ring', text: 'reconnected' });
-          start().catch((err) => {
-            this.warn(`Re-registration failed: ${err.message}`);
-          });
-        });
-        connection.on('disconnected', () => {
-          this.status({ fill: 'red', shape: 'ring', text: 'disconnected' });
-        });
-        return; // Skip sending values if NATS is closed
+        // console.log('[DataHub Output] Heartbeat skipped: NATS closed.');
+        return;
       }
       if (!loadedPayloads || !loadedSubjects) return;
 
       // If we have no definitions yet, nothing to send
-      if (definitions.length === 0) {
-        // console.log('[DataHub Output] Heartbeat skipped: No definitions.');
-        return;
-      }
+      if (definitions.length === 0) return;
 
       // Log heartbeat occasionally to prove aliveness
       const nowMs = Date.now();
       if (!this.lastHeartbeatLog || nowMs - this.lastHeartbeatLog > 10000) {
-        console.log(`[DataHub Output] Sending heartbeat for ${definitions.length} vars...`);
         this.lastHeartbeatLog = nowMs;
       }
 
       const stateObj = {};
-      const nowNs = Date.now() * 1_000_000;
       for (const s of stateMap.values()) {
         s.timestamp = BigInt(Date.now()) * 1_000_000n; // Force refresh timestamp
         stateObj[s.id] = s;
@@ -187,7 +170,7 @@ module.exports = function (RED) {
         const subject = loadedSubjects.varsChangedEvent(this.providerId);
 
         await nc.publish(subject, payload);
-        await nc.flush(); // Ensure NATS accepts the packet (catches Permission Errors)
+        await nc.flush();
       } catch (err) {
         this.warn(`Heartbeat error: ${err.message}`);
       }
@@ -197,6 +180,18 @@ module.exports = function (RED) {
       sendValuesUpdate();
     }, 1000); // 1.0s interval matches Python SDK
 
+    // Reconnect Handler (Defined outside start to be referenced in close)
+    const onReconnect = () => {
+      console.log('[DataHub Output] Connection restored (event). Re-sending definition...');
+      this.status({ fill: 'green', shape: 'ring', text: 'reconnected' });
+      // Force definition update immediately upon reconnection
+      if (loadedPayloads && loadedSubjects) {
+        sendDefinitionUpdate(loadedPayloads, loadedSubjects).catch(err => {
+          this.warn(`Reconnect update error: ${err.message}`);
+        });
+      }
+    };
+
     const start = async () => {
       try {
         console.log('[DataHub Output] Starting...');
@@ -209,13 +204,14 @@ module.exports = function (RED) {
         nc = await connection.acquire();
         console.log('[DataHub Output] NATS acquired.');
 
+        // ATTACH LISTENER HERE
+        connection.on('reconnected', onReconnect);
+
         if (definitions.length > 0) {
           // Initial publish
           await sendDefinitionUpdate(payloads, subjects);
 
           // Subscribe to Registry State changes
-          // The registry publishes its state (RUNNING=1) when it comes online.
-          // Providers MUST re-publish their definition when this happens.
           nc.subscribe(subjects.registryStateEvent(), {
             callback: (err, msg) => {
               if (err) return;
@@ -237,10 +233,7 @@ module.exports = function (RED) {
         sub = nc.subscribe(subjects.readVariablesQuery(this.providerId), {
           callback: (err, msg) => {
             if (err) {
-              // Suppress permission violation error as it's expected for some tokens
-              // and doesn't prevent pushing data.
               if (err.message.includes('Permissions Violation')) {
-                this.trace(`Read request permission invalid (expected for push-only): ${err.message}`);
                 return;
               }
               this.warn(`Read request error: ${err.message}`);
@@ -251,28 +244,80 @@ module.exports = function (RED) {
         });
         console.log('[DataHub Output] Subscribed to Read Query.');
 
-        // Listen for Definition READ requests (Discovery)
-        // SKIPPED: Permission Violation on v1.loc.<id>.def.qry.read
-        // Data Hub seems to discover providers via initial announcement or direct variable reads.
-        /*
-        const defSub = nc.subscribe(subjects.readProviderDefinitionQuery(this.providerId), {
-          callback: (err, msg) => {
-            if (err) {
-              this.warn(`Def request error: ${err.message}`);
-              return;
-            }
-            if (!msg.reply) return;
- 
-            // Send known definition
-            const { payload } = payloads.buildProviderDefinitionEvent(definitions);
-            nc.publish(msg.reply, payload);
-          }
-        });
-        */
+        // LISTEN FOR WRITE COMMANDS (BIDIRECTIONAL)
+        if (config.enableWrites) {
+          const writeSubject = subjects.writeVariablesCommand(this.providerId);
+          console.log(`[DataHub Output] Subscribing to WRITE command: ${writeSubject}`);
 
-        // Track the subscription to close it later if needed (though existing code only tracks 'sub')
-        // Ideally we should track both or use a subscription manager, but for now let's hope 'sub' isn't the only one closed.
-        // Actually, looking at close(), it likely calls connection.release(). NATS connection close cleans up subs.
+          nc.subscribe(writeSubject, {
+            callback: (err, msg) => {
+              if (err) {
+                this.warn(`Write command error: ${err.message}`);
+                return;
+              }
+              try {
+                const updates = payloads.decodeWriteVariablesCommand(msg.data);
+                if (!updates || updates.length === 0) return;
+
+                console.log(`[DataHub Output] Received WRITE for ${updates.length} vars.`);
+
+                // Prepare output for Node-RED Flow
+                const outputMsgs = [];
+                let stateChanged = false;
+
+                updates.forEach(update => {
+                  // Find defining key by ID
+                  // This is expensive O(N). Optimization: Map<ID, Key>
+                  // But definitions are usually few (<1000).
+                  // We have stateMap keyed by ID!
+                  const currentState = stateMap.get(update.id);
+                  if (currentState) {
+                    // Update internal state
+                    currentState.value = update.value;
+                    currentState.timestamp = BigInt(Date.now()) * 1_000_000n;
+                    currentState.quality = 'GOOD_LOCAL_OVERRIDE'; // Mark as written? Or just GOOD? 
+                    // NATS Sample uses GOOD.
+
+                    // Find key (optional, for convenience in msg)
+                    const def = definitions.find(d => d.id === update.id);
+                    const key = def ? def.key : `id_${update.id}`;
+
+                    outputMsgs.push({
+                      topic: key,
+                      payload: update.value,
+                      var: key,
+                      value: update.value,
+                      providerId: this.providerId,
+                      _msgid: RED.util.generateId()
+                    });
+                    stateChanged = true;
+                  }
+                });
+
+                if (stateChanged) {
+                  // ACK changes back to DataHub (VariablesChangedEvent)
+                  // This confirms to the writer that the value was accepted.
+                  sendValuesUpdate();
+
+                  // Emit to 2nd Output
+                  if (outputMsgs.length > 0) {
+                    // Node-RED send: [output1, output2]
+                    // We send null to output1 (pass-through not involved here)
+                    // We send array of msgs to output2? Or one by one?
+                    // Ideally one array if multiple updates?
+                    // Let's send them individually to be safe with flows.
+                    outputMsgs.forEach(m => {
+                      this.send([null, m]);
+                    });
+                  }
+                }
+
+              } catch (e) {
+                this.warn(`Failed to process write command: ${e.message}`);
+              }
+            }
+          });
+        }
 
         this.status({ fill: 'green', shape: 'dot', text: 'ready' });
 
@@ -317,7 +362,6 @@ module.exports = function (RED) {
             }
 
             let definitionsChanged = false;
-            const states = [];
 
             entries.forEach(({ key, value }) => {
               // Ensure we don't accidentally send undefined/null as value if logic slipped through
@@ -364,11 +408,15 @@ module.exports = function (RED) {
 
     this.on('close', async (done) => {
       try {
+        // REMOVE LISTENER
+        if (connection && onReconnect) {
+          connection.removeListener('reconnected', onReconnect);
+        }
+
         if (valueHeartbeat) clearInterval(valueHeartbeat);
         if (sub) {
           await sub.drain();
         }
-        // if (outputHeartbeat) clearInterval(outputHeartbeat);
         await connection.release();
       }
       catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-uos-nats",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Node-RED nodes for Weidmüller u-OS Data Hub. Read, write, and provide variables via NATS protocol with OAuth2 authentication. Features: Variable Key resolution, custom icons, example flows, and provider definition caching.",
   "author": {
     "name": "IoTUeli",