node-opcua-address-space 2.139.0 → 2.141.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.139.0",
+    "version": "2.141.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -18,18 +18,17 @@
     "dependencies": {
         "@types/lodash": "4.17.13",
         "@types/semver": "^7.5.8",
-        "async": "^3.2.6",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.139.0",
+        "node-opcua-address-space-base": "2.141.0",
         "node-opcua-assert": "2.139.0",
         "node-opcua-basic-types": "2.139.0",
         "node-opcua-binary-stream": "2.139.0",
-        "node-opcua-client-dynamic-extension-object": "2.139.0",
+        "node-opcua-client-dynamic-extension-object": "2.141.0",
         "node-opcua-constants": "2.139.0",
         "node-opcua-crypto": "4.15.0",
-        "node-opcua-data-access": "2.139.0",
+        "node-opcua-data-access": "2.141.0",
         "node-opcua-data-model": "2.139.0",
         "node-opcua-data-value": "2.139.0",
         "node-opcua-date-time": "2.139.0",
@@ -38,23 +37,23 @@
         "node-opcua-extension-object": "2.139.0",
         "node-opcua-factory": "2.139.0",
         "node-opcua-nodeid": "2.139.0",
-        "node-opcua-nodeset-ua": "2.139.0",
+        "node-opcua-nodeset-ua": "2.141.0",
         "node-opcua-numeric-range": "2.139.0",
         "node-opcua-object-registry": "2.139.0",
-        "node-opcua-pseudo-session": "2.139.0",
-        "node-opcua-service-browse": "2.139.0",
-        "node-opcua-service-call": "2.139.0",
-        "node-opcua-service-history": "2.139.0",
-        "node-opcua-service-translate-browse-path": "2.139.0",
-        "node-opcua-service-write": "2.139.0",
+        "node-opcua-pseudo-session": "2.141.0",
+        "node-opcua-service-browse": "2.141.0",
+        "node-opcua-service-call": "2.141.0",
+        "node-opcua-service-history": "2.141.0",
+        "node-opcua-service-translate-browse-path": "2.141.0",
+        "node-opcua-service-write": "2.141.0",
         "node-opcua-status-code": "2.139.0",
-        "node-opcua-types": "2.139.0",
+        "node-opcua-types": "2.141.0",
         "node-opcua-utils": "2.139.0",
         "node-opcua-variant": "2.139.0",
-        "node-opcua-xml2json": "2.139.0",
+        "node-opcua-xml2json": "2.141.0",
         "semver": "^7.6.3",
         "set-prototype-of": "^1.0.0",
-        "thenify": "^3.3.1",
+        "thenify-ex": "4.2.0",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
@@ -62,8 +61,8 @@
         "node-opcua-leak-detector": "2.139.0",
         "node-opcua-nodesets": "2.139.0",
         "node-opcua-packet-analyzer": "2.139.0",
-        "node-opcua-service-filter": "2.139.0",
-        "node-opcua-test-fixtures": "2.139.0",
+        "node-opcua-service-filter": "2.141.0",
+        "node-opcua-test-fixtures": "2.141.0",
         "source-map-support": "^0.5.21"
     },
     "author": "Etienne Rossignon",
