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

package/README.md

@@ -80,7 +80,12 @@ Publishes your own data to the Data Hub.
 - **Provider ID:** Leave empty to use your Client ID (Recommended).
 - **Input:** Send a JSON object: `{ "machine": { "status": "active" } }`.
 - **Auto-Discovery:** Automatically creates variable definitions based on your JSON structure.
-- **Keep-Alive:** Configurable interval (Default: 300s / 5min) to refresh definitions, preventing timeouts (Provider disappearance) while minimizing traffic.
+- **Bi-Directional:** Enable "Allow external writes" to let other apps write to your variables. Changes are emitted continuously on the **2nd Output**.
+- **Keep-Alive:** Configurable interval (Default: 300s / 5min).
+- **Quality & Timestamp:** Override metadata by sending an object:
+  ```json
+  { "temp": { "value": 23.5, "quality": "BAD", "timestamp": 1712000000 } }
+  ```
 
 ---
 

package/nodes/datahub-input.js

@@ -214,7 +214,14 @@ module.exports = function (RED) {
 
             // If Wildcard (empty targetIds and isWildcard=true) -> Request ALL.
             // If Specific (targetIds has items) -> Request specific.
-            const snapshotMsg = await nc.request(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(targetIds), { timeout: 2000 });
+            // Use serialRequest via Config Node to prevent concurrency issues on the connection
+            let snapshotMsg;
+            if (typeof connection.serialRequest === 'function') {
+              snapshotMsg = await connection.serialRequest(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(targetIds), { timeout: 5000 });
+            } else {
+              // Fallback for older config nodes (should not happen if package updated correctly)
+              snapshotMsg = await nc.request(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(targetIds), { timeout: 5000 });
+            }
 
             const bb = new flatbuffers.ByteBuffer(snapshotMsg.data);
             const snapshotObj = ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(bb);
@@ -239,7 +246,9 @@ module.exports = function (RED) {
 
 
 
-        // Initial snapshot
+        // Initial snapshot with random jitter into prevent concurrency overload
+        // (If multiple nodes start simultaneously)
+        await new Promise(r => setTimeout(r, Math.floor(Math.random() * 500) + 100));
         await performSnapshot();
 
         // Setup polling if configured

package/nodes/datahub-output.html

@@ -156,4 +156,17 @@
   }
 }</pre>
   <p>becomes variables <code>machine.status</code> and <code>machine.details.temp</code> in the Data Hub.</p>
+
+  <h3>Advanced: Manual Quality & Timestamp</h3>
+  <p>You can override the quality and timestamp by sending a value object instead of a raw value:</p>
+<pre>{
+  "machine": {
+    "temp": {
+        "value": 45.2,
+        "quality": "BAD",
+        "timestamp": 1712000000000
+    }
+  }
+}</pre>
+  <p>Supported Qualities: <code>GOOD</code>, <code>BAD</code>, <code>UNCERTAIN</code>.</p>
 </script>

package/nodes/datahub-output.js

@@ -33,7 +33,20 @@ const defaultValue = (type) => {
 const flattenPayload = (value, prefix = '') => {
   const entries = [];
   const path = (key) => (prefix ? `${prefix}.${key}` : key);
+
+  // Extended Value Object Detection:
+  // If object has 'value' AND ('quality' OR 'timestamp'), treat as single leaf with metadata.
   if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+    if ('value' in value && ('quality' in value || 'timestamp' in value)) {
+      entries.push({
+        key: prefix || 'value', // If root is the object
+        value: value.value,
+        quality: value.quality,
+        timestamp: value.timestamp
+      });
+      return entries;
+    }
+
     Object.entries(value).forEach(([key, val]) => {
       if (val !== undefined) {
         entries.push(...flattenPayload(val, path(key)));
@@ -363,7 +376,8 @@ module.exports = function (RED) {
 
             let definitionsChanged = false;
 
-            entries.forEach(({ key, value }) => {
+            entries.forEach((entry) => {
+              const { key, value } = entry;
               // Ensure we don't accidentally send undefined/null as value if logic slipped through
               if (value === undefined || value === null) return;
 
@@ -371,11 +385,30 @@ module.exports = function (RED) {
               if (created) {
                 definitionsChanged = true;
               }
+
+              // Handle custom timestamp
+              let ts = BigInt(Date.now()) * 1_000_000n;
+              if (entry.timestamp) {
+                try {
+                  // Support Date object or number (ms)
+                  const ms = (entry.timestamp instanceof Date) ? entry.timestamp.getTime() : Number(entry.timestamp);
+                  if (!isNaN(ms)) {
+                    ts = BigInt(Math.floor(ms)) * 1_000_000n;
+                  }
+                } catch (e) { /* ignore */ }
+              }
+
+              // Handle custom quality
+              let qual = 'GOOD';
+              if (entry.quality) {
+                qual = String(entry.quality).toUpperCase();
+              }
+
               const state = {
                 id: def.id,
                 value,
-                timestamp: BigInt(Date.now()) * 1_000_000n,
-                quality: 'GOOD',
+                timestamp: ts,
+                quality: qual,
               };
               // states.push(state); // No longer pushing to a temporary 'states' array
               stateMap.set(def.id, state); // Update the global stateMap

package/nodes/uos-config.js

@@ -175,6 +175,31 @@ module.exports = function (RED) {
       return this.nc;
     };
 
+    this.requestQueue = Promise.resolve();
+
+    this.serialRequest = async (subject, payload, options = {}) => {
+      // Enqueue request to run sequentially
+      const result = this.requestQueue.then(async () => {
+        const nc = await this.ensureConnection();
+        return nc.request(subject, payload, options);
+      });
+
+      // Ensure queue does not block on failures (catch individually inside the chain logic)
+      // Actually, chaining the result directly makes the next one wait for result resolution.
+      // We want to update queue pointer to catch errors so next request still runs.
+      this.requestQueue = result.catch(() => { });
+
+      return result;
+    };
+
+    /**
+     * @deprecated Use serialRequest for concurrency safety
+     */
+    this.acquire = async () => {
+      this.users += 1;
+      return this.ensureConnection();
+    };
+
     this.getGrantedScopes = async () => {
       await this.getToken();
       return this.tokenInfo?.grantedScope || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-uos-nats",
-  "version": "1.1.0",
+  "version": "1.2.2",
   "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",