node-opcua-address-space 2.66.2 → 2.68.0

package/src/ua_variable_impl.ts

@@ -9,6 +9,7 @@
 import * as chalk from "chalk";
 
 import {
+    BindExtensionObjectOptions,
     CloneExtraInfo,
     ContinuationData,
     defaultCloneExtraInfo,
@@ -80,7 +81,7 @@ import {
     BaseNode,
     UAVariableT
 } from "node-opcua-address-space-base";
-import { UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
+import { EnumFilterOperator, UAHistoricalDataConfiguration } from "node-opcua-nodeset-ua";
 
 import { SessionContext } from "../source/session_context";
 import { convertToCallbackFunction1 } from "../source/helpers/multiform_func";
@@ -88,6 +89,7 @@ import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
 import { _clone, ToStringBuilder, UAVariable_toString, valueRankToString } from "./base_node_private";
 import { EnumerationInfo, IEnumItem, UADataTypeImpl } from "./ua_data_type_impl";
 import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
+import { extractPartialData, propagateTouchValueUpward, setExtensionObjectValue, _bindExtensionObject, _installExtensionObjectBindingOnProperties, _setExtensionObject, _touchValue } from "./ua_variable_impl_ext_obj";
 
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
@@ -157,7 +159,6 @@ function _dataType_toUADataType(addressSpace: IAddressSpace, dataType: DataType)
     }
     return dataTypeNode as UADataType;
 }
-
 /*=
  *
  * @param addressSpace
@@ -681,7 +682,8 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 if (
                     this.dataType.namespace === 0 &&
                     this.dataType.value === DataType.LocalizedText &&
-                    variant.dataType !== DataType.LocalizedText &&  variant.dataType !== DataType.Null
+                    variant.dataType !== DataType.LocalizedText &&
+                    variant.dataType !== DataType.Null
                 ) {
                     throw new Error(
                         "Variant must provide a valid LocalizedText : variant = " +
@@ -699,7 +701,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             if (basicType === DataType.ByteString && variant.dataType === DataType.String) {
                 return; // this is allowed
             }
-            
+
             if (
                 basicType !== DataType.Null &&
                 basicType !== DataType.Variant &&
@@ -757,7 +759,22 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             dataValue.sourceTimestamp = now.timestamp;
             dataValue.statusCode = statusCode;
             dataValue.value = variant1;
-            this._internal_set_dataValue(dataValue);
+
+            if (dataValue.value.dataType === DataType.ExtensionObject) {
+                this.$dataValue = dataValue;
+                assert(this.checkExtensionObjectIsCorrect(dataValue.value.value));
+                // ----------------------------------
+                if (this.$extensionObject) {
+                    // we have an extension object already bound to this node
+                    // the client is asking us to replace the object entierly by a new one
+                    const ext = dataValue.value.value;
+                    _setExtensionObject(this, ext);
+                    return;
+                }
+            } else {
+                this._internal_set_dataValue(dataValue);
+            }
+
         } catch (err) {
             errorLog("UAVariable#setValueFromString Error : ", this.browseName.toString(), this.nodeId.toString());
             errorLog((err as Error).message);
@@ -981,32 +998,12 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     }
 
     /**
-     * @method touchValue
      * touch the source timestamp of a Variable and cascade up the change
      * to the parent variable if any.
-     *
-     * @param [optionalNow=null] {Object}
-     * @param optionalNow.timestamp    {Date}
-     * @param optionalNow.picoseconds  {Number}
      */
     public touchValue(optionalNow?: PreciseClock): void {
         const now = optionalNow || getCurrentClock();
-        this.$dataValue.sourceTimestamp = now.timestamp;
-        this.$dataValue.sourcePicoseconds = now.picoseconds;
-        this.$dataValue.serverTimestamp = now.timestamp;
-        this.$dataValue.serverPicoseconds = now.picoseconds;
-
-        this.$dataValue.statusCode = StatusCodes.Good;
-
-        if (this.minimumSamplingInterval === 0) {
-            if (this.listenerCount("value_changed") > 0) {
-                const clonedDataValue = this.readValue();
-                this.emit("value_changed", clonedDataValue);
-            }
-        }
-        if (this.parent && this.parent.nodeClass === NodeClass.Variable) {
-            (this.parent as UAVariable).touchValue(now);
-        }
+        propagateTouchValueUpward(this, now);
     }
 
     /**
@@ -1170,7 +1167,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         if (!context) {
             context = SessionContext.defaultContext;
         }
-        assert(callback instanceof Function);
+        assert(typeof callback  === 'function');
 
         this.__waiting_callbacks = this.__waiting_callbacks || [];
         this.__waiting_callbacks.push(callback);
@@ -1263,6 +1260,12 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
         assert(newVariable.dataType === this.dataType);
         newVariable.$dataValue = this.$dataValue.clone();
+
+        // 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);
+        }
         return newVariable;
     }
 
@@ -1318,281 +1321,35 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             return false;
         }
     }
+
     /**
-     * @method bindExtensionObject
-     * @return {ExtensionObject}
+     * @private
+     * install UAVariable to exposed th  
+     * 
+     * precondition:
      */
