node-opcua-address-space 2.187.12 → 2.187.16

package/dist/impl/ua_variable_impl.js

@@ -278,7 +278,7 @@ export class UAVariableImpl extends BaseNodeImpl {
             // Table 51: no encoding can be applied to a non-Structure value
             return makeNowDataValue({ statusCode: StatusCodes.BadDataEncodingInvalid });
         }
-        if (this._timestamped_get_func) {
+        if (this._timestamped_get_func && !this._getterIsAsync) {
             if (this._timestamped_get_func.length === 0) {
                 const dataValueOrPromise = this._timestamped_get_func();
                 if (!Object.hasOwn(dataValueOrPromise.constructor.prototype, "then")) {
@@ -350,7 +350,7 @@ export class UAVariableImpl extends BaseNodeImpl {
         const dataTypeNode = this.addressSpace.findDataType(this.dataType);
         return dataTypeNode._getEnumerationInfo();
     }
-    asyncRefresh(oldestDate, callback) {
+    asyncRefresh(oldestDate, callback, context) {
         // asyncRefresh is always invoked with a callback at runtime: the public overload without
         // a callback is only reachable through the withCallback() wrapper installed below, which
         // synthesizes one before calling into this implementation.
@@ -409,7 +409,7 @@ export class UAVariableImpl extends BaseNodeImpl {
                     this._internal_set_dataValue(refreshed, null);
                 }
                 cb(err, this.$dataValue);
-            });
+            }, context);
             answeredAtOnce = false;
         }
         catch (err) {
@@ -729,6 +729,11 @@ export class UAVariableImpl extends BaseNodeImpl {
         assert(write_func);
         write_func.call(this, dataValue, (err, statusCode1) => {
             if (!err) {
+                // a write the setter answers Bad did not happen: the stored value stays as it was
+                if (statusCode1?.isNotGood()) {
+                    callback?.(null, statusCode1);
+                    return;
+                }
                 dataValue && this.verifyVariantCompatibility(dataValue.value);
                 if (indexRange && !indexRange.isEmpty()) {
                     if (!indexRange.isValid()) {
@@ -791,7 +796,7 @@ export class UAVariableImpl extends BaseNodeImpl {
                 }
             }
             callback?.(err || null, statusCode1);
-        });
+        }, context, indexRange);
         return undefined;
     }
     writeAttribute(context, writeValueOptions, callback) {
@@ -1005,6 +1010,7 @@ export class UAVariableImpl extends BaseNodeImpl {
             this._set_func = null;
             this.refreshFunc = undefined;
             this._refreshFuncWrapsGetter = false;
+            this._getterIsAsync = false;
             this._historyRead = UAVariableImpl.prototype._historyRead;
         }
         options = options || {};
@@ -1034,37 +1040,26 @@ export class UAVariableImpl extends BaseNodeImpl {
             this._readValueAsync(context, (err, dataValue) => (err ? reject(err) : resolve(dataValue)));
         });
     }
-    _readValueAsync(context, callback, readAt) {
-        context = context || SessionContext.defaultContext;
-        if (this.__waiting_callback) {
-            // a refresh is in progress: its value answers this read too
-            this.__more_waiting_callbacks ??= [];
-            this.__more_waiting_callbacks.push(callback);
-            return;
-        }
-        if (this.isDisposed()) {
-            callback?.(null, new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown }));
-            return;
-        }
-        this.__waiting_callback = callback;
-        // runs once per sample of every monitored item, so nothing here allocates a closure or
-        // binds a function: the denial (if any) is a StatusCode, and the callback that releases
-        // the waiting readers is made once per variable
-        let denied = null;
+    /**
+     * why this context may not read the Value, or null when it may: the gates of readValue(),
+     * applied to every read of readValueAsync, including one that joins a refresh in flight.
+     * Runs once per sample of every monitored item: it allocates nothing
+     */
+    _readDenial(context) {
         if (context.isAccessRestricted(this)) {
             // same gate as readValue(): a variable bound with a simple get()
             // also gets a refreshFunc, sending every read down the asyncRefresh
-            // branch below - which calls the getter directly and never passes
+            // branch of _readValueAsync - which calls the getter directly and never passes
             // through readValue(). Without this check here, a node hardened
             // with AccessRestrictions(EncryptionRequired) answered its value
             // over an unencrypted channel.
-            denied = StatusCodes.BadSecurityModeInsufficient;
+            return StatusCodes.BadSecurityModeInsufficient;
         }
         else if (!this.isReadable(context)) {
-            denied = StatusCodes.BadNotReadable;
+            return StatusCodes.BadNotReadable;
         }
         else if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
-            denied = StatusCodes.BadUserAccessDenied;
+            return StatusCodes.BadUserAccessDenied;
         }
         else if (
         // as in readValue(): the Read permission has just passed, only the access level is
@@ -1072,8 +1067,33 @@ export class UAVariableImpl extends BaseNodeImpl {
         this.isUserReadable === UAVariableImpl.prototype.isUserReadable
             ? !this.checkAccessLevelPrivate(context, AccessLevelFlag.CurrentRead)
             : !this.isUserReadable(context)) {
-            denied = StatusCodes.BadNotReadable;
+            return StatusCodes.BadNotReadable;
+        }
+        return null;
+    }
+    _readValueAsync(context, callback, readAt) {
+        context = context || SessionContext.defaultContext;
+        if (this.__waiting_callback) {
+            // a refresh is in progress: its value answers this read too, once this read's own
+            // access checks have passed (they depend on its context, not on the first reader's)
+            const joinerDenied = this._readDenial(context);
+            if (joinerDenied) {
+                callback(null, makeNowDataValue({ statusCode: joinerDenied }));
+                return;
+            }
+            this.__more_waiting_callbacks ??= [];
+            this.__more_waiting_callbacks.push(callback);
+            return;
+        }
+        if (this.isDisposed()) {
+            callback?.(null, new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown }));
+            return;
         }
