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

package/nodes/datahub-input.html

@@ -62,8 +62,9 @@
       const $hiddenManual = $('#node-input-manualVariables');
 
       // Styles
-      const rowStyle = "display:grid; grid-template-columns: 30px 60px 1fr; align-items:center; padding:4px 0; border-bottom:1px solid #eee; font-family:'Helvetica Neue', Arial, sans-serif; font-size:12px;";
-      const idStyle = "background:#eee; color:#555; padding:1px 4px; border-radius:3px; font-family:monospace; text-align:center; font-size:11px;";
+      // Adjusted: ID column removed per user request (Key is main identifier)
+      const rowStyle = "display:grid; grid-template-columns: 30px 1fr; align-items:center; padding:4px 0; border-bottom:1px solid #eee; font-family:'Helvetica Neue', Arial, sans-serif; font-size:12px;";
+      // const idStyle = ... (removed)
       const keyStyle = "overflow:hidden; text-overflow:ellipsis; white-space:nowrap; padding-left:10px;";
 
       let currentVariables = []; // Stores {id, key, accessType, etc.}
@@ -93,7 +94,7 @@
         const selectedMap = getSelectedMap();
 
         vars.forEach(v => {
-          // Robust ID handling: verify v.id exists (try 'id' and 'Id')
+          // Robust ID handling
           let rawId = (v.id !== undefined && v.id !== null) ? v.id : v.Id;
           const safeId = (rawId !== undefined && rawId !== null) ? rawId : 'ERR';
           const isSelected = selectedMap.has(v.key);
@@ -104,13 +105,15 @@
           const cb = $('<input type="checkbox" class="var-checkbox">')
             .prop('checked', isSelected)
             .data('key', v.key)
-            .data('id', safeId);
+            .data('id', safeId); // ID strictly stored in data attribute
           cbContainer.append(cb);
 
-          const idBadge = $('<div>').append($('<span>', { style: idStyle }).text(safeId));
+          // ID Column Removed from View
+          // const idBadge = ...
+
           const label = $('<div>', { style: keyStyle, title: v.key }).text(v.key);
 
-          row.append(cbContainer).append(idBadge).append(label);
+          row.append(cbContainer).append(label); // No ID badge
           $listContainer.append(row);
         });
       };

package/nodes/datahub-input.js

