node-opcua-client-proxy 2.139.0 → 2.141.0

package/source/object_explorer.ts

@@ -1,19 +1,18 @@
 /**
  * @module node-opcua-client-proxy
  */
-import async from "async";
 
 import { assert } from "node-opcua-assert";
-import { Callback, ErrorCallback } from "node-opcua-status-code";
 import { AttributeIds, BrowseDirection, makeNodeClassMask, makeResultMask } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import { ArgumentDefinition, IBasicSessionReadCallback, IBasicSessionBrowseCallback } from "node-opcua-pseudo-session";
-import { BrowseResult, ReferenceDescription } from "node-opcua-service-browse";
-import { CallMethodRequest, CallMethodResult, Argument } from "node-opcua-service-call";
-import { StatusCodes } from "node-opcua-status-code";
+import {
+    IBasicSessionReadAsyncSimple,
+    IBasicSessionBrowseAsyncSimple
+} from "node-opcua-pseudo-session";
+import { ReferenceDescription } from "node-opcua-service-browse";
+import { CallMethodRequest, Argument } from "node-opcua-service-call";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { DataType, Variant, VariantArrayType, VariantLike } from "node-opcua-variant";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
 import { make_errorLog, make_debugLog } from "node-opcua-debug";
 import { DataTypeIds } from "node-opcua-constants";
 
@@ -22,7 +21,6 @@ import { UAProxyManager } from "./proxy_manager";
 import { ProxyVariable } from "./proxy_variable";
 import { MethodDescription, ArgumentEx } from "./proxy_base_node";
 
-
 const doDebug = false;
 const errorLog = make_errorLog("Proxy");
 const debugLog = make_debugLog("Proxy");
