node-opcua-address-space 2.69.1 → 2.70.2

package/source/loader/make_xml_extension_object_parser.ts

@@ -1,5 +1,7 @@
+import { Byte, Int16, Int32, Int64, SByte, UAString, UInt16, UInt32 } from "node-opcua-basic-types";
+import { LocalizedTextLike, LocalizedTextOptions } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
-import { coerceNodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
+import { coerceNodeId, NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
 import { EnumDefinition, StructureDefinition } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
 import { DataType } from "node-opcua-variant";
@@ -8,57 +10,110 @@ import { ReaderState, ReaderStateParserLike, ParserLike, XmlAttributes } from "n
 const warningLog = make_warningLog(__filename);
 const debugLog = make_debugLog(__filename);
 
+export interface QualifiedNameOptions {
+    namespaceIndex?: UInt16;
+    name?: UAString;
+}
+interface QualifiedNameParserChild {
+    parent: {
+        qualifiedName: QualifiedNameOptions;
+    };
+    text: string;
+}
+interface QualifiedNameParser {
+    value: QualifiedNameOptions;
+    qualifiedName: QualifiedNameOptions;
+    text: string;
+}
+
+const qualifiedNameReader: ReaderStateParserLike = {
+    init(this: QualifiedNameParser) {
+        this.qualifiedName = {};
+        this.value = {};
+    },
+    parser: {
+        Name: {
+            finish(this: QualifiedNameParserChild) {
+                this.parent.qualifiedName.name = this.text.trim();
+            }
+        },
+        NamespaceIndex: {
+            finish(this: QualifiedNameParserChild) {
+                const ns = parseInt(this.text, 10);
+                this.parent.qualifiedName.namespaceIndex = ns;
+            }
+        }
+    },
+    finish(this: QualifiedNameParser) {
+        this.value = this.qualifiedName;
+        this.value.name = "qdqsdqs";
+    }
+};
+
+interface LocalizedTextParser {
+    localizedText: LocalizedTextOptions;
+    value: LocalizedTextOptions;
+}
+interface LocalizedTextChildParser {
+    parent: LocalizedTextParser;
+    text: string;
+}
 const localizedTextReader: ReaderStateParserLike = {
-    init(this: any) {
+    init(this: LocalizedTextParser) {
         this.localizedText = {};
     },
     parser: {
         Locale: {
-            finish(this: any) {
+            finish(this: LocalizedTextChildParser) {
                 this.parent.localizedText = this.parent.localizedText || {};
                 this.parent.localizedText.locale = this.text.trim();
             }
         },
         Text: {
-            finish(this: any) {
+            finish(this: LocalizedTextChildParser) {
                 this.parent.localizedText = this.parent.localizedText || {};
                 this.parent.localizedText.text = this.text.trim();
             }
         }
     },
-    finish(this: any) {
+    finish(this: LocalizedTextParser) {
         this.value = this.localizedText;
     }
 };
 
 function clamp(value: number, minValue: number, maxValue: number) {
-    if(value < minValue) {
+    if (value < minValue) {
         warningLog(`invalid value range : ${value} < ${minValue} but should be [${minValue} , ${maxValue}]`);
         return minValue;
     }
-    if(value > maxValue) {
+    if (value > maxValue) {
         warningLog(`invalid value range : ${value} > ${maxValue} but should be [${minValue} , ${maxValue}]`);
         return maxValue;
     }
     return value;
 }
 
+interface Parser<T> {
+    value: T | null;
+    text: string;
+}
 const partials: { [key: string]: ReaderStateParserLike } = {
     LocalizedText: localizedTextReader,
+    QualifiedName: qualifiedNameReader,
     String: {
-        finish(this: any) {
+        finish(this: Parser<string>) {
             this.value = this.text;
         }
     },
 
     Boolean: {
-        finish(this: any) {
+        finish(this: Parser<boolean>) {
             this.value = this.text.toLowerCase() === "true" ? true : false;
         }
     },
 
     ByteString: {
-        init(this: any) {
+        init(this: Parser<Buffer>) {
             this.value = null;
         },
         finish(this: any) {
@@ -69,74 +124,74 @@ const partials: { [key: string]: ReaderStateParserLike } = {
     },
 
     Float: {
-        finish(this: any) {
+        finish(this: Parser<number>) {
             this.value = parseFloat(this.text);
         }
     },
 
     Double: {
-        finish(this: any) {
+        finish(this: Parser<number>) {
             this.value = parseFloat(this.text);
         }
     },
     Byte: {
-        finish(this: any) {
+        finish(this: Parser<Byte>) {
             this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
     SByte: {
-        finish(this: any) {
+        finish(this: Parser<SByte>) {
             this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
     Int8: {
-        finish(this: any) {
+        finish(this: Parser<SByte>) {
             this.value = clamp(parseInt(this.text, 10), -128, 127);
         }
     },
 
     Int16: {
-        finish(this: any) {
+        finish(this: Parser<Int16>) {
             this.value = clamp(parseInt(this.text, 10), -32768, 32767);
         }
     },
     Int32: {
-        finish(this: any) {
+        finish(this: Parser<Int32>) {
             this.value = clamp(parseInt(this.text, 10), -2147483648, 2147483647);
         }
     },
     Int64: {
-        finish(this: any) {
+        finish(this: Parser<Int32>) {
             this.value = parseInt(this.text, 10);
         }
     },
 
     UInt8: {
-        finish(this: any) {
+        finish(this: Parser<Byte>) {
             this.value = clamp(parseInt(this.text, 10), 0, 255);
         }
     },
 
     UInt16: {
-        finish(this: any) {
+        finish(this: Parser<UInt16>) {
             this.value = clamp(parseInt(this.text, 10), 0, 65535);
         }
     },
 
     UInt32: {
-        finish(this: any) {
+        finish(this: Parser<UInt32>) {
             this.value = clamp(parseInt(this.text, 10), 0, 4294967295);
         }
     },
 
     UInt64: {
-        finish(this: any) {
+        finish(this: Parser<UInt32>) {
             this.value = parseInt(this.text, 10);
         }
     },
 
     DateTime: {
-        finish(this: any) {
+        finish(this: Parser<Date>) {
             // to do check Local or GMT
             this.value = new Date(this.text);
         }
@@ -150,21 +205,13 @@ const partials: { [key: string]: ReaderStateParserLike } = {
     },
 
     NodeId: {
-        finish(this: any) {
+        finish(this: Parser<NodeId>) {
             // to do check Local or GMT
             this.value = coerceNodeId(this.text);
         }
     }
 };
 
-interface Field {
-    dataType: any;
-    description?: string;
-    name: string;
-    value?: any;
-    valueRank?: number; // default is -1 => scalar
-}
-
 export interface TypeInfo1 {
     name: string;
     definition: StructureDefinition;
@@ -247,7 +294,7 @@ function _makeTypeReader(
             }
 
             if (field.valueRank === undefined || field.valueRank === -1) {
-                // scalar 
+                // scalar
                 const parser = fieldParser;
                 if (!parser) {
                     throw new Error("??? " + field.dataType + "  " + field.name);

package/src/data_access/add_dataItem_stuff.ts

@@ -45,7 +45,7 @@ export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_s
     const addressSpace = variable.addressSpace;
     const namespace = addressSpace.getNamespace(variable.nodeId.namespace);
 
-    if (Object.prototype.hasOwnProperty.call(options, "definition")) {
+    if (Object.prototype.hasOwnProperty.call(options, "definition") && options.definition !== undefined) {
         namespace.addVariable({
             browseName: { name: "Definition", namespaceIndex: 0 },
             dataType: "String",
@@ -58,7 +58,7 @@ export function add_dataItem_stuff(variable: UAVariable, options: add_dataItem_s
         });
     }
 
-    if (Object.prototype.hasOwnProperty.call(options, "valuePrecision")) {
+    if (Object.prototype.hasOwnProperty.call(options, "valuePrecision") && options.valuePrecision !== undefined) {
         assert(typeof options.valuePrecision === "number");
 
         namespace.addVariable({

package/src/data_access/ua_multistate_value_discrete.ts

@@ -264,6 +264,7 @@ export function _addMultiStateValueDiscrete<T, DT extends DataType>(
         accessLevel: "CurrentRead",
         browseName: { name: "EnumValues", namespaceIndex: 0 },
         dataType: "EnumValueType",
+        valueRank: 1,
         minimumSamplingInterval: 0,
         modellingRule: options.modellingRule ? "Mandatory" : undefined,
         propertyOf: variable,

package/src/namespace_impl.ts

@@ -847,21 +847,7 @@ export class NamespaceImpl implements NamespacePrivate {
      *
      *   });
      *
-     * @param options
-     * @param options.browseName {String}
-     * @param options.definition {String}
-     * @param [options.valuePrecision {Double |null} =null]
-     * @param options.instrumentRange
-     * @param options.instrumentRange.low {Double}
-     * @param options.instrumentRange.high {Double}
-     * @param options.engineeringUnitsRange.low {Double}
-     * @param options.engineeringUnitsRange.high {Double}
-     * @param options.engineeringUnits {String}
-     * @param options.dataType {NodeId} // todo :check
-     * @param [options.accessLevel {AccessLevelFlag} = "CurrentRead | CurrentWrite"]
-     * @param [options.userAccessLevel {AccessLevelFlag} = "CurrentRead | CurrentWrite"]
-     * @param options.value
-     * @param [options.modellingRule]
+  
      * @return {UAVariable}
      */
     public addAnalogDataItem<T, DT extends DataType>(options: AddAnalogDataItemOptions): UAAnalogItem<T, DT> {
@@ -881,20 +867,6 @@ export class NamespaceImpl implements NamespacePrivate {
 
         const variable = this.addVariable(clone_options) as UAVariableImpl;
 
-        // var variable = namespace.addVariable({
-        //    componentOf:     options.componentOf,
-        //    organizedBy:     options.organizedBy,
-        //    browseName:      options.browseName,
-        //    nodeId:          options.nodeId,
-        //    value:           options.value,
-        //    accessLevel:     options.accessLevel,
-        //    userAccessLevel: options.userAccessLevel,
-        //    modellingRule:   options.modellingRule
-        //
-        //    typeDefinition: analogItemType.nodeId,
-        //    dataType:       dataType,
-        // });
-
         add_dataItem_stuff(variable, options);
 
         // mandatory (EURange in the specs)

package/src/ua_variable_impl.ts

@@ -769,8 +769,14 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             dataValue.value = variant1;
 
             if (dataValue.value.dataType === DataType.ExtensionObject) {
+                const valueIsCorrect = this.checkExtensionObjectIsCorrect(dataValue.value.value);
+                if (!valueIsCorrect) {
+                    errorLog("Invalid value !");
+                    errorLog(this.toString());
+                    errorLog(dataValue.toString());
+                    this.checkExtensionObjectIsCorrect(dataValue.value.value);
+                }
                 this.$dataValue = dataValue;
-                assert(this.checkExtensionObjectIsCorrect(dataValue.value.value));
                 // ----------------------------------
                 if (this.$extensionObject) {
                     // we have an extension object already bound to this node
@@ -1271,7 +1277,18 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         // also bind extension object
         const v = newVariable.$dataValue.value;
         if (v.dataType === DataType.ExtensionObject && v.value && v.arrayType === VariantArrayType.Scalar) {
-            newVariable.bindExtensionObject(newVariable.$dataValue.value.value);
+            try {
+                newVariable.bindExtensionObject(newVariable.$dataValue.value.value);
+            } catch (err) {
+                errorLog("Errro binding extension objects");
+                errorLog((err as Error).message);
+                errorLog(this.toString());
+                errorLog("---------------------------------------");
+                errorLog(this.$dataValue.toString());
+                errorLog("---------------------------------------");
+                errorLog(newVariable.$dataValue.toString());
+                throw err;
+            }
         }
         return newVariable;
     }
@@ -1295,22 +1312,68 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             return true;
         }
         const addressSpace = this.addressSpace;
-
-        // istanbul ignore next
-        if (!(extObj && extObj.constructor)) {
-            errorLog(extObj);
-            throw new Error("expecting an valid extension object");
-        }
         const dataType = addressSpace.findDataType(this.dataType);
         if (!dataType) {
             // may be we are in the process of loading a xml file and the corresponding dataType
             // has not yet been loaded !
             return true;
         }
-        try {
-            const Constructor = addressSpace.getExtensionObjectConstructor(this.dataType);
+
+        const Constructor = addressSpace.getExtensionObjectConstructor(this.dataType);
+
+        if (this.valueRank === -1) {
+            /** Scalar */
             if (extObj instanceof Array) {
-                for (const e of extObj) {
+                return false;
+            }
+            return checkExtensionObjectIsCorrectScalar.call(this, extObj);
+        } else if (this.valueRank === 1) {
+            /** array */
+            if (!(extObj instanceof Array)) {
+                // let's coerce this scalar into an 1-element array if it is a valid extension object
+                if (checkExtensionObjectIsCorrectScalar.call(this, extObj)) {
+                    warningLog(
+                        `checkExtensionObjectIsCorrect : expecting a array but got a scalar (value rank of ${this.browseName.toString()} is 1)`
+                    );
+                    extObj = [extObj];
+                } else {
+                    return false;
+                }
+            }
+            return checkExtensionObjectIsCorrectArray.call(this, extObj);
+        } else if (this.valueRank === 0) {
+            // Scalar or Array
+            const isCorrectScalar = !Array.isArray(extObj) && checkExtensionObjectIsCorrectScalar.call(this, extObj);
+            const isCorrectArray =
+                Array.isArray(extObj) && checkExtensionObjectIsCorrectArray.call(this, extObj as ExtensionObject[]);
+            return isCorrectArray || isCorrectScalar;
+        } else {
+            throw new Error(
+                `checkExtensionObjectIsCorrect: Not Implemented case, please contact sterfive : this.valueRank =${this.valueRank}`
+            );
+        }
+        function checkExtensionObjectIsCorrectScalar(
+            this: UAVariableImpl,
+            extObj: ExtensionObject | ExtensionObject[] | null
+        ): boolean {
+            // istanbul ignore next
+            if (!(extObj && extObj.constructor)) {
+                errorLog(extObj);
+                throw new Error("expecting an valid extension object");
+            }
+            return extObj.constructor.name === Constructor.name;
+        }
+
+        function checkExtensionObjectIsCorrectArray(this: UAVariableImpl, extObjArray: ExtensionObject[]): boolean {
+            // istanbul ignore next
+            for (const extObj of extObjArray) {
+                if (!(extObj && extObj.constructor)) {
+                    errorLog(extObj);
+                    throw new Error("expecting an valid extension object");
+                }
+            }
+            try {
+                for (const e of extObjArray) {
                     if (!e) {
                         continue;
                     }
@@ -1320,12 +1383,10 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                     }
                 }
                 return true;
-            } else {
-                return extObj.constructor.name === Constructor.name;
+            } catch (err) {
+                errorLog(err);
+                return false;
             }
-        } catch (err) {
-            errorLog(err);
-            return false;
         }
     }
 
@@ -1350,10 +1411,24 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
      * @method bindExtensionObject
      * @return {ExtensionObject}
      */
-    public bindExtensionObject(
-        optionalExtensionObject?: ExtensionObject,
+    public bindExtensionObjectScalar(
+        optionalExtensionObject: ExtensionObject,
         options?: BindExtensionObjectOptions
     ): ExtensionObject | null {
+        return this.bindExtensionObject(optionalExtensionObject, options) as ExtensionObject | null;
+    }
+
+    public bindExtensionObjectArray(
+        optionalExtensionObject: ExtensionObject[],
+        options?: BindExtensionObjectOptions
+    ): ExtensionObject[] | null {
+        return this.bindExtensionObject(optionalExtensionObject, options) as ExtensionObject[] | null;
+    }
+
+    public bindExtensionObject(
+        optionalExtensionObject?: ExtensionObject | ExtensionObject[],
+        options?: BindExtensionObjectOptions
+    ): ExtensionObject | ExtensionObject[] | null {
         return _bindExtensionObject(this, optionalExtensionObject, options);
     }
 

package/src/ua_variable_impl_ext_obj.ts

@@ -10,7 +10,7 @@ import { NodeId } from "node-opcua-nodeid";
 import { StatusCodes, CallbackT, StatusCode } from "node-opcua-status-code";
 import { StructureField } from "node-opcua-types";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { DataType, Variant, VariantLike } from "node-opcua-variant";
+import { DataType, Variant, VariantLike, VariantArrayType } from "node-opcua-variant";
 
 import { valueRankToString } from "./base_node_private";
 import { UAVariableImpl } from "./ua_variable_impl";
@@ -77,7 +77,6 @@ function makeHandler(variable: UAVariable) {
  *
  */
 export function _touchValue(property: UAVariableImpl, now: PreciseClock): void {
-
     property.$dataValue.sourceTimestamp = now.timestamp;
     property.$dataValue.sourcePicoseconds = now.picoseconds;
     property.$dataValue.serverTimestamp = now.timestamp;
@@ -115,13 +114,24 @@ function propagateTouchValueDownward(self: UAVariableImpl, now: PreciseClock): v
     }
 }
 
-export function _setExtensionObject(self: UAVariableImpl, ext: ExtensionObject): void {
+export function _setExtensionObject(self: UAVariableImpl, ext: ExtensionObject | ExtensionObject[]): void {
     // assert(!(ext as any).$isProxy, "internal error ! ExtensionObject has already been proxied !");
-    ext = unProxy(ext);
-    self.$extensionObject = new Proxy(ext, makeHandler(self));
-    self.$dataValue.value.dataType = DataType.ExtensionObject;
-    self.$dataValue.value.value = self.$extensionObject;
-    self.$dataValue.statusCode = StatusCodes.Good;
+    if (Array.isArray(ext)) {
+        assert(self.valueRank === 1, "Only Array is supported for the time being");
+        ext = ext.map((e) => unProxy(e));
+        self.$dataValue.value.arrayType = VariantArrayType.Array;
+        self.$extensionObject = ext.map((e) => new Proxy(e, makeHandler(self)));
+        self.$dataValue.value.dataType = DataType.ExtensionObject;
+        self.$dataValue.value.value = self.$extensionObject;
+        self.$dataValue.statusCode = StatusCodes.Good;
+        return;
+    } else {
+        ext = unProxy(ext);
+        self.$extensionObject = new Proxy(ext, makeHandler(self));
+        self.$dataValue.value.dataType = DataType.ExtensionObject;
+        self.$dataValue.value.value = self.$extensionObject;
+        self.$dataValue.statusCode = StatusCodes.Good;
+    }
 
     const now = getCurrentClock();
     propagateTouchValueUpward(self, now);
@@ -312,13 +322,15 @@ export function _installExtensionObjectBindingOnProperties(
     }
 }
 
+// eslint-disable-next-line complexity
 export function _bindExtensionObject(
     self: UAVariableImpl,
-    optionalExtensionObject?: ExtensionObject,
+    optionalExtensionObject?: ExtensionObject | ExtensionObject[],
     options?: BindExtensionObjectOptions
-) {
+): ExtensionObject | ExtensionObject[] | null {
     options = options || { createMissingProp: false };
 
+
     const addressSpace = self.addressSpace;
     const structure = addressSpace.findDataType("Structure");
     let extensionObject_;
@@ -335,6 +347,11 @@ export function _bindExtensionObject(
     if (!dt.isSupertypeOf(structure)) {
         return null;
     }
+
+    if (self.valueRank !== -1 && self.valueRank !==1) {
+        throw new Error("Cannot bind an extension object here, valueRank must be scalar (-1) or one-dimensional (1)");
+    }
+    
     // istanbul ignore next
     if (doDebug) {
         debugLog(" ------------------------------ binding ", self.browseName.toString(), self.nodeId.toString());
@@ -406,28 +423,60 @@ export function _bindExtensionObject(
 
     function innerBindExtensionObject() {
         if (s.value && (s.value.dataType === DataType.Null || (s.value.dataType === DataType.ExtensionObject && !s.value.value))) {
-            // create a structure and bind it
-            extensionObject_ = optionalExtensionObject || addressSpace.constructExtensionObject(self.dataType, {});
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            self.bindVariable(
-                {
-                    timestamped_get() {
-                        const d = new DataValue(self.$dataValue);
-                        d.value.value = self.$extensionObject ? self.$extensionObject.clone() : null;
-                        return d;
+            if (self.valueRank === -1 /** Scalar */) {
+                // create a structure and bind it
+                extensionObject_ = optionalExtensionObject || addressSpace.constructExtensionObject(self.dataType, {});
+                // eslint-disable-next-line @typescript-eslint/no-this-alias
+                self.bindVariable(
+                    {
+                        timestamped_get() {
+                            const d = new DataValue(self.$dataValue);
+                            d.value.value = self.$extensionObject ? self.$extensionObject.clone() : null;
+                            return d;
+                        },
+                        timestamped_set(dataValue: DataValue, callback: CallbackT<StatusCode>) {
+                            const ext = dataValue.value.value;
+                            if (!self.checkExtensionObjectIsCorrect(ext)) {
+                                return callback(null, StatusCodes.BadInvalidArgument);
+                            }
+                            _setExtensionObject(self, ext);
+                            callback(null, StatusCodes.Good);
+                        }
                     },
-                    timestamped_set(dataValue: DataValue, callback: CallbackT<StatusCode>) {
-                        const ext = dataValue.value.value;
-                        if (!self.checkExtensionObjectIsCorrect(ext)) {
-                            return callback(null, StatusCodes.BadInvalidArgument);
+                    true
+                );
+                _setExtensionObject(self, extensionObject_);
+            } else if (self.valueRank === 1 /** Array */) {
+                // create a structure and bind it
+
+                extensionObject_ = optionalExtensionObject || [];
+                // eslint-disable-next-line @typescript-eslint/no-this-alias
+                self.bindVariable(
+                    {
+                        timestamped_get() {
+                            const d = new DataValue(self.$dataValue);
+
+                            d.value.value = self.$extensionObject
+                                ? self.$extensionObject.map((e: ExtensionObject) => e.clone())
+                                : null;
+                            return d;
+                        },
+                        timestamped_set(dataValue: DataValue, callback: CallbackT<StatusCode>) {
+                            const ext = dataValue.value.value;
+                            if (!self.checkExtensionObjectIsCorrect(ext)) {
+                                return callback(null, StatusCodes.BadInvalidArgument);
+                            }
+                            _setExtensionObject(self, ext);
+                            callback(null, StatusCodes.Good);
                         }
-                        _setExtensionObject(self, ext);
-                        callback(null, StatusCodes.Good);
-                    }
-                },
-                true
-            );
-            _setExtensionObject(self, extensionObject_);
+                    },
+                    true
+                );
+                _setExtensionObject(self, extensionObject_);
+            } else {
+                errorLog(self.toString());
+                errorLog("Unsupported case ! valueRank= ", self.valueRank);
+            }
         } else {
             // verify that variant has the correct type
             assert(s.value.dataType === DataType.ExtensionObject);