node-opcua-address-space 2.120.0 → 2.121.0

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"),