@@ -61,81 +59,55 @@ const resultMask = makeResultMask("ReferenceType | IsForward | BrowseName | Node
  *
  * for an enumeration dataType will be DataType.Int32
  */
-function convertNodeIdToDataTypeAsync(
-    session: IBasicSessionReadCallback & IBasicSessionBrowseCallback,
-    dataTypeId: NodeId,
-    callback: Callback<DataType>
-) {
+async function convertNodeIdToDataTypeAsync(
+    session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
+    dataTypeId: NodeId
+): Promise<DataType> {
     const nodeToRead = {
         attributeId: AttributeIds.BrowseName,
         nodeId: dataTypeId
     };
-    session.read(nodeToRead, (err: Error | null, dataValue?: DataValue) => {
-        // istanbul ignore next
-        if (err) {
-            setImmediate(() => {
-                callback(err);
-            });
-            return;
-        }
+    const dataValue = await session.read(nodeToRead);
+    let dataType: DataType;
+    // istanbul ignore next
+    if (dataValue.statusCode.isNotGood()) {
+        dataType = DataType.Null;
+        return dataType;
+    }
 
-        dataValue = dataValue!;
+    const dataTypeName = dataValue.value.value;
 
-        let dataType: DataType;
-        // istanbul ignore next
-        if (dataValue.statusCode.isNotGood()) {
-            dataType = DataType.Null;
-            setImmediate(() => {
-                callback(null, dataType);
-            });
-            return;
-        }
+    if (dataTypeId.namespace === 0 && dataTypeId.value === DataTypeIds.Enumeration) {
+        dataType = DataType.Int32;
+        return dataType;
+    }
 
-        const dataTypeName = dataValue.value.value;
+    if (dataTypeId.namespace === 0 && DataType[dataTypeId.value as number]) {
+        dataType = (DataType as any)[dataTypeId.value as number] as DataType;
+        return dataType;
+    }
 
-        if (dataTypeId.namespace === 0 && dataTypeId.value === DataTypeIds.Enumeration) {
-            dataType = DataType.Int32;
-            setImmediate(() => {
-                callback(null, dataType);
-            });
-            return;
-        }
+    /// example => Duration (i=290) => Double (i=11)
+    // read subTypeOf
+    const nodeToBrowse = {
+        browseDirection: BrowseDirection.Inverse,
+        includeSubtypes: false,
+        nodeId: dataTypeId,
+        // BrowseDescription
+        referenceTypeId: makeRefId("HasSubtype"),
+        // xx nodeClassMask: makeNodeClassMask("ObjectType"),
+        resultMask
+    };
+    // tslint:disable:no-shadowed-variable
+    const browseResult = await session.browse(nodeToBrowse);
 
-        if (dataTypeId.namespace === 0 && DataType[dataTypeId.value as number]) {
-            dataType = (DataType as any)[dataTypeId.value as number] as DataType;
-            setImmediate(() => {
-                callback(null, dataType);
-            });
-            return;
-        }
+    const references = browseResult!.references;
 
-        /// example => Duration (i=290) => Double (i=11)
-        // read subTypeOf
-        const nodeToBrowse = {
-            browseDirection: BrowseDirection.Inverse,
-            includeSubtypes: false,
-            nodeId: dataTypeId,
-            // BrowseDescription
-            referenceTypeId: makeRefId("HasSubtype"),
-            // xx nodeClassMask: makeNodeClassMask("ObjectType"),
-            resultMask
-        };
-        // tslint:disable:no-shadowed-variable
-        session.browse(nodeToBrowse, (err: Error | null, browseResult?: BrowseResult) => {
-            // istanbul ignore next
-            if (err) {
-                return callback(err);
-            }
-
-            const references = browseResult!.references;
-
-            if (!references || references.length !== 1) {
-                return callback(new Error("cannot find SuperType of " + dataTypeName.toString()));
-            }
-            const nodeId = references[0].nodeId;
-            return convertNodeIdToDataTypeAsync(session, nodeId, callback);
-        });
-    });
+    if (!references || references.length !== 1) {
+        throw new Error("cannot find SuperType of " + dataTypeName.toString());
+    }
+    const nodeId = references[0].nodeId;
+    return convertNodeIdToDataTypeAsync(session, nodeId);
 }
 
 function convertToVariant(value: unknown, arg: ArgumentEx, propName: string): Variant {
@@ -163,18 +135,13 @@ function convertToVariantArray(inputArgsDef: ArgumentEx[], inputArgs: Record<str
     return inputArguments;
 }
 
-const thenify = require("thenify");
+import { ProxyNode } from "./proxy_transition";
+import { StatusCode } from "node-opcua-status-code";
 
 function makeFunction(obj: any, methodName: string) {
-    return thenify.withCallback(function functionCaller(
-        this: any,
-        inputArgs: Record<string, unknown>,
-        callback: (err: Error | null, output?: Record<string, unknown>) => void
-    ) {
+    return async function functionCaller(this: any, inputArgs: Record<string, unknown>): Promise<{ statusCode: StatusCode, output?: Record<string, unknown> }> {
         const session = this.proxyManager.session;
 
-        assert(typeof callback === "function");
-
         const methodDef = this.$methods[methodName];
         // convert input arguments into Variants
         const inputArgsDef = methodDef.inputArguments || [];
@@ -187,60 +154,48 @@ function makeFunction(obj: any, methodName: string) {
             objectId: obj.nodeId
         });
 
-        session.call(methodToCall, (err: Error | null, callResult?: CallMethodResult) => {
-            // istanbul ignore next
-            if (err) {
-                return callback(err);
-            }
-
-            callResult = callResult!;
-
-            if (callResult.statusCode.isNotGood()) {
-                return callback(new Error("Error " + callResult.statusCode.toString()));
-            }
-
-            callResult.outputArguments = callResult.outputArguments || [];
-
-            if (callResult.outputArguments.length !== methodDef.outputArguments.length) {
-                return callback(
-                    new Error(
-                        "Internal error callResult.outputArguments.length " +
-                            callResult.outputArguments.length +
-                            " " +
-                            obj[methodName].outputArguments.length
-                    )
-                );
-            }
-            const output: Record<string, unknown> = {};
-            methodDef.outputArguments.map((arg: Argument, index: number) => {
-                const variant = callResult!.outputArguments![index];
-                const propName = lowerFirstLetter(arg.name!);
-                output[propName] = variant.value;
-            });
-
-            callback(err, output);
+        const callResult = await session.call(methodToCall);
+
+        if (callResult.statusCode.isNotGood()) {
+            return { statusCode: callResult.statusCode };
+        }
+
+        callResult.outputArguments = callResult.outputArguments || [];
+
+        if (callResult.outputArguments.length !== methodDef.outputArguments.length) {
+            throw new Error(
+                "Internal error callResult.outputArguments.length " +
+                    callResult.outputArguments.length +
+                    " " +
+                    obj[methodName].outputArguments.length
+            );
+        }
+        const output: Record<string, unknown> = {};
+        methodDef.outputArguments.map((arg: Argument, index: number) => {
+            const variant = callResult!.outputArguments![index];
+            const propName = lowerFirstLetter(arg.name!);
+            output[propName] = variant.value;
         });
-    });
+
+        return { statusCode: callResult.statusCode, output };
+    };
 }
 
-function extractDataType(session:  IBasicSessionReadCallback & IBasicSessionBrowseCallback, arg: ArgumentEx, callback: ErrorCallback): void {
+async function extractDataType(
+    session: IBasicSessionReadAsyncSimple & IBasicSessionBrowseAsyncSimple,
+    arg: ArgumentEx
+): Promise<void> {
     if (arg.dataType && arg._basicDataType) {
-        setImmediate(callback); // already converted
         return;
     }
-
-    convertNodeIdToDataTypeAsync(session, arg.dataType, (err?: Error | null, dataType?: DataType) => {
-        if (!err) {
-            arg._basicDataType = dataType!;
-        }
-        callback(err || undefined);
-    });
+    const dataType = await convertNodeIdToDataTypeAsync(session, arg.dataType);
+    arg._basicDataType = dataType!;
 }
 /**
-
+ 
  * @private
  */
-function add_method(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription, outerCallback: (err?: Error) => void) {
+async function add_method(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription): Promise<void> {
     const session = proxyManager.session;
 
     const methodName = lowerFirstLetter(reference.browseName.name!);
@@ -249,93 +204,52 @@ function add_method(proxyManager: UAProxyManager, obj: any, reference: Reference
     let outputArguments: ArgumentEx[] = [];
 
     // tslint:disable:no-shadowed-variable
-    async.series(
-        [
-            (callback: ErrorCallback) => {
-                session.getArgumentDefinition(reference.nodeId, (err, argumentDefinition) => {
-                    // istanbul ignore next
-                    if (err) {
-                        errorLog("getArgumentDefinition failed ", err);
-                        return callback(err);
-                    }
-                    // istanbul ignore next
-                    if (!argumentDefinition) {
-                        return callback(new Error("Internal Error"));
-                    }
-                    inputArguments = (argumentDefinition.inputArguments as ArgumentEx[]) || [];
-                    outputArguments = (argumentDefinition.outputArguments as ArgumentEx[]) || [];
-
-                    const _extractDataType = extractDataType.bind(null, session);
-                    async.series(
-                        [
-                            (innerCallback) => async.eachSeries(inputArguments, _extractDataType, innerCallback),
-                            (innerCallback) => async.eachSeries(outputArguments, _extractDataType, innerCallback)
-                        ],
-                        (err) => callback(err!)
-                    );
-                });
-            },
-
-            (callback: ErrorCallback) => {
-                const methodObj: MethodDescription = {
-                    browseName: methodName,
-                    executableFlag: false,
-                    func: makeFunction(obj, methodName),
-                    nodeId: reference.nodeId,
-                    inputArguments,
-                    outputArguments
-                };
-                obj.$methods[methodName] = methodObj;
-                obj[methodName] = methodObj.func;
-
-                obj[methodName].inputArguments = inputArguments;
-                obj[methodName].outputArguments = outputArguments;
-
-                doDebug && debugLog("installing method name", methodName);
-                proxyManager._monitor_execution_flag(methodObj, () => {
-                    callback();
-                });
-            }
-        ],
-        (err) => {
-            if (err) {
-                errorLog("Error =>", err);
-            }
-            outerCallback(err!);
-        }
-    );
-}
+    const argumentDefinition = await session.getArgumentDefinition(reference.nodeId);
+    inputArguments = (argumentDefinition.inputArguments as ArgumentEx[]) || [];
+    outputArguments = (argumentDefinition.outputArguments as ArgumentEx[]) || [];
 
-function add_component(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription, callback: (err?: Error) => void) {
-    const session = proxyManager.session;
+    const promises: Promise<void>[] = [];
+    for (const arg of inputArguments || []) {
+        promises.push(extractDataType(session, arg));
+    }
+    for (const arg of outputArguments || []) {
+        promises.push(extractDataType(session, arg));
+    }
+    await Promise.all(promises);
 
-    const name = lowerFirstLetter(reference.browseName.name || "");
+    const methodObj: MethodDescription = {
+        browseName: methodName,
+        executableFlag: false,
+        func: makeFunction(obj, methodName) as any,
+        nodeId: reference.nodeId,
+        inputArguments,
+        outputArguments
+    };
+    obj.$methods[methodName] = methodObj;
+    obj[methodName] = methodObj.func;
 
-    proxyManager.getObject(reference.nodeId, (err?: Error | null, childObj?: any) => {
-        // istanbul ignore else
-        if (!err) {
-            childObj = new ObjectExplorer({
-                name,
-                nodeId: reference.nodeId,
-                parent: obj,
-                proxyManager
-            });
-            obj[name] = childObj;
-            obj.$components.push(childObj);
-
-            childObj.$resolve(callback);
-        } else {
-            callback(err);
-        }
+    obj[methodName].inputArguments = inputArguments;
+    obj[methodName].outputArguments = outputArguments;
+
+    doDebug && debugLog("installing method name", methodName);
+    await proxyManager._monitor_execution_flag(methodObj);
+}
+
+async function add_component(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription): Promise<void> {
+    const name = lowerFirstLetter(reference.browseName.name || "");
+    let childObj1 = await proxyManager.getObject(reference.nodeId);
+    const childObj = new ObjectExplorer({
+        name,
+        nodeId: reference.nodeId,
+        parent: obj,
+        proxyManager
     });
+    obj[name] = childObj;
+    obj.$components.push(childObj);
+    await childObj.$resolve();
 }
 
-function addFolderElement(
-    proxyManager: UAProxyManager,
-    obj: any,
-    reference: ReferenceDescription,
-    callback: (err?: Error) => void
-) {
+async function addFolderElement(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription): Promise<void> {
     const session = proxyManager.session;
 
     const name = lowerFirstLetter(reference.browseName.name || "");
@@ -349,59 +263,39 @@ function addFolderElement(
 
     obj[name] = childObj;
     obj.$organizes.push(childObj);
-    childObj.$resolve(callback);
+    await childObj.$resolve();
 }
 
-function add_property(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription, callback: (err?: Error) => void) {
+async function add_property(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription): Promise<void> {
     const session = proxyManager.session;
 
     const name = lowerFirstLetter(reference.browseName.name || "");
 
     obj[name] = new ProxyVariable(proxyManager, reference.nodeId, reference);
     obj.$properties[name] = obj[name];
-
-    setImmediate(callback);
 }
 
-function add_typeDefinition(
-    proxyManager: UAProxyManager,
-    obj: any,
-    references: ReferenceDescription[],
-    callback: (err?: Error) => void
-): void {
+async function add_typeDefinition(proxyManager: UAProxyManager, obj: any, references: ReferenceDescription[]): Promise<void> {
     const session = proxyManager.session;
     references = references || [];
     if (references.length !== 1) {
-        setImmediate(callback);
         return;
     }
     const reference = references[0];
     assert(!obj.typeDefinition, "type definition can only be set once");
     obj.typeDefinition = reference.browseName.name || "";
-    setImmediate(callback);
 }
 
-function addFromState(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription, callback: (err?: Error) => void) {
-    proxyManager.getObject(reference.nodeId, (err: Error | null, childObj: any) => {
-        if (err) {
-            callback(err);
-        }
-        obj.$fromState = childObj;
-        callback();
-    });
+async function addFromState(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription): Promise<void> {
+    const childObj = await proxyManager.getObject(reference.nodeId);
+    obj.$fromState = childObj;
 }
 
-function addToState(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription, callback: (err?: Error) => void) {
-    proxyManager.getObject(reference.nodeId, (err: Error | null, childObj: any) => {
-        if (err) {
-            callback(err);
-        }
-        obj.$toState = childObj;
-        callback();
-    });
+async function addToState(proxyManager: UAProxyManager, obj: any, reference: ReferenceDescription): Promise<void> {
+    const childObj = await proxyManager.getObject(reference.nodeId);
+    obj.$toState = childObj;
 }
-
-export class ObjectExplorer {
+export class ObjectExplorer  {
     public proxyManager: UAProxyManager;
     public name: string;
     public nodeId: NodeId;
@@ -414,26 +308,19 @@ export class ObjectExplorer {
         this.parent = options.parent;
     }
 
-    public $resolve(callback: (err?: Error) => void): void {
-        this.proxyManager.getObject(this.nodeId, (err: Error | null, childObj: any) => {
-            // istanbul ignore next
-            if (err) {
-                return callback(err);
-            }
-
-            this.parent[this.name] = childObj;
-            this.parent.$components.push(childObj);
-
-            callback();
-        });
+    public async $resolve(): Promise<void> {
+        const childObj = await this.proxyManager.getObject(this.nodeId);
+        this.parent[this.name] = childObj;
+        this.parent.$components.push(childObj);
     }
 }
+
 function t(references: ReferenceDescription[] | null) {
     if (!references) return "";
     return references.map((r: ReferenceDescription) => r.browseName.name + " " + r.nodeId.toString());
 }
 
-export function readUAStructure(proxyManager: UAProxyManager, obj: { nodeId: NodeId }, callback: ErrorCallback): void {
+export async function readUAStructure(proxyManager: UAProxyManager, obj: { nodeId: NodeId }): Promise<ProxyNode> {
     const session = proxyManager.session;
 
     //   0   Object
@@ -441,7 +328,7 @@ export function readUAStructure(proxyManager: UAProxyManager, obj: { nodeId: Nod
     //   2   Method
     const nodeId = obj.nodeId;
     const nodesToBrowse = [
-        // Components (except Methods)
+        // 0. Components (except Methods)
         {
             // BrowseDescription
             browseDirection: BrowseDirection.Forward,
@@ -451,7 +338,7 @@ export function readUAStructure(proxyManager: UAProxyManager, obj: { nodeId: Nod
             referenceTypeId: makeRefId("HasComponent"),
             resultMask
         },
-        // Properties
+        // 1. Properties
         {
             // BrowseDescription
             browseDirection: BrowseDirection.Forward,
@@ -462,7 +349,7 @@ export function readUAStructure(proxyManager: UAProxyManager, obj: { nodeId: Nod
             resultMask
         },
 
-        // Methods
+        // 2.  Methods
         {
             // BrowseDescription
             browseDirection: BrowseDirection.Forward,
@@ -509,83 +396,38 @@ export function readUAStructure(proxyManager: UAProxyManager, obj: { nodeId: Nod
             resultMask
         }
     ];
-    session.browse(nodesToBrowse, (err: Error | null, browseResults?: BrowseResult[]) => {
-        browseResults = browseResults || [];
+    const browseResults = await session.browse(nodesToBrowse);
+    // istanbul ignore next
+    if (doDebug) {
+        debugLog("Components", t(browseResults[0].references));
+        debugLog("Properties", t(browseResults[1].references));
+        debugLog("Methods", t(browseResults[2].references));
+    }
 
-        // istanbul ignore next
-        if (err) {
-            return callback(err);
-        }
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog("Components", t(browseResults[0].references));
-            debugLog("Properties", t(browseResults[1].references));
-            debugLog("Methods", t(browseResults[2].references));
-        }
-        async.series(
-            [
-                (callback: ErrorCallback) => {
-                    async.mapSeries(
-                        browseResults![0].references!,
-                        (reference, innerCallback) => add_component(proxyManager, obj, reference, innerCallback),
-                        (err) => callback(err!)
-                    );
-                },
-
-                (callback: ErrorCallback) => {
-                    async.mapSeries(
-                        browseResults![1].references!,
-                        (reference, innerCallback) => add_property(proxyManager, obj, reference, innerCallback),
-                        (err) => callback(err!)
-                    );
-                },
-
-                // now enrich our object with nice callable async methods
-                (callback: ErrorCallback) => {
-                    async.mapSeries(
-                        browseResults![2].references!,
-                        (reference, innerCallback) => add_method(proxyManager, obj, reference, innerCallback),
-                        (err) => callback(err!)
-                    );
-                },
-
-                // now set typeDefinition
-                (callback: ErrorCallback) => {
-                    add_typeDefinition(proxyManager, obj, browseResults![3].references!, callback);
-                },
-
-                // FromState
-                (callback: ErrorCallback) => {
-                    // fromState
-                    const reference = browseResults![4].references ? browseResults![4].references![0] : null;
-                    // fromState
-                    if (reference) {
-                        return addFromState(proxyManager, obj, reference, callback);
-                    }
-                    callback();
-                },
-
-                // ToState
-                (callback: ErrorCallback) => {
-                    const reference = browseResults![5].references ? browseResults![5].references![0] : null;
-                    // fromState
-                    if (reference) {
-                        return addToState(proxyManager, obj, reference, callback);
-                    }
-                    callback();
-                },
-
-                // Organizes
-                (callback: ErrorCallback) => {
-                    async.mapSeries(
-                        browseResults![6].references!,
-                        (reference: ReferenceDescription, callback: ErrorCallback) =>
-                            addFolderElement(proxyManager, obj, reference, callback),
-                        (err) => callback(err!)
-                    );
-                }
-            ],
-            (err) => callback(err!)
-        );
-    });
+    const promises: Promise<void>[] = [];
+
+    for (const reference of browseResults[0].references || []) {
+        promises.push(add_component(proxyManager, obj, reference));
+    }
+    for (const reference of browseResults[1].references || []) {
+        promises.push(add_property(proxyManager, obj, reference));
+    }
+    for (const reference of browseResults[2].references || []) {
+        promises.push(add_method(proxyManager, obj, reference));
+    }
+    browseResults[3].references &&
+        browseResults[3].references.length &&
+        promises.push(add_typeDefinition(proxyManager, obj, browseResults[3].references || []));
+    browseResults[4].references &&
+        browseResults[4].references.length &&
+        promises.push(addFromState(proxyManager, obj, browseResults[4].references[0]));
+    browseResults[5].references &&
+        browseResults[5].references.length &&
+        promises.push(addToState(proxyManager, obj, browseResults[5].references[0]));
+    for (const reference of browseResults[6].references || []) {
+        promises.push(addFolderElement(proxyManager, obj, reference));
+    }
+
+    await Promise.all(promises);
+    return obj as ProxyNode;
 }