node-opcua-address-space 2.56.2 → 2.60.0

package/dist/src/ua_variable_impl.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UAVariableImplT = exports.UAVariableImpl = exports.verifyRankAndDimensions = exports.adjust_userAccessLevel = exports.adjust_accessLevel = void 0;
+exports.UAVariableImplT = exports.UAVariableImpl = exports.adjust_userAccessLevel = exports.adjust_accessLevel = void 0;
 /* eslint-disable max-statements */
 /* eslint-disable complexity */
 /**
@@ -104,13 +104,13 @@ function validateDataType(addressSpace, dataTypeNodeId, variantDataType, nodeId,
     }
     let builtInType;
     let builtInUADataType;
-    const destUADataType = addressSpace.findNode(dataTypeNodeId);
+    const destUADataType = addressSpace.findDataType(dataTypeNodeId);
     (0, node_opcua_assert_1.assert)(destUADataType instanceof ua_data_type_impl_1.UADataTypeImpl);
     if (destUADataType.isAbstract || destUADataType.nodeId.namespace !== 0) {
         builtInUADataType = destUADataType;
     }
     else {
-        builtInType = node_opcua_variant_1.DataType[addressSpace.findCorrespondingBasicDataType(destUADataType)];
+        builtInType = addressSpace.findCorrespondingBasicDataType(destUADataType);
         builtInUADataType = addressSpace.findDataType(builtInType);
     }
     (0, node_opcua_assert_1.assert)(builtInUADataType instanceof ua_data_type_impl_1.UADataTypeImpl);
@@ -121,8 +121,8 @@ function validateDataType(addressSpace, dataTypeNodeId, variantDataType, nodeId,
     if (destUADataType.isSupertypeOf(enumerationUADataType)) {
         // istanbul ignore next
         if (doDebug) {
-            console.log("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
-            console.log("enumerationUADataType.", enumerationUADataType.browseName.toString(), enumerationUADataType.nodeId.toString());
+            debugLog("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
+            debugLog("enumerationUADataType.", enumerationUADataType.browseName.toString(), enumerationUADataType.nodeId.toString());
         }
         return true;
     }
@@ -134,45 +134,18 @@ function validateDataType(addressSpace, dataTypeNodeId, variantDataType, nodeId,
     if (doDebug) {
         if (dest_isSuperTypeOf_variant) {
             /* istanbul ignore next*/
-            console.log(chalk.green(" ---------- Type match !!! "), " on ", nodeId.toString());
+            debugLog(chalk.green(" ---------- Type match !!! "), " on ", nodeId.toString());
         }
         else {
             /* istanbul ignore next*/
-            console.log(chalk.red(" ---------- Type mismatch "), " on ", nodeId.toString());
+            debugLog(chalk.red(" ---------- Type mismatch "), " on ", nodeId.toString());
         }
-        console.log(chalk.cyan(" Variable data Type is    = "), destUADataType.browseName.toString());
-        console.log(chalk.cyan(" which matches basic Type = "), builtInUADataType.browseName.toString());
-        console.log(chalk.yellow("        Actual   dataType = "), variantUADataType.browseName.toString());
+        debugLog(chalk.cyan(" Variable data Type is    = "), destUADataType.browseName.toString());
+        debugLog(chalk.cyan(" which matches basic Type = "), builtInUADataType.browseName.toString());
+        debugLog(chalk.yellow("        Actual   dataType = "), variantUADataType.browseName.toString());
     }
     return dest_isSuperTypeOf_variant;
 }