-    public bindExtensionObject(optionalExtensionObject?: ExtensionObject): ExtensionObject | null {
-        const addressSpace = this.addressSpace;
-        const structure = addressSpace.findDataType("Structure");
-        let extensionObject_;
-
-        if (!structure) {
-            // the addressSpace is limited and doesn't provide extension object
-            // bindExtensionObject cannot be performed and shall finish here.
-            return null;
-        }
-
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog(" ------------------------------ binding ", this.browseName.toString(), this.nodeId.toString());
-        }
-        assert(structure && structure.browseName.toString() === "Structure", "expecting DataType Structure to be in IAddressSpace");
-
-        const dt = this.getDataTypeNode() as UADataTypeImpl;
-        if (!dt.isSupertypeOf(structure)) {
-            return null;
-        }
-
-        // the namespace for the structure browse name elements
-        const structureNamespace = dt.nodeId.namespace;
-
-        // -------------------- make sure we do not bind a variable twice ....
-        if (this.$extensionObject) {
-            // istanbul ignore next
-            // if (!force && !utils.isNullOrUndefined(optionalExtensionObject)) {
-            //     throw new Error(
-            //         "bindExtensionObject: unsupported case : $extensionObject already exists on " +
-            //             this.browseName.toString() +
-            //             " " +
-            //             this.nodeId.toString()
-            //     );
-            // }
-            // istanbul ignore next
-            if (!this.checkExtensionObjectIsCorrect(this.$extensionObject!)) {
-                warningLog(
-                    "on node : ",
-                    this.browseName.toString(),
-                    this.nodeId.toString(),
-                    "dataType=",
-                    this.dataType.toString({ addressSpace: this.addressSpace })
-                );
-                warningLog(this.$extensionObject?.toString());
-                throw new Error(
-                    "bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
-                        this.dataType.toString({ addressSpace: this.addressSpace }) +
-                        " but we got a " +
-                        this.$extensionObject?.constructor.name
-                );
-            }
-            return this.$extensionObject;
-            // throw new Error("Variable already bound");
-        }
-        this.$extensionObject = optionalExtensionObject;
-
-        // ------------------------------------------------------------------
-
-        function prepareVariantValue(dataType: DataType, value: VariantLike): VariantLike {
-            if ((dataType === DataType.Int32 || dataType === DataType.UInt32) && value && (value as any).key) {
-                value = value.value;
-            }
-            return value;
-        }
-
-        const bindProperty = (propertyNode: UAVariableImpl, name: string, extensionObject: ExtensionObject, dataType: DataType) => {
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const self = this;
-            propertyNode.bindVariable(
-                {
-                    timestamped_get: () => {
-                        const propertyValue = self.$extensionObject[name];
-
-                        if (propertyValue === undefined) {
-                            propertyNode.$dataValue.value.dataType = DataType.Null;
-                            propertyNode.$dataValue.statusCode = StatusCodes.Good;
-                            propertyNode.$dataValue.value.value = null;
-                            return new DataValue(propertyNode.$dataValue);
-                        }
-                        const value = prepareVariantValue(dataType, propertyValue);
-                        propertyNode.$dataValue.statusCode = StatusCodes.Good;
-                        propertyNode.$dataValue.value.dataType = dataType;
-                        propertyNode.$dataValue.value.value = value;
-                        return new DataValue(propertyNode.$dataValue);
-                    },
-                    timestamped_set: (dataValue: DataValue, callback: CallbackT<StatusCode>) => {
-                        dataValue;
-                        callback(null, StatusCodes.BadNotWritable);
-                    }
-                },
-                true
-            );
-        };
-        const components = this.getComponents();
-
-        // ------------------------------------------------------
-        // make sure we have a structure
-        // ------------------------------------------------------
-        const s = this.readValue();
-        // istanbul ignore next
-        if (this.dataTypeObj.isAbstract) {
-            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 === DataType.Null || (s.value.dataType === DataType.ExtensionObject && !s.value.value))) {
-            // create a structure and bind it
-            extensionObject_ = this.$extensionObject || addressSpace.constructExtensionObject(this.dataType, {});
-            extensionObject_ = new Proxy(extensionObject_, makeHandler(this));
-            this.$extensionObject = extensionObject_;
-
-            const theValue = new Variant({
-                dataType: DataType.ExtensionObject,
-                value: this.$extensionObject
-            });
-            this.setValueFromSource(theValue, StatusCodes.Good);
-
-            // eslint-disable-next-line @typescript-eslint/no-this-alias
-            const self = this;
-            this.bindVariable(
-                {
-                    timestamped_get() {
-                        self.$dataValue.value.value = self.$extensionObject;
-                        const d = new DataValue(self.$dataValue);
-                        d.value = new Variant(d.value);
-                        return d;
-                    },
-                    timestamped_set(dataValue: DataValue, callback: CallbackT<StatusCode>) {
-                        const ext = dataValue.value.value;
-                        if (!self.checkExtensionObjectIsCorrect(ext)) {
-                            return callback(null, StatusCodes.BadInvalidArgument);
-                        }
-                        self.$extensionObject = new Proxy(ext, makeHandler(self));
-                        self.touchValue();
-                        callback(null, StatusCodes.Good);
-                    }
-                },
-                true
-            );
-        } else {
-            // verify that variant has the correct type
-            assert(s.value.dataType === DataType.ExtensionObject);
-            this.$extensionObject = s.value.value;
-            assert(this.checkExtensionObjectIsCorrect(this.$extensionObject!));
-            assert(s.statusCode.equals(StatusCodes.Good));
-        }
-
-        // ------------------------------------------------------
-        // now bind each member
-        // ------------------------------------------------------
-        const definition = dt._getDefinition() as StructureDefinition | null;
-
-        // istanbul ignore next
-        if (!definition) {
-            throw new Error("xx definition missing in " + dt.toString());
-        }
-
-        const getOrCreateProperty = (field: StructureField): UAVariableImpl => {
-            let property: UAVariableImpl;
-            const selectedComponents = components.filter(
-                (f) => f instanceof UAVariableImpl && f.browseName.name!.toString() === field.name
-            );
-
-            if (field.dataType.value === DataType.Variant) {
-                warningLog("Warning : variant is not supported in ExtensionObject");
-            }
-            if (selectedComponents.length === 1) {
-                property = selectedComponents[0] as UAVariableImpl;
-                /* istanbul ignore next */
-            } else {
-                debugLog("adding missing array variable", field.name, this.browseName.toString(), this.nodeId.toString());
-                // todo: Handle array appropriately...
-                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() },
-                    componentOf: this,
-                    dataType: field.dataType,
-                    minimumSamplingInterval: this.minimumSamplingInterval
-                }) as UAVariableImpl;
-                assert(property.minimumSamplingInterval === this.minimumSamplingInterval);
-            }
-            return property;
-        };
-
-        for (const field of definition.fields || []) {
-            if (NodeId.sameNodeId(NodeId.nullNodeId, field.dataType)) {
-                warningLog("field.dataType is null ! ", field.toString(), NodeId.nullNodeId.toString());
-                warningLog(" dataType replaced with BaseDataType ");
-                warningLog(definition.toString());
-                field.dataType = this.resolveNodeId("BaseDataType");
-            }
-
-            const camelCaseName = lowerFirstLetter(field.name!);
-            assert(Object.prototype.hasOwnProperty.call(this.$extensionObject, camelCaseName));
-
-            const propertyNode = getOrCreateProperty(field);
-
-            propertyNode.$dataValue.statusCode = StatusCodes.Good;
-            propertyNode.touchValue();
-
-            const basicDataType = addressSpace.findCorrespondingBasicDataType(field.dataType);
-
-            // istanbul ignore next
-            if (doDebug) {
-                const x = addressSpace.findNode(field.dataType)!.browseName.toString();
-                debugLog(
-                    chalk.cyan("xxx"),
-                    " dataType",
-                    w(field.dataType.toString(), 8),
-                    w(field.name!, 35),
-                    "valueRank",
-                    chalk.cyan(w(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 && basicDataType === DataType.ExtensionObject) {
-                assert(this.$extensionObject[camelCaseName] instanceof Object);
-                this.$extensionObject[camelCaseName] = new Proxy(this.$extensionObject[camelCaseName], makeHandler(propertyNode));
-
-                propertyNode._internal_set_value(
-                    new Variant({
-                        dataType: DataType.ExtensionObject,
-                        value: this.$extensionObject[camelCaseName]
-                    })
-                );
-
-                propertyNode.bindExtensionObject();
-                propertyNode.$extensionObject = this.$extensionObject[camelCaseName];
-            } else {
-                const prop = this.$extensionObject[camelCaseName];
-                if (prop === undefined) {
-                    propertyNode._internal_set_value(
-                        new Variant({
-                            dataType: DataType.Null
-                        })
-                    );
-                } else {
-                    const preparedValue = prepareVariantValue(basicDataType, prop);
-                    propertyNode._internal_set_value(
-                        new Variant({
-                            dataType: basicDataType,
-                            value: preparedValue
-                        })
-                    );
+    public installExtensionObjectVariables(): void {
+        _installExtensionObjectBindingOnProperties(this, { createMissingProp: true });
+        // now recursively install extension object on children
+        for (const child of this.getComponents()) {
+            if (child.nodeClass === NodeClass.Variable && child instanceof UAVariableImpl) {
+                if (child.isExtensionObject()) {
+                    child.installExtensionObjectVariables();
                 }
-
-                // eslint-disable-next-line @typescript-eslint/no-this-alias
-                const self = this;
-                //  property.camelCaseName = camelCaseName;
-                propertyNode.setValueFromSource = function (this: UAVariableImpl, variant: VariantLike) {
-                    // eslint-disable-next-line @typescript-eslint/no-this-alias
-                    const inner_this = this;
-                    const variant1 = Variant.coerce(variant);
-                    inner_this.verifyVariantCompatibility(variant1);
-                    self.$extensionObject[camelCaseName] = variant1.value;
-                    self.touchValue();
-                };
             }
-            assert(propertyNode.readValue().statusCode.equals(StatusCodes.Good));
-            bindProperty(propertyNode, camelCaseName, this.$extensionObject, basicDataType);
         }
-        assert(this.$extensionObject instanceof Object);
-        return this.$extensionObject;
     }
+    /**
+     * @method bindExtensionObject
+     * @return {ExtensionObject}
+     */
+    public bindExtensionObject(
+        optionalExtensionObject?: ExtensionObject,
+        options?: BindExtensionObjectOptions
+    ): ExtensionObject | null {
+       return  _bindExtensionObject(this, optionalExtensionObject, options);
+    }
+
 
     public updateExtensionObjectPartial(partialExtensionObject?: { [key: string]: any }): ExtensionObject {
         setExtensionObjectValue(this, partialExtensionObject);
@@ -1600,43 +1357,11 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     }
 
     public incrementExtensionObjectPartial(path: string | string[]): void {
-        let name;
-        if (typeof path === "string") {
-            path = path.split(".");
-        }
-        assert(path instanceof Array);
-        const extensionObject = this.constructExtensionObjectFromComponents();
-        let i;
-        // read partial value
-        const partialData: any = {};
-        let p: any = partialData;
-        for (i = 0; i < path.length - 1; i++) {
-            name = path[i];
-            p[name] = {};
-            p = p[name];
-        }
-        name = path[path.length - 1];
-        p[name] = 0;
-
-        let c1 = partialData;
-        let c2 = extensionObject;
-
-        for (i = 0; i < path.length - 1; i++) {
-            name = path[i];
-            c1 = partialData[name];
-            c2 = extensionObject[name];
-        }
-        name = path[path.length - 1];
-        c1[name] = c2[name];
-        c1[name] += 1;
-
+        const extensionObject = this.readValue().value.value as ExtensionObject;
+        const partialData = extractPartialData(path, extensionObject);
         setExtensionObjectValue(this, partialData);
     }
 
-    public constructExtensionObjectFromComponents(): any {
-        return this.readValue().value.value;
-    }
-
     public toString(): string {
         const options = new ToStringBuilder();
         UAVariable_toString.call(this, options);
@@ -1687,7 +1412,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         callback?: CallbackT<HistoryReadResult>
     ): any {
         assert(context instanceof SessionContext);
-        assert(callback instanceof Function);
+        assert(typeof callback === 'function');
         if (typeof this._historyRead !== "function") {
             return callback!(null, new HistoryReadResult({ statusCode: StatusCodes.BadNotReadable }));
         }
@@ -1779,14 +1504,15 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         }
         this.$dataValue.value = value;
     }
+
+
     public _internal_set_dataValue(dataValue: DataValue, indexRange?: NumericRange | null): void {
         assert(dataValue, "expecting a dataValue");
         assert(dataValue instanceof DataValue, "expecting dataValue to be a DataValue");
         assert(dataValue !== this.$dataValue, "expecting dataValue to be different from previous DataValue instance");
-        
 
         const addressSpace = this.addressSpace;
-        if(!addressSpace) {
+        if (!addressSpace) {
             warningLog("UAVariable#_internal_set_dataValue : no addressSpace ! may be node has already been deleted ?");
             return;
         }
@@ -1808,6 +1534,14 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 warningLog(dataValue.toString());
                 throw new Error("Invalid Extension Object on nodeId =" + this.nodeId.toString());
             }
+            // ----------------------------------
+            // if (this.$extensionObject) {
+            //     // we have an extension object already bound to this node
+            //     // the client is asking us to replace the object entierly by a new one
+            //     const ext = dataValue.value.value;
+            //     _setExtensionObject(this, ext);
+            //     return;
+            // }
         }
         // // istanbul ignore next
         // if (this.dataType.namespace === 0) {
@@ -1952,6 +1686,7 @@ export interface UAVariableImpl {
     $$indexPropertyName: any;
 }
 
+
 function check_valid_array(dataType: DataType, array: any): boolean {
     if (Array.isArray(array)) {
         return true;
@@ -2307,54 +2042,6 @@ function bind_getter(this: UAVariableImpl, options: GetterOptions) {
     }
 }
 
-function w(str: string, n: number): string {
-    return (str + "                                                              ").substr(0, n);
-}
-
-function _getter(target: any, key: string /*, receiver*/) {
-    if (target[key] === undefined) {
-        return undefined;
-    }
-    return target[key];
-}
-
-function _setter(variable: UAVariable, target: any, key: string, value: any /*, receiver*/) {
-    target[key] = value;
-    const child = (variable as any)[key] as UAVariable | null;
-    if (child && child.touchValue) {
-        child.touchValue();
-    }
-    return true; // true means the set operation has succeeded
-}
-
-function makeHandler(variable: UAVariable) {
-    const handler = {
-        get: _getter,
-        set: _setter.bind(null, variable)
-    };
-    return handler;
-}
-
-function setExtensionObjectValue(node: UAVariableImpl, partialObject: any) {
-    const extensionObject = node.$extensionObject;
-    if (!extensionObject) {
-        throw new Error("setExtensionObjectValue node has no extension object " + node.browseName.toString());
-    }
-
-    function _update_extension_object(extObject: any, partialObject1: any) {
-        const keys = Object.keys(partialObject1);
-        for (const prop of keys) {
-            if (extObject[prop] instanceof Object) {
-                _update_extension_object(extObject[prop], partialObject1[prop]);
-            } else {
-                extObject[prop] = partialObject1[prop];
-            }
-        }
-    }
-
-    _update_extension_object(extensionObject, partialObject);
-}
-
 export interface UAVariableImplT<T, DT extends DataType> extends UAVariableImpl, UAVariableT<T, DT> {
     on(): any;
     once(): any;