@vitormnm/node-red-simple-opcua 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vitor Mião
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,128 @@
+# @vitormnm/node-red-simple-opcua
+OPC UA client and server with a simple graphical interface for Node-RED.
+fully parameterized via 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
+ - 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) 
+
+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"
+        }
+    ]
+}
+```
+
+

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

@@ -0,0 +1,291 @@
+"use strict";
+
+const {
+    AttributeIds,
+    BrowseDirection,
+    DataType,
+    NodeClass,
+    coerceNodeId,
+    makeNodeId
+} = require("node-opcua");
+
+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: []
+    };
+
+    const browseResult = await session.browse({
+        nodeId: nodeID,
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        resultMask: 63
+    });
+
+    const references = browseResult && Array.isArray(browseResult.references)
+        ? browseResult.references
+        : [];
+
+    for (const reference of references) {
+        result.browse.push(await mapReference(session, reference));
+    }
+
+    return result;
+}
+
+function normalizeBrowseRoots(payload) {
+    if (payload === undefined || payload === null) {
+        return [{ name: "RootFolder", nodeID: ROOT_NODE_ID }];
+    }
+
+    if (!Array.isArray(payload)) {
+        throw new Error("OPC UA browse expects msg.payload as an array");
+    }
+
+    if (!payload.length) {
+        return [{ name: "RootFolder", nodeID: ROOT_NODE_ID }];
+    }
+
+    return payload.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw new Error("Each browse item must be an object");
+        }
+
+        return {
+            name: typeof item.name === "string" && item.name.trim() ? item.name.trim() : "",
+            nodeID: normalizeNodeId(item.nodeID || item.nodeId)
+        };
+    });
+}
+
+async function mapReference(session, reference) {
+    const childNodeId = normalizeNodeId(reference.nodeId);
+    const nodeClass = resolveNodeClassName(reference.nodeClass);
+    const browseName = extractBrowseName(reference.browseName, childNodeId);
+    const item = {
+        nodeID: childNodeId,
+        nodeClass,
+        browseName,
+        displayName: extractDisplayName(reference.displayName, browseName),
+        description: await readDescription(session, childNodeId)
+    };
+
+    const hasTypeDefinition = await readHasTypeDefinition(session, childNodeId);
+    if (hasTypeDefinition) {
+        item.hasTypeDefinition = hasTypeDefinition;
+    }
+
+    if (nodeClass === "Variable") {
+        item.value = await readValue(session, childNodeId);
+        item.dataType = await readDataType(session, childNodeId);
+        return item;
+    }
+
+    if (nodeClass === "Method") {
+        const definition = await readMethodArguments(session, childNodeId);
+        item.inputArguments = definition.inputArguments;
+        item.outputArguments = definition.outputArguments;
+        return item;
+    }
+
+    return item;
+}
+
+async function readHasTypeDefinition(session, nodeId) {
+    try {
+        const browseResult = await session.browse({
+            nodeId,
+            browseDirection: BrowseDirection.Forward,
+            referenceTypeId: makeNodeId(40, 0), // HasTypeDefinition
+            includeSubtypes: false,
+            resultMask: 63
+        });
+        const references = browseResult && Array.isArray(browseResult.references)
+            ? browseResult.references
+            : [];
+        if (!references.length) {
+            return null;
+        }
+
+        const reference = references[0];
+        const typeNodeId = normalizeNodeId(reference.nodeId);
+        return {
+            nodeID: typeNodeId,
+            browseName: extractBrowseName(reference.browseName, typeNodeId),
+            displayName: extractDisplayName(reference.displayName, typeNodeId)
+        };
+    } catch (error) {
+        return null;
+    }
+}
+
+async function readBrowseName(session, nodeId, fallback) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.BrowseName
+        });
+        const value = dataValue && dataValue.value ? dataValue.value.value : null;
+        if (value && value.name) {
+            return String(value.name);
+        }
+    } catch (error) {
+        // Use fallback below.
+    }
+
+    return String(fallback || nodeId);
+}
+
+async function readDescription(session, nodeId) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.Description
+        });
+        const value = dataValue && dataValue.value ? dataValue.value.value : null;
+
+        if (typeof value === "string") {
+            return value;
+        }
+
+        if (value && typeof value.text === "string") {
+            return value.text;
+        }
+    } catch (error) {
+        // Return empty description when unavailable.
+    }
+
+    return "";
+}
+
+async function readValue(session, nodeId) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.Value
+        });
+
+        if (!dataValue || !dataValue.value) {
+            return "";
+        }
+
+        const value = dataValue.value.value;
+        return value === undefined || value === null ? "" : value;
+    } catch (error) {
+        return "";
+    }
+}
+
+async function readDataType(session, nodeId) {
+    try {
+        const dataValue = await session.read({
+            nodeId,
+            attributeId: AttributeIds.DataType
+        });
+
+        const value = dataValue && dataValue.value ? dataValue.value.value : null;
+        if (!value) {
+            return "";
+        }
+
+        if (value.namespace === 0 && typeof value.value === "number") {
+            return DataType[value.value] || value.toString();
+        }
+
+        return value.toString();
+    } catch (error) {
+        return "";
+    }
+}
+
+async function readMethodArguments(session, nodeId) {
+    try {
+        const definition = await session.getArgumentDefinition(nodeId);
+        return {
+            inputArguments: normalizeMethodArguments(definition && definition.inputArguments),
+            outputArguments: normalizeMethodArguments(definition && definition.outputArguments)
+        };
+    } catch (error) {
+        return {
+            inputArguments: [],
+            outputArguments: []
+        };
+    }
+}
+
+function normalizeNodeId(nodeId) {
+    return coerceNodeId(nodeId).toString();
+}
+
+function resolveNodeClassName(nodeClass) {
+    if (!nodeClass && nodeClass !== 0) {
+        return "";
+    }
+
+    if (typeof nodeClass === "object" && typeof nodeClass.key === "string") {
+        return nodeClass.key;
+    }
+
+    if (typeof nodeClass === "string") {
+        return nodeClass;
+    }
+
+    return NodeClass[nodeClass] || String(nodeClass);
+}
+
+function extractBrowseName(browseName, fallback) {
+    if (browseName && typeof browseName.name === "string" && browseName.name) {
+        return browseName.name;
+    }
+
+    return String(fallback || "");
+}
+
+function extractDisplayName(displayName, fallback) {
+    if (displayName && typeof displayName.text === "string" && displayName.text) {
+        return displayName.text;
+    }
+
+    if (typeof displayName === "string" && displayName) {
+        return displayName;
+    }
+
+    return String(fallback || "");
+}
+
+function normalizeMethodArguments(argumentsList) {
+    if (!Array.isArray(argumentsList)) {
+        return [];
+    }
+
+    return argumentsList.map((argument, index) => ({
+        name: argument && argument.name ? String(argument.name) : "arg" + (index + 1),
+        dataType: resolveArgumentDataType(argument && argument.dataType),
+        description: argument && argument.description && typeof argument.description.text === "string"
+            ? argument.description.text
+            : ""
+    }));
+}
+
+function resolveArgumentDataType(dataType) {
+    if (!dataType) {
+        return "";
+    }
+
+    if (dataType.namespace === 0 && typeof dataType.value === "number") {
+        return DataType[dataType.value] || dataType.toString();
+    }
+
+    return dataType.toString();
+}
+
+const ROOT_NODE_ID = "i=84";
+
+module.exports = {
+    browseNode,
+    normalizeBrowseRoots,
+    normalizeNodeId,
+    ROOT_NODE_ID
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+
+const { dataValueToItemResult, resolveNodeId } = require("../opcua-client-utils");
+
+class OpcUaClientReadService {
+    async execute(node, msg, session, itemsResolver) {
+        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA read");
+        const nodeIds = items.map((item) => resolveNodeId(item));
+        const values = await session.readVariableValue(nodeIds);
+        return values.map((dataValue, index) => dataValueToItemResult(items[index], dataValue));
+    }
+}
+
+module.exports = {
+    OpcUaClientReadService
+};

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

@@ -0,0 +1,25 @@
+"use strict";
+
+const { ClientSubscription } = require("node-opcua");
+
+class OpcUaClientSubscriptionIdService {
+    async execute(node) {
+        const session = await node.connection.getSession();
+        const subscription = ClientSubscription.create(session, {
+            requestedPublishingInterval: 1000,
+            requestedLifetimeCount: 100,
+            requestedMaxKeepAliveCount: 10,
+            maxNotificationsPerPublish: 100,
+            publishingEnabled: true,
+            priority: 10
+        });
+
+        const subscriptionId = subscription.subscriptionId;
+        await subscription.terminate();
+        return subscriptionId;
+    }
+}
+
+module.exports = {
+    OpcUaClientSubscriptionIdService
+};

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

@@ -0,0 +1,171 @@
+"use strict";
+
+const {
+    ClientMonitoredItem,
+    ClientSubscription,
+    TimestampsToReturn,
+    AttributeIds,
+    constructEventFilter
+} = require("node-opcua");
+
+const {
+    dataValueToItemResult,
+    dataValueToItemResultEvent,
+    resolveName,
+    resolveNodeId,
+    statusCodeToString
+} = require("../opcua-client-utils");
+
+class OpcUaClientSubscriptionService {
+    async startDataSubscription(node, msg, itemsResolver) {
+        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA subscription");
+        await this.stop(node);
+
+        const session = await node.connection.getSession();
+        const subscription = ClientSubscription.create(session, {
+            requestedPublishingInterval: node.publishingInterval,
+            requestedLifetimeCount: 60,
+            requestedMaxKeepAliveCount: 10,
+            maxNotificationsPerPublish: 100,
+            publishingEnabled: true,
+            priority: 1
+        });
+
+        subscription.on("error", (error) => {
+            node.status({ fill: "red", shape: "ring", text: "subscription error" });
+            node.error(error);
+        });
+
+        node.subscription = subscription;
+        node.monitoredItems = items.map((item) => {
+            const monitoredItem = ClientMonitoredItem.create(
+                subscription,
+                { nodeId: resolveNodeId(item) },
+                {
+                    samplingInterval: node.samplingInterval,
+                    discardOldest: true,
+                    queueSize: 1
+                },
+                TimestampsToReturn.Both
+            );
+
+            monitoredItem.on("changed", (dataValue) => {
+                const payload = dataValueToItemResult(item, dataValue);
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: resolveName(item, payload.nodeID) + " changed"
+                });
+                node.send({
+                    topic: payload.name,
+                    payload,
+                    opcua: {
+                        mode: "subscription",
+                        nodeID: payload.nodeID,
+                        status: payload.status
+                    }
+                });
+            });
+
+            monitoredItem.on("err", (message) => {
+                node.status({ fill: "red", shape: "ring", text: statusCodeToString(message) });
+            });
+
+            return monitoredItem;
+        });
+
+        return items;
+    }
+
+    async startEventSubscription(node, msg, itemsResolver) {
+        const items = itemsResolver.ensureClientItems(node, msg, "OPC UA subscription");
+        await this.stop(node);
+
+        const session = await node.connection.getSession();
+        const subscription = ClientSubscription.create(session, {
+            requestedPublishingInterval: node.publishingInterval,
+            requestedLifetimeCount: 60,
+            requestedMaxKeepAliveCount: 10,
+            maxNotificationsPerPublish: 100,
+            publishingEnabled: true,
+            priority: 2
+        });
+
+        subscription.on("error", (error) => {
+            node.status({ fill: "red", shape: "ring", text: "subscription error" });
+            node.error(error);
+        });
+
+        node.subscription = subscription;
+
+        const eventFilter = constructEventFilter([
+            "EventId",
+            "EventType",
+            "SourceName",
+            "SourceNode",
+            "Message",
+            "Severity",
+            "ActiveState",
+            "AckedState",
+            "ConfirmedState",
+            "Time"
+        ]);
+
+        node.monitoredItems = items.map((item) => {
+            const monitoredItem = ClientMonitoredItem.create(
+                subscription,
+                {
+                    nodeId: resolveNodeId(item),
+                    attributeId: AttributeIds.EventNotifier
+                },
+                {
+                    samplingInterval: 0,
+                    queueSize: 100,
+                    discardOldest: true,
+                    filter: eventFilter
+                },
+                TimestampsToReturn.Both
+            );
+
+            monitoredItem.on("changed", async (eventFields) => {
+                const payload = await dataValueToItemResultEvent(item, eventFields, session);
+                node.status({
+                    fill: "blue",
+                    shape: "dot",
+                    text: resolveName(item, payload.nodeID) + " changed"
+                });
+                node.send({
+                    topic: payload.name,
+                    payload,
+                    opcua: {
+                        mode: "subscription",
+                        nodeID: payload.nodeID,
+                        status: payload.status
+                    }
+                });
+            });
+
+            monitoredItem.on("err", (message) => {
+                node.status({ fill: "red", shape: "ring", text: statusCodeToString(message) });
+            });
+
+            return monitoredItem;
+        });
+
+        return items;
+    }
+
+    async stop(node) {
+        const subscription = node.subscription;
+        node.monitoredItems = [];
+        node.subscription = null;
+
+        if (subscription) {
+            await subscription.terminate();
+        }
+    }
+}
+
+module.exports = {
+    OpcUaClientSubscriptionService
+};

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

@@ -0,0 +1,53 @@
+"use strict";
+
+const { DataType, coerceNodeId } = require("node-opcua");
+const {
+    buildVariantFromItem,
+    dataValueToItemResult,
+    normalizeTypeName,
+    resolveNodeId,
+    statusCodeToString
+} = require("../opcua-client-utils");
+
+class OpcUaClientWriteService {
+    async execute(node, msg, session, itemsResolver) {
+        const items = itemsResolver.ensureWriteItems(node, msg);
+        const results = [];
+
+        for (const item of items) {
+            const nodeId = resolveNodeId(item);
+
+            try {
+                const explicitType = normalizeTypeName(item.type);
+                const builtInType = await session.getBuiltInDataType(coerceNodeId(nodeId));
+                const typeName = explicitType || DataType[builtInType];
+                const variant = buildVariantFromItem(item, typeName);
+                const statusCode = await session.writeSingleNode(nodeId, variant);
+                const dataValue = await session.readVariableValue(nodeId);
+                const result = dataValueToItemResult(item, dataValue);
+
+                if (statusCode && statusCode.name && statusCode.name !== "Good") {
+                    result.status = statusCodeToString(statusCode);
+                }
+
+                results.push(result);
+            } catch (itemError) {
+                results.push({
+                    name: item.name || nodeId,
+                    nodeID: nodeId,
+                    value: item.value,
+                    type: normalizeTypeName(item.type) || null,
+                    status: itemError.message,
+                    sourceTimestamp: null,
+                    serverTimestamp: null
+                });
+            }
+        }
+
+        return results;
+    }
+}
+
+module.exports = {
+    OpcUaClientWriteService
+};