node-opcua-client 2.124.0 → 2.125.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-client",
-    "version": "2.124.0",
+    "version": "2.125.0",
     "description": "pure nodejs OPCUA SDK - module client",
     "scripts": {
         "clean": "npx rimraf node_modules dist *.tsbuildinfo certificates",
@@ -17,58 +17,58 @@
         "@types/async": "^3.2.24",
         "async": "^3.2.5",
         "chalk": "4.1.2",
-        "node-opcua-alarm-condition": "2.124.0",
+        "node-opcua-alarm-condition": "2.125.0",
         "node-opcua-assert": "2.120.0",
-        "node-opcua-basic-types": "2.121.0",
-        "node-opcua-buffer-utils": "2.120.0",
-        "node-opcua-certificate-manager": "2.121.0",
-        "node-opcua-client-dynamic-extension-object": "2.124.0",
-        "node-opcua-common": "2.123.0",
-        "node-opcua-constants": "2.121.0",
+        "node-opcua-basic-types": "2.125.0",
+        "node-opcua-buffer-utils": "2.125.0",
+        "node-opcua-certificate-manager": "2.125.0",
+        "node-opcua-client-dynamic-extension-object": "2.125.0",
+        "node-opcua-common": "2.125.0",
+        "node-opcua-constants": "2.125.0",
         "node-opcua-crypto": "4.8.0",
-        "node-opcua-data-model": "2.121.0",
-        "node-opcua-data-value": "2.121.0",
-        "node-opcua-date-time": "2.121.0",
-        "node-opcua-debug": "2.121.0",
-        "node-opcua-extension-object": "2.121.0",
+        "node-opcua-data-model": "2.125.0",
+        "node-opcua-data-value": "2.125.0",
+        "node-opcua-date-time": "2.125.0",
+        "node-opcua-debug": "2.125.0",
+        "node-opcua-extension-object": "2.125.0",
         "node-opcua-hostname": "2.120.0",
-        "node-opcua-nodeid": "2.121.0",
-        "node-opcua-object-registry": "2.121.0",
+        "node-opcua-nodeid": "2.125.0",
+        "node-opcua-object-registry": "2.125.0",
         "node-opcua-pki": "4.10.0",
-        "node-opcua-pseudo-session": "2.124.0",
-        "node-opcua-schemas": "2.123.0",
-        "node-opcua-secure-channel": "2.124.0",
-        "node-opcua-service-browse": "2.123.0",
-        "node-opcua-service-call": "2.123.0",
-        "node-opcua-service-discovery": "2.123.0",
-        "node-opcua-service-endpoints": "2.123.0",
-        "node-opcua-service-filter": "2.123.0",
-        "node-opcua-service-history": "2.123.0",
-        "node-opcua-service-query": "2.123.0",
-        "node-opcua-service-read": "2.123.0",
-        "node-opcua-service-register-node": "2.123.0",
-        "node-opcua-service-secure-channel": "2.123.0",
-        "node-opcua-service-session": "2.123.0",
-        "node-opcua-service-subscription": "2.124.0",
-        "node-opcua-service-translate-browse-path": "2.123.0",
-        "node-opcua-service-write": "2.123.0",
-        "node-opcua-status-code": "2.121.0",
-        "node-opcua-types": "2.123.0",
-        "node-opcua-utils": "2.120.0",
-        "node-opcua-variant": "2.121.0",
+        "node-opcua-pseudo-session": "2.125.0",
+        "node-opcua-schemas": "2.125.0",
+        "node-opcua-secure-channel": "2.125.0",
+        "node-opcua-service-browse": "2.125.0",
+        "node-opcua-service-call": "2.125.0",
+        "node-opcua-service-discovery": "2.125.0",
+        "node-opcua-service-endpoints": "2.125.0",
+        "node-opcua-service-filter": "2.125.0",
+        "node-opcua-service-history": "2.125.0",
+        "node-opcua-service-query": "2.125.0",
+        "node-opcua-service-read": "2.125.0",
+        "node-opcua-service-register-node": "2.125.0",
+        "node-opcua-service-secure-channel": "2.125.0",
+        "node-opcua-service-session": "2.125.0",
+        "node-opcua-service-subscription": "2.125.0",
+        "node-opcua-service-translate-browse-path": "2.125.0",
+        "node-opcua-service-write": "2.125.0",
+        "node-opcua-status-code": "2.125.0",
+        "node-opcua-types": "2.125.0",
+        "node-opcua-utils": "2.125.0",
+        "node-opcua-variant": "2.125.0",
         "thenify": "^3.3.1"
     },
     "devDependencies": {
         "@types/underscore": "^1.11.15",
         "dequeue": "^1.0.5",
-        "mocha": "^10.3.0",
-        "node-opcua-address-space": "2.124.0",
-        "node-opcua-binary-stream": "2.120.0",
-        "node-opcua-factory": "2.121.0",
-        "node-opcua-leak-detector": "2.121.0",
+        "mocha": "^10.4.0",
+        "node-opcua-address-space": "2.125.0",
+        "node-opcua-binary-stream": "2.125.0",
+        "node-opcua-factory": "2.125.0",
+        "node-opcua-leak-detector": "2.125.0",
         "node-opcua-nodesets": "2.121.0",
         "should": "^13.2.3",
-        "sinon": "^17.0.1",
+        "sinon": "^18.0.0",
         "underscore": "^1.13.6"
     },
     "eslintConfig": {
@@ -91,7 +91,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "75b5e34e797094a83833ea2d7c72ca3e5983d648",
+    "gitHead": "a0e0a2f1045e6e402dd4619c625c90008f0617ed",
     "files": [
         "dist",
         "source"

package/source/index.ts

@@ -45,9 +45,10 @@ export {
     sameNodeId,
     ExpandedNodeId,
     makeExpandedNodeId,
+    NodeIdLike,
     coerceExpandedNodeId
 } from "node-opcua-nodeid";
-export { StatusCode, StatusCodes } from "node-opcua-status-code";
+export { StatusCode, StatusCodes, ErrorCallback } from "node-opcua-status-code";
 export * from "node-opcua-variant";
 export * from "node-opcua-data-value";
 export * from "node-opcua-data-model";
@@ -71,3 +72,5 @@ export * from "node-opcua-service-write";
 export * from "node-opcua-service-filter";
 export * from "node-opcua-pseudo-session";
 export * from "node-opcua-client-dynamic-extension-object";
+export { DataTypeDefinition } from "node-opcua-types";
+export { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";

package/source/opcua_client.ts

@@ -97,14 +97,20 @@ export type WithSubscriptionFunc = (session: ClientSession, subscription: Client
 export type WithSubscriptionFuncP<T> = (session: ClientSession, subscription: ClientSubscription) => Promise<T>;
 
 export interface OPCUAClient {
+    /**
+     *
+     * @param endpointUrl
+     * @param inner_func
+     */
     withSessionAsync<T>(endpointUrl: string | EndpointWithUserIdentity, inner_func: WithSessionFuncP<T>): Promise<T>;
 
-    withSession(
-        endpointUrl: string | EndpointWithUserIdentity,
-        inner_func: (session: ClientSession, done: (err?: Error) => void) => void,
-        callback: (err?: Error) => void
-    ): void;
 
+    /**
+     *
+     * @param endpointUrl
+     * @param parameters
+     * @param inner_func
+     */
     withSubscriptionAsync<T>(
         endpointUrl: string | EndpointWithUserIdentity,
         parameters: ClientSubscriptionOptions,

package/source/private/client_session_impl.ts

@@ -29,7 +29,8 @@ import {
     NodeAttributes,
     ResponseCallback,
     BrowseDescriptionLike,
-    IBasicSessionAsync2
+    IBasicSessionAsync2,
+    readNamespaceArray
 } from "node-opcua-pseudo-session";
 import { AnyConstructorFunc } from "node-opcua-schemas";
 import { ClientSecureChannelLayer, requestHandleNotSetValue, SignatureData } from "node-opcua-secure-channel";
@@ -221,7 +222,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
     public _closeEventHasBeenEmitted: boolean;
     private _publishEngine: ClientSidePublishEngine | null;
     private _keepAliveManager?: ClientSessionKeepAliveManager;
-    private _namespaceArray?: any;
+    private $$namespaceArray?: string[];
     private recursive_repair_detector = 0;
 
     constructor(client: IClientBase) {
@@ -270,6 +271,9 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         return this._client ? this._client.isReconnecting || this._reconnecting?.reconnecting : false;
     }
 
+    protected resolveNodeId(nodeId: NodeIdLike): NodeIdLike {
+        return resolveNodeId(nodeId);
+    }
     public getPublishEngine(): ClientSidePublishEngine {
         if (!this._publishEngine) {
             this._publishEngine = new ClientSidePublishEngine(this);
@@ -406,8 +410,8 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                     if (r.references && r.references.length > this.requestedMaxReferencesPerNode) {
                         warningLog(
                             chalk.yellow("warning") +
-                                " BrowseResponse : the server didn't take into" +
-                                " account our requestedMaxReferencesPerNode "
+                            " BrowseResponse : the server didn't take into" +
+                            " account our requestedMaxReferencesPerNode "
                         );
                         warningLog("        this.requestedMaxReferencesPerNode= " + this.requestedMaxReferencesPerNode);
                         warningLog("        got " + r.references.length + "for " + nodesToBrowse[i].nodeId.toString());
@@ -416,7 +420,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 }
             }
             for (const r of results) {
-                r.references = r.references || /* istanbul ignore next */ [];
+                r.references = r.references || /* istanbul ignore next */[];
             }
             assert(results[0] instanceof BrowseResult);
             return callback(null, isArray ? results : results[0]);
@@ -652,7 +656,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                     continuationPoint: undefined,
                     dataEncoding: undefined, // {namespaceIndex: 0, name: undefined},
                     indexRange: undefined,
-                    nodeId: resolveNodeId(node as NodeIdLike)
+                    nodeId: this.resolveNodeId(node as NodeIdLike)
                 });
             } else {
                 nodesToRead.push(node as HistoryReadValueIdOptions);
@@ -715,7 +719,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 return callback(new Error(response.responseHeader.serviceResult.toString()));
             }
 
-            response.results = response.results || /* istanbul ignore next */ [];
+            response.results = response.results || /* istanbul ignore next */[];
             callback(null, response);
         });
     }
@@ -847,7 +851,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 return callback(new Error(response.responseHeader.serviceResult.toString()));
             }
 