+        this.__waiting_callback = callback;
+        // runs once per sample of every monitored item, so nothing here allocates a closure or
+        // binds a function: the denial (if any) is a StatusCode, and the callback that releases
+        // the waiting readers is made once per variable
+        const denied = this._readDenial(context);
         this.__satisfy_waiting_callbacks ??= (err, dataValue) => {
             // now call all pending callbacks, in the order of the reads
             const first = this.__waiting_callback;
@@ -1099,10 +1119,10 @@ export class UAVariableImpl extends BaseNodeImpl {
                 this.__sharedReadClock = readAt !== undefined;
                 if (this.asyncRefresh === wrappedAsyncRefresh) {
                     // the thenified wrapper adds nothing when a callback is given
-                    asyncRefreshImpl.call(this, clock, satisfy_callbacks);
+                    asyncRefreshImpl.call(this, clock, satisfy_callbacks, context);
                 }
                 else {
-                    this.asyncRefresh(clock, satisfy_callbacks);
+                    this.asyncRefresh(clock, satisfy_callbacks, context);
                 }
                 // consumed by asyncRefresh on entry; cleared here for an overridden one that never reads it
                 this.__sharedReadClock = false;
@@ -1711,7 +1731,17 @@ import { withCallback } from "thenify-ex";
 // readValueAsync calls the unwrapped asyncRefresh directly: binding the thenified wrapper on
 // every sample cost more than the refresh itself
 const asyncRefreshImpl = UAVariableImpl.prototype.asyncRefresh;
-UAVariableImpl.prototype.asyncRefresh = withCallback(asyncRefreshImpl);
+// the promise form when no callback is given, as withCallback() does: written out because that
+// wrapper takes the last argument for the callback, and the context comes after it
+UAVariableImpl.prototype.asyncRefresh = function (oldestDate, callback, context) {
+    if (typeof callback === "function") {
+        asyncRefreshImpl.call(this, oldestDate, callback, context);
+        return undefined;
+    }
+    return new Promise((resolve, reject) => {
+        asyncRefreshImpl.call(this, oldestDate, (err, dataValue) => (err ? reject(err) : resolve(dataValue)), context);
+    });
+};
 const wrappedAsyncRefresh = UAVariableImpl.prototype.asyncRefresh;
 UAVariableImpl.prototype.writeValue = withCallback(UAVariableImpl.prototype.writeValue);
 UAVariableImpl.prototype.writeAttribute = withCallback(UAVariableImpl.prototype.writeAttribute);
@@ -1822,7 +1852,8 @@ function turn_sync_to_async(f, numberOfArgs) {
         };
     }
     else {
-        assert(f.length === numberOfArgs + 1);
+        // a callback-style function; it may declare the trailing context and indexRange parameters
+        assert(f.length >= numberOfArgs + 1 && f.length <= numberOfArgs + 3);
         return f;
     }
 }
