node-opcua-address-space 2.91.1 → 2.93.0

package/src/namespace_impl.ts

@@ -11,7 +11,7 @@ import { AccessRestrictionsFlag, coerceLocalizedText, QualifiedNameLike } from "
 import { QualifiedName } from "node-opcua-data-model";
 import { BrowseDirection } from "node-opcua-data-model";
 import { NodeClass } from "node-opcua-data-model";
-import { dumpIf, make_errorLog } from "node-opcua-debug";
+import { dumpIf, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { NodeIdLike, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
 import { NodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
@@ -143,6 +143,7 @@ function _makeHashKey(nodeId: NodeId): string | number {
 }
 const doDebug = false;
 const errorLog = make_errorLog("AddressSpace");
+const warningLog = make_warningLog("AddressSpace");
 
 const regExp1 = /^(s|i|b|g)=/;
 const regExpNamespaceDotBrowseName = /^[0-9]+:(.*)/;
@@ -469,16 +470,6 @@ export class NamespaceImpl implements NamespacePrivate {
 
     /**
      * add a variable as a component of the parent node
-     *
-     * @method addVariable
-     * @param options
-     * @param options.browseName       the variable name
-     * @param options.dataType        the variable datatype ( "Double", "UInt8" etc...)
-     * @param [options.typeDefinition="BaseDataVariableType"]
-     * @param [options.modellingRule=null] the Modelling rule : "Optional" , "Mandatory"
-     * @param [options.valueRank= -1]    the valueRank
-     * @param [options.arrayDimensions]
-     * @return UAVariable
      */
     public addVariable(options: AddVariableOptions): UAVariable {
         assert(arguments.length === 1, "Invalid arguments IAddressSpace#addVariable now takes only one argument.");
@@ -581,7 +572,7 @@ export class NamespaceImpl implements NamespacePrivate {
         options1.nodeClass = NodeClass.ReferenceType;
         options1.references = options.references || [];
         options1.nodeId = options.nodeId;
-        
+
         if (options.subtypeOf) {
             const subtypeOfNodeId = addressSpace._coerceType(options.subtypeOf, "References", NodeClass.ReferenceType);
 
@@ -1443,7 +1434,7 @@ export class NamespaceImpl implements NamespacePrivate {
      */
     public addState(
         component: UAStateMachineEx,
-        stateName: string,
+        stateName: QualifiedNameLike,
         stateNumber: number,
         isInitialState: boolean
     ): UAState | UAInitialState {
@@ -1454,9 +1445,7 @@ export class NamespaceImpl implements NamespacePrivate {
         const _component = component as UAStateMachineImpl;
 
         assert(_component.nodeClass === NodeClass.Object || _component.nodeClass === NodeClass.ObjectType);
-        assert(typeof stateName === "string");
-        assert(typeof isInitialState === "boolean");
-
+      
         const initialStateType = addressSpace.findObjectType("InitialStateType")!;
         const stateType = addressSpace.findObjectType("StateType")!;
 
@@ -1486,7 +1475,8 @@ export class NamespaceImpl implements NamespacePrivate {
         component: UAStateMachineEx,
         fromState: string,
         toState: string,
-        transitionNumber: number
+        transitionNumber: number,
+        browseName?: QualifiedNameLike
     ): UATransitionEx {
         const addressSpace = this.addressSpace;
 
@@ -1497,7 +1487,7 @@ export class NamespaceImpl implements NamespacePrivate {
         assert(typeof toState === "string");
         assert(isFinite(transitionNumber));
 
-        const fromStateNode = _component.getComponentByName(fromState, _component.nodeId.namespace);
+        const fromStateNode = _component.getComponentByName(fromState);
 
         // istanbul ignore next
         if (!fromStateNode) {
@@ -1517,8 +1507,11 @@ export class NamespaceImpl implements NamespacePrivate {
         if (!transitionType) {
             throw new Error("Cannot find TransitionType");
         }
+
+        browseName = browseName || fromState + "To" + toState; //  "Transition";
+
         const transition = transitionType.instantiate({
-            browseName: fromState + "To" + toState + "Transition",
+            browseName,
             componentOf: _component
         }) as UATransitionImpl;
 
@@ -1686,7 +1679,7 @@ export class NamespaceImpl implements NamespacePrivate {
                 "\n" +
                 "existing node = " +
                 exstingNode.toString() +
-                "this parent : " + node.parentNodeId?.toString() 
+                "this parent : " + node.parentNodeId?.toString()
             );
         }
 
@@ -1994,9 +1987,26 @@ export class NamespaceImpl implements NamespacePrivate {
 
         options.arrayDimensions = options.arrayDimensions || null;
         assert(Array.isArray(options.arrayDimensions) || options.arrayDimensions === null);
+
         // -----------------------------------------------------
+        const hasGetter = (options: AddVariableOptions2) => {
+            return typeof options.value?.get === "function" || typeof options.value?.timestamped_get === "function"
+        }
+
+        // istanbul ignore next
+        if (options.minimumSamplingInterval === undefined && hasGetter(options)) {
+            // a getter has been specified and no options.minimumSamplingInterval has been specified
+            warningLog("[NODE-OPCUA-W30", "namespace#addVariable a getter has been specified and minimumSamplingInterval is missing.\nMinimumSamplingInterval has been adjusted to 1000 ms");
+            options.minimumSamplingInterval = 1000;
+        }
 
         options.minimumSamplingInterval = options.minimumSamplingInterval !== undefined ? +options.minimumSamplingInterval : 0;
+
+        // istanbul ignore next
+        if (options.minimumSamplingInterval === 0 && hasGetter(options)) {
+            warningLog("[NODE-OPCUA-W31", "namespace#addVariable a getter has been specified and minimumSamplingInterval is 0.\nThis may conduct to an unpredicable behavior.\nPlease specify a non zero minimum sampling interval")
+        }
+
         let references = options.references || ([] as AddReferenceOpts[]);
 
         references = ([] as AddReferenceOpts[]).concat(references, [

package/src/state_machine/finite_state_machine.ts

@@ -25,14 +25,27 @@ const doDebug = false;
 export declare interface UATransitionImpl extends UATransition, UATransitionEx { }
 export class UATransitionImpl implements UATransition, UATransitionEx { }
 
-function getComponentFromTypeAndSubtype(typeDef: UAObjectType): UAObject[] {
-    const components_parts: BaseNode[][] = [];
-    components_parts.push(typeDef.getComponents());
-    while (typeDef.subtypeOfObj) {
+function getComponentOfType(typeDef: UAObjectType, typedefinition: UAObjectType): UAObject[] {
+
+    const get = (typeDef: UAObjectType) =>
+        typeDef.getComponents().filter((cc) => {
+            const c = cc as UAObject | UAVariable | UAMethod;
+            if (c.nodeClass !== NodeClass.Object) return false;
+            if (!c.typeDefinitionObj || c.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
+                return false;
+            }
+            return c.typeDefinitionObj.isSubtypeOf(typedefinition);
+        });
+
+    let components_parts: BaseNode[] = get(typeDef);
+
+    while (components_parts.length === 0 && typeDef.subtypeOfObj) {
+        // there is no element of that type available in the top level
         typeDef = typeDef.subtypeOfObj;
-        components_parts.push(typeDef.getComponents());
+        components_parts = get(typeDef);
     }
-    return Array.prototype.concat.apply([], components_parts).filter((x: BaseNode) => x.nodeClass === NodeClass.Object);
+    return components_parts as UAObject[];
+
 }
 
 export interface UAStateMachineImpl {
@@ -86,15 +99,7 @@ export function getFiniteStateMachineTypeStates(uaFiniteStateMachineType: UAObje
 
     assert(initialStateType.isSubtypeOf(stateType));
 
-
-    let comp = getComponentFromTypeAndSubtype(uaFiniteStateMachineType);
-
-    comp = comp.filter((c) => {
-        if (!c.typeDefinitionObj || c.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
-            return false;
-        }
-        return c.typeDefinitionObj.isSubtypeOf(stateType);
-    });
+    const comp = getComponentOfType(uaFiniteStateMachineType, stateType);
 
     return comp as UAState[];
 }
@@ -106,16 +111,7 @@ export function getFiniteStateMachineTypeTransitions(uaFiniteStateMachineType: U
     if (!transitionType) {
         throw new Error("cannot find TransitionType");
     }
-
-    let comp = getComponentFromTypeAndSubtype(uaFiniteStateMachineType);
-
-    comp = comp.filter((c) => {
-        if (!c.typeDefinitionObj || c.typeDefinitionObj.nodeClass !== NodeClass.ObjectType) {
-            return false;
-        }
-        return c.typeDefinitionObj.isSubtypeOf(transitionType);
-    });
-
+    const comp = getComponentOfType(uaFiniteStateMachineType, transitionType);
     return comp as UATransitionEx[];
 
 }
@@ -172,13 +168,10 @@ export class UAStateMachineImpl extends UAObjectImpl implements UAStateMachineEx
     get initialState(): UAState | null {
         const addressSpace = this.addressSpace;
 
-        const initialStateType = addressSpace.findObjectType("InitialStateType");
+        const initialStateType = addressSpace.findObjectType("InitialStateType")!;
         const typeDef = this.typeDefinitionObj;
 
-        let comp = getComponentFromTypeAndSubtype(typeDef);
-
-        comp = comp.filter((c: any) => c.typeDefinitionObj === initialStateType);
-
+        const comp = getComponentOfType(typeDef, initialStateType);
         // istanbul ignore next
         if (comp.length > 1) {
             throw new Error(" More than 1 initial state in stateMachine");
@@ -444,7 +437,7 @@ registerNodePromoter(ObjectTypeIds.FiniteStateMachineType, promoteToStateMachine
 
 export class UAStateMachineTypeImpl extends UAObjectTypeImpl implements UAStateMachineTypeHelper {
     getStateByName(name: string): UAState | null {
-        return getFiniteStateMachineTypeStateByName(this,  name);
+        return getFiniteStateMachineTypeStateByName(this, name);
     }
     getStates(): UAState[] {
         return getFiniteStateMachineTypeStates(this);

package/src/tool_isSubtypeOf.ts

@@ -107,13 +107,13 @@ export function construct_isSubtypeOf<T extends UAType>(Class: typeof BaseNodeIm
                 "expecting baseType to be " +
                     Class.name +
                     " but got " +
-                    baseType.constructor.name +
+                    baseType.toString() +
                     " " +
                     NodeClass[(baseType as BaseNode).nodeClass]
             );
         }
         if (!(this instanceof Class)) {
-            throw new Error("expecting this to be " + Class.name + " but got " + baseType.constructor.name);
+            throw new Error("expecting this to be " + Class.name + " but got " + baseType.toString());
         }
         return _slow_isSubtypeOf.call(this, Class, baseType as T);
     }, hashBaseNode);

package/src/ua_method_impl.ts

@@ -42,7 +42,7 @@ const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 
 function default_check_valid_argument(arg: unknown): boolean {
-    return (arg as any).constructor.name === "Argument";
+    return (arg as any) instanceof Argument;
 }
 
 export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
@@ -177,11 +177,11 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         if (object.nodeClass !== NodeClass.Object && object.nodeClass !== NodeClass.ObjectType) {
             warningLog(
                 "Method " +
-                    this.nodeId.toString() +
-                    " " +
-                    this.browseName.toString() +
-                    " called for a node that is not a Object/ObjectType but " +
-                    NodeClass[context.object!.nodeClass]
+                this.nodeId.toString() +
+                " " +
+                this.browseName.toString() +
+                " called for a node that is not a Object/ObjectType but " +
+                NodeClass[context.object!.nodeClass]
             );
             return callback(null, { statusCode: StatusCodes.BadNodeIdInvalid });
         }

package/src/ua_variable_impl.ts

@@ -138,7 +138,9 @@
         return (
             v &&
             v.constructor &&
-            (v.constructor.name === "ConstantStatusCode" ||
+            (
+                v instanceof StatusCode ||
+                v.constructor.name === "ConstantStatusCode" ||
                 v.constructor.name === "StatusCode" ||
                 v.constructor.name === "ModifiableStatusCode")
         );
@@ -537,6 +539,10 @@
             return this.addressSpacePrivate.isEnumeration(this.dataType);
         }
 
+        /**
+         * return true if the DataType is of type Extension object
+         * this is not taking into account the valueRank of the variable 
+         */
         public isExtensionObject(): boolean {
             // DataType must be one of Structure
             if (this.dataType.isEmpty()) return false;
@@ -1508,7 +1514,7 @@
 
             // coerce to ExtensionObject[] when this.valueRank === 1
             if (optionalExtensionObject && this.valueRank === 1 && !Array.isArray(optionalExtensionObject) && optionalExtensionObject instanceof ExtensionObject) {
-                warningLog("bindExtensionObject: coerce to ExtensionObject[] when this.valueRank === 1");
+                warningLog("bindExtensionObject: coerce to ExtensionObject[] when valueRank === 1 and value is a scalar extension object");
                 optionalExtensionObject = [optionalExtensionObject];
             }
 
@@ -1800,7 +1806,7 @@
                         propagateTouchValueDownward(this, preciseClock, cache);
                     }
                 } else {
-                    this.emit("value_changed", this.$dataValue, indexRange);
+                    this.emit("value_changed", this.$dataValue.clone(), indexRange);
                 }
             }
         }

package/src/ua_variable_impl_ext_obj.ts

@@ -104,12 +104,9 @@ export function _touchValue(property: UAVariableImpl, now: PreciseClock): void {
     property.$dataValue.serverTimestamp = now.timestamp;
     property.$dataValue.serverPicoseconds = now.picoseconds;
     property.$dataValue.statusCode = StatusCodes.Good;
-    // if (property.minimumSamplingInterval === 0) {
     if (property.listenerCount("value_changed") > 0) {
-        const clonedDataValue = property.readValue();
-        property.emit("value_changed", clonedDataValue);
+        property.emit("value_changed", property.$dataValue.clone());
     }
-    // }
 }
 
 export function propagateTouchValueUpward(self: UAVariableImpl, now: PreciseClock, cache?: Set<UAVariable>): void {
@@ -346,6 +343,7 @@ function _installFields2(uaVariable: UAVariableImpl, { get, set }: {
             const sourceTime = coerceClock(dataValue.sourceTimestamp, dataValue.sourcePicoseconds);
             const value = dataValue.value.value;
             set(field.name!, value, sourceTime);
+            propertyNode.touchValue(sourceTime);
         }
 
         if (propertyNode.dataTypeObj.basicDataType === DataType.ExtensionObject) {
@@ -396,9 +394,10 @@ function isVariableContainingExtensionObject(uaVariable: UAVariableImpl): boolea
 }
 
 function _innerBindExtensionObjectScalar(uaVariable: UAVariableImpl,
-    { get, set }: {
+    { get, set, setField }: {
         get: () => ExtensionObject;
         set: (value: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => void;
+        setField: (fieldName: string, value: any, sourceTimestamp: PreciseClock, cache?: Set<UAVariableImpl>) => void;
     },
     options?: BindExtensionObjectOptions
 ) {
@@ -420,10 +419,7 @@ function _innerBindExtensionObjectScalar(uaVariable: UAVariableImpl,
             return extObj[lowerFirstLetter(fieldName)];
         },
         set: (fieldName: string, value: any, sourceTime: PreciseClock) => {
-            const extObj = get() as any;
-            extObj[lowerFirstLetter(fieldName)] = value;
-            //1 propagateTouchValueDownward(uaVariable, sourceTime);
-            //1 propagateTouchValueUpward(uaVariable, sourceTime);
+            setField(fieldName, value, sourceTime);
         }
     }, options);
 
@@ -497,7 +493,7 @@ export function _bindExtensionObject(
                 "bindExtensionObject: $extensionObject is incorrect: we are expecting a " +
                 uaVariable.dataType.toString({ addressSpace: uaVariable.addressSpace }) +
                 " but we got a " +
-                uaVariable.$extensionObject?.constructor.name
+                uaVariable.$extensionObject?.schema.name
             );
         }
         return uaVariable.$extensionObject;
@@ -530,7 +526,12 @@ export function _bindExtensionObject(
                 _innerBindExtensionObjectScalar(uaVariable,
                     {
                         get: () => uaVariable.$extensionObject,
-                        set: (value: ExtensionObject) => installExt(uaVariable, value)
+                        set: (value: ExtensionObject) => installExt(uaVariable, value),
+                        setField: (fieldName: string, value: any) => {
+                            const extObj = uaVariable.$extensionObject;
+                            getProxyTarget(extObj)[lowerFirstLetter(fieldName)] = value;
+                        }
+
                     }, options);
                 return;
             } else if (uaVariable.valueRank === 1 /** Array */) {
@@ -546,7 +547,11 @@ export function _bindExtensionObject(
             _innerBindExtensionObjectScalar(uaVariable,
                 {
                     get: () => uaVariable.$extensionObject,
-                    set: (value: ExtensionObject) => installExt(uaVariable, value)
+                    set: (value: ExtensionObject) => installExt(uaVariable, value),
+                    setField: (fieldName: string, value: any) => {
+                        const extObj = uaVariable.$extensionObject;
+                        getProxyTarget(extObj)[lowerFirstLetter(fieldName)] = value;
+                    }
                 }, options);
         }
     }
@@ -575,7 +580,7 @@ export function _bindExtensionObjectArrayOrMatrix(
     options?: BindExtensionObjectOptions
 ): ExtensionObject[] {
 
-    options = options || { createMissingProp: false};
+    options = options || { createMissingProp: false };
     options.createMissingProp = options.createMissingProp || false;
 
     // istanbul ignore next
@@ -592,7 +597,7 @@ export function _bindExtensionObjectArrayOrMatrix(
         assert(Array.isArray(uaVariable.$dataValue.value.value));
         optionalExtensionObjectArray = uaVariable.$dataValue.value.value;
     }
-    
+
     if ((arrayDimensions.length === 0 || arrayDimensions.length === 1 && arrayDimensions[0] === 0) && optionalExtensionObjectArray) {
         arrayDimensions[0] = optionalExtensionObjectArray.length;
     }
@@ -652,7 +657,7 @@ export function _bindExtensionObjectArrayOrMatrix(
             if (!options.createMissingProp) {
                 continue;
             }
-            
+
             uaElement = namespace.addVariable({
                 browseName,
                 nodeId,
@@ -678,7 +683,6 @@ export function _bindExtensionObjectArrayOrMatrix(
                 {
                     get: () => uaVariable.$$extensionObjectArray[capturedIndex],
                     set: (newValue: ExtensionObject, sourceTimestamp: PreciseClock, cache: Set<UAVariableImpl>) => {
-
                         assert(!isProxy(uaVariable.$$extensionObjectArray[capturedIndex]));
                         uaVariable.$$extensionObjectArray[capturedIndex] = newValue;
                         if (uaVariable.$$extensionObjectArray !== uaVariable.$dataValue.value.value) {
@@ -687,6 +691,12 @@ export function _bindExtensionObjectArrayOrMatrix(
                         }
                         propagateTouchValueDownward(capturedUaElement, sourceTimestamp, cache);
                         propagateTouchValueUpward(capturedUaElement, sourceTimestamp, cache);
+                    },
+                    setField: (fieldName: string, newValue: any, sourceTimestamp: PreciseClock, cache?: Set<UAVariableImpl>) => {
+                        // istanbul ignore next doDebug && debugLog("setField", fieldName, newValue, sourceTimestamp, cache);
+                        const extObj = uaVariable.$$extensionObjectArray[capturedIndex];
+                        (isProxy(extObj) ? getProxyTarget(extObj) : extObj)[lowerFirstLetter(fieldName)] = newValue;
+                        propagateTouchValueUpward(capturedUaElement, sourceTimestamp, cache);
                     }
                 }, { ...options, force: true });