-            response.results = response.results || /* istanbul ignore next */ [];
+            response.results = response.results || /* istanbul ignore next */[];
 
             assert(nodesToRead.length === response.results.length);
 
@@ -990,7 +994,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             if (response.responseHeader.serviceResult.isNot(StatusCodes.Good)) {
                 return callback(new Error(response.responseHeader.serviceResult.toString()));
             }
-            response.results = response.results || /* istanbul ignore next */ [];
+            response.results = response.results || /* istanbul ignore next */[];
             assert(nodesToWrite.length === response.results.length);
             callback(null, isArray ? response.results : response.results[0]);
         });
@@ -1046,7 +1050,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         const nodeToWrite = new WriteValue({
             attributeId: AttributeIds.Value,
             indexRange: undefined,
-            nodeId: resolveNodeId(nodeId),
+            nodeId: this.resolveNodeId(nodeId),
             value: new DataValue({ value })
         });
 
@@ -1162,6 +1166,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
      * @param args
      */
     public read(...args: any[]): any {
+
         if (args.length === 2) {
             return this.read(args[0], 0, args[1]);
         }
@@ -1193,7 +1198,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 warningLog(
                     chalk.yellow(
                         "please make sure to refactor your code and check that " +
-                            "the second argument of your callback function is named"
+                        "the second argument of your callback function is named"
                     ),
                     chalk.cyan("dataValue" + (isArray ? "s" : ""))
                 );
@@ -1204,7 +1209,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
 
         // coerce nodeIds
         for (const node of nodesToRead) {
-            node.nodeId = resolveNodeId(node.nodeId);
+            node.nodeId = this.resolveNodeId(node.nodeId);
         }
 
         const request = new ReadRequest({
@@ -1226,7 +1231,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
 
             // perform ExtensionObject resolution
             promoteOpaqueStructureWithCallback(this, response.results!, () => {
-                response.results = response.results || /* istanbul ignore next */ [];
+                response.results = response.results || /* istanbul ignore next */[];
                 return callback(null, isArray ? response.results : response.results[0]);
             });
         });
@@ -1427,7 +1432,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 if (!response) {
                     return callback(new Error("Internal Error"));
                 }
-                response.results = response.results || /* istanbul ignore next */ [];
+                response.results = response.results || /* istanbul ignore next */[];
                 callback(err, isArray ? response.results : response.results[0]);
             }
         );
