@vitormnm/node-red-simple-opcua 1.0.2 → 1.1.0

package/client/opcua-client-config.js

@@ -0,0 +1,159 @@
+"use strict";
+
+const {
+    OPCUAClient,
+    getMethodArgumentDefinition,
+    resolveMethodObjectId,
+    resolveSecurityMode,
+    resolveSecurityPolicy
+} = require("./opcua-client-utils");
+
+const {
+    browseNode,
+    ROOT_NODE_ID
+} = require("./lib/opcua-client-browser");
+
+module.exports = function (RED) {
+    function OpcUaClientConfigNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.name = (config.name || "").trim();
+        node.endpoint = (config.endpoint || "").trim();
+        node.securityPolicy = config.securityPolicy || "None";
+        node.securityMode = config.securityMode || "None";
+        node.authType = config.authType || "anonymous";
+        node.client = null;
+        node.session = null;
+        node.connectPromise = null;
+        node.methodObjectIdCache = new Map();
+        node.methodDefinitionCache = new Map();
+
+        node.on("close", function (done) {
+            node.closeConnection().then(() => done(), done);
+        });
+    }
+
+    OpcUaClientConfigNode.prototype.getSession = async function () {
+        if (this.session) {
+            return this.session;
+        }
+
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+
+        if (!this.endpoint) {
+            throw new Error("OPC UA endpoint is not configured");
+        }
+
+        this.connectPromise = (async () => {
+            const client = OPCUAClient.create({
+                endpointMustExist: false,
+                keepSessionAlive: true,
+                securityMode: resolveSecurityMode(this.securityMode),
+                securityPolicy: resolveSecurityPolicy(this.securityPolicy)
+            });
+
+            try {
+                await client.connect(this.endpoint);
+
+                const credentials = this.credentials || {};
+                const session = this.authType === "username"
+                    ? await client.createSession({
+                        userName: credentials.username || "",
+                        password: credentials.password || ""
+                    })
+                    : await client.createSession();
+
+                session.on("session_closed", () => {
+                    this.session = null;
+                    this.methodObjectIdCache.clear();
+                    this.methodDefinitionCache.clear();
+                });
+
+                this.client = client;
+                this.session = session;
+                return session;
+            } catch (error) {
+                try {
+                    await client.disconnect();
+                } catch (disconnectError) {
+                    // Ignore secondary disconnect failures after a failed connect/createSession.
+                }
+                this.client = null;
+                this.session = null;
+                throw error;
+            } finally {
+                this.connectPromise = null;
+            }
+        })();
+
+        return this.connectPromise;
+    };
+
+    OpcUaClientConfigNode.prototype.resolveMethodObjectId = async function (session, methodNodeId) {
+        return resolveMethodObjectId(session, methodNodeId, this.methodObjectIdCache);
+    };
+
+    OpcUaClientConfigNode.prototype.getMethodArgumentDefinition = async function (session, methodNodeId) {
+        return getMethodArgumentDefinition(session, methodNodeId, this.methodDefinitionCache);
+    };
+
+    OpcUaClientConfigNode.prototype.closeConnection = async function () {
+        const session = this.session;
+        const client = this.client;
+
+        this.session = null;
+        this.client = null;
+        this.connectPromise = null;
+        this.methodObjectIdCache.clear();
+        this.methodDefinitionCache.clear();
+
+        if (session) {
+            try {
+                await session.close();
+            } catch (error) {
+                // Ignore close errors during shutdown.
+            }
+        }
+
+        if (client) {
+            try {
+                await client.disconnect();
+            } catch (error) {
+                // Ignore disconnect errors during shutdown.
+            }
+        }
+    };
+
+    RED.nodes.registerType("opcua-client-config", OpcUaClientConfigNode, {
+        credentials: {
+            username: { type: "text" },
+            password: { type: "password" }
+        }
+    });
+
+    RED.httpAdmin.get("/opcua-client-config/:id/browse", 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 payload = await browseForEditor(configNode, req.query.nodeId);
+            res.json(payload);
+        } catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+};
+
+async function browseForEditor(configNode, nodeId) {
+    const session = await configNode.getSession();
+    return browseNode(session, {
+        nodeID: nodeId || ROOT_NODE_ID
+    });
+}

package/client/opcua-client-utils.js

