node-red-contrib-uos-nats 0.2.99 → 0.2.101

package/lib/payloads.js

@@ -110,12 +110,11 @@ export function parseRegistryStateEvent(buffer) {
 }
 
 // Encode write variables command
-export function encodeWriteVariablesCommand(variables) {
-    // variables: [{id: number, value: any}, ...]
+// Encode write variables command
+export function encodeWriteVariablesCommand(variables, fingerprint = BigInt(0)) {
     // variables: [{id: number, value: any}, ...]
     // VariableListT constructor: fingerprint, baseTimestamp, items
-    // VariableListT constructor: fingerprint, baseTimestamp, items
-    const varList = new VariableListT(BigInt(0), nowNs(), []);
+    const varList = new VariableListT(fingerprint, nowNs(), []);
     varList.items = variables.map(v => {
         const varT = new VariableT();
         varT.id = v.id;

package/nodes/datahub-write.js

@@ -8,18 +8,14 @@ const providerCache = new Map();
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 
 module.exports = function (RED) {
-    async function resolveVariableKey(nc, providerId, key, node, payloads) {
+    // Helper to get or fetch provider definition
+    async function getProviderDefinition(nc, providerId, node, payloads) {
         const cacheKey = `${providerId}`;
         const cached = providerCache.get(cacheKey);
 
         // Check cache
         if (cached && (Date.now() - cached.timestamp < CACHE_TTL)) {
-            const variable = cached.definition.variables.find(v => v.key === key);
-            if (variable) {
-                node.debug && node.debug(`Key '${key}' resolved to ID ${variable.id} (cached)`);
-                // Return full object including type
-                return { id: variable.id, dataType: variable.dataType };
-            }
+            return cached.definition;
         }
 
         // Query provider definition
@@ -28,7 +24,6 @@ module.exports = function (RED) {
             const query = payloads.buildReadProviderDefinitionQuery();
 
             // Strategy 1: Direct Query (v1.loc.<provider>.def.qry.read)
-            // This is required for providers like Node-RED itself or simple Python scripts
             const directSubject = `v1.loc.${providerId}.def.qry.read`;
             try {
                 const response = await nc.request(directSubject, query, { timeout: 1000 });
@@ -38,7 +33,6 @@ module.exports = function (RED) {
             }
 
             // Strategy 2: Registry Query (v1.loc.registry.providers.<provider>.def.qry.read)
-            // Fallback for managed providers
             if (!definition) {
                 const registrySubject = `v1.loc.registry.providers.${providerId}.def.qry.read`;
                 const response = await nc.request(registrySubject, query, { timeout: 2000 });
@@ -55,6 +49,17 @@ module.exports = function (RED) {
                 timestamp: Date.now()
             });
 
+            return definition;
+
+        } catch (err) {
+            throw new Error(`Failed to fetch definition for '${providerId}': ${err.message}`);
+        }
+    }
+
+    async function resolveVariableKey(nc, providerId, key, node, payloads) {
+        try {
+            const definition = await getProviderDefinition(nc, providerId, node, payloads);
+
             // Find variable by key
             const variable = definition.variables.find(v => v.key === key);
             if (!variable) {
@@ -62,13 +67,14 @@ module.exports = function (RED) {
             }
 
             node.debug && node.debug(`Key '${key}' resolved to ID ${variable.id} (Type: ${variable.dataType})`);
-            return { id: variable.id, dataType: variable.dataType };
+            return { id: variable.id, dataType: variable.dataType, fingerprint: definition.fingerprint };
 
         } catch (err) {
             throw new Error(`Failed to resolve key '${key}': ${err.message}`);
         }
     }
 
+
     function DataHubWriteNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
@@ -88,6 +94,7 @@ module.exports = function (RED) {
         this.variableKey = config.variableKey?.trim();
         this.resolvedId = null; // Cached resolved ID
         this.resolvedDataType = null; // Cached Data Type for strict writing
+        this.resolvedFingerprint = BigInt(0); // Cached Fingerprint
         this.payloads = null; // Will be loaded dynamically
 
         if (!this.providerId) {
@@ -97,11 +104,7 @@ module.exports = function (RED) {
         }
 
         // Validate: either ID or Key required
-        if (!this.variableId && !this.variableKey) {
-            node.error('Either Variable ID or Variable Key is required');
-            node.status({ fill: 'red', shape: 'dot', text: 'missing variable' });
-            return;
-        }
+        // Relaxed validation for Batch Mode (handled in Input)
 
         // If ID provided and valid, use it
         if (this.variableId && !isNaN(this.variableId)) {
@@ -110,10 +113,6 @@ module.exports = function (RED) {
         } else if (this.variableKey) {
             // Key provided - will resolve on first message
             node.status({ fill: 'yellow', shape: 'ring', text: 'key needs resolution' });
-        } else {
-            node.error('Invalid Variable ID');
-            node.status({ fill: 'red', shape: 'dot', text: 'invalid ID' });
-            return;
         }
 
         // Load payloads module dynamically
@@ -148,6 +147,7 @@ module.exports = function (RED) {
 
                 // Prepare list of variables to write
                 let varsToWrite = [];
+                let currentFingerprint = node.resolvedFingerprint || BigInt(0);
 
                 // MODE 1: Batch Write (Object or Array) AND no configured single variable
                 // If the user configured a Provider but NOT a Variable ID/Key, we assume Dynamic Mode.
@@ -165,8 +165,6 @@ module.exports = function (RED) {
                         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.
-                            // But user map might be { "1": val, "machine.temp": val }.
-                            // We can check if k is Int.
                             const asInt = parseInt(k, 10);
                             if (!isNaN(asInt) && String(asInt) === k) {
                                 return { id: asInt, value: v };
@@ -184,10 +182,14 @@ module.exports = function (RED) {
                             if (item.key) {
                                 // Resolve Key
                                 try {
+                                    // Resolving individual keys for batch... this might be slow if uncached.
+                                    // Optimization: resolveVariableKey uses cache.
                                     const resolved = await resolveVariableKey(nc, node.providerId, item.key, node, node.payloads);
                                     targetId = resolved.id;
                                     // Use resolved type if not explicit
                                     if (!targetType) targetType = resolved.dataType;
+                                    // Use the fingerprint from the LAST resolution (assuming they come from same provider version)
+                                    if (resolved.fingerprint) currentFingerprint = resolved.fingerprint;
                                 } catch (e) {
                                     node.warn(`Skipping key '${item.key}': ${e.message}`);
                                     continue;
@@ -211,11 +213,7 @@ module.exports = function (RED) {
                     }
 
                 } else {
-                    // MODE 2: Single Mode (Configured in Node or Primitive Payload)
-                    // If Single Mode is active, we IGNORE the structure of obj/array and write the WHOLE msg.payload 
-                    // to the configured target variable. (e.g. payload IS the value).
-                    // UNLESS strict check? No, standard behavior is payload=value.
-
+                    // MODE 2: Single Mode
                     if (!isSingleMode) {
                         // No variable configured and primitive payload? Error.
                         node.error("Configuration Error: No Variable configured and payload is not a batch object.");
@@ -226,13 +224,49 @@ module.exports = function (RED) {
                     let varId = node.resolvedId;
                     let varType = node.resolvedDataType;
 
+                    // Logic to ensure we have a fingerprint (critical for strict providers)
+                    // If we have an ID but no fingerprint, we must fetch the definition.
+                    if (varId && (node.resolvedFingerprint === BigInt(0) || !node.resolvedFingerprint)) {
+                        try {
+                            node.status({ fill: 'yellow', shape: 'dot', text: 'fetching definition...' });
+                            // Reuse resolveVariableKey logic but just to get definition? 
+                            // We can't use resolveVariableKey easily if we don't have a key.
+                            // But we can peek into the cache directly or force a lookup.
+                            // Let's call a simplified lookup.
+
+                            // We don't have a dedicated function for "getDefinition", so we construct it or assume key is available?
+                            // If user selected from list, we might NOT have the key in config (if legacy)? 
+                            // But usually we do.
+                            // If we don't have key, we can matches by ID.
+
+                            const definitions = await getProviderDefinition(nc, node.providerId, node, node.payloads);
+                            node.resolvedFingerprint = definitions.fingerprint;
+                            currentFingerprint = definitions.fingerprint;
+
+                            // Optional: Verify ID matches and get Type
+                            const foundVar = definitions.variables.find(v => v.id === varId);
+                            if (foundVar) {
+                                varType = foundVar.dataType;
+                                node.resolvedDataType = varType; // update cache
+                            }
+
+                        } catch (e) {
+                            node.warn(`Could not fetch fingerprint for provider ${node.providerId}: ${e.message}`);
+                            // Non-fatal? If strict, write will fail. If not, 0 might work.
+                        }
+                    }
+
                     if (!varId && node.variableKey) {
                         node.status({ fill: 'yellow', shape: 'dot', text: 'resolving key...' });
                         const resolved = await resolveVariableKey(nc, node.providerId, node.variableKey, node, node.payloads);
                         varId = resolved.id;
                         varType = resolved.dataType;
+
                         node.resolvedId = varId;
                         node.resolvedDataType = varType;
+                        node.resolvedFingerprint = resolved.fingerprint;
+                        currentFingerprint = resolved.fingerprint;
+
                         node.status({ fill: 'green', shape: 'ring', text: 'ready' });
                     }
 
@@ -244,8 +278,8 @@ module.exports = function (RED) {
                 }
 
                 // Build write command (Flatbuffer)
-                // varsToWrite: [{id, value, dataType}]
-                const writeCommand = node.payloads.encodeWriteVariablesCommand(varsToWrite);
+                // Pass the fingerprint (defaults to 0 if not found)
+                const writeCommand = node.payloads.encodeWriteVariablesCommand(varsToWrite, currentFingerprint);
 
                 // Publish write command
                 const subject = `v1.loc.${node.providerId}.vars.cmd.write`;

package/package.json

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