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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitormnm/node-red-simple-opcua",
-  "version": "1.5.0",
+  "version": "1.6.3",
   "publishConfig": {
     "access": "public"
   },

package/server/lib/opcua-address-space-builder.js

@@ -22,7 +22,8 @@ class OpcUaAddressSpaceBuilder {
         this.registry = options.registry;
         this.node = options.node;
         this.serverName = options.serverName;
-        this.authorizationDisabled = !!options.allowAnonymous;
+        const hasUsers = Array.isArray(options.users) && options.users.length > 0;
+        this.authorizationDisabled = !hasUsers;
         this.nodeEntries = new Map();
         this.variableStore = new Map();
         this.variableNodeIdStore = new Map();
@@ -82,6 +83,7 @@ class OpcUaAddressSpaceBuilder {
         this.variableStore.clear();
         this.variableNodeIdStore.clear();
         this.objectTypeStore.clear();
+        if (this.enumerationStore) this.enumerationStore.clear();
         this.alarmStore.clear(); // Adicione esta linha
         this.pendingAlarms = [];
     }
@@ -134,7 +136,20 @@ class OpcUaAddressSpaceBuilder {
     }
 
     readValue(identifierType, identifier) {
-        return this.getVariableRecord(identifierType, identifier).getValue();
+        const record = this.getVariableRecord(identifierType, identifier);
+        let val = record.getValue();
+        if (record.type === "Int64" || record.type === "UInt64") {
+            const convertToNumber = (v) => {
+                const num = Number(v);
+                return Number.isFinite(num) ? num : v;
+            };
+            if (record.isArray) {
+                val = Array.isArray(val) ? val.map(convertToNumber) : convertToNumber(val);
+            } else {
+                val = convertToNumber(val);
+            }
+        }
+        return val;
     }
 
     writeValue(identifierType, identifier, value) {
@@ -149,6 +164,10 @@ class OpcUaAddressSpaceBuilder {
             this.collectObjectTypeDefinition(desiredEntries, objectTypeConfig, objectTypeConfigs);
         });
 
+        (Array.isArray(treeConfig.enumerations) ? treeConfig.enumerations : []).forEach((enumerationConfig) => {
+            this.collectEnumerationDefinition(desiredEntries, enumerationConfig);
+        });
+
         (Array.isArray(treeConfig.folders) ? treeConfig.folders : []).forEach((folderConfig) => {
             this.collectBranch(desiredEntries, "folder", folderConfig, "", "organizedBy", objectTypeConfigs);
         });
@@ -183,6 +202,11 @@ class OpcUaAddressSpaceBuilder {
         });
     }
 