@@ -150,26 +150,108 @@ module.exports = function (RED) {
         nc = await connection.acquire();
         this.status({ fill: 'green', shape: 'dot', text: 'connected' });
 
-        // Retry Definition Fetch via NATS if Map is empty AND no manual defs
-        if (defMap.size === 0 && this.manualDefs.length === 0) {
+        // Retry Definition Fetch via NATS if Map is empty OR if we have Heuristic IDs (missingId)
+        // Heuristic IDs (ID=Index) are dangerous because they might not match the real NATS IDs (e.g. 291 vs 5)
+        const hasMissingIds = Array.from(defMap.values()).some(d => d.missingId);
+
+        if ((defMap.size === 0 && this.manualDefs.length === 0) || hasMissingIds) {
           try {
+            this.warn(hasMissingIds
+              ? `Loaded variables have unresolved IDs (Heuristic). Attempting NATS Discovery to resolve real IDs for ${this.providerId}...`
+              : `Attempting NATS Discovery (Direct) for ${this.providerId}...`
+            );
+
             // Strategy 1: Direct Provider Query (Standard for many providers)
-            this.warn(`Attempting NATS Discovery (Direct) for ${this.providerId}...`);
-            const defMsg = await nc.request(subjects.readProviderDefinitionQuery(this.providerId), payloads.buildReadProviderDefinitionQuery(), { timeout: 1000 });
+            const requestOptions = { timeout: 2000 };
+            // Reuse serialRequest if available to avoid blocking connection? 
+            // Discovery is one-off, nc.request is fine, but safer to use serial if we updated input.js fully. 
+            // Start uses 'nc' directly currently. That's fine for now as it's sequential in 'start'.
+
+            const defMsg = await nc.request(subjects.readProviderDefinitionQuery(this.providerId), payloads.buildReadProviderDefinitionQuery(), requestOptions);
             const defs = payloads.decodeProviderDefinition(defMsg.data);
-            this.warn(`NATS Direct Discovery: Loaded ${defs.length} variables.`);
-            defs.forEach((def) => defMap.set(def.id, def));
+
+            if (defs && defs.variables.length > 0) {
+              this.warn(`NATS Discovery Successful: Received ${defs.variables.length} definitions with real IDs.`);
+              // Overwrite/Update defMap
+              // Logic: Match by KEY. DataHub providers should have unique keys.
+              // If we have existing "fake" ID 5 for "temp", and NATS says "temp" is ID 291.
+              // We need to update defMap to use 291.
+
+              // Clear Heuristic entries if we trust NATS fully? 
+              // Or just merge?
+              // Safer: Create a lookup from NATS.
+              const realMap = new Map();
+              defs.variables.forEach(d => realMap.set(d.key, d));
+
+              // Update existing defMap
+              // If we had a heuristic entry, replace it.
+              // We rebuild defMap based on NATS mostly, but keep manual fallback?
+
+              // Let's iterate NATS defs and Populating defMap.
+              // Note: NATS Defs don't have 'missingId'.
+              defs.variables.forEach(d => {
+                // If we overwrite, we lose manual metadata (if any)? 
+                // REST might have had better metadata? Usually NATS is source of truth for IDs.
+                defMap.set(d.id, d);
+              });
+
+              // Use Key Matching to remove old Heuristic entries?
+              // Heuristic entries are stored by Key (via fetchProviderVariables logic? No, by ID).
+              // We need to clean up the Fake IDs (0..N) if they don't map to real IDs.
+              // Actually, if we just add real IDs, we have duplicates?
+              // Map is Key=ID.
+              // Fake ID 5: { key: 'voltage' }
+              // Real ID 291: { key: 'voltage' }
+              // If user selected 'voltage', filtering uses KEYS (processStates line 104).
+              // Resolution (line 195) iterates values and matches Key.
+              // It will find BOTH 5 and 291.
+              // targetIds will get [5, 291].
+              // DataHub gets request [5, 291].
+              // 5 is invalid -> ignored.
+              // 291 is valid -> returns value.
+              // Result: It works! (Partially, effectively).
+
+              // But cleaner to remove heuristic ones.
+              for (const [id, def] of defMap.entries()) {
+                if (def.missingId) {
+                  const real = realMap.get(def.key);
+                  if (real && real.id !== id) {
+                    defMap.delete(id); // Remove fake ID
+                  }
+                }
+              }
+              this.warn(`IDs resolved via NATS. Mapped ${defs.variables.length} real IDs.`);
+            }
+
           } catch (firstErr) {
-            // Strategy 2: Registry Query (Central lookup, often requires different perms or used by Hub)
+            // Strategy 2: Registry Query
             try {
-              this.warn(`NATS Direct failed (${firstErr.message}), trying Registry Discovery...`);
-              // Note: 'registryProviderQuery' accesses the central registry which might proxy the definition
+              if (!hasMissingIds) { // Only log if we were truly empty
+                this.warn(`NATS Direct failed (${firstErr.message}), trying Registry Discovery...`);
+              }
               const regMsg = await nc.request(subjects.registryProviderQuery(this.providerId), payloads.buildReadProviderDefinitionQuery(), { timeout: 2000 });
               const defs = payloads.decodeProviderDefinition(regMsg.data);
-              this.warn(`NATS Registry Discovery: Loaded ${defs.length} variables.`);
-              defs.forEach((def) => defMap.set(def.id, def));
+              if (defs && defs.variables.length > 0) {
+                this.warn(`NATS Registry Discovery: Loaded ${defs.variables.length} variables.`);
+                // Same merge logic
+                const realMap = new Map();
+                defs.variables.forEach(d => realMap.set(d.key, d));
+                defs.variables.forEach(d => defMap.set(d.id, d));
+                for (const [id, def] of defMap.entries()) {
+                  if (def.missingId) {
+                    const real = realMap.get(def.key);
+                    if (real && real.id !== id) {
+                      defMap.delete(id);
+                    }
+                  }
+                }
+              }
             } catch (secondErr) {
-              this.warn(`All Discovery methods failed (REST, NATS Direct, NATS Registry). Please use Manual Definitions (Name:ID). Error: ${secondErr.message}`);
+              if (!hasMissingIds) {
+                this.warn(`All Discovery methods failed (REST, NATS Direct, NATS Registry). Please use Manual Definitions (Name:ID). Error: ${secondErr.message}`);
+              } else {
+                this.warn(`NATS ID Resolution failed. Continuing with Heuristic (Index-based) IDs. This generally fails for advanced providers.`);
+              }
             }
           }
         }
@@ -230,12 +312,41 @@ module.exports = function (RED) {
             // Re-process states (lookup names, formatting)
             const filteredSnapshot = processStates(states);
 
-            if (filteredSnapshot.length) {
+            if (filteredSnapshot.length > 0) {
               this.send({ payload: { type: 'snapshot', variables: filteredSnapshot } });
             } else {
               if (states.length > 0) {
                 this.warn(`Snapshot received data but everything was filtered out. Check Variable selection. Debug: First raw ID: ${states[0].id}, DefMap has it? ${defMap.has(states[0].id)}`);
               } else {
+                // EMPTY RESPONSE
+                // Check if we requested multiple IDs. Some providers fail on bulk read.
+                if (targetIds.length > 1) {
+                  this.warn(`Snapshot Bulk Read failed (Empty List). Retrying ${targetIds.length} variables individually...`);
+                  const accumulatedStates = [];
+
+                  for (const id of targetIds) {
+                    try {
+                      let msg;
+                      if (typeof connection.serialRequest === 'function') {
+                        msg = await connection.serialRequest(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery([id]), { timeout: 2000 });
+                      } else {
+                        msg = await nc.request(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery([id]), { timeout: 2000 });
+                      }
+                      const singleResponse = payloads.decodeVariableList(ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(new flatbuffers.ByteBuffer(msg.data)).variables());
+                      if (singleResponse.length > 0) {
+                        accumulatedStates.push(...singleResponse);
+                      }
+                    } catch (e) { /* ignore single failures */ }
+                  }
+
+                  const accumulatedFiltered = processStates(accumulatedStates);
+                  if (accumulatedFiltered.length > 0) {
+                    this.send({ payload: { type: 'snapshot', variables: accumulatedFiltered } });
+                    this.warn(`Snapshot Recovery successful! Retrieved ${accumulatedFiltered.length} items via single requests.`);
+                    return; // Success
+                  }
+                }
+
                 this.warn(`Snapshot received empty list from Data Hub. (Requested ${targetIds.length > 0 ? targetIds.length + ' specific IDs' : 'ALL variables'}).`);
               }
             }

package/nodes/datahub-write.html

@@ -29,8 +29,9 @@
             const $inputKey = $('#node-input-variableKey');
 
             // Styles matching Read Node exactly
-            const rowStyle = "display:grid; grid-template-columns: 30px 60px 1fr; align-items:center; padding:4px 0; border-bottom:1px solid #eee; font-family:'Helvetica Neue', Arial, sans-serif; font-size:12px; cursor:pointer;";
-            const idStyle = "background:#eee; color:#555; padding:1px 4px; border-radius:3px; font-family:monospace; text-align:center; font-size:11px;";
+            // Adjusted: ID column removed
+            const rowStyle = "display:grid; grid-template-columns: 30px 1fr; align-items:center; padding:4px 0; border-bottom:1px solid #eee; font-family:'Helvetica Neue', Arial, sans-serif; font-size:12px; cursor:pointer;";
+            // const idStyle = ...
             const keyStyle = "overflow:hidden; text-overflow:ellipsis; white-space:nowrap; padding-left:10px;";
 
             // Removed iconStyle, using checkbox instead
@@ -60,12 +61,12 @@
 
                     cbContainer.append(cb);
 
-                    // ID
-                    const idCol = $('<div>', { style: 'text-align:center;' }).append($('<span>', { style: idStyle }).text(safeId));
+                    // ID - HIDDEN
+                    // const idCol = $('<div>', { style: 'text-align:center;' }).append($('<span>', { style: idStyle }).text(safeId));
                     // Key
                     const keyCol = $('<div>', { style: keyStyle, title: v.key }).text(v.key);
 
-                    row.append(cbContainer).append(idCol).append(keyCol);
+                    row.append(cbContainer).append(keyCol); // No ID Col
 
                     // Click Handler (Row or Checkbox)
                     const selectRow = () => {

package/nodes/datahub-write.js

@@ -106,13 +106,36 @@ module.exports = function (RED) {
         // Validate: either ID or Key required
         // Relaxed validation for Batch Mode (handled in Input)
 
-        // If ID provided and valid, use it
-        if (this.variableId && !isNaN(this.variableId)) {
+        // If Key is provided, we should ALWAYS resolve it to ensure ID is fresh (Auto-Healing)
+        // If only ID is provided (legacy), we trust it.
+        if (this.variableKey) {
+            // Trigger background resolution
+            node.status({ fill: 'yellow', shape: 'dot', text: 'resolving...' });
+            resolveVariableKey(await configNode.acquire(), this.providerId, this.variableKey, node, node.payloads)
+                .then(resolved => {
+                    node.resolvedId = resolved.id;
+                    node.resolvedDataType = resolved.dataType;
+                    node.resolvedFingerprint = resolved.fingerprint;
+
+                    if (node.variableId && node.variableId !== resolved.id) {
+                        node.warn(`Auto-Healed ID for '${this.variableKey}': Configured=${node.variableId}, Resolved=${resolved.id}`);
+                    }
+                    node.status({ fill: 'green', shape: 'ring', text: 'ready' });
+                })
+                .catch(err => {
+                    node.warn(`ID Resolution failed for '${this.variableKey}': ${err.message}. Using configured ID: ${this.variableId}`);
+                    // Fallback to configured ID if resolution failed
+                    if (this.variableId && !isNaN(this.variableId)) {
+                        node.resolvedId = this.variableId;
+                        node.status({ fill: 'green', shape: 'ring', text: 'ready (fallback)' });
+                    } else {
+                        node.status({ fill: 'red', shape: 'dot', text: 'resolution failed' });
+                    }
+                });
+        } else if (this.variableId && !isNaN(this.variableId)) {
+            // Legacy/Manual Mode without Key
             this.resolvedId = this.variableId;
             node.status({ fill: 'green', shape: 'ring', text: 'ready' });
-        } else if (this.variableKey) {
-            // Key provided - will resolve on first message
-            node.status({ fill: 'yellow', shape: 'ring', text: 'key needs resolution' });
         }
 
         // Load payloads module dynamically

package/package.json

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