node-opcua-client 2.71.0 → 2.72.2

package/dist/verify.js

@@ -1,135 +1,135 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.performCertificateSanityCheck = exports.verifyIsOPCUAValidCertificate = void 0;
-const node_opcua_crypto_1 = require("node-opcua-crypto");
-const node_opcua_debug_1 = require("node-opcua-debug");
-const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
-const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
-const errorLog = (0, node_opcua_debug_1.make_errorLog)(__filename);
-const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
-function verifyIsOPCUAValidCertificate(certificate, certificateFile, type, applicationUri) {
-    var _a, _b, _c, _d, _e;
-    const certificateInfo = (0, node_opcua_crypto_1.exploreCertificate)(certificate);
-    const now = new Date();
-    if (certificateInfo.tbsCertificate.validity.notBefore.getTime() > now.getTime()) {
-        // check that certificate is active
-        // certificate is not active yet
-        warningLog(`[NODE-OPCUA-W02] The certificate is not active yet\n` +
-            `notBefore       ${certificateInfo.tbsCertificate.validity.notBefore.toISOString()}\n` +
-            `certificateFile ${certificateFile}`);
-    }
-    //  check that certificate has not expired
-    if (certificateInfo.tbsCertificate.validity.notAfter.getTime() <= now.getTime()) {
-        // certificate is obsolete
-        warningLog(`[NODE-OPCUA-W03] The certificate has expired\n` +
-            `Please regenerate a valid certificate\n` +
-            `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
-            `certificateFile= ${certificateFile}`);
-    }
-    else {
-        const tenDays = 10 * 24 * 60 * 60 * 1000;
-        if (certificateInfo.tbsCertificate.validity.notAfter.getTime() <= now.getTime() + tenDays) {
-            // certificate is going to expired very soon
-            warningLog(`[NODE-OPCUA-W05] The certificate is about to expire in less than 10 days.\n` +
-                `Please regenerate a valid certificate as soon as possible\n` +
-                `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
-                `certificateFile= ${certificateFile}\n`);
-        }
-    }
-    // check that server certificate matches Application URI
-    const uniformResourceIdentifier = (_c = (_b = (_a = certificateInfo === null || certificateInfo === void 0 ? void 0 : certificateInfo.tbsCertificate) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.subjectAltName) === null || _c === void 0 ? void 0 : _c.uniformResourceIdentifier;
-    if (!uniformResourceIdentifier) {
-        warningLog(`[NODE-OPCUA-W14] The certificate subjectAltName uniformResourceIdentifier is missing.\n` +
-            `Please regenerate a specific certificate with a uniformResourceIdentifier that matches your ${type} applicationUri\n` +
-            `applicationUri  = ${applicationUri}\n` +
-            `certificateFile = ${certificateFile}\n`);
-        return;
-    }
-    else if (uniformResourceIdentifier[0] !== applicationUri) {
-        warningLog(`[NODE-OPCUA-W06] The certificate subjectAltName does not match the ${type} applicationUri\n` +
-            `Please regenerate a specific certificate that matches your ${type} applicationUri\n` +
-            `certificate subjectAltName  = ${uniformResourceIdentifier[0]}\n` +
-            `${type} applicationUri  = ${applicationUri}\n` +
-            `certificateFile         = ${certificateFile}\n`);
-    }
-    const keyUsage = (_d = certificateInfo.tbsCertificate.extensions) === null || _d === void 0 ? void 0 : _d.keyUsage;
-    if (!keyUsage) {
-        warningLog(`[NODE-OPCUA-W15] The certificate keyUsage is missing\n` + `certificateFile = ${certificateFile}`);
-    }
-    else {
-        // spec says that certificate shall include digitalSignature, nonRepudiation, keyEncipherment and dataEncipherment.
-        // Other key uses are allowed.
-        if (!keyUsage.digitalSignature || !keyUsage.nonRepudiation || !keyUsage.keyEncipherment || !keyUsage.dataEncipherment) {
-            warningLog(`[NODE-OPCUA-W16] The certificate keyUsage must include digitalSignature, nonRepudiation, keyEncipherment and dataEncipherment.\n` +
-                `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
-                `certificateFile = ${certificateFile}`);
-        }
-    }
-    const extKeyUsage = (_e = certificateInfo.tbsCertificate.extensions) === null || _e === void 0 ? void 0 : _e.extKeyUsage;
-    if (!extKeyUsage) {
-        warningLog(`[NODE-OPCUA-W17] The certificate extKeyUsage is missing\n` + `certificateFile = ${certificateFile}`);
-    }
-    else {
-        // spec says that certificate shall include digitalSignature, nonRepudiation, keyEncipherment and dataEncipherment.
-        // Other key uses are allowed.
-        if (!extKeyUsage.clientAuth && !extKeyUsage.serverAuth) {
-            warningLog(`[NODE-OPCUA-W18] The certificate extKeyUsage must include clientAuth and/or serverAuth.\n` +
-                `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
-                `certificateFile = ${certificateFile}`);
-        }
-    }
-    const keyLengthInBits = certificateInfo.tbsCertificate.subjectPublicKeyInfo.keyLength * 8;
-    if (keyLengthInBits < 1024) {
-        errorLog(`[NODE-OPCUA-W19] The public key length shall be greater than or equal to 1024 bits. key length is ${keyLengthInBits}.\n` +
-            `see https://reference.opcfoundation.org/v104/GDS/docs/7.6.3/\n` +
-            `certificateFile = ${certificateFile}`);
-    }
-    else if (keyLengthInBits < 2048) {
-        warningLog(`[NODE-OPCUA-W23] key lengths less than 2048 are considered insecure. key length is ${keyLengthInBits}\n` +
-            `see https://reference.opcfoundation.org/v104/Core/docs/Part2/6.8/\n` +
-            `certificateFile = ${certificateFile}`);
-    }
-}
-exports.verifyIsOPCUAValidCertificate = verifyIsOPCUAValidCertificate;
-function performCertificateSanityCheck(serverOrClient, certificateManager, applicationUri) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // verify that certificate is matching private key, and inform the developper if not
-        const certificate = this.getCertificate();
-        const privateKey = (0, node_opcua_crypto_1.convertPEMtoDER)(this.getPrivateKey());
-        //
-        if (!(0, node_opcua_crypto_1.publicKeyAndPrivateKeyMatches)(certificate, privateKey)) {
-            errorLog("[NODE-OPCUA-E01] Configuration error : the certificate and the private key do not match !");
-            errorLog("                  please check the configuration of the OPCUA Server");
-            errorLog("                    privateKey= ", this.privateKeyFile);
-            errorLog(" certificateManager.privateKey= ", certificateManager.privateKey);
-            errorLog("               certificateFile= ", this.certificateFile);
-            throw new Error("[NODE-OPCUA-E01] Configuration error : the certificate and the private key do not match ! please fix your configuration");
-        }
-        // verify that the certificate provided has the right key length ( at least 2048)
-        const privateKeyInfo = (0, node_opcua_crypto_1.explorePrivateKey)(privateKey);
-        const keyLengthInBits = privateKeyInfo.modulus.length * 8;
-        if (keyLengthInBits <= 1024) {
-            warningLog(`[NODE-OPCUA-W04] The public/private key pair uses a key length which is equal or lower than 1024 bits. ( key length was ${keyLengthInBits} )\n` +
-                `OPCUA version 1.04 requires that security key length are greater or equal to 2048 bits.\n` +
-                `The ${serverOrClient} is operating at risk.                                             `);
-        }
-        // verify that the certificate has a valid date and has expected extensions fields such as DNS and IP.
-        const status1 = yield certificateManager.trustCertificate(certificate);
-        const status = yield certificateManager.verifyCertificateAsync(certificate);
-        if (status !== "Good") {
-            warningLog("[NODE-OPCUA-W04] Warning: the certificate status is = ", status, " file = ", this.certificateFile);
-        }
-        verifyIsOPCUAValidCertificate(certificate, this.certificateFile, serverOrClient, applicationUri);
-    });
-}
-exports.performCertificateSanityCheck = performCertificateSanityCheck;
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performCertificateSanityCheck = exports.verifyIsOPCUAValidCertificate = void 0;
+const node_opcua_crypto_1 = require("node-opcua-crypto");
+const node_opcua_debug_1 = require("node-opcua-debug");
+const doDebug = (0, node_opcua_debug_1.checkDebugFlag)(__filename);
+const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
+const errorLog = (0, node_opcua_debug_1.make_errorLog)(__filename);
+const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
+function verifyIsOPCUAValidCertificate(certificate, certificateFile, type, applicationUri) {
+    var _a, _b, _c, _d, _e;
+    const certificateInfo = (0, node_opcua_crypto_1.exploreCertificate)(certificate);
+    const now = new Date();
+    if (certificateInfo.tbsCertificate.validity.notBefore.getTime() > now.getTime()) {
+        // check that certificate is active
+        // certificate is not active yet
+        warningLog(`[NODE-OPCUA-W02] The certificate is not active yet\n` +
+            `notBefore       ${certificateInfo.tbsCertificate.validity.notBefore.toISOString()}\n` +
+            `certificateFile ${certificateFile}`);
+    }
+    //  check that certificate has not expired
+    if (certificateInfo.tbsCertificate.validity.notAfter.getTime() <= now.getTime()) {
+        // certificate is obsolete
+        warningLog(`[NODE-OPCUA-W03] The certificate has expired\n` +
+            `Please regenerate a valid certificate\n` +
+            `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
+            `certificateFile= ${certificateFile}`);
+    }
+    else {
+        const tenDays = 10 * 24 * 60 * 60 * 1000;
+        if (certificateInfo.tbsCertificate.validity.notAfter.getTime() <= now.getTime() + tenDays) {
+            // certificate is going to expired very soon
+            warningLog(`[NODE-OPCUA-W05] The certificate is about to expire in less than 10 days.\n` +
+                `Please regenerate a valid certificate as soon as possible\n` +
+                `notAfter       = ${certificateInfo.tbsCertificate.validity.notAfter.toISOString()}\n` +
+                `certificateFile= ${certificateFile}\n`);
+        }
+    }
+    // check that server certificate matches Application URI
+    const uniformResourceIdentifier = (_c = (_b = (_a = certificateInfo === null || certificateInfo === void 0 ? void 0 : certificateInfo.tbsCertificate) === null || _a === void 0 ? void 0 : _a.extensions) === null || _b === void 0 ? void 0 : _b.subjectAltName) === null || _c === void 0 ? void 0 : _c.uniformResourceIdentifier;
+    if (!uniformResourceIdentifier) {
+        warningLog(`[NODE-OPCUA-W14] The certificate subjectAltName uniformResourceIdentifier is missing.\n` +
+            `Please regenerate a specific certificate with a uniformResourceIdentifier that matches your ${type} applicationUri\n` +
+            `applicationUri  = ${applicationUri}\n` +
+            `certificateFile = ${certificateFile}\n`);
+        return;
+    }
+    else if (uniformResourceIdentifier[0] !== applicationUri) {
+        warningLog(`[NODE-OPCUA-W06] The certificate subjectAltName does not match the ${type} applicationUri\n` +
+            `Please regenerate a specific certificate that matches your ${type} applicationUri\n` +
+            `certificate subjectAltName  = ${uniformResourceIdentifier[0]}\n` +
+            `${type} applicationUri  = ${applicationUri}\n` +
+            `certificateFile         = ${certificateFile}\n`);
+    }
+    const keyUsage = (_d = certificateInfo.tbsCertificate.extensions) === null || _d === void 0 ? void 0 : _d.keyUsage;
+    if (!keyUsage) {
+        warningLog(`[NODE-OPCUA-W15] The certificate keyUsage is missing\n` + `certificateFile = ${certificateFile}`);
+    }
+    else {
+        // spec says that certificate shall include digitalSignature, nonRepudiation, keyEncipherment and dataEncipherment.
+        // Other key uses are allowed.
+        if (!keyUsage.digitalSignature || !keyUsage.nonRepudiation || !keyUsage.keyEncipherment || !keyUsage.dataEncipherment) {
+            warningLog(`[NODE-OPCUA-W16] The certificate keyUsage must include digitalSignature, nonRepudiation, keyEncipherment and dataEncipherment.\n` +
+                `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
+                `certificateFile = ${certificateFile}`);
+        }
+    }
+    const extKeyUsage = (_e = certificateInfo.tbsCertificate.extensions) === null || _e === void 0 ? void 0 : _e.extKeyUsage;
+    if (!extKeyUsage) {
+        warningLog(`[NODE-OPCUA-W17] The certificate extKeyUsage is missing\n` + `certificateFile = ${certificateFile}`);
+    }
+    else {
+        // spec says that certificate shall include digitalSignature, nonRepudiation, keyEncipherment and dataEncipherment.
+        // Other key uses are allowed.
+        if (!extKeyUsage.clientAuth && !extKeyUsage.serverAuth) {
+            warningLog(`[NODE-OPCUA-W18] The certificate extKeyUsage must include clientAuth and/or serverAuth.\n` +
+                `see https://reference.opcfoundation.org/v104/Core/docs/Part6/6.2.2/\n` +
+                `certificateFile = ${certificateFile}`);
+        }
+    }
+    const keyLengthInBits = certificateInfo.tbsCertificate.subjectPublicKeyInfo.keyLength * 8;
+    if (keyLengthInBits < 1024) {
+        errorLog(`[NODE-OPCUA-W19] The public key length shall be greater than or equal to 1024 bits. key length is ${keyLengthInBits}.\n` +
+            `see https://reference.opcfoundation.org/v104/GDS/docs/7.6.3/\n` +
+            `certificateFile = ${certificateFile}`);
+    }
+    else if (keyLengthInBits < 2048) {
+        warningLog(`[NODE-OPCUA-W23] key lengths less than 2048 are considered insecure. key length is ${keyLengthInBits}\n` +
+            `see https://reference.opcfoundation.org/v104/Core/docs/Part2/6.8/\n` +
+            `certificateFile = ${certificateFile}`);
+    }
+}
+exports.verifyIsOPCUAValidCertificate = verifyIsOPCUAValidCertificate;
+function performCertificateSanityCheck(serverOrClient, certificateManager, applicationUri) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // verify that certificate is matching private key, and inform the developper if not
+        const certificate = this.getCertificate();
+        const privateKey = (0, node_opcua_crypto_1.convertPEMtoDER)(this.getPrivateKey());
+        //
+        if (!(0, node_opcua_crypto_1.publicKeyAndPrivateKeyMatches)(certificate, privateKey)) {
+            errorLog("[NODE-OPCUA-E01] Configuration error : the certificate and the private key do not match !");
+            errorLog("                  please check the configuration of the OPCUA Server");
+            errorLog("                    privateKey= ", this.privateKeyFile);
+            errorLog(" certificateManager.privateKey= ", certificateManager.privateKey);
+            errorLog("               certificateFile= ", this.certificateFile);
+            throw new Error("[NODE-OPCUA-E01] Configuration error : the certificate and the private key do not match ! please fix your configuration");
+        }
+        // verify that the certificate provided has the right key length ( at least 2048)
+        const privateKeyInfo = (0, node_opcua_crypto_1.explorePrivateKey)(privateKey);
+        const keyLengthInBits = privateKeyInfo.modulus.length * 8;
+        if (keyLengthInBits <= 1024) {
+            warningLog(`[NODE-OPCUA-W04] The public/private key pair uses a key length which is equal or lower than 1024 bits. ( key length was ${keyLengthInBits} )\n` +
+                `OPCUA version 1.04 requires that security key length are greater or equal to 2048 bits.\n` +
+                `The ${serverOrClient} is operating at risk.                                             `);
+        }
+        // verify that the certificate has a valid date and has expected extensions fields such as DNS and IP.
+        const status1 = yield certificateManager.trustCertificate(certificate);
+        const status = yield certificateManager.verifyCertificateAsync(certificate);
+        if (status !== "Good") {
+            warningLog("[NODE-OPCUA-W04] Warning: the certificate status is = ", status, " file = ", this.certificateFile);
+        }
+        verifyIsOPCUAValidCertificate(certificate, this.certificateFile, serverOrClient, applicationUri);
+    });
+}
+exports.performCertificateSanityCheck = performCertificateSanityCheck;
 //# sourceMappingURL=verify.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-client",
