node-opcua-address-space 2.119.2 → 2.121.0

package/source/loader/load_nodeset2.ts

@@ -91,7 +91,7 @@ function convertAccessLevel(accessLevel?: string | null): AccessLevelFlag {
 
 type Task = (addressSpace: IAddressSpace) => Promise<void>;
 
-function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, valueRank: number): VariantOptions | undefined {
+function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, valueRank: number, arrayDimensions?: number[]  |null): VariantOptions | undefined {
     let variant: VariantOptions = { dataType: DataType.Null };
 
     const nodeDataType = addressSpace.findNode(dataTypeNode) as UADataType;
@@ -136,7 +136,7 @@ function makeDefaultVariant(addressSpace: IAddressSpace, dataTypeNode: NodeId, v
                 break;
             default:
                 arrayType = VariantArrayType.Matrix;
-                variant = { dataType: basicDataType, value: [], arrayType, dimensions: [] };
+                variant = { dataType: basicDataType, value: [], arrayType, dimensions: arrayDimensions };
                 break;
         }
     }
@@ -1408,7 +1408,9 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
                 const task = async (addressSpace2: IAddressSpace) => {
                     const dataTypeNode = capturedVariable.dataType;
                     const valueRank = capturedVariable.valueRank;
-                    const value = makeDefaultVariant(addressSpace, dataTypeNode, valueRank);
+                    const arrayDimensions = capturedVariable.arrayDimensions;
+             
+                    const value = makeDefaultVariant(addressSpace, dataTypeNode, valueRank, arrayDimensions);
                     if (value) {
                         if (false && doDebug) {
                             debugLog("2 setting value to ", capturedVariable.nodeId.toString(), value);

package/source/pseudo_session.ts

@@ -68,10 +68,7 @@ export function innerBrowse(
             if (!engine.continuationPointManager) {
                 return new BrowseResult({ statusCode: StatusCodes.BadNoContinuationPoints });
             }
-            if (index === 0) {
-                // clear previous continuation points
-                engine.continuationPointManager.clearContinuationPoints();
-            }
+
             if (engine.continuationPointManager.hasReachedMaximum(engine.maxBrowseContinuationPoints)) {
                 return new BrowseResult({ statusCode: StatusCodes.BadNoContinuationPoints });
             }
@@ -79,7 +76,7 @@ export function innerBrowse(
             const truncatedResult = engine.continuationPointManager.registerReferences(
                 engine.requestedMaxReferencesPerNode,
                 result.references || [],
-                { continuationPoint: null, index }
+                { continuationPoint: null }
             );
             let { statusCode } = truncatedResult;
             const { continuationPoint, values } = truncatedResult;
@@ -108,7 +105,6 @@ export function innerBrowseNext(
         .map((continuationPoint: ContinuationPoint, index: number) => {
             return engine.continuationPointManager.getNextReferences(0, {
                 continuationPoint,
-                index,
                 releaseContinuationPoints
             });
         })

package/src/_mandatory_child_or_requested_optional_filter.ts

@@ -1,7 +1,7 @@
 import { assert } from "node-opcua-assert";
 import { BaseNode, UAMethod, UAObject, UAReference, UAVariable, CloneFilter, fullPath2 } from "node-opcua-address-space-base";
-
 import { checkDebugFlag, make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
+import { BrowseDirection } from "node-opcua-data-model";
 
 import { _clone_hierarchical_references } from "./base_node_private";
 
@@ -23,7 +23,7 @@ export class MandatoryChildOrRequestedOptionalFilter implements CloneFilter {
         assert(null !== instance);
         this.optionalsMap = optionalsMap;
         this.instance = instance;
-        this.references = instance.allReferences();
+        this.references = instance.findReferencesEx("Aggregates", BrowseDirection.Forward);
     }
 
     public shouldKeep(node: BaseNode): boolean {

package/src/address_space.ts

@@ -56,7 +56,7 @@ import {
     ShutdownTask,
     RaiseEventData
 } from "node-opcua-address-space-base";
-import { make_debugLog, make_errorLog } from "node-opcua-debug";
+import { make_debugLog, make_warningLog, make_errorLog } from "node-opcua-debug";
 
 import { adjustBrowseDirection } from "../source/helpers/adjust_browse_direction";
 import { UARootFolder } from "../source/ua_root_folder";
@@ -80,6 +80,7 @@ import { BaseNodeImpl } from "./base_node_impl";
 const doDebug = false;
 const errorLog = make_errorLog(__filename);
 const debugLog = make_debugLog(__filename);
+const warningLog = make_warningLog(__filename);
 
 // tslint:disable-next-line:no-var-requires
 const Dequeue = require("dequeue");
@@ -253,7 +254,9 @@ export class AddressSpace implements AddressSpacePrivate {
     /**
      * @method registerNamespace
      *
-     * register a new namespace
+     * register a new namespace,
+     * it is OK to call registerNamespace even if namespace has already been registered; 
+     * in this case the registerNamespace has no effect and returns the existing namespace.
      *
      * @param namespaceUri {string}
      * @returns {Namespace}
@@ -806,8 +809,8 @@ export class AddressSpace implements AddressSpacePrivate {
                 }
                 /* istanbul ignore next */
                 if (!alreadyVisited(k)) {
-                    throw new Error(
-                        " cannot find property '" +
+                    warningLog(
+                        "constructEventData:  cannot find property '" +
                             k +
                             "' in [ " +
                             Object.keys(visitedProperties).join(", ") +

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -17,7 +17,6 @@ import {
     NodeClass,
     QualifiedName
 } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { minDate } from "node-opcua-basic-types";
 import { coerceNodeId, makeNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
@@ -60,6 +59,8 @@ export declare interface UAConditionImpl extends UAConditionEx, UABaseEventImpl
     on(eventName: string, eventHandler: any): this;
     conditionClassId: UAProperty<NodeId, /*c*/ DataType.NodeId>;
     conditionClassName: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
+    conditionSubClassId: UAProperty<NodeId[], DataType.NodeId>;
+    conditionSubClassName: UAProperty<LocalizedText[], DataType.LocalizedText>;
 }
 /**
  *
@@ -1208,7 +1209,6 @@ function _create_new_branch_id() {
     return makeNodeId(randomGuid(), 1);
 }
 
-
 // tslint:disable:no-console
 function _install_condition_variable_type<T, DT extends DataType>(node: UAConditionVariable<T, DT>) {
     // from spec 1.03 : 5.3 condition variables
@@ -1220,7 +1220,6 @@ function _install_condition_variable_type<T, DT extends DataType>(node: UACondit
         console.warn("cannot find node.sourceTimestamp", node.browseName.toString());
     }
     node.accessLevel = makeAccessLevelFlag("CurrentRead");
-
 }
 
 /**

package/src/base_node_impl.ts

@@ -87,6 +87,8 @@ const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
 const debugLog = make_debugLog(__filename);
 
+const HasEventSourceReferenceType = resolveNodeId("HasEventSource");
+const HasNotifierReferenceType = resolveNodeId("HasNotifier");  
 
 function defaultBrowseFilterFunc(context?: ISessionContext): boolean {
     return true;
@@ -180,7 +182,6 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         return _private._displayName;
     }
 
-    
     public setDisplayName(value: LocalizedTextLike[] | LocalizedTextLike): void {
         if (!Array.isArray(value)) {
             return this.setDisplayName([value]);
@@ -199,7 +200,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         return _private._description!;
     }
 
-    public setDescription(value: LocalizedTextLike| null): void {
+    public setDescription(value: LocalizedTextLike | null): void {
         this._setDescription(value);
         /**
          * fires when the description attribute is changed.
@@ -504,6 +505,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
 
     /**
      * return a array with the notifiers of this object.
+     * only reference of exact type HasNotifier are returned.
      */
     public getNotifiers(): BaseNode[] {
         // const _cache = BaseNode_getCache(this);
@@ -511,11 +513,12 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         //     _cache._notifiers = this.findReferencesAsObject("HasNotifier", true);
         // }
         // return _cache._notifiers;
-        return this.findReferencesAsObject("HasNotifier", true);
+        return this.findReferencesAsObject(HasNotifierReferenceType, true);
     }
 
     /**
      * return a array with the event source of this object.
+     *  only reference of exact type HasEventSource are returned.
      */
     public getEventSources(): BaseNode[] {
         // const _cache = BaseNode_getCache(this);
@@ -523,7 +526,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         //     _cache._eventSources = this.findReferencesAsObject("HasEventSource", true);
         // }
         // return _cache._eventSources;
-        return this.findReferencesAsObject("HasEventSource", true);
+        return this.findReferencesAsObject(HasEventSourceReferenceType, true);
     }
 
     /**
@@ -535,7 +538,7 @@ export class BaseNodeImpl extends EventEmitter implements BaseNode {
         //     _cache._eventSources = this.findReferencesAsObject("HasEventSource", false);
         // }
         // return _cache._eventSources;
-        return this.findReferencesAsObject("HasEventSource", false);
+        return this.findReferencesAsObject(HasEventSourceReferenceType, false);
     }
 
     /**

package/src/base_node_private.ts

@@ -542,7 +542,10 @@ function _clone_children_on_template(
                 )
             );
 
-        const typeDefinitionChild = typeDefinitionNode.getChildByName(node.browseName);
+        // Find aggregates with same browseName as node. Do not search children as this includes nodes with HasSubType relation which we do
+        // not want. See issue #1326.
+        const aggregates = typeDefinitionNode.getAggregates().filter((n) => n.browseName.equals(node.browseName));
+        const typeDefinitionChild = aggregates.length > 0 ? aggregates[0] : null;
         if (typeDefinitionChild) {
             const references = typeDefinitionChild.findReferencesEx("Aggregates", BrowseDirection.Forward);
 
@@ -1053,7 +1056,7 @@ export function _clone<T extends UAObject | UAVariable | UAMethod>(
                 );
                 typeDefinitionNode = typeDefinitionNode.subtypeOfObj;
             }
-            
+
             extraInfo.popContext();
 
         }

package/src/historical_access/address_space_historical_data_node.ts

@@ -445,9 +445,9 @@ function _historyReadRaw(
             historyReadRawModifiedDetails.numValuesPerNode,
             continuationData
         );
-        const { statusCode, values } = cnt;
+        const { statusCode, values, continuationPoint } = cnt;
         const result2 = new HistoryReadResult({
-            continuationPoint: cnt.continuationPoint,
+            continuationPoint,
             historyData: new HistoryData({ dataValues: values }),
             statusCode
         });

package/src/namespace_impl.ts

@@ -2000,7 +2000,7 @@ export class NamespaceImpl implements NamespacePrivate {
             // 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"
+                "namespace#addVariable a getter has been specified and minimumSamplingInterval is missing.\nMinimumSamplingInterval has been adjusted to 1000 ms\nvariable = "+ options?.browseName?.toString()
             );
             options.minimumSamplingInterval = 1000;
         }

package/src/ua_method_impl.ts

@@ -135,7 +135,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
         if (async_func.length === 2) {
             async_func = callbackify(async_func as MethodFunctorA) as MethodFunctorC;
         }
-        assert(async_func.length === 3);
+        assert(async_func.length === 3, " a method with callback should have 3 arguments : got " + async_func.length);
         this._asyncExecutionFunction = async_func;
     }
     public execute(

package/src/ua_object_impl.ts

@@ -42,6 +42,18 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
     private _eventNotifier: EventNotifierFlags;
     public readonly nodeClass = NodeClass.Object;
     public get eventNotifier(): EventNotifierFlags {
+
+        // ensure eventNotifier is set if the node has some event
+
+        if (!this._eventNotifier) {
+            // const s = this.getEventSources();
+            const s = this.getEventSources();
+            const n = this.getNotifiers();
+            if (s.length > 0 || n.length > 0) {
+                this._eventNotifier = this._eventNotifier | EventNotifierFlags.SubscribeToEvents;
+            }
+        }
+
         return this._eventNotifier;
     }
     public readonly symbolicName: string | null;

package/src/ua_variable_impl.ts

@@ -1870,19 +1870,19 @@ function check_valid_array(dataType: DataType, array: any): boolean {
     return false;
 }
 
-function _apply_default_timestamps(dataValue: DataValue): void {
-    const now = getCurrentClock();
-    assert(dataValue instanceof DataValue);
-
-    if (!dataValue.sourceTimestamp) {
-        dataValue.sourceTimestamp = now.timestamp;
-        dataValue.sourcePicoseconds = now.picoseconds;
-    }
-    if (!dataValue.serverTimestamp) {
-        dataValue.serverTimestamp = now.timestamp;
-        dataValue.serverPicoseconds = now.picoseconds;
-    }
-}
+// function _apply_default_timestamps(dataValue: DataValue): void {
+//     const now = getCurrentClock();
+//     assert(dataValue instanceof DataValue);
+
+//     if (!dataValue.sourceTimestamp) {
+//         dataValue.sourceTimestamp = now.timestamp;
+//         dataValue.sourcePicoseconds = now.picoseconds;
+//     }
+//     if (!dataValue.serverTimestamp) {
+//         dataValue.serverTimestamp = now.timestamp;
+//         dataValue.serverPicoseconds = now.picoseconds;
+//     }
+// }
 
 function unsetFlag(flags: number, mask: number): number {
     return flags & ~mask;
@@ -1949,17 +1949,33 @@ function _default_writable_timestamped_set_func(
     callback(null, StatusCodes.Good, dataValue);
 }
 
-function turn_sync_to_async<T, D, R>(f: (this: T, data: D) => R, numberOfArgs: number) {
+type f1<T, D, R> = (this: T, data: D) => R;
+type f2<T, D, R> = (this: T, data: D) => Promise<R>;
+type f3<T, D, R> = (this: T, data: D, callback: (err: Error | null, r?: R) => void) => void;
+
+function turn_sync_to_async<T, D, R>(f: f1<T, D, R> | f2<T, D, R> | f3<T, D, R>, numberOfArgs: number): f3<T, D, R> {
     if (f.length <= numberOfArgs) {
         return function (this: T, data: D, callback: (err: Error | null, r?: R) => void) {
-            try {
-                const r = f.call(this, data);
-                setImmediate(() => {
-                    return callback(null, r);
+            new Promise<R>((resolve, reject) => {
+                try {
+                    // const ff1 = f as f1<T, D, R>;
+                    const ff2 = f as f2<T, D, R>;
+                    const r: R | Promise<R> = ff2.call(this, data);
+                    if (r instanceof Promise) {
+                        r.then(resolve, reject);
+                    } else {
+                        resolve(r);
+                    }
+                } catch (err) {
+                    reject(err);
+                }
+            })
+                .then((r) => {
+                    callback(null, r);
+                })
+                .catch((err) => {
+                    callback(err as Error);
                 });
-            } catch (err) {
-                return callback(err as Error);
-            }
         };
     } else {
         assert(f.length === numberOfArgs + 1);
@@ -1977,8 +1993,10 @@ function coerceDataValue(dataValue: DataValue | DataValueLike): DataValue {
 }
 
 // variation #3 :
-function _Variable_bind_with_async_refresh(this: UAVariableImpl, options: any) {
-    /* jshint validthis: true */
+function _Variable_bind_with_async_refresh(
+    this: UAVariableImpl,
+    options: { refreshFunc: RefreshFunc; get?: undefined; timestamped_get?: undefined }
+) {
     assert(this instanceof UAVariableImpl);
 
     assert(typeof options.refreshFunc === "function");
@@ -2050,7 +2068,6 @@ function _Variable_bind_with_timestamped_get(
 
 // variation 1
 function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOptions) {
-    /* jshint validthis: true */
     assert(this instanceof UAVariableImpl);
     assert(typeof options.get === "function", "should specify get function");
     assert(options.get!.length === 0, "get function should not have arguments");
@@ -2082,7 +2099,14 @@ function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOpt
                 !this.$dataValue.statusCode.isGoodish() ||
                 !sameVariant(this.$dataValue.value, value as Variant)
             ) {
-                this._inner_replace_dataValue(new DataValue({ value }));
+                // rebuilding artificially timestamps with current clock as they are not provided 
+                // by the underlying getter function
+                const { timestamp: sourceTimestamp, picoseconds: sourcePicoseconds } = getCurrentClock();
+                const serverTimestamp = sourceTimestamp;
+                const serverPicoseconds = sourcePicoseconds;
+                this._inner_replace_dataValue(
+                    new DataValue({ value, sourceTimestamp, sourcePicoseconds, serverTimestamp, serverPicoseconds })
+                );
             }
             return this.$dataValue;
         }
@@ -2094,7 +2118,8 @@ function _Variable_bind_with_simple_get(this: UAVariableImpl, options: GetterOpt
     });
 }
 
-function _Variable_bind_with_simple_set(this: UAVariableImpl, options: any) {
+type SimpleSetOptions = { set?: SetFunc; timestamped_set: undefined };
+function _Variable_bind_with_simple_set(this: UAVariableImpl, options: SimpleSetOptions) {
     assert(this instanceof UAVariableImpl);
     assert(typeof options.set === "function", "should specify set function");
     assert(!options.timestamped_set, "should not specify a timestamped_set function");
@@ -2102,7 +2127,9 @@ function _Variable_bind_with_simple_set(this: UAVariableImpl, options: any) {
     assert(!this._timestamped_set_func);
     assert(!this._set_func);
 
-    this._set_func = turn_sync_to_async(options.set, 1);
+    //
+    this._set_func = turn_sync_to_async(options.set!, 1);
+
     assert(this._set_func.length === 2, " set function must have 2 arguments ( variant, callback)");
 
     this._timestamped_set_func = (
@@ -2149,9 +2176,13 @@ interface SetterOptions {
     timestamped_get?: TimestampGetFunc;
 }
 function bind_setter(this: UAVariableImpl, options: SetterOptions) {
-    if (typeof options.set === "function") {
+    if (options.set && typeof options.set === "function") {
         // variation 1
-        _Variable_bind_with_simple_set.call(this, options);
+        if (options.timestamped_set === undefined) {
+            _Variable_bind_with_simple_set.call(this, options as SimpleSetOptions);
+        } else {
+            throw new Error("bind_setter : options should not specify both set and timestamped_set ");
+        }
     } else if (typeof options.timestamped_set === "function") {
         // variation 2
         assert(typeof options.timestamped_get === "function", "timestamped_set must be used with timestamped_get ");
@@ -2174,10 +2205,11 @@ function bind_setter(this: UAVariableImpl, options: SetterOptions) {
     }
 }
 
+type RefreshFunc = (callback: CallbackT<DataValue>) => void;
 interface GetterOptions {
     get?: GetFunc;
     timestamped_get?: TimestampGetFunc;
-    refreshFunc?: (callback: CallbackT<DataValue>) => void;
+    refreshFunc?: RefreshFunc;
     dataType?: DataType | string;
     value?: any;
 }
@@ -2193,7 +2225,10 @@ function bind_getter(this: UAVariableImpl, options: GetterOptions) {
         });
     } else if (typeof options.refreshFunc === "function") {
         // variation 3
-        _Variable_bind_with_async_refresh.call(this, options);
+        if (options.get !== undefined || options.timestamped_get !== undefined) {
+            throw new Error("bind_getter : options should not specify both get and timestamped_get ");
+        }
+        _Variable_bind_with_async_refresh.call(this, { refreshFunc: options.refreshFunc! });
     } else {
         assert(
             !Object.prototype.hasOwnProperty.call(options, "set"),