@@ -1472,7 +1477,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             if (!response || !(response instanceof TranslateBrowsePathsToNodeIdsResponse)) {
                 return callback(new Error("Internal Error"));
             }
-            response.results = response.results || /* istanbul ignore next */ [];
+            response.results = response.results || /* istanbul ignore next */[];
 
             callback(null, isArray ? response.results : response.results[0]);
         });
@@ -1615,9 +1620,9 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
             if (response.responseHeader.serviceResult.isNot(StatusCodes.Good)) {
                 err = new Error(
                     " ServiceResult is " +
-                        response.responseHeader.serviceResult.toString() +
-                        " request was " +
-                        request.constructor.name
+                    response.responseHeader.serviceResult.toString() +
+                    " request was " +
+                    request.constructor.name
                 );
 
                 if (response && response.responseHeader.serviceDiagnostics) {
@@ -1857,7 +1862,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         assert(Array.isArray(nodesToRegister));
 
         const request = new RegisterNodesRequest({
-            nodesToRegister: nodesToRegister.map(resolveNodeId)
+            nodesToRegister: nodesToRegister.map((n) => this.resolveNodeId(n))
         });
 
         this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
@@ -1870,7 +1875,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
                 return callback(new Error("Internal Error"));
             }
 
-            response.registeredNodeIds = response.registeredNodeIds || /* istanbul ignore next */ [];
+            response.registeredNodeIds = response.registeredNodeIds || /* istanbul ignore next */[];
 
             callback(null, response.registeredNodeIds);
         });