+    collectEnumerationDefinition(desiredEntries, config) {
+        const path = this.buildEnumerationPath(config.name);
+        desiredEntries.set(path, this.buildEntryDefinition("enumeration", config, path, "", "typeDefinition"));
+    }
+
     collectBranch(desiredEntries, kind, config, parentPath, relationship, objectTypeConfigs, options) {
         const settings = options || {};
         const path = settings.preserveCollectionNames
@@ -635,6 +659,11 @@ class OpcUaAddressSpaceBuilder {
             return;
         }
 
+        if (definition.kind === "enumeration") {
+            this.addEnumerationTypeDefinition(definition.config);
+            return;
+        }
+
         if (definition.kind === "object") {
             this.addObject(parentNode, definition.config, definition.parentPath, definition.relationship, definition.path);
             return;
@@ -702,6 +731,10 @@ class OpcUaAddressSpaceBuilder {
             this.objectTypeStore.delete(entry.config.name);
         }
 
+        if (entry.kind === "enumeration" && this.enumerationStore) {
+            this.enumerationStore.delete(entry.config.name);
+        }
+
         try {
             entry.namespace.deleteNode(entry.node);
 
@@ -774,6 +807,28 @@ class OpcUaAddressSpaceBuilder {
         });
     }
 
+    addEnumerationTypeDefinition(config) {
+        const namespace = this.getNamespaceForConfig(config);
+        const enumTypeNode = namespace.addEnumerationType({
+            browseName: config.displayName || config.name,
+            displayName: config.displayName || config.name,
+            description: config.description || "",
+            nodeId: this.resolveNodeId(config, this.buildEnumerationPath(config.name), namespace),
+            enumeration: config.enumeration
+        });
+
+        const path = this.buildEnumerationPath(config.name);
+
+        this.registerNodeEntry("enumeration", path, "", "typeDefinition", config, enumTypeNode, namespace);
+        if (!this.enumerationStore) this.enumerationStore = new Map();
+        this.enumerationStore.set(config.name, {
+            node: enumTypeNode,
+            config: config,
+            path: path,
+            namespace: namespace
+        });
+    }
+
     addObjectTypeInstance(parentNode, instanceConfig, parentPath, relationship, pathOverride) {
         const objectTypeEntry = this.objectTypeStore.get(instanceConfig.objectsType);
         if (!objectTypeEntry || !objectTypeEntry.node) {
@@ -1032,6 +1087,14 @@ class OpcUaAddressSpaceBuilder {
         this.registerNodeEntry("folder", nextPath, parentPath, relationship, folderConfig, folderNode, namespace);
     }
 
+    resolveDataType(type) {
+        if (DATA_TYPE_MAP[type]) return DATA_TYPE_MAP[type];
+        if (this.enumerationStore && this.enumerationStore.has(type)) {
+            return this.enumerationStore.get(type).node.nodeId;
+        }
+        return type;
+    }
+
     addVariable(parentNode, variableConfig, parentPath, pathOverride) {
         const namespace = this.getNamespaceForConfig(variableConfig);
         const name = variableConfig.name;
@@ -1044,7 +1107,7 @@ class OpcUaAddressSpaceBuilder {
             type,
             access,
             isArray: this.isArrayValue(variableConfig.value),
-            currentValue: variableConfig.value
+            currentValue: this.coerceValue(variableConfig.value, type, this.isArrayValue(variableConfig.value))
         };
 
         const variableNode = namespace.addVariable({
@@ -1054,7 +1117,7 @@ class OpcUaAddressSpaceBuilder {
             description: variableConfig.description || "",
             nodeId,
             rolePermissions: this.buildRolePermissions("variable", variableConfig),
-            dataType: type,
+            dataType: this.resolveDataType(type),
             modellingRule: this.isObjectTypePath(parentPath) ? "Mandatory" : undefined,
             valueRank: state.isArray ? 1 : -1,
             accessLevel: access === "readwrite" ? "CurrentRead | CurrentWrite" : "CurrentRead",
@@ -1070,14 +1133,40 @@ class OpcUaAddressSpaceBuilder {
                         value: state.currentValue
                     });
 
+                    let val = state.currentValue;
+                    if (state.type === "Int64" || state.type === "UInt64") {
+                        const bigIntToInt64Array = (v) => {
+                            let bigintVal;
+                            try {
+                                bigintVal = BigInt(v);
+                            } catch (e) {
+                                bigintVal = 0n;
+                            }
+                            const mask = 0xFFFFFFFFFFFFFFFFn;
+                            bigintVal = bigintVal & mask;
+
+                            const high = Number(bigintVal >> 32n);
+                            const low = Number(bigintVal & 0xFFFFFFFFn);
+                            return [high, low];
+                        };
+
+                        if (state.isArray) {
+                            val = Array.isArray(val) ? val.map(bigIntToInt64Array) : [bigIntToInt64Array(val)];
+                        } else {
+                            val = bigIntToInt64Array(val);
+                        }
+                    }
+
                     const variantOptions = {
-                        dataType: DATA_TYPE_MAP[state.type],
-                        value: state.currentValue
+                        dataType: DATA_TYPE_MAP[state.type] || DataType.Int32,
+                        value: val
                     };
 
                     // ByteString nunca e array - Buffer nao deve ser VariantArrayType.Array
                     if (state.type !== "ByteString" && this.isArrayValue(state.currentValue)) {
                         variantOptions.arrayType = VariantArrayType.Array;
+                    } else if (state.type === "Int64" || state.type === "UInt64") {
+                        variantOptions.arrayType = VariantArrayType.Scalar;
                     }
 
                     return new Variant(variantOptions);
@@ -1119,6 +1208,8 @@ class OpcUaAddressSpaceBuilder {
             path: path,
             nodeId: nodeId,
             nodeIdKey: this.normalizeNodeIdKey(nodeId),
+            type: state.type,
+            isArray: state.isArray,
             getValue: () => state.currentValue,
             setRuntimeValue: (nextValue) => {
                 state.currentValue = this.coerceValue(nextValue, state.type, state.isArray);
@@ -1228,6 +1319,10 @@ class OpcUaAddressSpaceBuilder {
         return "__objectTypes." + name;
     }
 
+    buildEnumerationPath(name) {
+        return "__enumerations." + name;
+    }
+
     buildCollectionPath(parentPath, collectionName, name) {
 
         // return parentPath ? parentPath + "." + collectionName + "." + name : collectionName + "." + name;
@@ -1264,6 +1359,21 @@ class OpcUaAddressSpaceBuilder {
     }
 
     emitTagAccess(operation, details) {
+        let val = details.value;
+        if (details.dataType === "Int64" || details.dataType === "UInt64") {
+            const convertToNumber = (v) => {
+                const num = Number(v);
+                return Number.isFinite(num) ? num : v;
+            };
+            const isArray = this.isArrayValue(val);
+            if (isArray) {
+                const items = this.extractArrayItems(val);
+                val = Array.isArray(items) ? items.map(convertToNumber) : convertToNumber(val);
+            } else {
+                val = convertToNumber(val);
+            }
+        }
+
         this.registry.emitTagAccess({
             operation,
             serverId: this.node.id,
@@ -1274,7 +1384,7 @@ class OpcUaAddressSpaceBuilder {
             nodeID: details.nodeID,
             browseName: details.browseName,
             dataType: details.dataType,
-            value: details.value
+            value: val
         });
     }
 
@@ -1443,7 +1553,11 @@ class OpcUaAddressSpaceBuilder {
         }
 
         if (this.extractArrayItems(value)) {
-            throw new Error("Expected scalar value for type " + type + " but received array");
+            if ((type === "Int64" || type === "UInt64") && Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+                // Do not throw, this is a standard scalar Int64/UInt64 represented as [high, low]
+            } else {
+                throw new Error("Expected scalar value for type " + type + " but received array");
+            }
         }
 
         return this.coerceScalarValue(value, type);
@@ -1468,6 +1582,86 @@ class OpcUaAddressSpaceBuilder {
             return Math.trunc(parsed);
         }
 
+        if (type === "Int64") {
+            const minVal = -9223372036854775808n;
+            const maxVal = 9223372036854775807n;
+            if (Array.isArray(value) && value.length === 2) {
+                try {
+                    const h = BigInt(value[0]);
+                    const l = BigInt(value[1]);
+                    const signMask = 1n << 31n;
+                    const shiftHigh = 1n << 32n;
+                    let bigintVal;
+                    if ((h & signMask) === signMask) {
+                        bigintVal = (h & ~signMask) * shiftHigh + l - 0x8000000000000000n;
+                    } else {
+                        bigintVal = h * shiftHigh + l;
+                    }
+                    if (bigintVal < minVal) bigintVal = minVal;
+                    else if (bigintVal > maxVal) bigintVal = maxVal;
+                    return String(bigintVal);
+                } catch (error) {
+                    return "0";
+                }
+            }
+            try {
+                let bigintVal = BigInt(value);
+                if (bigintVal < minVal) bigintVal = minVal;
+                else if (bigintVal > maxVal) bigintVal = maxVal;
+                return String(bigintVal);
+            } catch (error) {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    try {
+                        let bigintVal = BigInt(Math.trunc(parsed));
+                        if (bigintVal < minVal) bigintVal = minVal;
+                        else if (bigintVal > maxVal) bigintVal = maxVal;
+                        return String(bigintVal);
+                    } catch (e2) {
+                        return "0";
+                    }
+                }
+                return "0";
+            }
+        }
+
+        if (type === "UInt64") {
+            const minVal = 0n;
+            const maxVal = 18446744073709551615n;
+            if (Array.isArray(value) && value.length === 2) {
+                try {
+                    const h = BigInt(value[0]);
+                    const l = BigInt(value[1]);
+                    const shiftHigh = 1n << 32n;
+                    let bigintVal = h * shiftHigh + l;
+                    if (bigintVal < minVal) bigintVal = minVal;
+                    else if (bigintVal > maxVal) bigintVal = maxVal;
+                    return String(bigintVal);
+                } catch (error) {
+                    return "0";
+                }
+            }
+            try {
+                let bigintVal = BigInt(value);
+                if (bigintVal < minVal) bigintVal = minVal;
+                else if (bigintVal > maxVal) bigintVal = maxVal;
+                return String(bigintVal);
+            } catch (error) {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    try {
+                        let bigintVal = BigInt(Math.trunc(parsed));
+                        if (bigintVal < minVal) bigintVal = minVal;
+                        else if (bigintVal > maxVal) bigintVal = maxVal;
+                        return String(bigintVal);
+                    } catch (e2) {
+                        return "0";
+                    }
+                }
+                return "0";
+            }
+        }
+
         if (type === "Float") {
             const parsed = Number(value);
             if (!Number.isFinite(parsed)) {
@@ -1574,7 +1768,7 @@ function compareEntryCreationOrder(left, right) {
 }
 
 function kindRank(kind) {
-    if (kind === "objectTypeDefinition") {
+    if (kind === "objectTypeDefinition" || kind === "enumeration") {
         return -1;
     }
     if (kind === "folder") {

package/server/lib/opcua-config.js

@@ -92,7 +92,17 @@ class OpcUaServerConfigParser {
         };
 
         (Array.isArray(groups) ? groups : []).forEach(addGroup);
-        (Array.isArray(users) ? users : []).forEach((user) => addGroup(user && user.group));
+        (Array.isArray(users) ? users : []).forEach((user) => {
+            if (user && user.group) {
+                if (typeof user.group === "string") {
+                    user.group.split(",").forEach(addGroup);
+                } else if (Array.isArray(user.group)) {
+                    user.group.forEach(addGroup);
+                } else {
+                    addGroup(user.group);
+                }
+            }
+        });
 
         return resolved;
     }
@@ -121,10 +131,17 @@ class OpcUaServerConfigParser {
             this._objectsTypesMap[typeDef.name] = typeDef;
         }
 
+        const enumerations = this.normalizeEnumerations(parsed.enumerations || parsed.enumeration || []);
+        this._enumerationsMap = {};
+        for (const enumDef of enumerations) {
+            this._enumerationsMap[enumDef.name] = enumDef;
+        }
+
         return {
             objects: this.normalizeObjects(parsed.objects || []),
             folders: this.normalizeFolders(parsed.folders || []),
             objectsTypes,
+            enumerations,
             nameSpaces: this.normalizeNamespaces(parsed.nameSpaces || parsed.namespaces || [])
         };
     }
@@ -366,6 +383,41 @@ class OpcUaServerConfigParser {
         return normalizedBranch;
     }
 
+    normalizeEnumerations(enumerations) {
+        if (!Array.isArray(enumerations)) {
+            throw new Error("'enumerations' must be an array");
+        }
+        return enumerations.map((config) => this.normalizeEnumeration(config));
+    }
+
+    normalizeEnumeration(enumerationConfig) {
+        if (!enumerationConfig || typeof enumerationConfig !== "object" || Array.isArray(enumerationConfig)) {
+            throw new Error("Each enumeration must be an object");
+        }
+
+        const name = this.requiredName(enumerationConfig, "enumeration");
+        
+        let enumerationStates = [];
+        if (Array.isArray(enumerationConfig.enumeration)) {
+            enumerationStates = enumerationConfig.enumeration.map(state => {
+                return {
+                    value: Number.isFinite(Number(state.value)) ? Number(state.value) : 0,
+                    displayName: typeof state.displayName === "string" ? state.displayName : ""
+                };
+            });
+        }
+
+        return {
+            name,
+            displayName: enumerationConfig.displayName || name,
+            description: enumerationConfig.description || "",
+            nodeId: this.normalizeOptionalNodeId(enumerationConfig.nodeId),
+            namespaceId: this.normalizeNamespaceId(enumerationConfig.namespaceId),
+            accessPermission: this.normalizeAccessPermissions(enumerationConfig.accessPermission || enumerationConfig.accessPermissions),
+            enumeration: enumerationStates
+        };
+    }
+
     // Returns the string value after "s=" in a nodeId like "ns=2;s=Motor_type2"
     _extractNodeIdValue(nodeId) {
         if (!nodeId) return "";
@@ -485,11 +537,21 @@ class OpcUaServerConfigParser {
         const username = typeof userConfig.username === "string" ? userConfig.username.trim() : "";
         const passwordHash = typeof userConfig.passwordHash === "string" ? userConfig.passwordHash : "";
         const password = typeof userConfig.password === "string" ? userConfig.password : "";
-        const group = typeof userConfig.group === "string"
-            ? userConfig.group.trim()
-            : typeof userConfig.role === "string"
-                ? userConfig.role.trim()
-                : "";
+        
+        let group = "";
+        if (userConfig.group !== undefined) {
+            if (Array.isArray(userConfig.group)) {
+                group = userConfig.group.map(g => typeof g === "string" ? g.trim() : "").filter(Boolean).join(",");
+            } else if (typeof userConfig.group === "string") {
+                group = userConfig.group.trim();
+            }
+        } else if (userConfig.role !== undefined) {
+            if (Array.isArray(userConfig.role)) {
+                group = userConfig.role.map(r => typeof r === "string" ? r.trim() : "").filter(Boolean).join(",");
+            } else if (typeof userConfig.role === "string") {
+                group = userConfig.role.trim();
+            }
+        }
 
         if (!username) {
             throw new Error("Each user requires a non-empty username");
@@ -543,6 +605,7 @@ class OpcUaServerConfigParser {
             uint16: "UInt16",
             int32: "Int32",
             uint32: "UInt32",
+            int64: "Int64",
             float: "Float",
             boolean: "Boolean",
             string: "String",
@@ -550,7 +613,7 @@ class OpcUaServerConfigParser {
             localizedText: "LocalizedText",
         };
         const canonical = aliases[normalized.toLowerCase()] || normalized;
-        if (!DATA_TYPE_MAP[canonical]) {
+        if (!DATA_TYPE_MAP[canonical] && (!this._enumerationsMap || !this._enumerationsMap[canonical])) {
             throw new Error("Unsupported variable type: " + type);
         }
 
@@ -638,7 +701,7 @@ class OpcUaServerConfigParser {
     }
 
     coerceScalarValue(value, type) {
-        if (type === "Int32") {
+        if (type === "Int32" || (this._enumerationsMap && this._enumerationsMap[type])) {
             const parsed = Number(value);
             if (!Number.isFinite(parsed)) {
                 return 0;
@@ -646,6 +709,66 @@ class OpcUaServerConfigParser {
             return Math.trunc(parsed);
         }
 
+        if (type === "Int64") {
+            const minVal = -9223372036854775808n;
+            const maxVal = 9223372036854775807n;
+            try {
+                let bigintVal = BigInt(value);
+                if (bigintVal < minVal) bigintVal = minVal;
+                else if (bigintVal > maxVal) bigintVal = maxVal;
+                return String(bigintVal);
+            } catch (error) {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    if (parsed >= 9223372036854775807) {
+                        return String(maxVal);
+                    }
+                    if (parsed <= -9223372036854775808) {
+                        return String(minVal);
+                    }
+                    try {
+                        let bigintVal = BigInt(Math.trunc(parsed));
+                        if (bigintVal < minVal) bigintVal = minVal;
+                        else if (bigintVal > maxVal) bigintVal = maxVal;
+                        return String(bigintVal);
+                    } catch (e2) {
+                        return "0";
+                    }
+                }
+                return "0";
+            }
+        }
+
+        if (type === "UInt64") {
+            const minVal = 0n;
+            const maxVal = 18446744073709551615n;
+            try {
+                let bigintVal = BigInt(value);
+                if (bigintVal < minVal) bigintVal = minVal;
+                else if (bigintVal > maxVal) bigintVal = maxVal;
+                return String(bigintVal);
+            } catch (error) {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    if (parsed >= 18446744073709551615) {
+                        return String(maxVal);
+                    }
+                    if (parsed <= 0) {
+                        return String(minVal);
+                    }
+                    try {
+                        let bigintVal = BigInt(Math.trunc(parsed));
+                        if (bigintVal < minVal) bigintVal = minVal;
+                        else if (bigintVal > maxVal) bigintVal = maxVal;
+                        return String(bigintVal);
+                    } catch (e2) {
+                        return "0";
+                    }
+                }
+                return "0";
+            }
+        }
+
         if (type === "Float") {
             const parsed = Number(value);
             if (!Number.isFinite(parsed)) {

package/server/lib/opcua-constants.js

@@ -45,6 +45,7 @@ const DATA_TYPE_MAP = {
     UInt16: DataType.UInt16,
     Int32: DataType.Int32,
     UInt32: DataType.UInt32,
+    Int64: DataType.Int64,
     Float: DataType.Float,
     Boolean: DataType.Boolean,
     String: DataType.String,

package/server/lib/opcua-server-methods.js

@@ -113,6 +113,8 @@ class OpcUaServerMethods {
                 const eventId = inputArguments[0].value;
                 const comment = inputArguments[1].value;
                 
+                
+
                 const alarm = context.object;
                 // severity atual
                 const severity = alarm.severity.readValue().value.value;