@vitormnm/node-red-simple-opcua 1.7.0 → 1.8.1

package/README.md

@@ -1,5 +1,3 @@
-# @vitormnm/node-red-simple-opcua
-
 OPC UA client and server with a simple graphical interface for Node-RED.
 
 This package provides a simplified, highly parameterized set of nodes to establish OPC UA Servers and Clients in Node-RED without complex coding.
@@ -40,6 +38,23 @@ Interacts with an active local server instance. It supports the following modes:
 
 ---
 
+### Supported Variable Data Types, Arrays & Matrices
+
+The server supports the following standard OPC UA data types, including arrays and matrices:
+
+- **Integers**: `Int16`, `UInt16`, `Int32`, `UInt32`, `Int64`
+- **Floats**: `Float`
+- **Others**: `Boolean`, `String`, `ByteString`
+- **Arrays (1D)**: Pass standard JavaScript arrays or JSON arrays as values (e.g., `[1, 2, 3, 4]` or `"[1, 2, 3, 4]"`).
+- **Multi-Dimensional Arrays (Matrices)**: Pass nested arrays. The dimensions are automatically detected based on the shape (e.g., `[[1, 2], [3, 4]]` is registered as a 2x2 matrix with dimensions `[2, 2]`, and `[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]` as a 2x2x2 matrix).
+
+*Note on 64-bit Integers (`Int64`/`UInt64`):*
+- *Scalars are represented as `[high, low]` arrays (e.g., `[0, 100]` for the value 100).*
+- *Arrays of 64-bit integers are represented as arrays of doublets (e.g., `[[0, 100], [0, 200]]`).*
+- *They are handled internally using JavaScript `BigInt`.*
+
+---
+
 ## Client Functionalities
 
 The client implementation consists of `opcua-client-config` (shared connection configuration) and `opcua-client` (the action node).

package/client/lib/opcua-client-browser.js

@@ -6,10 +6,11 @@ const {
     DataType,
     NodeClass,
     coerceNodeId,
-    makeNodeId
+    makeNodeId,
+    VariantArrayType
 } = require("node-opcua");
 
