node-red-contrib-uos-nats 1.3.39 → 1.3.52

package/README.md

@@ -68,12 +68,28 @@ Reads values from existing providers (like `u_os_adm`).
 - **Provider ID:** Name of the source provider.
 - **Variables:** Use **Load Variables** to browse and select variables.
 - **Trigger:** "Event" (instant update) or "Poll" (interval).
+- **Dynamic Read:** Send `msg.payload` as an Array of keys (e.g. `["machine.status", "temp"]`) to trigger a specific snapshot, ignoring the node configuration.
 
 ### DataHub - Write
 Changes values in other providers.
-- **Single Mode:** Select a variable from the list. Send `msg.payload` = value.
-- **Batch Mode:** Select NO variable (clear selection). Send `msg.payload` as a JSON object: `{"var_key": value, "var2": value}`.
-- **Strict Mode:** Automatically handles Fingerprints for strict providers (e.g. `u_os_sbm`).
+-   **Single Mode:** Select a variable from the list. Send `msg.payload` = value.
+-   **Batch Mode:** Select NO variable (clear selection). Send `msg.payload` as a JSON object: `{"var_key": value, "var2": value}` (uses Configured Provider).
+-   **Dynamic Mode:** Send a full target object to write anywhere:
+    ```json
+    {
+      "provider": "target_provider_id",
+      "key": "variable_key",
+      "value": 123
+    }
+    ```json
+    {
+      "provider": "target_provider_id",
+      "key": "variable_key",
+      "value": 123
+    }
+    ```
+    Or send an **Array** of these objects to write to multiple providers in one go.
+-   **Strict Mode:** Automatically handles Fingerprints for strict providers (e.g. `u_os_sbm`).
 
 ### DataHub - Provider
 Publishes your own data to the Data Hub.
@@ -92,10 +108,11 @@ Publishes your own data to the Data Hub.
 ## Troubleshooting
 
 - **Provider not visible?** Ensure **Provider ID** matches your **Client ID**. Easiest way: Leave Provider ID empty in the node.
+- **Node Status is Green (Ring)?**
+  - `waiting for provider`: The node is connected to NATS (OK), but the target Provider (e.g. `u_os_sbm`) is currently offline. It will resume automatically.
 - **Node Status is Yellow?**
-  - `cooldown (10s)`: The node is waiting to protect the device. This is normal after an error.
-  - `provider offline`: The connection to NATS is OK, but the target (e.g. `u_os_sbm`) is not responding (503).
-  - `auth failed`: Check your OAuth Client Secret and Scopes.
+  - `cooldown (10s)`: The node is pausing after an error to protect the network.
+  - `auth failed`: OAuth credentials generated an error. Check Client Secret.
 - **Node Status is Red?**
   - `illegal ID`: You used a reserved name like `u_os_sbm`. Rename your Client/Provider.
   - `write error`: A command failed. Check Scopes (`hub.variables.readwrite`) or Fingerprint.

package/nodes/datahub-input.html

@@ -348,4 +348,8 @@
         <li><b>Provider ID:</b> ID of the data source (e.g., <code>u_os_adm</code>). Use the search button to find available providers.</li>
         <li><b>Variables:</b> Click "Load Variables" to select specific data points. Leave empty to read everything.</li>
     </ol>
+    <p>
+        <b>Dynamic Read:</b> Send <code>msg.payload</code> as an Array of variable keys (e.g. <code>["var1", "var2"]</code>) 
+        to read specific variables on demand. This overrides the node's configuration for that single request.
+    </p>
 </script>

package/nodes/datahub-input.js

@@ -168,101 +168,126 @@ module.exports = function (RED) {
           return; // Stop here, do not start Interval or Subscription
         }
 
-        performSnapshot = async () => {
-          // Debugging connection state
+        performSnapshot = async (overrideItems) => {
           if (!nc || nc.isClosed()) {
             this.warn('Snapshot skipped: Connection is closed or not ready.');
             return;
           }
 
-          try {
-            // Resolve requested variable names to IDs
-            let targetIds = [];
-            let isWildcard = (this.variables.length === 0);
+          // Group items by Provider
+          // Default Provider: this.providerId
+          const requests = new Map(); // ProviderId -> Set<VariableId>
+
+          if (overrideItems) {
+            // Dynamic Mode: Resolve each item
+            for (const item of overrideItems) {
+              let pId = (typeof item === 'object' && item.provider) ? item.provider : this.providerId;
+              let key = (typeof item === 'object') ? item.key : item; // String or Object.key
 
+              if (!key) continue;
+
+              try {
+                // Use Config Node Resolution (Cache)
+                // This handles fetching definitions for ANY provider on demand
+                const resolved = await connection.resolveVariableId(pId, key);
+
+                if (!requests.has(pId)) requests.set(pId, new Set());
+                requests.get(pId).add(resolved.id);
+              } catch (e) {
+                this.warn(`Dynamic Read: Skipping '${key}' on '${pId}': ${e.message}`);
+              }
+            }
+          } else {
+            // Static Mode: Use local defMap for configured provider
+            const targetIds = new Set();
+            const isWildcard = (this.variables.length === 0);
             if (!isWildcard) {
-              // Reverse lookup: Find Def by Key
               const requestedKeys = new Set(this.variables);
-
               for (const def of defMap.values()) {
-                if (requestedKeys.has(def.key)) {
-                  targetIds.push(Number(def.id));
-                }
+                if (requestedKeys.has(def.key)) targetIds.add(def.id);
               }
-
-              // CRITICAL FIX: If user requested specific variables but we found NONE, 
-              // we MUST NOT send an empty list, because that would interpret as "Read All".
-              if (targetIds.length === 0) {
-                // Already handled by Gate above mostly, but good for safety
-                this.warn(`Snapshot Aborted: None of the ${this.variables.length} requested variables could be resolved to IDs.`);
+              if (targetIds.size === 0) {
+                this.warn(`Snapshot Aborted: None of the configured variables could be resolved.`);
                 return;
               }
             }
+            requests.set(this.providerId, targetIds); // Empty Set = Wildcard
+          }
 
-            // If Wildcard (empty targetIds and isWildcard=true) -> Request ALL.
-            // If Specific (targetIds has items) -> Request specific.
-            // Use serialRequest via Config Node to prevent concurrency issues on the connection
-            // Simple Snapshot Logic using Config Node Semaphore
-            // The Config Node now handles concurrency (max 3 parallel), preventing 503s naturally.
-            // We use a simple retry wrapper just in case.
-            let lastError;
-            for (let attempt = 1; attempt <= 3; attempt++) {
-              try {
-                let snapshotMsg;
-                // If config node has serialRequest (Semaphore), use it.
-                if (typeof connection.serialRequest === 'function') {
-                  snapshotMsg = await connection.serialRequest(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(targetIds), { timeout: 10000 });
-                } else {
-                  // Fallback to direct request (unsafe)
-                  snapshotMsg = await nc.request(subjects.readVariablesQuery(this.providerId), payloads.buildReadVariablesQuery(targetIds), { timeout: 10000 });
-                }
+          if (requests.size === 0) {
+            this.warn("Snapshot Aborted: No valid variables resolved.");
+            return;
+          }
 
-                const bb = new flatbuffers.ByteBuffer(snapshotMsg.data);
-                const snapshotObj = ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(bb);
-                const states = payloads.decodeVariableList(snapshotObj.variables());
-
-                const filteredSnapshot = processStates(states);
-                if (filteredSnapshot.length > 0) {
-                  this.send({ payload: { type: 'snapshot', variables: filteredSnapshot } });
-                  this.status({ fill: 'green', shape: 'dot', text: 'active' });
-                } else {
-                  // Handle empty/partial...
-                  this.status({ fill: 'green', shape: 'ring', text: 'active (empty)' });
-                }
-                return true; // Success
+          const allResults = [];
+          const errors = [];
 
-              } catch (err) {
-                lastError = err;
-                // If semaphore is full or timeout, wait a bit
-                await new Promise(r => setTimeout(r, 1000 * attempt));
-              }
-            }
-            if (lastError) {
-              const msg = lastError.message || '';
-              if (msg.includes('503') || msg.includes('no responders')) {
-                this.debug(`Snapshot skipped (Provider offline/503): ${msg}`);
-                this.status({ fill: 'yellow', shape: 'dot', text: 'provider offline' });
-              } else if (msg.includes('Cooldown')) {
-                this.debug(`Snapshot skipped (Cooldown): ${msg}`);
-                this.status({ fill: 'yellow', shape: 'ring', text: 'cooldown (10s)' });
-              } else if (msg.includes('Authorization') || msg.includes('Permission')) {
-                this.debug(`Snapshot skipped (Auth): ${msg}`);
-                this.status({ fill: 'yellow', shape: 'ring', text: 'auth failed' });
+          // Execute Requests (Serial or Parallel?) 
+          // Using Serial to be safe with connection bandwidth
+          for (const [pId, varIds] of requests) {
+            try {
+              let targetIdsArr = Array.from(varIds);
+
+              // Request
+              let snapshotMsg;
+              if (typeof connection.serialRequest === 'function') {
+                snapshotMsg = await connection.serialRequest(subjects.readVariablesQuery(pId), payloads.buildReadVariablesQuery(targetIdsArr), { timeout: 10000 });
               } else {
-                this.warn(`Snapshot failed: ${msg}`);
-                this.status({ fill: 'red', shape: 'ring', text: 'snapshot error' });
+                snapshotMsg = await nc.request(subjects.readVariablesQuery(pId), payloads.buildReadVariablesQuery(targetIdsArr), { timeout: 10000 });
               }
-            }
-          } catch (e) {
-            const msg = e.message || '';
-            if (msg.includes('503') || msg.includes('no responders')) {
-              this.debug(`Snapshot skipped (Provider offline/503): ${msg}`);
-            } else if (msg.includes('Cooldown')) {
-              // Ignore cooldown errors in outer catch
-            } else {
-              this.warn(`Snapshot failed: ${msg}`);
+
+              const bb = new flatbuffers.ByteBuffer(snapshotMsg.data);
+              const snapshotObj = ReadVariablesQueryResponse.getRootAsReadVariablesQueryResponse(bb);
+              const states = payloads.decodeVariableList(snapshotObj.variables());
+
+              // Add Provider Info to Result?
+              // ProcessStates adds keys, but we might want to know which provider it came from if mixed?
+              // The current `processStates` maps IDs back to Keys using `defMap`. 
+              // ISSUE: `defMap` only has local provider defs.
+              // If we read from foreign provider, `processStates` will return IDs or "Unknown".
+              // We need `resolveVariableId` to also START caching the reverse lookup or we assume result has IDs?
+              // Wait, `decodeVariableList` returns {id, value}.
+              // `processStates` tries to find Key.
+
+              // QUICK FIX for Dynamic Multi-Provider:
+              // If pId !== this.providerId, we don't have local defMap.
+              // But `resolveVariableId` (in config) caches definitions.
+              // We can ask config to resolve ID back to Key? Or just return ID?
+              // Better: We know the Keys we asked for.
+
+              // Let's modify processStates to accept a custom Map?
+              // Or simple: Just return the raw objects with IDs if we can't map them?
+              // Actually, for Dynamic Read, users might accept {id, value} or we try to enrich.
+
+              const enriched = states.map(s => {
+                // Try local defMap
+                if (pId === this.providerId && defMap.has(s.id)) {
+                  return { ...s, key: defMap.get(s.id).key, provider: pId };
+                }
+                // Try Config Node Cache (it has all fetched defs)
+                const cachedDef = connection.getProviderVariable(pId, s.id);
+                if (cachedDef) {
+                  return { ...s, key: cachedDef.key, provider: pId };
+                }
+                return { ...s, key: `id:${s.id}`, provider: pId };
+              });
+
+              allResults.push(...enriched);
+
+            } catch (err) {
+              errors.push(`${pId}: ${err.message}`);
             }
           }
+
+          if (allResults.length > 0) {
+            this.send({ payload: { type: 'snapshot', variables: allResults } });
+            this.status({ fill: 'green', shape: 'dot', text: 'active' });
+          } else if (errors.length > 0) {
+            this.warn(`Snapshot errors: ${errors.join('; ')}`);
+            this.status({ fill: 'red', shape: 'ring', text: 'error' });
+          } else {
+            this.status({ fill: 'green', shape: 'ring', text: 'empty' });
+          }
         };
 
 
@@ -334,7 +359,14 @@ module.exports = function (RED) {
     };
 
     this.on('input', (msg, send, done) => {
-      performSnapshot()
+      let overrideItems = null;
+      if (Array.isArray(msg.payload) && msg.payload.length > 0) {
+        // Pass the raw array items (String or Object {provider, key})
+        // performSnapshot will handle filtering
+        overrideItems = msg.payload;
+      }
+
+      performSnapshot(overrideItems)
         .then(() => done())
         .catch((err) => done(err));
     });

package/nodes/datahub-output.html

@@ -135,7 +135,9 @@
     <dd>Connection node with host/port and OAuth credentials.</dd>
     <dt>Provider ID</dt>
     <dd>The unique ID for this provider. <b>Note:</b> You cannot use <code>u_os_sbm</code> (Reserved system name).</dd>
-    <dd><b>Auto Mode:</b> Shows the <em>Client Name</em> from your Config. Uses this name automatically.</dd>
+    <dt>Provider ID</dt>
+    <dd>The unique ID for this provider. <b>Note:</b> You cannot use <code>u_os_sbm</code> (Reserved system name).</dd>
+    <dd><b>Auto Mode:</b> If empty, uses your **Client Name** (e.g. `nodered`) to match your Connection.</dd>
     <dt>Keep-Alive (s)</dt>
     <dd>Interval in seconds to refresh the provider definition. Default: <b>300s (5 min)</b>.</dd>
     <dt>Allow external writes</dt>

package/nodes/datahub-output.js

@@ -77,11 +77,10 @@ module.exports = function (RED) {
       return;
     }
     // Retrieve configuration node
-    // Default to Connection's Client Name (Friendly Name) because Client ID is often a UUID
-    // that doesn't match the desired Provider ID. User typically expects 'nodered' not '0069...'
+    // Auto Mode: Prefer Client Name ("nodered") to match Connection Name.
+    // This ensures consistency with DataHub UI expectations.
     let defaultId = connection.clientName;
     if (!defaultId) {
-      // Fallback to ID if Name is missing (should not happen as Name is mandatory)
       defaultId = connection.clientId || 'nodered';
     }
 
@@ -134,6 +133,7 @@ module.exports = function (RED) {
     };
 
     // Check Singleton Status
+    this.fatalError = false;
     let isPrimary = false;
     const existingNodeId = providerRegistry.get(this.providerId);
     if (existingNodeId && existingNodeId !== this.id) {
@@ -147,7 +147,8 @@ module.exports = function (RED) {
     // --- SEND DEFINITION HELPER ---
     const sendDefinitionUpdate = async (modPayloads, modSubjects) => {
       if (!nc) return;
-      if (!isPrimary) return; // Only Primary sends definitions
+      if (!isPrimary) return;
+      if (this.fatalError) return; // permanent lockout
 
       try {
         const { payload, fingerprint: fp } = modPayloads.buildProviderDefinitionEvent(definitions);
@@ -160,7 +161,17 @@ module.exports = function (RED) {
         await nc.flush();
         console.log(`[DataHub Output] Definition published. FP: ${fp}`);
       } catch (err) {
-        this.warn(`Definition update error: ${err.message}`);
+        let msg = err.message || '';
+        // Check for fatal Auth/Permission errors
+        if (msg.includes('Authorization') || msg.includes('permissions') || msg.includes('10003') || msg.includes('Access Denied')) {
+          this.fatalError = true;
+          this.error(`FATAL AUTH ERROR: ${msg}. Stopping provider to protect connection.`);
+          this.status({ fill: 'red', shape: 'dot', text: 'auth blocked (permanent)' });
+          // Clear heartbeats
+          if (outputHeartbeat) clearInterval(outputHeartbeat);
+        } else {
+          this.warn(`Definition update error: ${err.message}`);
+        }
       }
     };
 
@@ -186,6 +197,7 @@ module.exports = function (RED) {
         // console.log('[DataHub Output] Heartbeat skipped: NATS closed.');
         return;
       }
+      if (this.fatalError) return; // permanent lockout
       if (!loadedPayloads || !loadedSubjects) return;
 
       // If we have no definitions yet, nothing to send

package/nodes/datahub-write.html

@@ -248,5 +248,24 @@
         <li><b>Provider ID:</b> Target provider (e.g. <code>u_os_adm</code>). Use the search button to find it.</li>
         <li><b>Variable:</b> Select a target variable. <b>Only writable variables are shown.</b></li>
     </ol>
-    <p>If no variable is selected, the node works in <b>Batch Mode</b> (expects JSON object payload).</p>
-</script>
+    <p>If no variable is selected, the node works in <b>Batch Mode</b> or <b>Dynamic Mode</b>.</p>
+    <ul>
+        <li><b>Batch:</b> Send a JSON object to update multiple keys for the configured Provider: <code>{"key": value, "key2": value}</code></li>
+        <li><b>Dynamic:</b> Send a specific object to target ANY Provider/Key:
+            <code>
+            {
+                "provider": "u_os_sbm",
+                "key": "machine.outputs.DO01",
+                "value": true
+            }
+            </code>
+        </li>
+        <li><b>Mixed Array:</b> Send an array of dynamic objects to write to multiple providers at once:
+            <code>
+            [
+              { "provider": "u_os_sbm", "key": "doo1", "value": true },
+              { "provider": "other_provider", "key": "var2", "value": 123 }
+            ]
+            </code>
+        </li>
+    </ul>

package/nodes/datahub-write.js

@@ -170,7 +170,8 @@ module.exports = function (RED) {
                         node.resolvedId = this.variableId;
                         // Log as debug implies we handle it gracefully => No User Warn
                         node.debug(`ID Resolution failed for '${this.variableKey}' (${err.message}). Using configured ID: ${this.variableId}`);
-                        node.status({ fill: 'green', shape: 'ring', text: 'ready (fallback)' });
+                        // User Request v1.3.48: Show Green 'ready' even if ID resolution failed (Dynamic Mode)
+                        node.status({ fill: 'green', shape: 'dot', text: 'ready' });
                     } else {
                         node.warn(`ID Resolution failed for '${this.variableKey}': ${err.message}`);
                         node.status({ fill: 'red', shape: 'dot', text: 'resolution failed' });
@@ -228,30 +229,40 @@ module.exports = function (RED) {
                         // Array: [{id:1, value:val}, {key:'k', value:val}]
                         items = rawPayload;
                     } else {
-                        // Object: { "key": val, "id:1": val }
-                        items = Object.entries(rawPayload).map(([k, v]) => {
-                            // Detect if key is actually an ID (e.g. "5" or "id:5")? 
-                            // Easier: treat all keys as Keys, unless user passes explicit Array.
-                            const asInt = parseInt(k, 10);
-                            if (!isNaN(asInt) && String(asInt) === k) {
-                                return { id: asInt, value: v };
-                            }
-                            return { key: k, value: v };
-                        });
+                        // Check for Single Dynamic Write Object
+                        // Format: { provider: "p", key: "k", value: "v" }
+                        if (rawPayload.provider || rawPayload.key || rawPayload.variableKey || rawPayload.variableId) {
+                            items = [rawPayload];
+                        } else {
+                            // Object: { "key": val, "id:1": val }
+                            items = Object.entries(rawPayload).map(([k, v]) => {
+                                // Detect if key is actually an ID (e.g. "5" or "id:5")? 
+                                // Easier: treat all keys as Keys, unless user passes explicit Array.
+                                const asInt = parseInt(k, 10);
+                                if (!isNaN(asInt) && String(asInt) === k) {
+                                    return { id: asInt, value: v };
+                                }
+                                return { key: k, value: v };
+                            });
+                        }
                     }
 
                     // Process Items
                     for (const item of items) {
-                        let targetId = item.id;
+                        let targetId = item.id || item.variableId;
                         let targetType = item.dataType; // Optional explicit type
 
                         if (targetId === undefined) {
-                            if (item.key) {
+                            const effectiveKey = item.key || item.variableKey;
+                            if (effectiveKey) {
                                 // Resolve Key
                                 try {
+                                    // Use Dynamic Provider if present, otherwise configured Provider
+                                    const effectiveProvider = item.provider || item.providerId || node.providerId;
+
                                     // Use Centralized Cache in Config Node
                                     if (typeof configNode.resolveVariableId === 'function') {
-                                        const resolved = await configNode.resolveVariableId(node.providerId, item.key);
+                                        const resolved = await configNode.resolveVariableId(effectiveProvider, effectiveKey);
                                         targetId = resolved.id;
                                         if (!targetType) targetType = resolved.dataType;
                                         if (resolved.fingerprint) currentFingerprint = resolved.fingerprint;
@@ -259,7 +270,7 @@ module.exports = function (RED) {
                                         throw new Error("Config Node too old");
                                     }
                                 } catch (e) {
-                                    node.warn(`Skipping key '${item.key}': ${e.message}`);
+                                    node.warn(`Skipping key '${effectiveKey}': ${e.message}`);
                                     continue;
                                 }
                             } else {

package/nodes/uos-config.js

@@ -176,37 +176,51 @@ module.exports = function (RED) {
       if (this.nc) {
         return this.nc;
       }
-      // Ensure we have a valid token initially
-      await this.getToken();
+      // Deduplication: Return existing promise if we are already connecting
+      if (this.connectionPromise) {
+        // this.log('Joining pending connection request...');
+        return this.connectionPromise;
+      }
 
-      // Use jwtAuthenticator to allow dynamic token refresh on reconnect
-      try {
-        this.nc = await connect({
-          servers: `nats://${this.host}:${this.port}`,
-          // Authenticator must be SYNCHRONOUS. We rely on background refresh to keep this.tokenInfo current.
-          // Token function must be SYNCHRONOUS if we rely on background refresh.
-          token: () => {
-            return this.tokenInfo ? this.tokenInfo.token : '';
-          },
-          name: this.clientName,
-          inboxPrefix: `_INBOX.${this.clientName}`,
-          maxReconnectAttempts: -1, // Infinite reconnects
-          reconnectTimeWait: 2000,
-        });
-        this.log(`NATS connecting with Name: '${this.clientName}'`);
+      this.connectionPromise = (async () => {
+        try {
+          // Ensure we have a valid token initially
+          await this.getToken();
+
+          this.nc = await connect({
+            servers: `nats://${this.host}:${this.port}`,
+            // Authenticator must be SYNCHRONOUS. We rely on background refresh to keep this.tokenInfo current.
+            // Token function must be SYNCHRONOUS if we rely on background refresh.
+            token: () => {
+              return this.tokenInfo ? this.tokenInfo.token : '';
+            },
+            // REVERT: Use Configured Client Name for Connection.
+            // Using UUID caused "Authorization Violation" for some users.
+            name: this.clientName,
+            inboxPrefix: `_INBOX.${this.clientName}`,
+            maxReconnectAttempts: -1, // Infinite reconnects
+            reconnectTimeWait: 2000,
+          });
 
-        // Reset Failure timestamp on success
-        this.authFailureTimestamp = 0;
+          this.log(`NATS connecting as Name: '${this.clientName}' (Dedup Active)`);
 
-      } catch (e) {
-        if (e.message && (e.message.includes('Authorization') || e.message.includes('Permissions') || e.message.includes('Authentication'))) {
-          this.warn(`NATS Authorization failed. Invalidating token cache. Circuit Breaker active for 10s.`);
-          this.tokenInfo = null; // Force fresh token next time
-          this.authFailureTimestamp = Date.now(); // Start Cooldown
+          // Reset Failure timestamp on success
+          this.authFailureTimestamp = 0;
+          return this.nc;
+
+        } catch (e) {
+          if (e.message && (e.message.includes('Authorization') || e.message.includes('Permissions') || e.message.includes('Authentication'))) {
+            this.warn(`NATS Authorization failed. Invalidating token cache. Circuit Breaker active for 10s.`);
+            this.tokenInfo = null; // Force fresh token next time
+            this.authFailureTimestamp = Date.now(); // Start Cooldown
+          }
+          this.error(`NATS connect failed: ${e.message}`);
+          throw e;
+        } finally {
+          this.connectionPromise = null;
         }
-        this.error(`NATS connect failed: ${e.message}`);
-        throw e;
-      }
+      })();
+      return this.connectionPromise;
       this.nc.closed().then(() => {
         this.nc = null;
         this.emit('disconnected');
@@ -545,8 +559,26 @@ module.exports = function (RED) {
       }
     };
 
-    this.on('close', (done) => {
-      this.release().finally(done);
+    this.on('close', async (done) => {
+      // Force Close Connection on Full Deploy (ignore reference count)
+      if (this.refreshTimer) {
+        clearTimeout(this.refreshTimer);
+        this.refreshTimer = null;
+      }
+
+      if (this.nc) {
+        const nc = this.nc;
+        this.nc = null;
+        this.users = 0;
+        try {
+          // Drain ensures all pending messages are sent before closing
+          await nc.drain();
+          // this.log('NATS Connection flushed and closed.');
+        } catch (err) {
+          this.warn(`Error closing NATS connection: ${err.message}`);
+        }
+      }
+      done();
     });
   }
 

package/package.json

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