@@ -1886,7 +1891,7 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
         assert(Array.isArray(nodesToUnregister));
 
         const request = new UnregisterNodesRequest({
-            nodesToUnregister: nodesToUnregister.map(resolveNodeId)
+            nodesToUnregister: nodesToUnregister.map((n) => this.resolveNodeId(n))
         });
 
         this.performMessageTransaction(request, (err: Error | null, response?: Response) => {
@@ -2020,36 +2025,16 @@ export class ClientSessionImpl extends EventEmitter implements ClientSession {
     public readNamespaceArray(callback: (err: Error | null, namespaceArray?: string[]) => void): void;
     public readNamespaceArray(...args: any[]): any {
         const callback = args[0];
-
-        this.read(
-            {
-                attributeId: AttributeIds.Value,
-                nodeId: resolveNodeId("Server_NamespaceArray")
-            },
-            (err: Error | null, dataValue?: DataValue) => {
-                /* istanbul ignore next */
-                if (err) {
-                    return callback(err);
-                }
-                /* istanbul ignore next */
-                if (!dataValue) {
-                    return callback(new Error("Internal Error"));
-                }
-
-                /* istanbul ignore next */
-                if (dataValue.statusCode.isNotGood()) {
-                    return callback(new Error("readNamespaceArray : " + dataValue.statusCode.toString()));
-                }
-                assert(dataValue.value.value instanceof Array);
-                this._namespaceArray = dataValue.value.value; // keep a cache
-                callback(null, this._namespaceArray);
-            }
-        );
+        readNamespaceArray(this)
+            .then((namespaceArray) => callback(null, namespaceArray))
+            .catch((err) => {
+                callback(err);
+            });
     }
 
     public getNamespaceIndex(namespaceUri: string): number {
-        assert(this._namespaceArray, "please make sure that readNamespaceArray has been called");
-        return this._namespaceArray.indexOf(namespaceUri);
+        assert(this.$$namespaceArray, "please make sure that readNamespaceArray has been called");
+        return this.$$namespaceArray!.indexOf(namespaceUri);
     }
 
     // tslint:disable:no-empty

package/source/private/opcua_client_impl.ts

@@ -3,7 +3,6 @@
  */
 import { callbackify } from "util";
 import { randomBytes, createPublicKey } from "crypto";
-import async from "async";
 import chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
@@ -38,6 +37,7 @@ import { ErrorCallback, Callback } from "node-opcua-status-code";
 
 import { SignatureDataOptions, UserIdentityToken } from "node-opcua-types";
 import { isNullOrUndefined, matchUri } from "node-opcua-utils";
+import { readNamespaceArray } from "node-opcua-pseudo-session";
 
 import { ClientSession } from "../client_session";
 import { ClientSubscription, ClientSubscriptionOptions } from "../client_subscription";
@@ -603,151 +603,14 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         });
         return session;
     }