-const { enrichItemResultWithEnumeration } = require("../opcua-client-utils");
+const { enrichItemResultWithEnumeration, reshapeArray } = require("../opcua-client-utils");
 
 async function browseNode(session, root) {
     const nodeID = normalizeNodeId(root.nodeID || root.nodeId || ROOT_NODE_ID);
@@ -123,7 +124,14 @@ async function browseNode(session, root) {
         if (nodeClass === "Variable") {
             const dataTypeValue = dataValues[i * 3 + 1]?.value?.value;
             const rawValueVariant = dataValues[i * 3 + 2]?.value;
-            const rawValue = rawValueVariant?.value;
+            let rawValue = rawValueVariant?.value;
+
+            if (rawValueVariant && rawValueVariant.arrayType === VariantArrayType.Matrix && rawValueVariant.dimensions && (Array.isArray(rawValue) || ArrayBuffer.isView(rawValue))) {
+                if (ArrayBuffer.isView(rawValue)) {
+                    rawValue = Array.from(rawValue);
+                }
+                rawValue = reshapeArray(rawValue, rawValueVariant.dimensions);
+            }
 
             item.dataType = dataTypeValue?.namespace === 0 && typeof dataTypeValue?.value === "number"
                 ? (DataType[dataTypeValue.value] || dataTypeValue.toString())
@@ -525,7 +533,14 @@ async function browseRecursiveNode(session, root) {
                     if (item.nodeClass === "Variable") {
                         const dataTypeValue = dataValues[index * 3 + 1]?.value?.value;
                         const rawValueVariant = dataValues[index * 3 + 2]?.value;
-                        const rawValue = rawValueVariant?.value;
+                        let rawValue = rawValueVariant?.value;
+
+                        if (rawValueVariant && rawValueVariant.arrayType === VariantArrayType.Matrix && rawValueVariant.dimensions && (Array.isArray(rawValue) || ArrayBuffer.isView(rawValue))) {
+                            if (ArrayBuffer.isView(rawValue)) {
+                                rawValue = Array.from(rawValue);
+                            }
+                            rawValue = reshapeArray(rawValue, rawValueVariant.dimensions);
+                        }
 
                         item.dataType = dataTypeValue?.namespace === 0 && typeof dataTypeValue?.value === "number"
                             ? (DataType[dataTypeValue.value] || dataTypeValue.toString())
@@ -569,11 +584,11 @@ async function browseRecursiveNode(session, root) {
         }
 
         const methods = allItems.filter(item => item.nodeClass === "Method");
-        for (const method of methods) {
+        await Promise.all(methods.map(async (method) => {
             const definition = await readMethodArguments(session, method.nodeID);
             method.inputArguments = definition.inputArguments;
             method.outputArguments = definition.outputArguments;
-        }
+        }));
     }
 
     return {

package/client/lib/opcua-client-write-service.js

@@ -1,11 +1,12 @@
 "use strict";
 
-const { AttributeIds, DataType, coerceNodeId } = require("node-opcua");
+const { AttributeIds, DataType, coerceNodeId, VariantArrayType } = require("node-opcua");
 const {
     buildVariantFromItem,
     normalizeTypeName,
     resolveNodeId,
-    statusCodeToString
+    statusCodeToString,
+    reshapeArray
 } = require("../opcua-client-utils");
 
 // Máximo de tags por chamada session.write (ajuste conforme limite do servidor)
@@ -84,7 +85,7 @@ async function writeBatches(session, items, variants) {
                 allStatusCodes[start + i] = sc;
             });
         } catch (batchError) {
-            // Se o batch falhar por completo, marca todos com erro
+            
             for (let i = start; i < end; i++) {
                 allStatusCodes[i] = { name: batchError.message, value: -1 };
             }
@@ -109,10 +110,19 @@ function buildResults(items, variants, statusCodes) {
         const scName = sc && sc.name ? sc.name : "Good";
         const typeName = DataType[variants[index].dataType] || null;
 
+        let val = variants[index].value;
+        const variant = variants[index];
+        if (variant && variant.arrayType === VariantArrayType.Matrix && variant.dimensions && (Array.isArray(val) || ArrayBuffer.isView(val))) {
+            if (ArrayBuffer.isView(val)) {
+                val = Array.from(val);
+            }
+            val = reshapeArray(val, variant.dimensions);
+        }
+
         return {
             name: item.name || nodeId,
             nodeID: nodeId,
-            value: variants[index].value,
+            value: val,
             type: typeName,
             status: scName,
             sourceTimestamp: null,

package/client/opcua-client-config.js

@@ -8,7 +8,10 @@ const {
     getMethodArgumentDefinition,
     resolveMethodObjectId,
     resolveSecurityMode,
-    resolveSecurityPolicy
+    resolveSecurityPolicy,
+    AttributeIds,
+    dataValueToItemResult,
+    enrichItemResultWithEnumeration
 } = require("./opcua-client-utils");
 
 const {
@@ -214,6 +217,40 @@ module.exports = function (RED) {
             res.status(500).json({ error: error.message });
         }
     });
+
+    RED.httpAdmin.get("/opcua-client-config/:id/read", RED.auth.needsPermission("flows.read"), async function (req, res) {
+        try {
+            const configNode = RED.nodes.getNode(req.params.id);
+
+            if (!configNode) {
+                res.status(404).json({ error: "OPC UA client configuration not found" });
+                return;
+            }
+
+            const nodeId = req.query.nodeId;
+            if (!nodeId) {
+                throw new Error("Missing nodeId parameter");
+            }
+
+            const session = await configNode.getSession();
+            const dataValue = await session.read({
+                nodeId: nodeId,
+                attributeId: AttributeIds.Value
+            });
+
+            if (dataValue.statusCode && !dataValue.statusCode.isGood()) {
+                throw new Error("Read failed: " + dataValue.statusCode.toString());
+            }
+
+            const cache = new Map();
+            let result = dataValueToItemResult({ nodeID: nodeId }, dataValue);
+            result = await enrichItemResultWithEnumeration(result, session, cache, nodeId);
+
+            res.json({ value: result.value, valueEnumeration: result.valueEnumeration });
+        } catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
 };
 
 async function browseForEditor(configNode, nodeId) {

package/client/opcua-client-utils.js

@@ -204,6 +204,70 @@ function coerceValue(value, typeName) {
     }
 }
 
+function getArrayDimensions(value, typeName) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    // Check if it is a 64-bit scalar represented as [high, low]
+    if ((typeName === "Int64" || typeName === "UInt64") && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+        return null;
+    }
+
+    const hasNestedArray = value.some(item => {
+        if (Array.isArray(item)) {
+            if ((typeName === "Int64" || typeName === "UInt64") && item.length === 2 && typeof item[0] === "number" && typeof item[1] === "number") {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    });
+
+    if (!hasNestedArray) {
+        return null;
+    }
+
+    const dimensions = [];
+    let current = value;
+    while (Array.isArray(current)) {
+        if ((typeName === "Int64" || typeName === "UInt64") && current.length === 2 && typeof current[0] === "number" && typeof current[1] === "number") {
+            break;
+        }
+        dimensions.push(current.length);
+        if (current.length === 0) {
+            break;
+        }
+        current = current[0];
+    }
+    return dimensions;
+}
+
+function flattenMatrix(value, typeName) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    if ((typeName === "Int64" || typeName === "UInt64") && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+        return [value];
+    }
+
+    const flat = [];
+    const recurse = (a) => {
+        for (const item of a) {
+            if (Array.isArray(item)) {
+                if ((typeName === "Int64" || typeName === "UInt64") && item.length === 2 && typeof item[0] === "number" && typeof item[1] === "number") {
+                    flat.push(item);
+                } else {
+                    recurse(item);
+                }
+            } else {
+                flat.push(item);
+            }
+        }
+    };
+    recurse(value);
+    return flat;
+}
+
 function buildVariantFromItem(item, fallbackTypeName) {
     const typeName = normalizeTypeName(item.type || fallbackTypeName || inferTypeName(item.value));
     const dataType = DataType[typeName];
@@ -212,6 +276,23 @@ function buildVariantFromItem(item, fallbackTypeName) {
         throw new Error("Unsupported OPC UA data type: " + typeName);
     }
 
+    const dimensions = getArrayDimensions(item.value, typeName);
+    if (dimensions) {
+        // Multi-dimensional array (Matrix)
+        const flatVal = flattenMatrix(item.value, typeName);
+        const coercedArray = coerceValue(flatVal, typeName);
+        const TypedArrayCtor = TYPED_ARRAY_MAP[dataType];
+
+        return new Variant({
+            dataType,
+            arrayType: VariantArrayType.Matrix,
+            dimensions,
+            value: TypedArrayCtor
+                ? TypedArrayCtor.from(coercedArray)
+                : coercedArray
+        });
+    }
+
     const isArray = Array.isArray(item.value);
 
     if (isArray) {
@@ -311,12 +392,48 @@ function resolve64BitValue(value, isUnsigned) {
     return value;
 }
 
+function reshapeArray(flatArray, dimensions) {
+    if (!dimensions || dimensions.length <= 1) {
+        return flatArray;
+    }
+
+    const reshape = (arr, dims, offset) => {
+        const size = dims[0];
+        if (dims.length === 1) {
+            return {
+                result: arr.slice(offset, offset + size),
+                nextOffset: offset + size
+            };
+        }
+
+        const result = [];
+        let currentOffset = offset;
+        for (let i = 0; i < size; i++) {
+            const step = reshape(arr, dims.slice(1), currentOffset);
+            result.push(step.result);
+            currentOffset = step.nextOffset;
+        }
+        return {
+            result: result,
+            nextOffset: currentOffset
+        };
+    };
+
+    return reshape(flatArray, dimensions, 0).result;
+}
+
 function dataValueToItemResult(item, dataValue) {
     const variant = dataValue && dataValue.value ? dataValue.value : null;
     let val = variant ? variant.value : null;
     if (variant && (variant.dataType === DataType.Int64 || variant.dataType === DataType.UInt64)) {
         val = resolve64BitValue(val, variant.dataType === DataType.UInt64);
     }
+    if (variant && variant.arrayType === VariantArrayType.Matrix && variant.dimensions && (Array.isArray(val) || ArrayBuffer.isView(val))) {
+        if (ArrayBuffer.isView(val)) {
+            val = Array.from(val);
+        }
+        val = reshapeArray(val, variant.dimensions);
+    }
     return {
         name: resolveName(item, resolveNodeId(item)),
         nodeID: resolveNodeId(item),
@@ -374,6 +491,12 @@ function callResultToItemResult(item, callResult, argumentDefinition) {
             if (variant && (variant.dataType === DataType.Int64 || variant.dataType === DataType.UInt64)) {
                 val = resolve64BitValue(val, variant.dataType === DataType.UInt64);
             }
+            if (variant && variant.arrayType === VariantArrayType.Matrix && variant.dimensions && (Array.isArray(val) || ArrayBuffer.isView(val))) {
+                if (ArrayBuffer.isView(val)) {
+                    val = Array.from(val);
+                }
+                val = reshapeArray(val, variant.dimensions);
+            }
             return {
                 name: outputDefinitions[index] && outputDefinitions[index].name
                     ? String(outputDefinitions[index].name)
@@ -468,12 +591,22 @@ async function getMethodArgumentDefinition(session, methodNodeId, cache) {
     return definition;
 }
 
+const PRIMITIVE_TYPES = new Set([
+    "Null", "Boolean", "SByte", "Byte", "Int16", "UInt16", "Int32", "UInt32", "Int64", "UInt64",
+    "Float", "Double", "String", "DateTime", "Guid", "ByteString", "XmlElement",
+    "NodeId", "ExpandedNodeId", "StatusCode", "QualifiedName", "LocalizedText"
+]);
+
 async function enrichItemResultWithEnumeration(result, session, cache, nodeId) {
     const type = result.type || result.dataType;
     if (!type) {
         return result;
     }
 
+    if (result.dataType && PRIMITIVE_TYPES.has(result.dataType)) {
+        return result;
+    }
+
     const isStandardEnum = type === "Int32" || type === "Enumeration";
     const isCustomNodeId = typeof type === "string" && (type.includes("i=") || type.includes("ns="));
 
@@ -487,88 +620,83 @@ async function enrichItemResultWithEnumeration(result, session, cache, nodeId) {
 
     try {
         const cacheKeyType = "dt:" + nodeId;
-        let dtNodeId = cache ? cache.get(cacheKeyType) : undefined;
-        if (dtNodeId === undefined) {
-            const isNodeIdLike = result.dataType && (
-                typeof result.dataType !== "string" || 
-                result.dataType.includes("i=") || 
-                result.dataType.includes("ns=")
-            );
-            if (isNodeIdLike) {
-                try {
-                    dtNodeId = coerceNodeId(result.dataType);
-                } catch (e) {
-                    dtNodeId = undefined;
+        let dtNodeIdPromise = cache ? cache.get(cacheKeyType) : undefined;
+        
+        if (dtNodeIdPromise === undefined) {
+            dtNodeIdPromise = (async () => {
+                const isNodeIdLike = result.dataType && (
+                    typeof result.dataType !== "string" || 
+                    result.dataType.includes("i=") || 
+                    result.dataType.includes("ns=")
+                );
+                if (isNodeIdLike) {
+                    try {
+                        return coerceNodeId(result.dataType);
+                    } catch (e) {
+                        return null;
+                    }
                 }
-            }
-            if (dtNodeId === undefined) {
                 const dv = await session.read({
                     nodeId: nodeId,
                     attributeId: AttributeIds.DataType
                 });
-                if (dv.statusCode.isGood()) {
-                    dtNodeId = dv.value.value;
-                    if (cache) cache.set(cacheKeyType, dtNodeId);
-                } else {
-                    if (cache) cache.set(cacheKeyType, null);
-                }
-            }
+                return dv.statusCode.isGood() ? dv.value.value : null;
+            })();
+            if (cache) cache.set(cacheKeyType, dtNodeIdPromise);
         }
         
+        const dtNodeId = await dtNodeIdPromise;
         if (!dtNodeId) return result;
         
         const cacheKeyStrings = "enumStrings:" + dtNodeId.toString();
-        let enumStrings = cache ? cache.get(cacheKeyStrings) : undefined;
+        let enumStringsPromise = cache ? cache.get(cacheKeyStrings) : undefined;
         
-        if (enumStrings === undefined) {
-            const browseResult = await session.browse({
-                nodeId: dtNodeId,
-                referenceTypeId: "HasProperty",
-                browseDirection: BrowseDirection.Forward,
-                includeSubtypes: true,
-                resultMask: 63
-            });
-            
-            const enumStringsRef = browseResult.references ? browseResult.references.find(r => r.browseName.name === "EnumStrings") : null;
-            const enumValuesRef = browseResult.references ? browseResult.references.find(r => r.browseName.name === "EnumValues") : null;
-
-            if (enumStringsRef) {
-                const dataValue = await session.read({
-                    nodeId: enumStringsRef.nodeId,
-                    attributeId: AttributeIds.Value
+        if (enumStringsPromise === undefined) {
+            enumStringsPromise = (async () => {
+                const browseResult = await session.browse({
+                    nodeId: dtNodeId,
+                    referenceTypeId: "HasProperty",
+                    browseDirection: BrowseDirection.Forward,
+                    includeSubtypes: true,
+                    resultMask: 63
                 });
-                if (dataValue.statusCode.isGood() && dataValue.value.value) {
-                    enumStrings = dataValue.value.value.map(lt => lt.text);
-                    if (cache) cache.set(cacheKeyStrings, enumStrings);
-                } else {
-                    if (cache) cache.set(cacheKeyStrings, null);
-                }
-            } else if (enumValuesRef) {
-                const dataValue = await session.read({
-                    nodeId: enumValuesRef.nodeId,
-                    attributeId: AttributeIds.Value
-                });
-                if (dataValue.statusCode.isGood() && dataValue.value.value) {
-                    const map = {};
-                    dataValue.value.value.forEach(ev => {
-                        let val;
-                        if (Array.isArray(ev.value) && ev.value.length === 2) {
-                            val = ev.value[1]; // low part of Int64
-                        } else {
-                            val = Number(ev.value);
-                        }
-                        map[val] = ev.displayName.text;
+                
+                const enumStringsRef = browseResult.references ? browseResult.references.find(r => r.browseName.name === "EnumStrings") : null;
+                const enumValuesRef = browseResult.references ? browseResult.references.find(r => r.browseName.name === "EnumValues") : null;
+
+                if (enumStringsRef) {
+                    const dataValue = await session.read({
+                        nodeId: enumStringsRef.nodeId,
+                        attributeId: AttributeIds.Value
                     });
-                    enumStrings = map;
-                    if (cache) cache.set(cacheKeyStrings, enumStrings);
-                } else {
-                    if (cache) cache.set(cacheKeyStrings, null);
+                    if (dataValue.statusCode.isGood() && dataValue.value.value) {
+                        return dataValue.value.value.map(lt => lt.text);
+                    }
+                } else if (enumValuesRef) {
+                    const dataValue = await session.read({
+                        nodeId: enumValuesRef.nodeId,
+                        attributeId: AttributeIds.Value
+                    });
+                    if (dataValue.statusCode.isGood() && dataValue.value.value) {
+                        const map = {};
+                        dataValue.value.value.forEach(ev => {
+                            let val;
+                            if (Array.isArray(ev.value) && ev.value.length === 2) {
+                                val = ev.value[1]; // low part of Int64
+                            } else {
+                                val = Number(ev.value);
+                            }
+                            map[val] = ev.displayName.text;
+                        });
+                        return map;
+                    }
                 }
-            } else {
-                if (cache) cache.set(cacheKeyStrings, null);
-            }
+                return null;
+            })();
+            if (cache) cache.set(cacheKeyStrings, enumStringsPromise);
         }
         
+        const enumStrings = await enumStringsPromise;
         if (enumStrings && enumStrings[result.value] !== undefined) {
             result.valueEnumeration = enumStrings[result.value];
             if (result.type) result.type = "Enumeration";
@@ -601,5 +729,6 @@ module.exports = {
     resolveNodeId,
     resolveSecurityMode,
     resolveSecurityPolicy,
+    reshapeArray,
     statusCodeToString
 };

package/client/opcua-client.html

@@ -50,6 +50,7 @@
         <div id="node-input-browse-context-menu" class="opcua-tree-context-menu" style="display:none;">
             <a href="#" id="node-input-browse-context-refresh"><i class="fa fa-refresh"></i> Refresh node</a>
             <a href="#" id="node-input-browse-context-copy-nodeid"><i class="fa fa-copy"></i> Copy NodeID</a>
+            <a href="#" id="node-input-browse-context-read-value"><i class="fa fa-eye"></i> Read value</a>
         </div>
     </div>