-    "version": "2.71.0",
+    "version": "2.72.2",
     "description": "pure nodejs OPCUA SDK - module -client",
     "scripts": {
         "clean": "npx rimraf dist *.tsbuildinfo certificates",
@@ -22,52 +22,52 @@
         "chalk": "4.1.2",
         "delayed": "^2.0.0",
         "node-opcua-assert": "2.66.0",
-        "node-opcua-basic-types": "2.71.0",
+        "node-opcua-basic-types": "2.72.1",
         "node-opcua-buffer-utils": "2.71.0",
-        "node-opcua-certificate-manager": "2.71.0",
-        "node-opcua-client-dynamic-extension-object": "2.71.0",
-        "node-opcua-common": "2.71.0",
+        "node-opcua-certificate-manager": "2.72.1",
+        "node-opcua-client-dynamic-extension-object": "2.72.2",
+        "node-opcua-common": "2.72.2",
         "node-opcua-constants": "2.70.0",
         "node-opcua-crypto": "^1.11.0",
-        "node-opcua-data-model": "2.71.0",
-        "node-opcua-data-value": "2.71.0",
+        "node-opcua-data-model": "2.72.1",
+        "node-opcua-data-value": "2.72.2",
         "node-opcua-date-time": "2.71.0",
         "node-opcua-debug": "2.71.0",
-        "node-opcua-extension-object": "2.71.0",
+        "node-opcua-extension-object": "2.72.1",
         "node-opcua-hostname": "2.67.0",
         "node-opcua-nodeid": "2.71.0",
         "node-opcua-object-registry": "2.71.0",
         "node-opcua-pki": "^2.17.0",
-        "node-opcua-pseudo-session": "2.71.0",
-        "node-opcua-schemas": "2.71.0",
-        "node-opcua-secure-channel": "2.71.0",
-        "node-opcua-service-browse": "2.71.0",
-        "node-opcua-service-call": "2.71.0",
-        "node-opcua-service-discovery": "2.71.0",
-        "node-opcua-service-endpoints": "2.71.0",
-        "node-opcua-service-filter": "2.71.0",
-        "node-opcua-service-history": "2.71.0",
-        "node-opcua-service-query": "2.71.0",
-        "node-opcua-service-read": "2.71.0",
-        "node-opcua-service-register-node": "2.71.0",
-        "node-opcua-service-secure-channel": "2.71.0",
-        "node-opcua-service-session": "2.71.0",
-        "node-opcua-service-subscription": "2.71.0",
-        "node-opcua-service-translate-browse-path": "2.71.0",
-        "node-opcua-service-write": "2.71.0",
+        "node-opcua-pseudo-session": "2.72.2",
+        "node-opcua-schemas": "2.72.2",
+        "node-opcua-secure-channel": "2.72.2",
+        "node-opcua-service-browse": "2.72.2",
+        "node-opcua-service-call": "2.72.2",
+        "node-opcua-service-discovery": "2.72.2",
+        "node-opcua-service-endpoints": "2.72.2",
+        "node-opcua-service-filter": "2.72.2",
+        "node-opcua-service-history": "2.72.2",
+        "node-opcua-service-query": "2.72.2",
+        "node-opcua-service-read": "2.72.2",
+        "node-opcua-service-register-node": "2.72.2",
+        "node-opcua-service-secure-channel": "2.72.2",
+        "node-opcua-service-session": "2.72.2",
+        "node-opcua-service-subscription": "2.72.2",
+        "node-opcua-service-translate-browse-path": "2.72.2",
+        "node-opcua-service-write": "2.72.2",
         "node-opcua-status-code": "2.71.0",
-        "node-opcua-types": "2.71.0",
+        "node-opcua-types": "2.72.2",
         "node-opcua-utils": "2.71.0",
-        "node-opcua-variant": "2.71.0",
+        "node-opcua-variant": "2.72.2",
         "once": "^1.4.0",
         "thenify": "^3.3.1",
         "underscore": "^1.13.4"
     },
     "devDependencies": {
         "dequeue": "^1.0.5",
-        "node-opcua-address-space": "2.71.0",
+        "node-opcua-address-space": "2.72.2",
         "node-opcua-binary-stream": "2.71.0",
-        "node-opcua-factory": "2.71.0",
+        "node-opcua-factory": "2.72.1",
         "node-opcua-leak-detector": "2.71.0",
         "node-opcua-nodesets": "2.71.0",
         "should": "^13.2.3",
@@ -93,5 +93,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "10f7cc1e1cd30dfef75adad9cb709a78401fabf3"
+    "gitHead": "07dcdd8e8c7f2b55544c6e23023093e35674829c"
 }

