@vitormnm/node-red-simple-opcua 1.6.3 → 1.8.0

package/README.md

@@ -1,136 +1,104 @@
-OPC UA client and server with a simple graphical interface for Node-RED.
-Fully parameterized in JSON.
-
-It supports the following OPC UA items on only 3 nodes.
-
- - alarms
- - events
- - events read and write tags in server(See which tags are being written to or read from the client directly on the server in a simple workflow)
- - methods(write methods in node-red flow)
- - variables
- - variables arrays
- - description and displayname nodes
- - objects
- - simple objectsType
- - custom namespace
- - custom nodeID
- - Subscription Variables and events in client
-
-**Server editor**
-![node-red-si](/resources/editorServer.PNG) 
-
-**Client editor**
-![node-red-si](/resources/editorClient.PNG) 
-
-### Support the development of this project and others if you found it useful.
-<a href="https://buymeacoffee.com/vitormnm">
-    <img src="./resources/bmc-button.svg" alt="Logo" width="200">
-</a>
-
----
-
-example json server config
-```
-{
-    "objects": [],
-    "folders": [
-        {
-            "name": "MyServer",
-            "displayName": "",
-            "description": "",
-            "nodeId": "",
-            "namespaceId": 2,
-            "objectsType": "",
-            "folders": [
-                {
-                    "name": "newFolder",
-                    "displayName": "",
-                    "description": "",
-                    "nodeId": "",
-                    "namespaceId": 2,
-                    "objectsType": "",
-                    "folders": [],
-                    "objects": [],
-                    "variables": [
-                        {
-                            "name": "newVariable",
-                            "type": "Int32",
-                            "value": "",
-                            "access": "readwrite",
-                            "description": "",
-                            "displayName": "",
-                            "nodeId": "",
-                            "namespaceId": 2
-                        }
-                    ],
-                    "alarms": [],
-                    "methods": [],
-                    "objectsTypes": []
-                }
-            ],
-            "objects": [
-                {
-                    "name": "newObject",
-                    "displayName": "",
-                    "description": "",
-                    "nodeId": "",
-                    "namespaceId": 2,
-                    "objectsType": "",
-                    "folders": [],
-                    "objects": [],
-                    "variables": [
-                        {
-                            "name": "newVariable",
-                            "type": "Int32",
-                            "value": "",
-                            "access": "readwrite",
-                            "description": "",
-                            "displayName": "",
-                            "nodeId": "",
-                            "namespaceId": 2
-                        }
-                    ],
-                    "alarms": [],
-                    "methods": [],
-                    "objectsTypes": []
-                }
-            ],
-            "variables": [
-                {
-                    "name": "newVariable",
-                    "type": "Int32",
-                    "value": "",
-                    "access": "readwrite",
-                    "description": "",
-                    "displayName": "",
-                    "nodeId": "",
-                    "namespaceId": 2
-                }
-            ],
-            "alarms": [],
-            "methods": [
-                {
-                    "name": "newMethod",
-                    "description": "",
-                    "displayName": "",
-                    "nodeId": "",
-                    "namespaceId": 2,
-                    "inputs": [],
-                    "outputs": []
-                }
-            ],
-            "objectsTypes": []
-        }
-    ],
-    "objectsTypes": [],
-    "nameSpaces": [
-        {
-            "id": 2,
-            "name": "urn:node-red:opc-ua-server"
-        }
-    ]
-}
-```
-Disclaimer
-This node was only used in simulation and testing environments.
-
+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.
+
+---
+
+## Features Overview
+
+- **Dynamic OPC UA Address Space**: Build hierarchical folders, objects, variables, and alarms dynamically from a visual tree editor or JSON.
+- **IPC Process Separation**: Server runtime runs in a child process, preventing heavy OPC UA operations from blocking the main Node-RED event loop.
+- **Rich Node-RED Integration**: Support for reading, writing, subscribing, calling methods, and managing sessions directly in Node-RED flows.
+
+---
+
+## Server Functionalities
+
+The server implementation consists of two nodes: `opc-ua-server` (the server runtime) and `opcua-server-io` (the data input/output node).
+
+### 1. OPC UA Server (`opc-ua-server`)
+This node instantiates the OPC UA Server process.
+- **Visual Tree Editor**: Build folders, variables, custom objects, ObjectTypes (templates), alarms, methods, and enumerations visually.
+- **Dynamic Address Space**: Rebuild the address space at runtime by passing a new JSON tree configuration in `msg.payload`.
+- **Authentication & Authorization**: Configure users, groups, and comma-separated access permissions for folders, variables, and methods.
+- **Security Policies**: Supports multiple security policies (`None`, `Basic256Sha256`, `Aes128_Sha256_RsaOaep`, etc.) and security modes (`None`, `Sign`, `SignAndEncrypt`).
+- **Certificate Management**: Manage trusted/rejected client certificates.
+
+### 2. Server I/O Node (`opcua-server-io`)
+Interacts with an active local server instance. It supports the following modes:
+- **Read**: Read values from server variables using a tag path or NodeId.
+- **Write**: Write values to server variables.
+- **Event**: Fire custom OPC UA events on target nodes.
+- **Events**: Stream variable read, write, and alarm events.
+- **Status**: Monitor server variable status snapshots.
+- **Active Alarms**: Query active alarms on the server.
+- **Get Sessions**: Retrieve active OPC UA client sessions.
+- **Delete Sessions**: Forcefully close specific active sessions by ID.
+- **Method Input / Output**: Route OPC UA method calls from clients into Node-RED flows and return output results.
+
+---
+
+### 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).
+
+### 1. Client Connection Config (`opcua-client-config`)
+Manages connection configuration to an external OPC UA server.
+- **Connection Strategy**: Limit reconnect retries to fail fast when servers are offline.
+- **Authentication**: Supports anonymous or username/password authentication.
+- **Session Caching**: Caches and reuse client sessions and method definitions.
+- **Address Space Browser**: Provides an endpoint for browsing the server address space directly in the Node-RED editor.
+
+### 2. OPC UA Client (`opcua-client`)
+Performs actions on the configured OPC UA server. It operates in the following modes:
+- **Read**: Batch read selected variables.
+- **Write**: Batch write values with automatic type resolution.
+- **Browse**: Browse child nodes of one or more node paths.
+- **Browse Recursive**: Recursively search all nodes starting from specified NodeIds, returning resolved type definitions, values, descriptions, and method arguments in optimized batched reads.
+- **Method**: Call OPC UA methods on the server.
+- **Subscription**: Subscribe to variable value updates (minimum 50ms sampling/publishing).
+- **Events**: Subscribe to OPC UA events.
+
+---
+
+## Editor Interfaces
+
+### Server Editor
+![Server Editor](./resources/editorServer.PNG)
+
+### Client Editor
+![Client Editor](./resources/editorClient.PNG)
+
+---
+
+
+
+
+### Support the Project
+If you find this project useful, please support its development:
+
+<a href="https://buymeacoffee.com/vitormnm">
+    <img src="./resources/bmc-button.svg" alt="Buy Me A Coffee" width="200">
+</a>
+
+
+[@vitormnm](https://vitormiao.com/)
+
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)

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