-function verifyRankAndDimensions(options) {
-    // evaluate valueRank arrayDimensions is specified but valueRank is null
-    if (options.arrayDimensions && options.valueRank === undefined) {
-        options.valueRank = options.arrayDimensions.length;
-    }
-    options.valueRank = options.valueRank === undefined ? -1 : options.valueRank || 0; // UInt32
-    (0, node_opcua_assert_1.assert)(typeof options.valueRank === "number");
-    options.arrayDimensions = options.arrayDimensions || null;
-    (0, node_opcua_assert_1.assert)(options.arrayDimensions === null || Array.isArray(options.arrayDimensions));
-    if (options.arrayDimensions && options.valueRank <= 0) {
-        throw new Error("[CONFORMANCE] arrayDimensions must be null if valueRank <=0");
-    }
-    // specify default arrayDimension if not provided
-    if (options.valueRank > 0 && !options.arrayDimensions) {
-        options.arrayDimensions = new Array(options.valueRank).fill(0);
-    }
-    if (!options.arrayDimensions && options.valueRank > 0) {
-        throw new Error("[CONFORMANCE] arrayDimension must be specified  if valueRank >0 " + options.valueRank);
-    }
-    if (options.valueRank > 0 && options.arrayDimensions.length !== options.valueRank) {
-        throw new Error("[CONFORMANCE] when valueRank> 0, arrayDimensions must have valueRank elements, this.valueRank =" +
-            options.valueRank +
-            "  whereas arrayDimensions.length =" +
-            options.arrayDimensions.length);
-    }
-}
-exports.verifyRankAndDimensions = verifyRankAndDimensions;
 /**
  * A OPCUA Variable Node
  *
@@ -203,16 +176,15 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
     constructor(options) {
         super(options);
         this.nodeClass = node_opcua_data_model_1.NodeClass.Variable;
-        verifyRankAndDimensions(options);
+        (0, node_opcua_variant_1.verifyRankAndDimensions)(options);
         this.valueRank = options.valueRank;
         this.arrayDimensions = options.arrayDimensions;
         this.dataType = this.resolveNodeId(options.dataType); // DataType (NodeId)
         this.accessLevel = adjust_accessLevel(options.accessLevel);
         this.userAccessLevel = adjust_userAccessLevel(options.userAccessLevel, this.accessLevel);
         this.minimumSamplingInterval = adjust_samplingInterval(options.minimumSamplingInterval || 0);
-        this.historizing = !!options.historizing; // coerced to boolean
-        this._dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.UncertainInitialValue, value: {} });
-        // xx options.value = options.value || { dataType: DataType.Null };
+        this.historizing = !!options.historizing; // coerced to boolean"
+        this.$dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.UncertainInitialValue, value: { dataType: node_opcua_variant_1.DataType.Null } });
         if (options.value) {
             this.bindVariable(options.value);
         }
@@ -301,10 +273,11 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         }
         if (this._timestamped_get_func) {
             if (this._timestamped_get_func.length === 0) {
-                this._dataValue = this._timestamped_get_func();
+                this.$dataValue = this._timestamped_get_func();
+                this.verifyVariantCompatibility(this.$dataValue.value);
             }
         }
-        let dataValue = this._dataValue;
+        let dataValue = this.$dataValue;
         if (isGoodish(dataValue.statusCode)) {
             // note : extractRange will clone the dataValue
             dataValue = (0, node_opcua_data_value_1.extractRange)(dataValue, indexRange);
@@ -342,6 +315,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         return dataTypeNode._getEnumerationInfo();
     }
     asyncRefresh(...args) {
+        this.verifyVariantCompatibility(this.$dataValue.value);
         const oldestDate = args[0];
         (0, node_opcua_assert_1.assert)(oldestDate instanceof Date);
         const callback = args[1];
@@ -358,21 +332,31 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                 return callback(null, dataValue);
             }
         }
-        if (this._dataValue.serverTimestamp && oldestDate.getTime() <= this._dataValue.serverTimestamp.getTime()) {
+        if (this.$dataValue.serverTimestamp && oldestDate.getTime() <= this.$dataValue.serverTimestamp.getTime()) {
             const dataValue = this.readValue();
             dataValue.serverTimestamp = oldestDate;
             dataValue.serverPicoseconds = 0;
             return callback(null, dataValue);
         }
-        this.refreshFunc.call(this, (err, dataValue) => {
-            if (err || !dataValue) {
-                dataValue = { statusCode: node_opcua_status_code_1.StatusCodes.BadNoDataAvailable };
-            }
-            if (dataValue !== this._dataValue) {
-                this._internal_set_dataValue(coerceDataValue(dataValue), null);
-            }
-            callback(err, this._dataValue);
-        });
+        try {
+            this.refreshFunc.call(this, (err, dataValue) => {
+                if (err || !dataValue) {
+                    errorLog("-------------- refresh call failed", this.browseName.toString(), this.nodeId.toString(), err === null || err === void 0 ? void 0 : err.message);
+                    dataValue = { statusCode: node_opcua_status_code_1.StatusCodes.BadNoDataAvailable };
+                }
+                if (dataValue !== this.$dataValue) {
+                    this._internal_set_dataValue(coerceDataValue(dataValue), null);
+                }
+                callback(err, this.$dataValue);
+            });
+        }
+        catch (err) {
+            errorLog("-------------- refresh call failed 2", this.browseName.toString(), this.nodeId.toString());
+            errorLog(err);
+            const dataValue = new node_opcua_data_value_1.DataValue({ statusCode: node_opcua_status_code_1.StatusCodes.BadInternalError });
+            this._internal_set_dataValue(dataValue, null);
+            callback(err, this.$dataValue);
+        }
     }
     readEnumValue() {
         const value = this.readValue().value.value;
@@ -441,10 +425,71 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                 return base_node_impl_1.BaseNodeImpl.prototype.readAttribute.call(this, context, attributeId);
         }
     }
-    adjustVariant(variant) {
+    getBasicDataType() {
+        if (this._basicDataType) {
+            return this._basicDataType;
+        }
+        if (this.dataType.namespace === 0 && this.dataType.value === 0) {
+            return node_opcua_variant_1.DataType.Null;
+        }
         const addressSpace = this.addressSpace;
-        const dataTypeNodeId = addressSpace.findCorrespondingBasicDataType(this.dataType);
-        return (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, dataTypeNodeId);
+        const dataTypeNode = addressSpace.findDataType(this.dataType);
+        const basicDataType = dataTypeNode ? dataTypeNode.getBasicDataType() : node_opcua_variant_1.DataType.Null;
+        // const basicDataType = addressSpace.findCorrespondingBasicDataType(this.dataType);
+        this._basicDataType = basicDataType;
+        return basicDataType;
+    }
+    adjustVariant(variant) {
+        return (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, this.getBasicDataType());
+    }
+    verifyVariantCompatibility(variant) {
+        var _a;
+        try {
+            // istanbul ignore next
+            if (Object.prototype.hasOwnProperty.call(variant, "value")) {
+                if (variant.dataType === null || variant.dataType === undefined) {
+                    throw new Error("Variant must provide a valid dataType" + variant.toString());
+                }
+                if (variant.dataType === node_opcua_variant_1.DataType.Boolean &&
+                    (this.dataType.namespace !== 0 || this.dataType.value !== node_opcua_variant_1.DataType.Boolean)) {
+                    throw new Error("Variant must provide a valid Boolean" + variant.toString());
+                }
+                if (this.dataType.namespace === 0 &&
+                    this.dataType.value === node_opcua_variant_1.DataType.LocalizedText &&
+                    variant.dataType !== node_opcua_variant_1.DataType.LocalizedText) {
+                    throw new Error("Variant must provide a valid LocalizedText" + variant.toString());
+                }
+            }
+            const basicType = this.getBasicDataType();
+            if (basicType !== node_opcua_variant_1.DataType.Null &&
+                basicType !== node_opcua_variant_1.DataType.Variant &&
+                variant.dataType !== node_opcua_variant_1.DataType.Null &&
+                variant.dataType !== basicType) {
+                const message = "UAVariable.setValueFromSource " +
+                    this.browseName.toString() +
+                    " nodeId:" +
+                    this.nodeId.toString() +
+                    " dataType:" +
+                    this.dataType.toString() +
+                    ":\n" +
+                    "the provided variant must have the expected dataType!\n" +
+                    "   - the expected dataType is " +
+                    chalk.cyan(node_opcua_variant_1.DataType[basicType]) +
+                    "\n" +
+                    "   - the actual dataType   is " +
+                    chalk.magenta(node_opcua_variant_1.DataType[variant.dataType]) +
+                    "\n" +
+                    "   - " +
+                    variant.toString();
+                throw new Error(message);
+            }
+        }
+        catch (err) {
+            errorLog("UAVariable  ", (_a = err) === null || _a === void 0 ? void 0 : _a.message, this.browseName.toString(), this.nodeId.toString());
+            errorLog(err.message);
+            errorLog(err.stack);
+            throw err;
+        }
     }
     /**
      * setValueFromSource is used to let the device sets the variable values
@@ -458,32 +503,24 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
      * @param [sourceTimestamp= Now]
      */
     setValueFromSource(variant, statusCode, sourceTimestamp) {
-        statusCode = statusCode || node_opcua_status_code_1.StatusCodes.Good;
-        // istanbul ignore next
-        if (Object.prototype.hasOwnProperty.call(variant, "value")) {
-            if (variant.dataType === null || variant.dataType === undefined) {
-                throw new Error("Variant must provide a valid dataType" + variant.toString());
-            }
-            if (variant.dataType === node_opcua_variant_1.DataType.Boolean &&
-                (this.dataType.namespace !== 0 || this.dataType.value !== node_opcua_variant_1.DataType.Boolean)) {
-                throw new Error("Variant must provide a valid Boolean" + variant.toString());
-            }
-            if (this.dataType.namespace === 0 &&
-                this.dataType.value === node_opcua_variant_1.DataType.LocalizedText &&
-                variant.dataType !== node_opcua_variant_1.DataType.LocalizedText) {
-                throw new Error("Variant must provide a valid LocalizedText" + variant.toString());
-            }
+        try {
+            statusCode = statusCode || node_opcua_status_code_1.StatusCodes.Good;
+            const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+            this.verifyVariantCompatibility(variant1);
+            const now = (0, node_opcua_date_time_1.coerceClock)(sourceTimestamp, 0);
+            const dataValue = new node_opcua_data_value_1.DataValue(null);
+            dataValue.serverPicoseconds = now.picoseconds;
+            dataValue.serverTimestamp = now.timestamp;
+            dataValue.sourcePicoseconds = now.picoseconds;
+            dataValue.sourceTimestamp = now.timestamp;
+            dataValue.statusCode = statusCode;
+            dataValue.value = variant1;
+            this._internal_set_dataValue(dataValue);
+        }
+        catch (err) {
+            errorLog("UAVariable#setValueFromString Error : ", this.browseName.toString(), this.nodeId.toString());
+            throw err;
         }
-        const variant1 = node_opcua_variant_1.Variant.coerce(variant);
-        const now = (0, node_opcua_date_time_1.coerceClock)(sourceTimestamp, 0);
-        const dataValue = new node_opcua_data_value_1.DataValue(null);
-        dataValue.serverPicoseconds = now.picoseconds;
-        dataValue.serverTimestamp = now.timestamp;
-        dataValue.sourcePicoseconds = now.picoseconds;
-        dataValue.sourceTimestamp = now.timestamp;
-        dataValue.statusCode = statusCode;
-        dataValue.value = variant1;
-        this._internal_set_dataValue(dataValue);
     }
     writeValue(context, dataValue, ...args) {
         context = context || session_context_1.SessionContext.defaultContext;
@@ -551,6 +588,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             if (!err) {
                 correctedDataValue = correctedDataValue || dataValue;
                 (0, node_opcua_assert_1.assert)(correctedDataValue instanceof node_opcua_data_value_1.DataValue);
+                correctedDataValue && this.verifyVariantCompatibility(correctedDataValue.value);
                 // xx assert(correctedDataValue.serverTimestamp);
                 if (indexRange && !indexRange.isEmpty()) {
                     if (!indexRange.isValid()) {
@@ -558,27 +596,27 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                     }
                     const newArrayOrMatrix = correctedDataValue.value.value;
                     if (correctedDataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Array) {
-                        if (this._dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Array) {
+                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Array) {
                             return callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
                         }
                         // check that destination data is also an array
-                        (0, node_opcua_assert_1.assert)(check_valid_array(this._dataValue.value.dataType, this._dataValue.value.value));
-                        const destArr = this._dataValue.value.value;
+                        (0, node_opcua_assert_1.assert)(check_valid_array(this.$dataValue.value.dataType, this.$dataValue.value.value));
+                        const destArr = this.$dataValue.value.value;
                         const result = indexRange.set_values(destArr, newArrayOrMatrix);
                         if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
                             return callback(null, result.statusCode);
                         }
                         correctedDataValue.value.value = result.array;
                         // scrap original array so we detect range
-                        this._dataValue.value.value = null;
+                        this.$dataValue.value.value = null;
                     }
                     else if (correctedDataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
-                        const dimensions = this._dataValue.value.dimensions;
-                        if (this._dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Matrix || !dimensions) {
+                        const dimensions = this.$dataValue.value.dimensions;
+                        if (this.$dataValue.value.arrayType !== node_opcua_variant_1.VariantArrayType.Matrix || !dimensions) {
                             // not a matrix !
                             return callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
                         }
-                        const matrix = this._dataValue.value.value;
+                        const matrix = this.$dataValue.value.value;
                         const result = indexRange.set_values_matrix({
                             matrix,
                             dimensions
@@ -586,10 +624,10 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                         if (result.statusCode.isNot(node_opcua_status_code_1.StatusCodes.Good)) {
                             return callback(null, result.statusCode);
                         }
-                        correctedDataValue.value.dimensions = this._dataValue.value.dimensions;
+                        correctedDataValue.value.dimensions = this.$dataValue.value.dimensions;
                         correctedDataValue.value.value = result.matrix;
                         // scrap original array so we detect range
-                        this._dataValue.value.value = null;
+                        this.$dataValue.value.value = null;
                     }
                     else {
                         return callback(null, node_opcua_status_code_1.StatusCodes.BadTypeMismatch);
@@ -656,6 +694,12 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         if (!this._validate_DataType(value.dataType)) {
             return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
         }
+        try {
+            this.verifyVariantCompatibility(value);
+        }
+        catch (err) {
+            return node_opcua_status_code_1.StatusCodes.BadTypeMismatch;
+        }
         return node_opcua_status_code_1.StatusCodes.Good;
     }
     /**
@@ -669,11 +713,11 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
      */
     touchValue(optionalNow) {
         const now = optionalNow || (0, node_opcua_date_time_1.getCurrentClock)();
-        this._dataValue.sourceTimestamp = now.timestamp;
-        this._dataValue.sourcePicoseconds = now.picoseconds;
-        this._dataValue.serverTimestamp = now.timestamp;
-        this._dataValue.serverPicoseconds = now.picoseconds;
-        this._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+        this.$dataValue.sourceTimestamp = now.timestamp;
+        this.$dataValue.sourcePicoseconds = now.picoseconds;
+        this.$dataValue.serverTimestamp = now.timestamp;
+        this.$dataValue.serverPicoseconds = now.picoseconds;
+        this.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
         if (this.minimumSamplingInterval === 0) {
             if (this.listenerCount("value_changed") > 0) {
                 const clonedDataValue = this.readValue();
@@ -841,7 +885,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             return;
         }
         const readImmediate = (innerCallback) => {
-            (0, node_opcua_assert_1.assert)(this._dataValue instanceof node_opcua_data_value_1.DataValue);
+            (0, node_opcua_assert_1.assert)(this.$dataValue instanceof node_opcua_data_value_1.DataValue);
             const dataValue = this.readValue();
             innerCallback(null, dataValue);
         };
@@ -899,7 +943,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         newVariable.bindVariable();
         (0, node_opcua_assert_1.assert)(typeof newVariable._timestamped_set_func === "function");
         (0, node_opcua_assert_1.assert)(newVariable.dataType === this.dataType);
-        newVariable._dataValue = this._dataValue.clone();
+        newVariable.$dataValue = this.$dataValue.clone();
         return newVariable;
     }
     getDataTypeNode() {
@@ -919,8 +963,9 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             return true;
         }
         const addressSpace = this.addressSpace;
+        // istanbul ignore next
         if (!(extObj && extObj.constructor)) {
-            console.log(extObj);
+            errorLog(extObj);
             throw new Error("expecting an valid extension object");
         }
         const dataType = addressSpace.findDataType(this.dataType);
@@ -948,7 +993,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             }
         }
         catch (err) {
-            console.log(err);
+            errorLog(err);
             return false;
         }
     }
@@ -957,7 +1002,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
      * @return {ExtensionObject}
      */
     bindExtensionObject(optionalExtensionObject) {
-        var _a, _b, _c;
+        var _a, _b;
         const addressSpace = this.addressSpace;
         const structure = addressSpace.findDataType("Structure");
         let extensionObject_;
@@ -968,7 +1013,7 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         }
         // istanbul ignore next
         if (doDebug) {
-            console.log(" ------------------------------ binding ", this.browseName.toString(), this.nodeId.toString());
+            debugLog(" ------------------------------ binding ", this.browseName.toString(), this.nodeId.toString());
         }
         (0, node_opcua_assert_1.assert)(structure && structure.browseName.toString() === "Structure", "expecting DataType Structure to be in IAddressSpace");
         const dt = this.getDataTypeNode();
@@ -990,8 +1035,8 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             // }
             // istanbul ignore next
             if (!this.checkExtensionObjectIsCorrect(this.$extensionObject)) {
-                console.log("on node : ", this.browseName.toString(), this.nodeId.toString(), "dataType=", this.dataType.toString({ addressSpace: this.addressSpace }));
-                console.log((_a = this.$extensionObject) === null || _a === void 0 ? void 0 : _a.toString());
+                warningLog("on node : ", this.browseName.toString(), this.nodeId.toString(), "dataType=", this.dataType.toString({ addressSpace: this.addressSpace }));
+                warningLog((_a = this.$extensionObject) === null || _a === void 0 ? void 0 : _a.toString());
                 throw new Error("bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
                     this.dataType.toString({ addressSpace: this.addressSpace }) +
                     " but we got a " +
@@ -1003,38 +1048,28 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         this.$extensionObject = optionalExtensionObject;
         // ------------------------------------------------------------------
         function prepareVariantValue(dataType, value) {
-            if (typeof dataType === "string") {
-                dataType = node_opcua_variant_1.DataType[dataType];
-            }
             if ((dataType === node_opcua_variant_1.DataType.Int32 || dataType === node_opcua_variant_1.DataType.UInt32) && value && value.key) {
                 value = value.value;
             }
             return value;
         }
-        const bindProperty = (propertyNode, name, extensionObject, dataTypeNodeId) => {
-            const dataTypeAsString = node_opcua_variant_1.DataType[dataTypeNodeId];
-            /*
-            property.setValueFromSource(new Variant({
-                dataType: dataType,
-                value: prepareVariantValue(dataType, this.$extensionObject[name])
-            }));
-             */
-            (0, node_opcua_assert_1.assert)(propertyNode.readValue().statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
+        const bindProperty = (propertyNode, name, extensionObject, dataType) => {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const self = this;
             propertyNode.bindVariable({
                 timestamped_get: () => {
-                    const prop = self.$extensionObject[name];
-                    if (prop === undefined) {
-                        propertyNode._dataValue.value.dataType = node_opcua_variant_1.DataType.Null;
-                        propertyNode._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-                        propertyNode._dataValue.value.value = null;
-                        return new node_opcua_data_value_1.DataValue(propertyNode._dataValue);
+                    const propertyValue = self.$extensionObject[name];
+                    if (propertyValue === undefined) {
+                        propertyNode.$dataValue.value.dataType = node_opcua_variant_1.DataType.Null;
+                        propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+                        propertyNode.$dataValue.value.value = null;
+                        return new node_opcua_data_value_1.DataValue(propertyNode.$dataValue);
                     }
-                    const value = prepareVariantValue(dataTypeNodeId, prop);
-                    propertyNode._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-                    propertyNode._dataValue.value.value = value;
-                    return new node_opcua_data_value_1.DataValue(propertyNode._dataValue);
+                    const value = prepareVariantValue(dataType, propertyValue);
+                    propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+                    propertyNode.$dataValue.value.dataType = dataType;
+                    propertyNode.$dataValue.value.value = value;
+                    return new node_opcua_data_value_1.DataValue(propertyNode.$dataValue);
                 },
                 timestamped_set: (dataValue, callback) => {
                     dataValue;
@@ -1049,8 +1084,8 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         const s = this.readValue();
         // istanbul ignore next
         if (this.dataTypeObj.isAbstract) {
-            console.log("Warning the DataType associated with this Variable is abstract ", this.dataTypeObj.browseName.toString());
-            console.log("You need to provide a extension object yourself ");
+            warningLog("Warning the DataType associated with this Variable is abstract ", this.dataTypeObj.browseName.toString());
+            warningLog("You need to provide a extension object yourself ");
             throw new Error("bindExtensionObject requires a extensionObject as associated dataType is only abstract");
         }
         if (s.value && (s.value.dataType === node_opcua_variant_1.DataType.Null || (s.value.dataType === node_opcua_variant_1.DataType.ExtensionObject && !s.value.value))) {
@@ -1067,8 +1102,8 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             const self = this;
             this.bindVariable({
                 timestamped_get() {
-                    self._dataValue.value.value = self.$extensionObject;
-                    const d = new node_opcua_data_value_1.DataValue(self._dataValue);
+                    self.$dataValue.value.value = self.$extensionObject;
+                    const d = new node_opcua_data_value_1.DataValue(self.$dataValue);
                     d.value = new node_opcua_variant_1.Variant(d.value);
                     return d;
                 },
@@ -1090,26 +1125,28 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
             (0, node_opcua_assert_1.assert)(this.checkExtensionObjectIsCorrect(this.$extensionObject));
             (0, node_opcua_assert_1.assert)(s.statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
         }
-        let property;
-        let camelCaseName;
         // ------------------------------------------------------
         // now bind each member
         // ------------------------------------------------------
-        const definition = dt._getDefinition(false);
+        const definition = dt._getDefinition();
         // istanbul ignore next
         if (!definition) {
             throw new Error("xx definition missing in " + dt.toString());
         }
-        for (const field of definition.fields || []) {
-            camelCaseName = (0, node_opcua_utils_1.lowerFirstLetter)(field.name);
-            const component = components.filter((f) => f.browseName.name.toString() === field.name);
-            if (component.length === 1) {
-                property = component[0];
+        const getOrCreateProperty = (field) => {
+            let property;
+            const selectedComponents = components.filter((f) => f instanceof UAVariableImpl && f.browseName.name.toString() === field.name);
+            if (field.dataType.value === node_opcua_variant_1.DataType.Variant) {
+                warningLog("Warning : variant is not supported in ExtensionObject");
+            }
+            if (selectedComponents.length === 1) {
+                property = selectedComponents[0];
                 /* istanbul ignore next */
             }
             else {
+                debugLog("adding missing array variable", field.name, this.browseName.toString(), this.nodeId.toString());
                 // todo: Handle array appropriately...
-                (0, node_opcua_assert_1.assert)(component.length === 0);
+                (0, node_opcua_assert_1.assert)(selectedComponents.length === 0);
                 // create a variable (Note we may use ns=1;s=parentName/0:PropertyName)
                 property = this.namespace.addVariable({
                     browseName: { namespaceIndex: structureNamespace, name: field.name.toString() },
@@ -1119,62 +1156,64 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
                 });
                 (0, node_opcua_assert_1.assert)(property.minimumSamplingInterval === this.minimumSamplingInterval);
             }
-            property._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
-            property.touchValue();
+            return property;
+        };
+        for (const field of definition.fields || []) {
             if (node_opcua_nodeid_1.NodeId.sameNodeId(node_opcua_nodeid_1.NodeId.nullNodeId, field.dataType)) {
-                debugLog("field.dataType is null ! " + field.name + " " + ((_c = field.description) === null || _c === void 0 ? void 0 : _c.text));
-                debugLog(" dataType replaced with BaseDataType ");
+                warningLog("field.dataType is null ! ", field.toString(), node_opcua_nodeid_1.NodeId.nullNodeId.toString());
+                warningLog(" dataType replaced with BaseDataType ");
+                warningLog(definition.toString());
                 field.dataType = this.resolveNodeId("BaseDataType");
             }
-            const dataTypeNodeId = addressSpace.findCorrespondingBasicDataType(field.dataType);
+            const camelCaseName = (0, node_opcua_utils_1.lowerFirstLetter)(field.name);
             (0, node_opcua_assert_1.assert)(Object.prototype.hasOwnProperty.call(this.$extensionObject, camelCaseName));
+            const propertyNode = getOrCreateProperty(field);
+            propertyNode.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.Good;
+            propertyNode.touchValue();
+            const basicDataType = addressSpace.findCorrespondingBasicDataType(field.dataType);
             // istanbul ignore next
             if (doDebug) {
                 const x = addressSpace.findNode(field.dataType).browseName.toString();
-                const basicType = addressSpace.findCorrespondingBasicDataType(field.dataType);
-                debugLog(chalk.cyan("xxx"), " dataType", w(field.dataType.toString(), 8), w(field.name, 35), "valueRank", chalk.cyan(w((0, base_node_private_1.valueRankToString)(field.valueRank), 10)), chalk.green(w(x, 25)), "basicType = ", chalk.yellow(w(basicType.toString(), 20)), property.nodeId.toString(), property.readValue().statusCode.toString());
+                debugLog(chalk.cyan("xxx"), " dataType", w(field.dataType.toString(), 8), w(field.name, 35), "valueRank", chalk.cyan(w((0, base_node_private_1.valueRankToString)(field.valueRank), 10)), chalk.green(w(x, 25)), "basicType = ", chalk.yellow(w(basicDataType.toString(), 20)), propertyNode.nodeId.toString(), propertyNode.readValue().statusCode.toString());
             }
-            if (this.$extensionObject[camelCaseName] !== undefined && dataTypeNodeId === node_opcua_variant_1.DataType.ExtensionObject) {
+            if (this.$extensionObject[camelCaseName] !== undefined && basicDataType === node_opcua_variant_1.DataType.ExtensionObject) {
                 (0, node_opcua_assert_1.assert)(this.$extensionObject[camelCaseName] instanceof Object);
-                this.$extensionObject[camelCaseName] = new Proxy(this.$extensionObject[camelCaseName], makeHandler(property));
-                property._dataValue.value = new node_opcua_variant_1.Variant({
+                this.$extensionObject[camelCaseName] = new Proxy(this.$extensionObject[camelCaseName], makeHandler(propertyNode));
+                propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
                     dataType: node_opcua_variant_1.DataType.ExtensionObject,
                     value: this.$extensionObject[camelCaseName]
-                });
-                property.bindExtensionObject();
-                property.$extensionObject = this.$extensionObject[camelCaseName];
+                }));
+                propertyNode.bindExtensionObject();
+                propertyNode.$extensionObject = this.$extensionObject[camelCaseName];
             }
             else {
-                const dataTypeAsString = node_opcua_variant_1.DataType[dataTypeNodeId];
-                (0, node_opcua_assert_1.assert)(typeof dataTypeAsString === "string");
                 const prop = this.$extensionObject[camelCaseName];
                 if (prop === undefined) {
-                    property._dataValue.value = new node_opcua_variant_1.Variant({
+                    propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
                         dataType: node_opcua_variant_1.DataType.Null
-                    });
+                    }));
                 }
                 else {
-                    const preparedValue = prepareVariantValue(dataTypeNodeId, prop);
-                    property._dataValue.value = new node_opcua_variant_1.Variant({
-                        dataType: dataTypeAsString,
+                    const preparedValue = prepareVariantValue(basicDataType, prop);
+                    propertyNode._internal_set_value(new node_opcua_variant_1.Variant({
+                        dataType: basicDataType,
                         value: preparedValue
-                    });
+                    }));
                 }
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const self = this;
-                property.camelCaseName = camelCaseName;
-                property.setValueFromSource = function (variant) {
+                //  property.camelCaseName = camelCaseName;
+                propertyNode.setValueFromSource = function (variant) {
                     // eslint-disable-next-line @typescript-eslint/no-this-alias
                     const inner_this = this;
-                    variant = node_opcua_variant_1.Variant.coerce(variant);
-                    // xx console.log("PropertySetValueFromSource this", inner_this.nodeId.toString(), inner_this.browseName.toString(), variant.toString(), inner_this.dataType.toString());
-                    // xx assert(variant.dataType === this.dataType);
-                    self.$extensionObject[inner_this.camelCaseName] = variant.value;
+                    const variant1 = node_opcua_variant_1.Variant.coerce(variant);
+                    inner_this.verifyVariantCompatibility(variant1);
+                    self.$extensionObject[camelCaseName] = variant1.value;
                     self.touchValue();
                 };
             }
-            (0, node_opcua_assert_1.assert)(property.readValue().statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
-            bindProperty(property, camelCaseName, this.$extensionObject, dataTypeNodeId);
+            (0, node_opcua_assert_1.assert)(propertyNode.readValue().statusCode.equals(node_opcua_status_code_1.StatusCodes.Good));
+            bindProperty(propertyNode, camelCaseName, this.$extensionObject, basicDataType);
         }
         (0, node_opcua_assert_1.assert)(this.$extensionObject instanceof Object);
         return this.$extensionObject;
@@ -1211,7 +1250,6 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         name = path[path.length - 1];
         c1[name] = c2[name];
         c1[name] += 1;
-        // xx console.log(partialData);
         setExtensionObjectValue(this, partialData);
     }
     constructExtensionObjectFromComponents() {
@@ -1261,10 +1299,16 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
     _validate_DataType(variantDataType) {
         return validateDataType(this.addressSpace, this.dataType, variantDataType, this.nodeId, /* allow Nulls */ false);
     }
+    _internal_set_value(value) {
+        if (value.dataType !== node_opcua_variant_1.DataType.Null) {
+            this.verifyVariantCompatibility(value);
+        }
+        this.$dataValue.value = value;
+    }
     _internal_set_dataValue(dataValue, indexRange) {
         (0, node_opcua_assert_1.assert)(dataValue, "expecting a dataValue");
         (0, node_opcua_assert_1.assert)(dataValue instanceof node_opcua_data_value_1.DataValue, "expecting dataValue to be a DataValue");
-        (0, node_opcua_assert_1.assert)(dataValue !== this._dataValue, "expecting dataValue to be different from previous DataValue instance");
+        (0, node_opcua_assert_1.assert)(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
         if (dataValue.value.arrayType === node_opcua_variant_1.VariantArrayType.Matrix) {
             if (!dataValue.value.dimensions) {
                 throw new Error("missing dimensions: a Matrix Variant needs a dimension");
@@ -1283,23 +1327,26 @@ class UAVariableImpl extends base_node_impl_1.BaseNodeImpl {
         // istanbul ignore next
         if (this.dataType.namespace === 0) {
             if (this.dataType.value === node_opcua_variant_1.DataType.LocalizedText && dataValue.value.dataType !== node_opcua_variant_1.DataType.LocalizedText) {
-                throw new Error("Invalid dataValue provided (expecting a LocalizedText) but got " + dataValue.toString());
+                const message = "Invalid dataValue provided (expecting a LocalizedText) but got " + dataValue.toString();
+                errorLog(message);
+                throw new Error(message);
             }
         }
-        const old_dataValue = this._dataValue;
-        this._dataValue = dataValue;
-        this._dataValue.statusCode = this._dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
+        this.verifyVariantCompatibility(dataValue.value);
+        const old_dataValue = this.$dataValue;
+        this.$dataValue = dataValue;
+        this.$dataValue.statusCode = this.$dataValue.statusCode || node_opcua_status_code_1.StatusCodes.Good;
         // repair missing timestamps
         if (!dataValue.serverTimestamp) {
-            this._dataValue.serverTimestamp = old_dataValue.serverTimestamp;
-            this._dataValue.serverPicoseconds = old_dataValue.serverPicoseconds;
+            this.$dataValue.serverTimestamp = old_dataValue.serverTimestamp;
+            this.$dataValue.serverPicoseconds = old_dataValue.serverPicoseconds;
         }
         if (!dataValue.sourceTimestamp) {
-            this._dataValue.sourceTimestamp = old_dataValue.sourceTimestamp;
-            this._dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds;
+            this.$dataValue.sourceTimestamp = old_dataValue.sourceTimestamp;
+            this.$dataValue.sourcePicoseconds = old_dataValue.sourcePicoseconds;
         }
         if (!(0, node_opcua_data_value_1.sameDataValue)(old_dataValue, dataValue)) {
-            this.emit("value_changed", this._dataValue, indexRange);
+            this.emit("value_changed", this.$dataValue, indexRange);
         }
     }
     _conditionRefresh(_cache) {
@@ -1467,7 +1514,7 @@ function _calculateEffectiveUserAccessLevelFromPermission(node, context, userAcc
 function adjustVariant2(variant) {
     // convert Variant( Scalar|ByteString) =>  Variant(Array|ByteArray)
     const addressSpace = this.addressSpace;
-    const basicType = addressSpace.findCorrespondingBasicDataType(this.dataType);
+    const basicType = this.getBasicDataType();
     variant = (0, node_opcua_variant_1.adjustVariant)(variant, this.valueRank, basicType);
     return variant;
 }
@@ -1511,7 +1558,7 @@ function _Variable_bind_with_async_refresh(options) {
     (0, node_opcua_assert_1.assert)(!this.refreshFunc);
     this.refreshFunc = options.refreshFunc;
     // assert(this.readValue().statusCode === StatusCodes.BadNodeIdUnknown);
-    this._dataValue.statusCode = node_opcua_status_code_1.StatusCodes.UncertainInitialValue;
+    this.$dataValue.statusCode = node_opcua_status_code_1.StatusCodes.UncertainInitialValue;
     // TO DO : REVISIT THIS ASSUMPTION
     if (false && this.minimumSamplingInterval === 0) {
         // when a getter /timestamped_getter or async_getter is provided
@@ -1530,7 +1577,10 @@ function _Variable_bind_with_timestamped_get(options) {
     const async_refresh_func = (callback) => {
         Promise.resolve(this._timestamped_get_func.call(this))
             .then((dataValue) => callback(null, dataValue))
-            .catch((err) => callback(err));
+            .catch((err) => {
+            errorLog("asyncRefresh error: Variable is  ", this.nodeId.toString(), this.browseName.toString());
+            callback(err);
+        });
     };
     if (options.timestamped_get.length === 0) {
         const timestamped_get = options.timestamped_get;
@@ -1575,13 +1625,10 @@ function _Variable_bind_with_simple_get(options) {
             return new node_opcua_data_value_1.DataValue({ statusCode: value });
         }
         else {
-            if (!this._dataValue || !isGoodish(this._dataValue.statusCode) || !(0, node_opcua_variant_1.sameVariant)(this._dataValue.value, value)) {
+            if (!this.$dataValue || !isGoodish(this.$dataValue.statusCode) || !(0, node_opcua_variant_1.sameVariant)(this.$dataValue.value, value)) {
                 this.setValueFromSource(value, node_opcua_status_code_1.StatusCodes.Good);
             }
-            else {
-                // XX console.log("YYYYYYYYYYYYYYYYYYYYYYYYYY",this.browseName.toString());
-            }
-            return this._dataValue;
+            return this.$dataValue;
         }
     };
     _Variable_bind_with_timestamped_get.call(this, {
@@ -1599,9 +1646,10 @@ function _Variable_bind_with_simple_set(options) {
     this._timestamped_set_func = (timestamped_value, indexRange, callback) => {
         (0, node_opcua_assert_1.assert)(timestamped_value instanceof node_opcua_data_value_1.DataValue);
         this._set_func(timestamped_value.value, (err, statusCode) => {
+            // istanbul ignore next
             if (!err && !statusCode) {
-                console.log(chalk.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
-                console.log(chalk.yellow("StatusCode.Good is assumed"));
+                errorLog(chalk.red("UAVariable Binding Error _set_func must return a StatusCode, check the bindVariable parameters"));
+                errorLog(chalk.yellow("StatusCode.Good is assumed"));
                 return callback(err, node_opcua_status_code_1.StatusCodes.Good, timestamped_value);
             }
             callback(err, statusCode, timestamped_value);