package/source/alarms_and_conditions/client_alarm.ts

@@ -3,7 +3,7 @@ import { assert } from "node-opcua-assert";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { lowerFirstLetter } from "node-opcua-utils";
-import { Variant } from "node-opcua-variant";
+import { DataType, Variant } from "node-opcua-variant";
 import { ClientSession } from "../client_session";
 
 export interface TVariant<T> extends Variant {
@@ -28,6 +28,7 @@ export interface ClientAlarm {
     fields: EventStuff;
     on(eventName: "changed", eventHandler: () => void): this;
     acknowledge(session: ClientSession, comment: string): Promise<StatusCode>;
+    getField(fieldName: string): Variant | null;
 }
 
 /**
@@ -62,6 +63,25 @@ export class ClientAlarm extends EventEmitter {
     public getRetain(): boolean {
         return this.fields.retain.value;
     }
+    public toString(): string {
+        return (
+            this.constructor.name +
+            ": " +
+            this.conditionId.toString() +
+            " " +
+            this.eventType.toString() +
+            " " +
+            Object.entries(this.fields)
+                .filter(([key, value]) => value.dataType !== DataType.Null)
+                .map(([key, value]) => key.padEnd(30) + "=" + value.toString())
+                .join("\n") +
+            "\n\n"
+        );
+    }
+
+    public getField(fieldName: string): Variant | null {
+        return (this.fields as any)[fieldName] || null;
+    }
 }
 
 // ------------------------------------------------------------------------------------------------------------------------------

package/source/alarms_and_conditions/client_alarm_list.ts

@@ -5,8 +5,12 @@ import { ClientAlarm, EventStuff } from "./client_alarm";
 
 export interface ClientAlarmList {
     on(eventName: "alarmChanged", handler: (alarm: ClientAlarm) => void): this;
-    // tslint:disable-next-line: unified-signatures
+    on(eventName: "alarmDeleted", handler: (alarm: ClientAlarm) => void): this;
     on(eventName: "newAlarm", handler: (alarm: ClientAlarm) => void): this;
+
+    emit(eventName: "alarmChanged", alarm: ClientAlarm): boolean;
+    emit(eventName: "newAlarm", alarm: ClientAlarm): boolean;
+    emit(eventName: "alarmDeleted", alarm: ClientAlarm): boolean;
 }
 // maintain a set of alarm list for a client
 export class ClientAlarmList extends EventEmitter implements Iterable<ClientAlarm> {
@@ -55,7 +59,7 @@ export class ClientAlarmList extends EventEmitter implements Iterable<ClientAlar
             const newAlarm = new ClientAlarm(eventField);
             this._map[key] = newAlarm;
             this.emit("newAlarm", newAlarm);
-            this.emit("alarmChanged", alarm);
+            this.emit("alarmChanged", newAlarm);
         } else {
             alarm.update(eventField);
             this.emit("alarmChanged", alarm);

package/source/alarms_and_conditions/client_alarm_tools.ts

@@ -7,14 +7,15 @@ import { Variant } from "node-opcua-variant";
 import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 
 import { ClientMonitoredItem } from "../client_monitored_item";
+import { ClientSubscription } from "../client_subscription";
 import { ClientSession } from "../client_session";
 import { EventStuff, fieldsToJson } from "./client_alarm";
 import { ClientAlarmList } from "./client_alarm_list";
 import { extractConditionFields } from "./client_alarm_tools_extractConditionFields";
 import { callConditionRefresh } from "./client_tools";
 
-const doDebug = checkDebugFlag(__filename);
-const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag("A&E");
+const debugLog = make_debugLog("A&E");
 
 function r(_key: string, o: { dataType?: unknown; value?: unknown }) {
     if (o && o.dataType === "Null") {
@@ -22,10 +23,14 @@ function r(_key: string, o: { dataType?: unknown; value?: unknown }) {
     }
     return o;
 }
-
+interface ClientSessionPriv extends ClientSession {
+    $clientAlarmList: ClientAlarmList | null;
+    $monitoredItemForAlarmList: ClientMonitoredItem | null;
+    $subscriptionforAlarmList: ClientSubscription | null;
+}
 // ------------------------------------------------------------------------------------------------------------------------------
 export async function uninstallAlarmMonitoring(session: ClientSession): Promise<void> {
-    const _sessionPriv = session as any;
+    const _sessionPriv = session as ClientSessionPriv;
     if (!_sessionPriv.$clientAlarmList) {
         return;
     }
@@ -34,7 +39,7 @@ export async function uninstallAlarmMonitoring(session: ClientSession): Promise<
     mi.removeAllListeners();
 
     _sessionPriv.$monitoredItemForAlarmList = null;
-    await _sessionPriv.$subscriptionforAlarmList.terminate();
+    await _sessionPriv.$subscriptionforAlarmList!.terminate();
     _sessionPriv.$clientAlarmList = null;
     return;
 }
@@ -53,7 +58,7 @@ export async function uninstallAlarmMonitoring(session: ClientSession): Promise<
 
 // ------------------------------------------------------------------------------------------------------------------------------
 export async function installAlarmMonitoring(session: ClientSession): Promise<ClientAlarmList> {
-    const _sessionPriv = session as any;
+    const _sessionPriv = session as ClientSessionPriv;
     // create
     if (_sessionPriv.$clientAlarmList) {
         return _sessionPriv.$clientAlarmList;
@@ -89,17 +94,22 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
     };
 
     // now create a event monitored Item
-    const event_monitoringItem = ClientMonitoredItem.create(
-        subscription,
-        itemToMonitor,
-        monitoringParameters,
-        TimestampsToReturn.Both
-    );
+    const eventMonitoringItem = await subscription.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
 
     const RefreshStartEventType = resolveNodeId("RefreshStartEventType").toString();
     const RefreshEndEventType = resolveNodeId("RefreshEndEventType").toString();
 
-    event_monitoringItem.on("changed", (eventFields: Variant[]) => {
+    const queueEvent: EventStuff[] = [];
+    function flushQueue() {
+        const q = [...queueEvent];
+        queueEvent.length = 0;
+        for (const pojo of q) {
+            clientAlarmList.update(pojo);
+        }
+    }
+
+    let inInit = true;
+    eventMonitoringItem.on("changed", (eventFields: Variant[]) => {
         debugLog("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ---- ALARM RECEIVED");
         const pojo = fieldsToJson(fields, eventFields) as EventStuff;
         try {
@@ -113,7 +123,10 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
                 // not a acknowledgeable condition
                 return;
             }
-            clientAlarmList.update(pojo);
+            queueEvent.push(pojo);
+            if (queueEvent.length === 1 && !inInit) {
+                setTimeout(() => flushQueue(), 10);
+            }
         } catch (err) {
             // tslint:disable-next-line: no-console
             console.log(JSON.stringify(pojo, r, " "));
@@ -139,7 +152,11 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
     } catch (err) {
         console.log("Server may not implement condition refresh", (<Error>err).message);
     }
-    _sessionPriv.$monitoredItemForAlarmList = event_monitoringItem;
+    _sessionPriv.$monitoredItemForAlarmList = eventMonitoringItem;
+
+    setTimeout(() => flushQueue(), 10);
+    inInit = false;
+
     // also request updates
     return clientAlarmList;
 }

package/source/alarms_and_conditions/client_tools.ts

@@ -20,9 +20,9 @@ import { ClientSubscription } from "../client_subscription";
 import { ClientSessionImpl } from "../private/client_session_impl";
 import { ClientSubscriptionImpl } from "../private/client_subscription_impl";
 
-const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
-const warningLog = make_warningLog(__filename);
+const debugLog = make_debugLog("A&E");
+const doDebug = checkDebugFlag("A&E");
+const warningLog = make_warningLog("A&E");
 
 
 export async function callConditionRefresh(subscription: ClientSubscription): Promise<void>;
@@ -68,7 +68,7 @@ export function callConditionRefresh(subscription: ClientSubscription, callback?
                     objectId: conditionTypeNodeId
                 };
 
-                doDebug && debugLog("Calling method ", methodToCall.toString());
+                doDebug && debugLog("Calling method ", new CallMethodRequest(methodToCall).toString());
                 theSession.call(methodToCall, (err: Error | null, result?: CallMethodResult) => {
                     if (err) {
                         return innerCallback(err);

package/source/client_base.ts

@@ -140,7 +140,7 @@ export interface OPCUAClientBaseOptions {
     /**
      * @advanced
      */
-    transportSettings?: TransportSettings
+    transportSettings?: TransportSettings;
 }
 
 export interface GetEndpointsOptions {
@@ -164,10 +164,13 @@ export interface OPCUAClientBase extends OPCUASecureObject {
     connect(endpointUrl: string, callback: ErrorCallback): void;
 
     /***
-     * causes client to close and disconnect the communication with server
+     * causes the client to close and disconnect the communication with server
+     *
+     * ### note
+     * > once the client has disconnected, it cannot reconnect to the server
+     *   you'll need to recreate a new Client object to reconnect to the server.
      */
     disconnect(): Promise<void>;
-
     disconnect(callback: ErrorCallback): void;
 
     findEndpointForSecurity(securityMode: MessageSecurityMode, securityPolicy: SecurityPolicy): EndpointDescription | undefined;

package/source/opcua_client.ts

@@ -107,11 +107,9 @@ export interface OPCUAClientOptions extends OPCUAClientBaseOptions {
 
 export interface OPCUAClient extends OPCUAClientBase {
     connect(endpointUrl: string): Promise<void>;
-
     connect(endpointUrl: string, callback: ErrorCallback): void;
 
     disconnect(): Promise<void>;
-
     disconnect(callback: ErrorCallback): void;
 
     getEndpoints(options?: GetEndpointsOptions): Promise<EndpointDescription[]>;