@@ -1901,14 +1932,16 @@ function _Variable_bind_with_timestamped_get(options) {
                 "\n value_check.constructor.name ", dataValue_verify ? dataValue_verify.constructor.name : "null");
             throw new Error(" Bind variable error: " + " the timestamped_get function must return a DataValue");
         }
+        this._getterIsAsync = isThenable(dataValue_verify);
         _Variable_bind_with_async_refresh.call(this, { refreshFunc: async_refresh_func });
     }
-    else if (options.timestamped_get.length === 1) {
+    else if (options.timestamped_get.length === 1 || options.timestamped_get.length === 2) {
+        // callback style: (callback) or (callback, context)
         _Variable_bind_with_async_refresh.call(this, { refreshFunc: options.timestamped_get });
     }
     else {
-        errorLog("timestamped_get has a invalid number of argument , should be 0 or 1  ");
-        throw new Error("timestamped_get has a invalid number of argument , should be 0 or 1  ");
+        errorLog("timestamped_get has a invalid number of argument , should be 0, 1 or 2  ");
+        throw new Error("timestamped_get has a invalid number of argument , should be 0, 1 or 2  ");
     }
 }
 // variation 1
@@ -1957,8 +1990,9 @@ function _Variable_bind_with_simple_set(options) {
     //
     const set_func = turn_sync_to_async(options.set, 1);
     this._set_func = set_func;
-    assert(set_func.length === 2, " set function must have 2 arguments ( variant, callback)");
-    this._timestamped_set_func = (timestamped_value, callback) => {
+    assert(set_func.length >= 2, " set function must have 2 arguments ( variant, callback)");
+    // the trailing arguments (context, indexRange) are a rest parameter so that the length stays 2
+    this._timestamped_set_func = (timestamped_value, callback, ...extra) => {
         assert(timestamped_value instanceof DataValue);
         set_func.call(this, timestamped_value.value, (err, statusCode) => {
             // c8 ignore next
@@ -1967,30 +2001,45 @@ function _Variable_bind_with_simple_set(options) {
                 errorLog(chalk.yellow("StatusCode.Good is assumed"));
                 return callback(err, StatusCodes.Good, timestamped_value);
             }
-            if (statusCode?.isNotGood()) {
-                // record the value but still record the statusCode !
-                timestamped_value.statusCode = statusCode;
-            }
             callback(err, statusCode ?? StatusCodes.BadInternalError, timestamped_value);
-        });
+        }, ...extra);
     };
 }
 function _Variable_bind_with_timestamped_set(options) {
-    assert(options.timestamped_set.length === 2 || options.timestamped_set.length === 1, "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){} or one paramater  timestamped_set: function(dataValue): Promise<StatusCode>{}");
+    assert(options.timestamped_set.length >= 1 && options.timestamped_set.length <= 4, "timestamped_set must have 2 parameters  timestamped_set: function(dataValue,callback){} or one paramater  timestamped_set: function(dataValue): Promise<StatusCode>{}");
     assert(!options.set, "should not specify set when timestamped_set_func exists ");
     // the callback form of a setter is a stateless wrapper around it (it takes the variable as
     // `this`): one per setter function, not one per variable. Every writable variable without a
     // setter of its own binds the same default, and a closure per variable was 110 bytes each
     let setter = callbackSetters.get(options.timestamped_set);
     if (!setter) {
-        setter = convertToCallbackFunction1(options.timestamped_set);
+        setter = convertToCallbackFunction1(options.timestamped_set, 2);
         callbackSetters.set(options.timestamped_set, setter);
     }
     this._timestamped_set_func = setter;
 }
 /** the callback form of each setter function met so far, see _Variable_bind_with_timestamped_set */
 const callbackSetters = new WeakMap();