+
     /**
-     * @method withSession
-     */
-    public withSession<T>(
-        endpointUrl: string | EndpointWithUserIdentity,
-        inner_func: (session: ClientSession) => Promise<T>
-    ): Promise<T>;
-
-    public withSession(
-        endpointUrl: string | EndpointWithUserIdentity,
-        inner_func: (session: ClientSession, done: (err?: Error) => void) => void,
-        callback: (err?: Error) => void
-    ): void;
-    /**
-     * @internal
-     * @param args
+     * 
+     * @param connectionPoint 
+     * @param func 
+     * @returns 
      */
-    public withSession(
-        connectionPoint: string | EndpointWithUserIdentity,
-        inner_func: (session: ClientSession, done: (err?: Error) => void) => void,
-        ...args: any[]
-    ): any {
-        const endpointUrl: string = typeof connectionPoint === "string" ? connectionPoint : connectionPoint.endpointUrl;
-        const userIdentity: UserIdentityInfo =
-            typeof connectionPoint === "string" ? { type: UserTokenType.Anonymous } : connectionPoint.userIdentity;
-
-        const callback = args[0];
-
-        assert(typeof inner_func === "function", "expecting inner function");
-        assert(typeof callback === "function", "expecting callback function");
-
-        let theSession: ClientSession;
-        let the_error: Error | undefined;
-
-        let need_disconnect = false;
-        async.series(
-            [
-                // step 1 : connect to
-                (innerCallback: ErrorCallback) => {
-                    this.connect(endpointUrl, (err?: Error) => {
-                        need_disconnect = true;
-                        if (err) {
-                            warningLog(err.message);
-                            errorLog(" cannot connect to endpoint :", endpointUrl);
-                        }
-                        innerCallback(err);
-                    });
-                },
-
-                // step 2 : createSession
-                (innerCallback: ErrorCallback) => {
-                    this.createSession2(userIdentity, (err: Error | null, session?: ClientSession) => {
-                        if (err) {
-                            return innerCallback(err);
-                        }
-                        if (!session) {
-                            return innerCallback(new Error("internal error"));
-                        }
-                        theSession = session;
-                        innerCallback();
-                    });
-                },
-
-                (innerCallback: ErrorCallback) => {
-                    try {
-                        inner_func(theSession, (err?: Error) => {
-                            the_error = err;
-                            innerCallback();
-                        });
-                    } catch (err) {
-                        errorLog("Exception catch in inner function,  check your code ", err);
-                        errorLog("OPCUAClientImpl#withClientSession", (<Error>err).message);
-                        the_error = err as Error;
-                        innerCallback();
-                    }
-                },
-
-                // close session
-                (innerCallback: ErrorCallback) => {
-                    theSession.close(/*deleteSubscriptions=*/ true, (err?: Error) => {
-                        if (err) {
-                            debugLog("OPCUAClientImpl#withClientSession: session closed failed ?");
-                        }
-                        innerCallback();
-                    });
-                },
-
-                (innerCallback: ErrorCallback) => {
-                    this.disconnect((err?: Error) => {
-                        need_disconnect = false;
-                        if (err) {
-                            errorLog("OPCUAClientImpl#withClientSession: client disconnect failed ?");
-                        }
-                        innerCallback();
-                    });
-                }
-            ],
-            (err1) => {
-                if (err1) {
-                    errorLog("err", err1.message);
-                }
-                if (need_disconnect) {
-                    errorLog("Disconnecting client after failure");
-                    this.disconnect((err2) => {
-                        return callback(the_error || err1 || err2);
-                    });
-                } else {
-                    return callback(the_error || err1);
-                }
-            }
-        );
-    }
-
-    public withSubscription(
-        endpointUrl: string | EndpointWithUserIdentity,
-        subscriptionParameters: ClientSubscriptionOptions,
-        innerFunc: (session: ClientSession, subscription: ClientSubscription, done: (err?: Error) => void) => void,
-        callback: (err?: Error) => void
-    ): void {
-        assert(typeof innerFunc === "function");
-        assert(typeof callback === "function");
-
-        this.withSession(
-            endpointUrl,
-            (session: ClientSession, done: (err?: Error) => void) => {
-                assert(typeof done === "function");
-
-                const subscription = new ClientSubscriptionImpl(session as ClientSessionImpl, subscriptionParameters);
-
-                try {
-                    innerFunc(session, subscription, (err?: Error) => {
-                        subscription.terminate((err1?: Error) => {
-                            done(err1);
-                        });
-                    });
-                } catch (err) {
-                    debugLog(err);
-                    done(err as Error);
-                }
-            },
-            callback
-        );
-    }
-
-    public async withSessionAsync(connectionPoint: string | EndpointWithUserIdentity, func: WithSessionFuncP<any>): Promise<any> {
+    public async withSessionAsync<T>(connectionPoint: string | EndpointWithUserIdentity, func: WithSessionFuncP<T>): Promise<T> {
         assert(typeof func === "function");
         assert(func.length === 1, "expecting a single argument in func");
 
@@ -764,6 +627,10 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         try {
             const session = await this.createSession2(userIdentity);
             let result;
+
+            // always need this 
+            await readNamespaceArray(session);
+
             try {
                 result = await func(session);
                 return result;
@@ -781,12 +648,12 @@ export class OPCUAClientImpl extends ClientBaseImpl implements OPCUAClient {
         }
     }
 
-    public async withSubscriptionAsync(
+    public async withSubscriptionAsync<T>(
         connectionPoint: string | EndpointWithUserIdentity,
         parameters: ClientSubscriptionOptions,
-        func: WithSubscriptionFuncP<any>
-    ): Promise<any> {
-        await this.withSessionAsync(connectionPoint, async (session: ClientSession) => {
+        func: WithSubscriptionFuncP<T>
+    ): Promise<T> {
+        return await this.withSessionAsync(connectionPoint, async (session: ClientSession) => {
             assert(session, " session must exist");
             const subscription = await session.createSubscription2(parameters);
             try {

package/source/private/reconnection/client_publish_engine_reconnection.ts

@@ -87,7 +87,7 @@ function __askSubscriptionRepublish(
     subscription: ClientSubscriptionImpl,
     callback: (err?: Error) => void
 ) {
-  
+
     _republish(engine, subscription, (err?: Error) => {
         // prettier-ignore
         { const _err = _shouldNotContinue2(subscription); if (_err) { return callback(_err); } }
@@ -113,7 +113,7 @@ function __askSubscriptionRepublish(
             debugLog(
                 chalk.bgWhite.red("__askSubscriptionRepublish failed " + " subscriptionId is not valid anymore on server side.")
             );
-            return recreateSubscriptionAndMonitoredItem(subscription, callback);
+            return recreateSubscriptionAndMonitoredItem(subscription).then(() => callback()).catch(err => callback(err));
         }
         if (err && err.message.match(/|MessageNotAvailable/)) {
             // start engine and start monitoring

package/source/private/reconnection/client_subscription_reconnection.ts

@@ -1,10 +1,9 @@
-import async from "async";
+import { promisify } from "util";
 import assert from "node-opcua-assert";
 import { TimestampsToReturn } from "node-opcua-data-value";
 import { make_debugLog, checkDebugFlag } from "node-opcua-debug";
 import { warningLog } from "node-opcua-pki";
 import { MonitoredItemCreateRequestOptions, CreateMonitoredItemsRequest, CreateMonitoredItemsResponse } from "node-opcua-types";
-import { ErrorCallback } from "node-opcua-status-code";
 
 import {
     IBasicSessionReadAsync,
@@ -20,128 +19,106 @@ import { _shouldNotContinue } from "./reconnection";
 const debugLog = make_debugLog("RECONNECTION");
 const doDebug = checkDebugFlag("RECONNECTION");
 
-function createMonitoredItemsAndRespectOperationalLimits(
+async function createMonitoredItemsAndRespectOperationalLimits(
     session: IBasicSessionReadAsync & IBasicSessionWithSubscription,
-    createMonitorItemsRequest: CreateMonitoredItemsRequest,
-    callback: (err: Error | null, response?: CreateMonitoredItemsResponse) => void
-) {
-    readOperationLimits(session)
-        .then((operationalLimits) => {
-            createMonitoredItemsLimit(operationalLimits.maxMonitoredItemsPerCall || 0, session, createMonitorItemsRequest)
-                .then((createMonitoredItemResponse) => callback(null, createMonitoredItemResponse))
-                .catch(callback);
-        })
-        .catch(callback);
+    createMonitorItemsRequest: CreateMonitoredItemsRequest
+): Promise<CreateMonitoredItemsResponse> {
+    const operationalLimits = await readOperationLimits(session);
+    const createMonitoredItemResponse = await createMonitoredItemsLimit(
+        operationalLimits.maxMonitoredItemsPerCall || 0,
+        session,
+        createMonitorItemsRequest
+    );
+    return createMonitoredItemResponse;
 }
 
+async function adjustMonitoredItemNodeIds(subscription: ClientSubscription, oldMonitoredItems: any) {
+// to Do 
+}
 /**
  *  utility function to recreate new subscription
  *  @method recreateSubscriptionAndMonitoredItem
  */
-export function recreateSubscriptionAndMonitoredItem(_subscription: ClientSubscription, callback: ErrorCallback): void {
+export async function recreateSubscriptionAndMonitoredItem(_subscription: ClientSubscription): Promise<void> 
+{
     debugLog("recreateSubscriptionAndMonitoredItem", _subscription.subscriptionId.toString());
 
     const subscription = _subscription as ClientSubscriptionImpl;
     if (subscription.subscriptionId === TERMINATED_SUBSCRIPTION_ID) {
         debugLog("Subscription is not in a valid state");
-        return callback();
+        return;
     }
 
     const oldMonitoredItems = subscription.monitoredItems;
     const oldSubscriptionId = subscription.subscriptionId;
 
-
-    
     subscription.publishEngine.unregisterSubscription(oldSubscriptionId);
 
-    async.series(
-        [
-            (innerCallback: ErrorCallback) => {
-                __create_subscription(subscription, innerCallback);
-            },
-            (innerCallback: ErrorCallback) => {
-                // prettier-ignore
-                { const _err = _shouldNotContinue(subscription.session); if (_err) { return innerCallback(_err); } }
+    await promisify(__create_subscription)(subscription);
+    
+    const _err = _shouldNotContinue(subscription.session); 
+    if (_err) { throw _err;  }
 
-                const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
+    const test = subscription.publishEngine.getSubscription(subscription.subscriptionId);
 
-                debugLog("recreating ", Object.keys(oldMonitoredItems).length, " monitored Items");
+    debugLog("recreating ", Object.keys(oldMonitoredItems).length, " monitored Items");
                 // re-create monitored items
-                const itemsToCreate: MonitoredItemCreateRequestOptions[] = [];
-
-                for (const monitoredItem of Object.values(oldMonitoredItems)) {
-                    assert(monitoredItem.monitoringParameters.clientHandle > 0);
-                    itemsToCreate.push({
-                        itemToMonitor: monitoredItem.itemToMonitor,
-                        monitoringMode: monitoredItem.monitoringMode,
-                        requestedParameters: monitoredItem.monitoringParameters
-                    });
-                }
-
-                const createMonitorItemsRequest = new CreateMonitoredItemsRequest({
-                    itemsToCreate,
-                    subscriptionId: subscription.subscriptionId,
-                    timestampsToReturn: TimestampsToReturn.Both // this.timestampsToReturn,
-                });
-
-                const session = subscription.session;
-                // istanbul ignore next
-                if (!session) {
-                    return innerCallback(new Error("no session"));
-                }
-
-                debugLog("Recreating ", itemsToCreate.length, " monitored items");
-
-                createMonitoredItemsAndRespectOperationalLimits(
-                    session,
-                    createMonitorItemsRequest,
-                    (err: Error | null, response?: CreateMonitoredItemsResponse) => {
-                        if (err) {
-                            debugLog("Recreating monitored item has failed with ", err.message);
-                            return innerCallback(err);
-                        }
-                        /* istanbul ignore next */
-                        if (!response) {
-                            return innerCallback(new Error("Internal Error"));
-                        }
-                        const monitoredItemResults = response.results || [];
-
-                        let _errCount = 0;
-                        monitoredItemResults.forEach((monitoredItemResult, index) => {
-                            const itemToCreate = itemsToCreate[index];
-                            /* istanbul ignore next */
-                            if (!itemToCreate || !itemToCreate.requestedParameters) {
-                                _errCount++;
-                                return;
-                            }
-                            const clientHandle = itemToCreate.requestedParameters.clientHandle;
-                            /* istanbul ignore next */
-                            if (!clientHandle) {
-                                _errCount++;
-                                return;
-                            }
-                            const monitoredItem = subscription.monitoredItems[clientHandle] as ClientMonitoredItemImpl;
-                            if (monitoredItem) {
-                                monitoredItem._applyResult(monitoredItemResult);
-                            } else {
-                                _errCount++;
-                                warningLog("cannot find monitored item for clientHandle !:", clientHandle);
-                                warningLog("itemsToCreate = ", itemsToCreate[index].toString());
-                            }
-                        });
-                        if (_errCount > 0) {
-                            warningLog("Warning: some monitored items have not been recreated properly");
-                        }
-                        innerCallback();
-                    }
-                );
-            }
-        ],
-        (err) => {
-            if (err) {
-                warningLog("!!recreateSubscriptionAndMonitoredItem has failed", err.message);
-            }
-            callback(err!);
+    const itemsToCreate: MonitoredItemCreateRequestOptions[] = [];
+
+    await adjustMonitoredItemNodeIds(subscription, oldMonitoredItems);
+
+    for (const monitoredItem of Object.values(oldMonitoredItems)) {
+        assert(monitoredItem.monitoringParameters.clientHandle > 0);
+        itemsToCreate.push({
+            itemToMonitor: monitoredItem.itemToMonitor,
+            monitoringMode: monitoredItem.monitoringMode,
+            requestedParameters: monitoredItem.monitoringParameters
+        });
+    }
+
+    const createMonitorItemsRequest = new CreateMonitoredItemsRequest({
+        itemsToCreate,
+        subscriptionId: subscription.subscriptionId,
+        timestampsToReturn: TimestampsToReturn.Both // this.timestampsToReturn,
+    });
+
+    const session = subscription.session;
+    // istanbul ignore next
+    if (!session) {
+        throw new Error("no session");
+    }
+
+    debugLog("Recreating ", itemsToCreate.length, " monitored items");
+
+    const response = await createMonitoredItemsAndRespectOperationalLimits(
+                        session,
+                        createMonitorItemsRequest);
+    const monitoredItemResults = response.results || [];
+
+    let _errCount = 0;
+    monitoredItemResults.forEach((monitoredItemResult, index) => {
+        const itemToCreate = itemsToCreate[index];
+        /* istanbul ignore next */
+        if (!itemToCreate || !itemToCreate.requestedParameters) {
+            _errCount++;
+            return;
         }
-    );
+        const clientHandle = itemToCreate.requestedParameters.clientHandle;
+        /* istanbul ignore next */
+        if (!clientHandle) {
+            _errCount++;
+            return;
+        }
+        const monitoredItem = subscription.monitoredItems[clientHandle] as ClientMonitoredItemImpl;
+        if (monitoredItem) {
+            monitoredItem._applyResult(monitoredItemResult);
+        } else {
+            _errCount++;
+            warningLog("cannot find monitored item for clientHandle !:", clientHandle);
+            warningLog("itemsToCreate = ", itemsToCreate[index].toString());
+        }
+    });
+    if (_errCount > 0) {
+        warningLog("Warning: some monitored items have not been recreated properly");
+    }
 }

package/source/private/reconnection/reconnection.ts

@@ -216,22 +216,19 @@ function repair_client_session_by_recreating_a_new_session(
                 doDebug && debugLog(chalk.red("          => RECREATING SUBSCRIPTION  "), subscriptionId);
                 assert(subscription.session === newSession, "must have the new session");
 
-                recreateSubscriptionAndMonitoredItem(subscription, (err1?: Error) => {
-                    // prettier-ignore
-                    { const err = _shouldNotContinue(session); if (err) { return next(err); } }
-
-                    if (err1) {
-                        doDebug && debugLog("_recreateSubscription failed !" + err1.message);
-                    }
-
+                recreateSubscriptionAndMonitoredItem(subscription).then(() => {
                     doDebug &&
                         debugLog(
                             chalk.cyan("          => RECREATING SUBSCRIPTION  AND MONITORED ITEM DONE subscriptionId="),
                             subscriptionId
                         );
+                    next();
 
+                }).catch((err) => {
+                    doDebug && debugLog("_recreateSubscription failed !" + (err as Error).message);
                     next();
                 });
+
             },
             (err1?: Error | null) => {
                 // prettier-ignore
@@ -495,7 +492,7 @@ export function repair_client_session(client: IClientBase, session: ClientSessio
 
     const repeatedAction = (callback: EmptyCallback) => {
         // prettier-ignore
-        {   const err = _shouldNotContinue(session);   if (err) { return callback(err); }}
+        { const err = _shouldNotContinue(session); if (err) { return callback(err); } }
 
         _repair_client_session(client, session, (err) => {
             // prettier-ignore