@@ -6,15 +6,19 @@ const {
     DataType,
     NodeClass,
     coerceNodeId,
-    makeNodeId
+    makeNodeId,
+    VariantArrayType
 } = require("node-opcua");
 
+const { enrichItemResultWithEnumeration, reshapeArray } = require("../opcua-client-utils");
+
 async function browseNode(session, root) {
     const nodeID = normalizeNodeId(root.nodeID || root.nodeId || ROOT_NODE_ID);
     const result = {
         name: root.name || await readBrowseName(session, nodeID, "RootFolder"),
         nodeID,
-        browse: []
+        status: "Good",
+        children: []
     };
 
 
@@ -30,11 +34,16 @@ async function browseNode(session, root) {
 
     let browseResult = await session.browse({
         nodeId: nodeID,
+        referenceTypeId: makeNodeId(33, 0), // HierarchicalReferences
         browseDirection: BrowseDirection.Forward,
         includeSubtypes: true,
         resultMask: 63
     });
 
+    if (browseResult.statusCode && !browseResult.statusCode.isGood()) {
+        throw new Error("Browse failed: " + browseResult.statusCode.toString());
+    }
+
     let references = [
         ...(browseResult.references || [])
     ];
@@ -61,19 +70,34 @@ async function browseNode(session, root) {
 
     // Monta lista de todos os atributos de todos os nós de uma vez
     const nodeIds = references.map(ref => normalizeNodeId(ref.nodeId));
-
-
-    const attributesToRead = nodeIds.flatMap(nodeId => [
-        { nodeId, attributeId: AttributeIds.Description },
-        { nodeId, attributeId: AttributeIds.DataType },
-        { nodeId, attributeId: AttributeIds.Value },
-    ]);
+    const typeIds = references
+        .map(ref => ref.typeDefinition ? normalizeNodeId(ref.typeDefinition) : null)
+        .filter(Boolean);
+    const uniqueTypeIds = [...new Set(typeIds)];
+
+    const attributesToRead = [
+        ...nodeIds.flatMap(nodeId => [
+            { nodeId, attributeId: AttributeIds.Description },
+            { nodeId, attributeId: AttributeIds.DataType },
+            { nodeId, attributeId: AttributeIds.Value },
+        ]),
+        ...uniqueTypeIds.map(nodeId => ({ nodeId, attributeId: AttributeIds.BrowseName }))
+    ];
 
     // UMA única chamada para todos os nós e atributos
     const dataValues = await session.read(attributesToRead);
 
+    const typeNamesMap = new Map();
+    const typeStartIdx = nodeIds.length * 3;
+    uniqueTypeIds.forEach((typeId, index) => {
+        const browseNameVal = dataValues[typeStartIdx + index]?.value?.value;
+        const name = browseNameVal?.name || typeId;
+        typeNamesMap.set(typeId, name);
+    });
+
+    const cache = new Map();
     // Distribui os resultados por nó (3 atributos por nó)
-    result.browse = await Promise.all(references.map(async (reference, i) => {
+    result.children = await Promise.all(references.map(async (reference, i) => {
         const childNodeId = nodeIds[i];
         const nodeClass = resolveNodeClassName(reference.nodeClass);
         const browseName = extractBrowseName(reference.browseName, childNodeId);
@@ -86,15 +110,40 @@ async function browseNode(session, root) {
 
         const item = { nodeID: childNodeId, nodeClass, browseName, displayName, description };
 
+        const typeNodeId = reference.typeDefinition ? normalizeNodeId(reference.typeDefinition) : null;
+        if (typeNodeId) {
+            const typeName = typeNamesMap.get(typeNodeId) || typeNodeId;
+            item.typeDefinition = typeNodeId;
+            item.hasTypeDefinition = {
+                nodeID: typeNodeId,
+                browseName: typeName,
+                displayName: typeName
+            };
+        }
+
         if (nodeClass === "Variable") {
             const dataTypeValue = dataValues[i * 3 + 1]?.value?.value;
-            const rawValue = dataValues[i * 3 + 2]?.value?.value;
+            const rawValueVariant = dataValues[i * 3 + 2]?.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())
                 : (dataTypeValue?.toString() ?? "");
 
+            if (rawValueVariant?.dataType === DataType.Enumeration) {
+                item.dataType = "Enumeration";
+            }
+
             item.value = rawValue ?? "";
+
+            await enrichItemResultWithEnumeration(item, session, cache, childNodeId);
         }
 
         if (nodeClass === "Method") {
@@ -358,11 +407,205 @@ function resolveArgumentDataType(dataType) {
     return dataType.toString();
 }
 
+async function browseRecursiveNode(session, root) {
+    const startNodeId = normalizeNodeId(root.nodeID || root.nodeId || ROOT_NODE_ID);
+    const rootName = root.name || await readBrowseName(session, startNodeId, "RootFolder");
+
+    const visited = new Set();
+    visited.add(startNodeId);
+
+    const allItems = [];
+
+    async function traverse(nodeID) {
+        let browseResult;
+        try {
+            browseResult = await session.browse({
+                nodeId: nodeID,
+                referenceTypeId: makeNodeId(33, 0), // HierarchicalReferences
+                browseDirection: BrowseDirection.Forward,
+                includeSubtypes: true,
+                resultMask: 63
+            });
+        } catch (err) {
+            if (nodeID === startNodeId) {
+                throw err;
+            }
+            return [];
+        }
+
+        if (browseResult.statusCode && !browseResult.statusCode.isGood()) {
+            if (nodeID === startNodeId) {
+                throw new Error("Browse failed: " + browseResult.statusCode.toString());
+            }
+            return [];
+        }
+
+        let references = [...(browseResult.references || [])];
+
+        while (browseResult.continuationPoint) {
+            try {
+                browseResult = await session.browseNext(
+                    browseResult.continuationPoint,
+                    false
+                );
+                references.push(...(browseResult.references || []));
+            } catch (err) {
+                break;
+            }
+        }
+
+        if (!references.length) {
+            return [];
+        }
+
+        const items = [];
+        for (const ref of references) {
+            const childNodeId = normalizeNodeId(ref.nodeId);
+            const nodeClass = resolveNodeClassName(ref.nodeClass);
+            const browseName = extractBrowseName(ref.browseName, childNodeId);
+            const displayName = extractDisplayName(ref.displayName, browseName);
+            const typeNodeId = ref.typeDefinition ? normalizeNodeId(ref.typeDefinition) : null;
+
+            const item = {
+                nodeID: childNodeId,
+                nodeClass,
+                browseName,
+                displayName
+            };
+            if (typeNodeId) {
+                item.typeDefinition = typeNodeId;
+            }
+
+            items.push(item);
+            allItems.push(item);
+
+            const expandable = nodeClass === "Object" || nodeClass === "Folder" || nodeClass === "View" || nodeClass === "ObjectType";
+            if (expandable && !visited.has(childNodeId)) {
+                visited.add(childNodeId);
+                item.children = await traverse(childNodeId);
+            }
+        }
+
+        return items;
+    }
+
+    const browseResult = await traverse(startNodeId);
+
+    if (allItems.length > 0) {
+        const cache = new Map();
+        const typeIds = allItems
+            .map(item => item.typeDefinition)
+            .filter(Boolean);
+        const uniqueTypeIds = [...new Set(typeIds)];
+
+        const typeNamesMap = new Map();
+        if (uniqueTypeIds.length > 0) {
+            try {
+                const typeAttributes = uniqueTypeIds.map(nodeId => ({ nodeId, attributeId: AttributeIds.BrowseName }));
+                const typeDataValues = await session.read(typeAttributes);
+                uniqueTypeIds.forEach((typeId, index) => {
+                    const browseNameVal = typeDataValues[index]?.value?.value;
+                    const name = browseNameVal?.name || typeId;
+                    typeNamesMap.set(typeId, name);
+                });
+            } catch (err) {
+                // Ignore type names read error, we'll fallback to NodeId below
+            }
+        }
+
+        const BATCH_SIZE = 100;
+        for (let i = 0; i < allItems.length; i += BATCH_SIZE) {
+            const chunk = allItems.slice(i, i + BATCH_SIZE);
+            const attributesToRead = chunk.flatMap(item => [
+                { nodeId: item.nodeID, attributeId: AttributeIds.Description },
+                { nodeId: item.nodeID, attributeId: AttributeIds.DataType },
+                { nodeId: item.nodeID, attributeId: AttributeIds.Value }
+            ]);
+
+            try {
+                const dataValues = await session.read(attributesToRead);
+                await Promise.all(chunk.map(async (item, index) => {
+                    const descValue = dataValues[index * 3]?.value?.value;
+                    item.description = typeof descValue === "string"
+                        ? descValue
+                        : (descValue?.text ?? "");
+
+                    if (item.nodeClass === "Variable") {
+                        const dataTypeValue = dataValues[index * 3 + 1]?.value?.value;
+                        const rawValueVariant = dataValues[index * 3 + 2]?.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())
+                            : (dataTypeValue?.toString() ?? "");
+
+                        if (rawValueVariant?.dataType === DataType.Enumeration) {
+                            item.dataType = "Enumeration";
+                        }
+
+                        item.value = rawValue ?? "";
+
+                        await enrichItemResultWithEnumeration(item, session, cache, item.nodeID);
+                    }
+
+                    if (item.typeDefinition) {
+                        const typeName = typeNamesMap.get(item.typeDefinition) || item.typeDefinition;
+                        item.hasTypeDefinition = {
+                            nodeID: item.typeDefinition,
+                            browseName: typeName,
+                            displayName: typeName
+                        };
+                    }
+                }));
+            } catch (readError) {
+                chunk.forEach(item => {
+                    item.description = "";
+                    if (item.nodeClass === "Variable") {
+                        item.dataType = "";
+                        item.value = "";
+                    }
+                    if (item.typeDefinition) {
+                        const typeName = typeNamesMap.get(item.typeDefinition) || item.typeDefinition;
+                        item.hasTypeDefinition = {
+                            nodeID: item.typeDefinition,
+                            browseName: typeName,
+                            displayName: typeName
+                        };
+                    }
+                });
+            }
+        }
+
+        const methods = allItems.filter(item => item.nodeClass === "Method");
+        for (const method of methods) {
+            const definition = await readMethodArguments(session, method.nodeID);
+            method.inputArguments = definition.inputArguments;
+            method.outputArguments = definition.outputArguments;
+        }
+    }
+
+    return {
+        name: rootName,
+        nodeID: startNodeId,
+        status: "Good",
+        children: browseResult
+    };
+}
+
 const ROOT_NODE_ID = "i=84";
 
 module.exports = {
     browseNode,
+    browseRecursiveNode,
     normalizeBrowseRoots,
     normalizeNodeId,
     ROOT_NODE_ID
 };
+

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

@@ -1,6 +1,6 @@
 "use strict";
 
-const { dataValueToItemResult, ensureArrayPayload, resolveNodeId, resolveMethodObjectId, buildVariantFromItem, callResultToItemResult } = require("../opcua-client-utils");
+const { dataValueToItemResult, ensureArrayPayload, resolveNodeId, resolveMethodObjectId, buildVariantFromItem, callResultToItemResult, getMethodArgumentDefinition } = require("../opcua-client-utils");
 
 class OpcUaClientMethodService {
     async execute(node, msg, session, itemsResolver) {

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

@@ -34,7 +34,6 @@ class OpcUaClientSubscriptionService {
 
         subscription.on("error", (error) => {
             node.status({ fill: "red", shape: "ring", text: "subscription error" });
-            node.error(error);
         });
 
         node.subscription = subscription;
@@ -97,7 +96,6 @@ class OpcUaClientSubscriptionService {
 
         subscription.on("error", (error) => {
             node.status({ fill: "red", shape: "ring", text: "subscription error" });
-            node.error(error);
         });
 
         node.subscription = subscription;

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,