@@ -0,0 +1,320 @@
+"use strict";
+
+const {
+    AttributeIds,
+    BrowseDirection,
+    coerceNodeId,
+    DataType,
+    MessageSecurityMode,
+    NodeClass,
+    OPCUAClient,
+    SecurityPolicy,
+    TimestampsToReturn,
+    Variant
+} = require("node-opcua");
+
+function resolveSecurityPolicy(name) {
+    return SecurityPolicy[name] || SecurityPolicy.None;
+}
+
+function resolveSecurityMode(name) {
+    return MessageSecurityMode[name] || MessageSecurityMode.None;
+}
+
+function normalizeTypeName(type) {
+    const raw = String(type || "").trim();
+    if (!raw) {
+        return "";
+    }
+
+    const aliases = {
+        Bool: "Boolean",
+        Boolean: "Boolean",
+        Byte: "Byte",
+        SByte: "SByte",
+        Int: "Int32",
+        Int16: "Int16",
+        Int32: "Int32",
+        Int64: "Int64",
+        UInt16: "UInt16",
+        UInt32: "UInt32",
+        UInt64: "UInt64",
+        Float: "Float",
+        Double: "Double",
+        String: "String",
+        DateTime: "DateTime"
+    };
+
+    return aliases[raw] || raw;
+}
+
+function inferTypeName(value) {
+    if (typeof value === "boolean") {
+        return "Boolean";
+    }
+    if (typeof value === "string") {
+        return "String";
+    }
+    if (typeof value === "number") {
+        return Number.isInteger(value) ? "Int32" : "Double";
+    }
+    if (value instanceof Date) {
+        return "DateTime";
+    }
+    if (Buffer.isBuffer(value)) {
+        return "ByteString";
+    }
+    return "String";
+}
+
+function coerceValue(value, typeName) {
+    switch (typeName) {
+        case "Boolean":
+            if (typeof value === "string") {
+                return value.trim().toLowerCase() === "true";
+            }
+            return Boolean(value);
+        case "Byte":
+        case "SByte":
+        case "Int16":
+        case "Int32":
+        case "UInt16":
+        case "UInt32":
+            return Number.parseInt(value, 10);
+        case "Int64":
+        case "UInt64":
+            return BigInt(value);
+        case "Float":
+        case "Double":
+            return Number.parseFloat(value);
+        case "DateTime":
+            return value instanceof Date ? value : new Date(value);
+        case "String":
+            return value === undefined || value === null ? "" : String(value);
+        default:
+            return value;
+    }
+}
+
+function buildVariantFromItem(item, fallbackTypeName) {
+    const typeName = normalizeTypeName(item.type || fallbackTypeName || inferTypeName(item.value));
+    const dataType = DataType[typeName];
+
+    if (dataType === undefined) {
+        throw new Error("Unsupported OPC UA data type: " + typeName);
+    }
+
+    return new Variant({
+        dataType,
+        value: coerceValue(item.value, typeName)
+    });
+}
+
+function ensureArrayPayload(msg, contextName) {
+    const payload = msg ? msg.payload : undefined;
+
+    if (!Array.isArray(payload) || payload.length === 0) {
+        throw new Error(contextName + " expects msg.payload as a non-empty array");
+    }
+
+    return payload;
+}
+
+function resolveNodeId(item) {
+    const nodeId = item && (item.nodeID || item.nodeId);
+    if (!nodeId || !String(nodeId).trim()) {
+        throw new Error("Each item must contain nodeID");
+    }
+    return String(nodeId).trim();
+}
+
+function resolveName(item, fallback) {
+    return String(item && item.name ? item.name : fallback || "").trim();
+}
+
+function statusCodeToString(statusCode) {
+    if (!statusCode) {
+        return "Unknown";
+    }
+    return statusCode.name || statusCode.toString();
+}
+
+function timestampToIso(value) {
+    return value instanceof Date && !Number.isNaN(value.getTime())
+        ? value.toISOString()
+        : null;
+}
+
+function variantTypeToName(variant) {
+    if (!variant || variant.dataType === undefined || variant.dataType === null) {
+        return null;
+    }
+    return DataType[variant.dataType] || String(variant.dataType);
+}
+
+function dataValueToItemResult(item, dataValue) {
+    const variant = dataValue && dataValue.value ? dataValue.value : null;
+    return {
+        name: resolveName(item, resolveNodeId(item)),
+        nodeID: resolveNodeId(item),
+        value: variant ? variant.value : null,
+        type: variantTypeToName(variant),
+        status: statusCodeToString(dataValue && dataValue.statusCode),
+        sourceTimestamp: timestampToIso(dataValue && dataValue.sourceTimestamp),
+        serverTimestamp: timestampToIso(dataValue && dataValue.serverTimestamp)
+    };
+}
+
+async function dataValueToItemResultEvent(item, eventFields, session) {
+    const variant = eventFields && eventFields.value ? eventFields.value : null;
+
+    // lê BrowseName do tipo
+    const dv = await session.read({
+        nodeId: eventFields[1].value,
+        attributeId: AttributeIds.BrowseName
+    });
+
+    const eventTypeName = dv.value.value.name;
+
+    return {
+        eventId: eventFields[0].value,
+        eventType: eventFields[1].value,
+        eventTypeName: eventTypeName,
+        sourceNode: eventFields[2].value.toString(),
+        sourceName: eventFields[3].value,
+        message: eventFields[4].value?.text,
+        severity: eventFields[5].value,
+        active: eventFields[6].value?.text, // Active / Inactive
+        AckedState: eventFields[7].value?.text, // Active / Inactive
+        ConfirmedState: eventFields[8].value?.text, // Active / Inactive
+        time: eventFields[9].value
+    };
+}
+
+function callResultToItemResult(item, callResult, argumentDefinition) {
+    const methodId = resolveMethodNodeId(item);
+    const outputDefinitions = argumentDefinition && Array.isArray(argumentDefinition.outputArguments)
+        ? argumentDefinition.outputArguments
+        : [];
+    const outputArguments = Array.isArray(callResult.outputArguments)
+        ? callResult.outputArguments
+        : [];
+
+    return {
+        name: resolveName(item, methodId),
+        nodeID: methodId,
+        status: statusCodeToString(callResult.statusCode),
+        outputs: outputArguments.map((variant, index) => ({
+            name: outputDefinitions[index] && outputDefinitions[index].name
+                ? String(outputDefinitions[index].name)
+                : "output" + (index + 1),
+            type: variantTypeToName(variant),
+            value: variant ? variant.value : null
+        }))
+    };
+}
+
+function resolveMethodNodeId(item) {
+    const methodId = item && (item.methodID || item.methodId || item.nodeID || item.nodeId);
+    if (!methodId || !String(methodId).trim()) {
+        throw new Error("Each method item must contain methodId or nodeID");
+    }
+
+    return String(methodId).trim();
+}
+
+async function resolveMethodObjectId(session, methodNodeId, cache) {
+    const cacheKey = String(methodNodeId);
+    if (cache && cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+    }
+
+    const browseResult = await session.browse({
+        nodeId: methodNodeId,
+        browseDirection: BrowseDirection.Inverse,
+        includeSubtypes: true,
+        resultMask: 63
+    });
+
+    const references = browseResult && Array.isArray(browseResult.references)
+        ? browseResult.references
+        : [];
+
+    const objectReferences = references.filter((reference) => {
+        const nodeClassName = resolveNodeClassName(reference.nodeClass);
+        return nodeClassName === "Object" || nodeClassName === "ObjectType";
+    });
+
+    const parentReference = objectReferences.find((reference) => isComponentReference(reference.referenceTypeId))
+        || objectReferences[0]
+        || references[0];
+
+    if (!parentReference) {
+        throw new Error("Unable to resolve parent object for method " + methodNodeId);
+    }
+
+    const objectId = parentReference.nodeId.toString();
+    if (cache) {
+        cache.set(cacheKey, objectId);
+    }
+    return objectId;
+}
+
+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 isComponentReference(referenceTypeId) {
+    const value = referenceTypeId && typeof referenceTypeId.toString === "function"
+        ? referenceTypeId.toString()
+        : String(referenceTypeId || "");
+
+    return value === "i=47" || value === "i=49";
+}
+
+async function getMethodArgumentDefinition(session, methodNodeId, cache) {
+    const cacheKey = String(methodNodeId);
+    if (cache && cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+    }
+
+    const definition = await session.getArgumentDefinition(methodNodeId);
+    if (cache) {
+        cache.set(cacheKey, definition);
+    }
+    return definition;
+}
+
+module.exports = {
+    AttributeIds,
+    coerceNodeId,
+    DataType,
+    OPCUAClient,
+    TimestampsToReturn,
+    buildVariantFromItem,
+    callResultToItemResult,
+    dataValueToItemResult,
+    dataValueToItemResultEvent,
+    ensureArrayPayload,
+    getMethodArgumentDefinition,
+    inferTypeName,
+    normalizeTypeName,
+    resolveMethodObjectId,
+    resolveName,
+    resolveNodeId,
+    resolveSecurityMode,
+    resolveSecurityPolicy,
+    statusCodeToString
+};