@@ -81,7 +80,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "b7a01d31c7602d323e60a5f4a54428199a266f29",
+    "gitHead": "7467e145ce9ebad2c80cabb096189bda7714083d",
     "files": [
         "dist",
         "distHelpers",

package/source/helpers/call_helpers.ts

@@ -8,7 +8,6 @@ import { CallMethodRequest } from "node-opcua-service-call";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { CallMethodResultOptions } from "node-opcua-types";
 import { Variant } from "node-opcua-variant";
-import { ResponseCallback } from "node-opcua-pseudo-session";
 import { ISessionContext, IAddressSpace, UAMethod, UAObject } from "node-opcua-address-space-base";
 
 import { getMethodDeclaration_ArgumentList, verifyArguments_ArgumentList } from "./argument_list";
@@ -30,12 +29,11 @@ import { resolveOpaqueOnAddressSpace } from "./resolve_opaque_on_address_space";
 //                               A server shall accept a ByteString if an array of Byte is expected.
 // BadNoCommunication
 
-export function callMethodHelper(
+export async function callMethodHelper(
     context: ISessionContext,
     addressSpace: IAddressSpace,
-    callMethodRequest: CallMethodRequest,
-    callback: ResponseCallback<CallMethodResultOptions>
-): void {
+    callMethodRequest: CallMethodRequest
+): Promise<CallMethodResultOptions> {
     const objectId = callMethodRequest.objectId;
     const methodId = callMethodRequest.methodId;
     const inputArguments = callMethodRequest.inputArguments || [];
@@ -45,24 +43,24 @@ export function callMethodHelper(
 
     const object = addressSpace.findNode(objectId) as UAObject;
     if (!object) {
-        return callback(null, { statusCode: StatusCodes.BadNodeIdUnknown });
+        return { statusCode: StatusCodes.BadNodeIdUnknown };
     }
     if (object.nodeClass !== NodeClass.Object && object.nodeClass !== NodeClass.ObjectType) {
-        return callback(null, { statusCode: StatusCodes.BadNodeIdInvalid });
+        return { statusCode: StatusCodes.BadNodeIdInvalid };
     }
 
     const methodObj = addressSpace.findNode(methodId) as UAMethod;
     if (!methodObj) {
-        return callback(null, { statusCode: StatusCodes.BadMethodInvalid });
+        return { statusCode: StatusCodes.BadMethodInvalid };
     }
     if (methodObj.nodeClass !== NodeClass.Method) {
-        return callback(null, { statusCode: StatusCodes.BadMethodInvalid });
+        return { statusCode: StatusCodes.BadMethodInvalid };
     }
 
     const response1 = getMethodDeclaration_ArgumentList(addressSpace, objectId, methodId);
 
     if (response1.statusCode.isNotGood()) {
-        return callback(null, { statusCode: response1.statusCode });
+        return { statusCode: response1.statusCode };
     }
     const methodDeclaration = response1.methodDeclaration!;
 
@@ -71,41 +69,34 @@ export function callMethodHelper(
 
     const response = verifyArguments_ArgumentList(addressSpace, methodInputArguments, inputArguments);
     if (response.statusCode.isNotGood()) {
-        return callback(null, response);
+        return response;
+    }
+
+
+    try {
+        await resolveOpaqueOnAddressSpace(addressSpace, inputArguments);
+
+        const callMethodResponse = await methodObj.execute(
+            object,
+            inputArguments,
+            context);
+        callMethodResponse.inputArgumentResults =
+            callMethodResponse.inputArgumentResults || response.inputArgumentResults || [];
+        assert(callMethodResponse.statusCode);
+
+        if (callMethodResponse.statusCode?.isGood()) {
+            assert(Array.isArray(callMethodResponse.outputArguments));
+        }
+
+        assert(Array.isArray(callMethodResponse.inputArgumentResults));
+        assert(callMethodResponse.inputArgumentResults!.length === methodInputArguments.length);
+
+        const outputArguments = callMethodResponse.outputArguments || [];
+        await resolveOpaqueOnAddressSpace(addressSpace, outputArguments as Variant[]);
+
+        return callMethodResponse;
+    } catch (err) {
+        return { statusCode: StatusCodes.BadInternalError };
     }
 
-    resolveOpaqueOnAddressSpace(addressSpace, inputArguments)
-        .then(() => {
-            methodObj.execute(
-                object,
-                inputArguments,
-                context,
-                (err: Error | null, callMethodResponse?: CallMethodResultOptions) => {
-                    /* istanbul ignore next */
-                    if (err) {
-                        return callback(err);
-                    }
-                    if (!callMethodResponse) {
-                        return callback(new Error("internal Error"));
-                    }
-
-                    callMethodResponse.inputArgumentResults =
-                        callMethodResponse.inputArgumentResults || response.inputArgumentResults || [];
-                    assert(callMethodResponse.statusCode);
-
-                    if (callMethodResponse.statusCode?.isGood()) {
-                        assert(Array.isArray(callMethodResponse.outputArguments));
-                    }
-
-                    assert(Array.isArray(callMethodResponse.inputArgumentResults));
-                    assert(callMethodResponse.inputArgumentResults!.length === methodInputArguments.length);
-
-                    const outputArguments = callMethodResponse.outputArguments || [];
-                    resolveOpaqueOnAddressSpace(addressSpace, outputArguments as Variant[])
-                        .then(() => callback(null, callMethodResponse))
-                        .catch(callback);
-                }
-            );
-        })
-        .catch((err) => callback(err));
 }

package/source/pseudo_session.ts

@@ -2,8 +2,6 @@
  * @module node-opcua-address-space
  */
 import { promisify } from "util";
-import async from "async";
-
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
 import { make_errorLog } from "node-opcua-debug";
@@ -198,38 +196,26 @@ export class PseudoSession implements IBasicSession {
         const _nodesToRead = nodesToRead as ReadValueIdOptions[];
         const context = this[$context];
 
-        setImmediate(() => {
-            async.map(
-                _nodesToRead,
-                (nodeToRead: ReadValueIdOptions, innerCallback: any) => {
-                    const obj = this[$addressSpace].findNode(nodeToRead.nodeId!);
-                    if (!obj || obj.nodeClass !== NodeClass.Variable || nodeToRead.attributeId !== AttributeIds.Value) {
-                        return innerCallback();
-                    }
-                    (obj as UAVariable).readValueAsync(context, innerCallback);
-                },
-                (err) => {
-                    const dataValues = _nodesToRead.map((nodeToRead: ReadValueIdOptions) => {
-                        assert(!!nodeToRead.nodeId, "expecting a nodeId");
-                        assert(!!nodeToRead.attributeId, "expecting a attributeId");
-
-                        const nodeId = nodeToRead.nodeId!;
-                        const attributeId = nodeToRead.attributeId!;
-                        const indexRange = nodeToRead.indexRange;
-                        const dataEncoding = nodeToRead.dataEncoding;
-                        const obj = this[$addressSpace].findNode(nodeId);
-                        if (!obj) {
-                            return new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown });
-                        }
-                        const context = this[$context];
-                        const dataValue = obj.readAttribute(context, attributeId, indexRange, dataEncoding);
-                        return dataValue;
-                    });
-
-                    callback!(null, isArray ? dataValues : dataValues[0]);
-                }
-            );
-        });
+        const readV = async (nodeToRead: ReadValueIdOptions): Promise<DataValue> => {
+            const obj = this[$addressSpace].findNode(nodeToRead.nodeId!);
+            if (!obj) {
+                return new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown });
+            }
+            // refresh the variable value if the attribute to read is the Value attribute
+            if (obj.nodeClass === NodeClass.Variable && nodeToRead.attributeId == AttributeIds.Value) {
+                (obj as UAVariable).readValueAsync(context);
+            }
+            assert(!!nodeToRead.nodeId, "expecting a nodeId");
+            assert(!!nodeToRead.attributeId, "expecting a attributeId");
+            const attributeId = nodeToRead.attributeId!;
+            const indexRange = nodeToRead.indexRange;
+            const dataEncoding = nodeToRead.dataEncoding;
+            const dataValue = obj.readAttribute(context, attributeId, indexRange, dataEncoding);
+            return dataValue;
+        };
+        Promise.all(_nodesToRead.map(async (nodeToRead: ReadValueIdOptions) => await readV(nodeToRead)))
+            .then((dataValues) => callback!(null, isArray ? dataValues : dataValues[0]))
+            .catch((err) => callback!(err));
     }
 
     public browseNext(
@@ -280,34 +266,24 @@ export class PseudoSession implements IBasicSession {
         if (!isArray) {
             methodsToCall = [methodsToCall as CallMethodRequestLike];
         }
-
-        async.map(
-            methodsToCall as CallMethodRequestLike[],
-            (methodToCall, innerCallback: (err: Error | null, result?: CallMethodResult) => void) => {
-                const callMethodRequest = new CallMethodRequest(methodToCall);
-
-                callMethodHelper(
-                    this[$context],
-                    this[$addressSpace],
-                    callMethodRequest,
-                    (err: Error | null, result?: CallMethodResultOptions) => {
-                        let callMethodResult: CallMethodResult;
-                        if (err) {
-                            errorLog("Internal Error = ", err);
-                            callMethodResult = new CallMethodResult({
-                                statusCode: StatusCodes.BadInternalError
-                            });
-                        } else {
-                            callMethodResult = new CallMethodResult(result);
-                        }
-                        innerCallback(null, callMethodResult);
-                    }
-                );
-            },
-            (err?: Error | null, callMethodResults?: any) => {
-                callback!(null, isArray ? callMethodResults! : callMethodResults![0]);
+        Promise.all((methodsToCall as CallMethodRequestLike[]).map(async (methodToCall) => {
+            const callMethodRequest = new CallMethodRequest(methodToCall);
+            try {
+                const result = await callMethodHelper(this[$context], this[$addressSpace], callMethodRequest);
+                return new CallMethodResult(result);
+            } catch (err) {
+                errorLog("Internal Error = ", err);
+                return new CallMethodResult({
+                    statusCode: StatusCodes.BadInternalError
+                });
             }
-        );
+        }))
+            .then((callMethodResults) => {
+                callback!(null, isArray ? callMethodResults : callMethodResults[0]);
+            })
+            .catch((err) => {
+                callback!(err);
+            });
     }
 
     public getArgumentDefinition(methodId: MethodId): Promise<ArgumentDefinition>;
@@ -373,11 +349,11 @@ export class PseudoSession implements IBasicSession {
 
 // tslint:disable:no-var-requires
 // tslint:disable:max-line-length
-const thenify = require("thenify");
-PseudoSession.prototype.read = thenify.withCallback(PseudoSession.prototype.read);
-PseudoSession.prototype.write = thenify.withCallback(PseudoSession.prototype.write);
-PseudoSession.prototype.browse = thenify.withCallback(PseudoSession.prototype.browse);
-PseudoSession.prototype.browseNext = thenify.withCallback(PseudoSession.prototype.browseNext);
-PseudoSession.prototype.getArgumentDefinition = thenify.withCallback(PseudoSession.prototype.getArgumentDefinition);
-PseudoSession.prototype.call = thenify.withCallback(PseudoSession.prototype.call);
-PseudoSession.prototype.translateBrowsePath = thenify.withCallback(PseudoSession.prototype.translateBrowsePath);
+import { withCallback } from "thenify-ex";
+PseudoSession.prototype.read = withCallback(PseudoSession.prototype.read);
+PseudoSession.prototype.write = withCallback(PseudoSession.prototype.write);
+PseudoSession.prototype.browse = withCallback(PseudoSession.prototype.browse);
+PseudoSession.prototype.browseNext = withCallback(PseudoSession.prototype.browseNext);
+PseudoSession.prototype.getArgumentDefinition = withCallback(PseudoSession.prototype.getArgumentDefinition);
+PseudoSession.prototype.call = withCallback(PseudoSession.prototype.call);
+PseudoSession.prototype.translateBrowsePath = withCallback(PseudoSession.prototype.translateBrowsePath);

package/src/ua_method_impl.ts

@@ -307,5 +307,5 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
 
 // tslint:disable:no-var-requires
 // tslint:disable:max-line-length
-const thenify = require("thenify");
-UAMethodImpl.prototype.execute = thenify.withCallback(UAMethodImpl.prototype.execute);
+import { withCallback } from "thenify-ex";
+UAMethodImpl.prototype.execute = withCallback(UAMethodImpl.prototype.execute);

package/src/ua_variable_impl.ts

@@ -1854,12 +1854,12 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 }
 
 // tslint:disable:no-var-requires
-const thenify = require("thenify");
-UAVariableImpl.prototype.asyncRefresh = thenify.withCallback(UAVariableImpl.prototype.asyncRefresh);
-UAVariableImpl.prototype.writeValue = thenify.withCallback(UAVariableImpl.prototype.writeValue);
-UAVariableImpl.prototype.writeAttribute = thenify.withCallback(UAVariableImpl.prototype.writeAttribute);
-UAVariableImpl.prototype.historyRead = thenify.withCallback(UAVariableImpl.prototype.historyRead);
-UAVariableImpl.prototype.readValueAsync = thenify.withCallback(UAVariableImpl.prototype.readValueAsync);
+import { withCallback } from "thenify-ex";
+UAVariableImpl.prototype.asyncRefresh = withCallback(UAVariableImpl.prototype.asyncRefresh);
+UAVariableImpl.prototype.writeValue = withCallback(UAVariableImpl.prototype.writeValue);
+UAVariableImpl.prototype.writeAttribute = withCallback(UAVariableImpl.prototype.writeAttribute);
+UAVariableImpl.prototype.historyRead = withCallback(UAVariableImpl.prototype.historyRead);
+UAVariableImpl.prototype.readValueAsync = withCallback(UAVariableImpl.prototype.readValueAsync);
 
 export interface UAVariableImplExtArray {
     $$variableType?: UAVariableType;