+/** an asynchronous setter that is told who writes (`timestamped_set_ctx`) */
+function _Variable_bind_with_context_setter(setter) {
+    // the context and the index range come after the callback, in a rest parameter: the length stays 2
+    this._timestamped_set_func = function (dataValue, callback, ...extra) {
+        const [context, indexRange] = extra;
+        let promise;
+        try {
+            promise = setter.call(this, dataValue, { context, indexRange });
+        }
+        catch (err) {
+            callback(err);
+            return;
+        }
+        Promise.resolve(promise).then((statusCode) => callback(null, statusCode), (err) => callback(err));
+    };
+}
 function bind_setter(options) {
+    if (options.timestamped_set && options.timestamped_set_ctx) {
+        throw new Error("bind_setter : options should not specify both timestamped_set and timestamped_set_ctx ");
+    }
     if (options.set && typeof options.set === "function") {
         // variation 1
         if (options.timestamped_set === undefined) {
@@ -2008,8 +2057,13 @@ function bind_setter(options) {
             timestamped_set: options.timestamped_set
         });
     }
-    else if (typeof options.timestamped_get === "function") {
-        // timestamped_get is  specified but timestamped_set is not
+    else if (typeof options.timestamped_set_ctx === "function") {
+        // variation 5: the setter is told who writes
+        assert(typeof options.timestamped_get === "function" || typeof options.timestamped_get_ctx === "function", "timestamped_set_ctx must be used with timestamped_get or timestamped_get_ctx");
+        _Variable_bind_with_context_setter.call(this, options.timestamped_set_ctx);
+    }
+    else if (typeof options.timestamped_get === "function" || typeof options.timestamped_get_ctx === "function") {
+        // a timestamped getter is specified but no setter
         // => Value is read-only
         _Variable_bind_with_timestamped_set.call(this, {
             set: undefined,
@@ -2023,6 +2077,28 @@ function bind_setter(options) {
         });
     }
 }
+/**
+ * variation 5: an asynchronous getter that is told who reads (`timestamped_get_ctx`). It is run by
+ * the refresh only, like any asynchronous getter, with the session context of the read.
+ */
+function _Variable_bind_with_context_getter(getter) {
+    _Variable_bind_with_async_refresh.call(this, {
+        refreshFunc: (callback, context) => {
+            let promise;
+            try {
+                promise = getter.call(this, { context });
+            }
+            catch (err) {
+                callback(err);
+                return;
+            }
+            Promise.resolve(promise).then((dataValue) => callback(null, dataValue), (err) => {
+                errorLog("timestamped_get_ctx error: Variable is ", this.nodeId.toString(), this.browseName.toString());
+                callback(err);
+            });
+        }
+    });
+}
 function bind_getter(options) {
     if (typeof options.get === "function") {
         // variation 1
@@ -2035,6 +2111,10 @@ function bind_getter(options) {
             timestamped_get: options.timestamped_get
         });
     }
+    else if (typeof options.timestamped_get_ctx === "function") {
+        // variation 5
+        _Variable_bind_with_context_getter.call(this, options.timestamped_get_ctx);
+    }
     else if (typeof options.refreshFunc === "function") {
         // variation 3
         if (options.get !== undefined || options.timestamped_get !== undefined) {