node-opcua-client 2.73.1 → 2.76.0

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.73.1",
+    "version": "2.76.0",
     "description": "pure nodejs OPCUA SDK - module -client",
     "scripts": {
         "clean": "npx rimraf dist *.tsbuildinfo certificates",
@@ -16,62 +16,62 @@
         "@ster5/global-mutex": "^1.2.0",
         "@types/async": "^3.2.13",
         "@types/once": "^1.4.0",
-        "@types/underscore": "^1.11.4",
         "async": "^3.2.4",
         "callbackify": "^1.1.0",
         "chalk": "4.1.2",
-        "delayed": "^2.0.0",
-        "node-opcua-assert": "2.66.0",
-        "node-opcua-basic-types": "2.73.0",
-        "node-opcua-buffer-utils": "2.71.0",
-        "node-opcua-certificate-manager": "2.73.0",
-        "node-opcua-client-dynamic-extension-object": "2.73.1",
-        "node-opcua-common": "2.73.1",
-        "node-opcua-constants": "2.70.0",
+        "node-opcua-assert": "2.76.0",
+        "node-opcua-basic-types": "2.76.0",
+        "node-opcua-buffer-utils": "2.76.0",
+        "node-opcua-certificate-manager": "2.76.0",
+        "node-opcua-client-dynamic-extension-object": "2.76.0",
+        "node-opcua-common": "2.76.0",
+        "node-opcua-constants": "2.74.0",
         "node-opcua-crypto": "^1.11.0",
-        "node-opcua-data-model": "2.73.1",
-        "node-opcua-data-value": "2.73.1",
-        "node-opcua-date-time": "2.73.0",
-        "node-opcua-debug": "2.71.0",
-        "node-opcua-extension-object": "2.73.1",
-        "node-opcua-hostname": "2.67.0",
-        "node-opcua-nodeid": "2.71.0",
-        "node-opcua-object-registry": "2.71.0",
+        "node-opcua-data-model": "2.76.0",
+        "node-opcua-data-value": "2.76.0",
+        "node-opcua-date-time": "2.76.0",
+        "node-opcua-debug": "2.76.0",
+        "node-opcua-extension-object": "2.76.0",
+        "node-opcua-hostname": "2.76.0",
+        "node-opcua-nodeid": "2.76.0",
+        "node-opcua-object-registry": "2.76.0",
         "node-opcua-pki": "^2.17.0",
-        "node-opcua-pseudo-session": "2.73.1",
-        "node-opcua-schemas": "2.73.1",
-        "node-opcua-secure-channel": "2.73.1",
-        "node-opcua-service-browse": "2.73.1",
-        "node-opcua-service-call": "2.73.1",
-        "node-opcua-service-discovery": "2.73.1",
-        "node-opcua-service-endpoints": "2.73.1",
-        "node-opcua-service-filter": "2.73.1",
-        "node-opcua-service-history": "2.73.1",
-        "node-opcua-service-query": "2.73.1",
-        "node-opcua-service-read": "2.73.1",
-        "node-opcua-service-register-node": "2.73.1",
-        "node-opcua-service-secure-channel": "2.73.1",
-        "node-opcua-service-session": "2.73.1",
-        "node-opcua-service-subscription": "2.73.1",
-        "node-opcua-service-translate-browse-path": "2.73.1",
-        "node-opcua-service-write": "2.73.1",
-        "node-opcua-status-code": "2.73.0",
-        "node-opcua-types": "2.73.1",
-        "node-opcua-utils": "2.71.0",
-        "node-opcua-variant": "2.73.1",
+        "node-opcua-pseudo-session": "2.76.0",
+        "node-opcua-schemas": "2.76.0",
+        "node-opcua-secure-channel": "2.76.0",
+        "node-opcua-service-browse": "2.76.0",
+        "node-opcua-service-call": "2.76.0",
+        "node-opcua-service-discovery": "2.76.0",
+        "node-opcua-service-endpoints": "2.76.0",
+        "node-opcua-service-filter": "2.76.0",
+        "node-opcua-service-history": "2.76.0",
+        "node-opcua-service-query": "2.76.0",
+        "node-opcua-service-read": "2.76.0",
+        "node-opcua-service-register-node": "2.76.0",
+        "node-opcua-service-secure-channel": "2.76.0",
+        "node-opcua-service-session": "2.76.0",
+        "node-opcua-service-subscription": "2.76.0",
+        "node-opcua-service-translate-browse-path": "2.76.0",
+        "node-opcua-service-write": "2.76.0",
+        "node-opcua-status-code": "2.76.0",
+        "node-opcua-types": "2.76.0",
+        "node-opcua-utils": "2.76.0",
+        "node-opcua-variant": "2.76.0",
         "once": "^1.4.0",
-        "thenify": "^3.3.1",
-        "underscore": "^1.13.4"
+        "thenify": "^3.3.1"
     },
     "devDependencies": {
+        "@types/underscore": "^1.11.4",
         "dequeue": "^1.0.5",
-        "node-opcua-address-space": "2.73.1",
-        "node-opcua-binary-stream": "2.73.0",
-        "node-opcua-factory": "2.73.1",
-        "node-opcua-leak-detector": "2.71.0",
-        "node-opcua-nodesets": "2.73.0",
+        "mocha": "^10.0.0",
+        "node-opcua-address-space": "2.76.0",
+        "node-opcua-binary-stream": "2.76.0",
+        "node-opcua-factory": "2.76.0",
+        "node-opcua-leak-detector": "2.76.0",
+        "node-opcua-nodesets": "2.74.0",
         "should": "^13.2.3",
-        "sinon": "^14.0.0"
+        "sinon": "^14.0.0",
+        "underscore": "^1.13.4"
     },
     "eslintConfig": {
         "env": {
@@ -93,5 +93,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "684a796e88e1732f418f2ada6aca2808e0115de8"
+    "gitHead": "75d9b8cf894c8fbadf77d2c4a48a730d055465e7"
 }

package/source/alarms_and_conditions/client_alarm.ts

@@ -1,11 +1,14 @@
 import { EventEmitter } from "events";
 import { assert } from "node-opcua-assert";
+import { make_warningLog } from "node-opcua-debug";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { StatusCode } from "node-opcua-status-code";
 import { lowerFirstLetter } from "node-opcua-utils";
 import { DataType, Variant } from "node-opcua-variant";
 import { ClientSession } from "../client_session";
 
+const warningLog = make_warningLog(__filename);
+
 export interface TVariant<T> extends Variant {
     value: T;
 }
@@ -20,6 +23,7 @@ export interface EventStuff {
     activeState: TTwoStateStatus;
     ackedState: TTwoStateStatus;
     confirmedState: TTwoStateStatus;
+    conditionName?: TVariant<string>;
 }
 
 export interface ClientAlarm {
@@ -84,36 +88,43 @@ export class ClientAlarm extends EventEmitter {
     }
 }
 
-// ------------------------------------------------------------------------------------------------------------------------------
-export function fieldsToJson(fields: string[], eventFields: Variant[]): EventStuff {
-    function setProperty(_data: any, fieldName: string, value: Variant) {
+/**
+ * @private
+ */
+export function fieldsToJson(fields: string[], eventFields: Variant[], flat?: boolean): EventStuff {
+
+    function setProperty(_data: Record<string, unknown>, fieldName: string, value: Variant) {
         let name: string;
         if (!fieldName || value === null) {
             return;
         }
-        const f = fieldName.split(".");
-        if (f.length === 1) {
-            fieldName = lowerFirstLetter(fieldName);
-            _data[fieldName] = value;
-        } else {
-            for (let i = 0; i < f.length - 1; i++) {
-                name = lowerFirstLetter(f[i]);
-                _data[name] = _data[name] || {};
-                _data = _data[name];
+        if (!flat) {
+            const f = fieldName.split(".");
+            if (f.length === 1) {
+                fieldName = lowerFirstLetter(fieldName);
+                _data[fieldName] = value;
+            } else {
+                for (let i = 0; i < f.length - 1; i++) {
+                    name = lowerFirstLetter(f[i]);
+                    _data[name] = _data[name] || {};
+                    _data = _data[name] as Record<string, unknown>;
+                }
+                name = lowerFirstLetter(f[f.length - 1]);
+                _data[name] = value;
             }
-            name = lowerFirstLetter(f[f.length - 1]);
+        } else {
+            const name = fieldName.split(".").map(lowerFirstLetter).join(".");
             _data[name] = value;
         }
     }
     if (fields.length > eventFields.length) {
-        // tslint:disable-next-line: no-console
-        console.log("warning fields.length !==  eventFields.length", fields.length, eventFields.length);
+        warningLog("warning fields.length !==  eventFields.length", fields.length, eventFields.length);
     }
     const data: any = {};
     for (let index = 0; index < fields.length; index++) {
         const variant = eventFields[index];
         setProperty(data, fields[index], variant);
     }
-    setProperty(data, "conditionId", eventFields[eventFields.length - 1]);
+
     return data;
 }

package/source/alarms_and_conditions/client_alarm_list.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
 import { assert } from "node-opcua-assert";
+import { DataType } from "node-opcua-basic-types";
 import { NodeId } from "node-opcua-nodeid";
 import { ClientAlarm, EventStuff } from "./client_alarm";
 

package/source/alarms_and_conditions/client_alarm_tools.ts

@@ -1,10 +1,10 @@
 import { AttributeIds } from "node-opcua-data-model";
 import { resolveNodeId } from "node-opcua-nodeid";
-import { constructEventFilter } from "node-opcua-service-filter";
+import { constructEventFilter, ofType } from "node-opcua-service-filter";
 import { ReadValueIdOptions, TimestampsToReturn } from "node-opcua-service-read";
 import { CreateSubscriptionRequestOptions, MonitoringParametersOptions } from "node-opcua-service-subscription";
-import { Variant } from "node-opcua-variant";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { DataType, Variant } from "node-opcua-variant";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
 
 import { ClientMonitoredItem } from "../client_monitored_item";
 import { ClientSubscription } from "../client_subscription";
@@ -16,6 +16,7 @@ import { callConditionRefresh } from "./client_tools";
 
 const doDebug = checkDebugFlag("A&E");
 const debugLog = make_debugLog("A&E");
+const warningLog = make_warningLog("A&E");
 
 function r(_key: string, o: { dataType?: unknown; value?: unknown }) {
     if (o && o.dataType === "Null") {
@@ -67,7 +68,7 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
     _sessionPriv.$clientAlarmList = clientAlarmList;
 
     const request: CreateSubscriptionRequestOptions = {
-        maxNotificationsPerPublish: 10000,
+        maxNotificationsPerPublish: 100,
         priority: 6,
         publishingEnabled: true,
         requestedLifetimeCount: 10000,
@@ -84,21 +85,20 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
 
     const fields = await extractConditionFields(session, "AlarmConditionType");
 
-    const eventFilter = constructEventFilter(fields, [resolveNodeId("AcknowledgeableConditionType")]);
+    const AcknowledgeableConditionType = resolveNodeId("AcknowledgeableConditionType");
+
+    const eventFilter = constructEventFilter(fields, ofType(AcknowledgeableConditionType));
 
     const monitoringParameters: MonitoringParametersOptions = {
         discardOldest: false,
         filter: eventFilter,
-        queueSize: 10000,
+        queueSize: 1000,
         samplingInterval: 0
     };
 
     // now create a event monitored Item
     const eventMonitoringItem = await subscription.monitor(itemToMonitor, monitoringParameters, TimestampsToReturn.Both);
 
-    const RefreshStartEventType = resolveNodeId("RefreshStartEventType").toString();
-    const RefreshEndEventType = resolveNodeId("RefreshEndEventType").toString();
-
     const queueEvent: EventStuff[] = [];
     function flushQueue() {
         const q = [...queueEvent];
@@ -110,17 +110,25 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
 
     let inInit = true;
     eventMonitoringItem.on("changed", (eventFields: Variant[]) => {
-        debugLog("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ---- ALARM RECEIVED");
-        const pojo = fieldsToJson(fields, eventFields) as EventStuff;
+        
+        const pojo = fieldsToJson(fields, eventFields);
+        const { eventType, eventId, conditionId, conditionName } = pojo;
+
+        debugLog(
+            "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ---- ALARM RECEIVED " +
+                eventType.value.toString() +
+                " " +
+                eventId.value?.toString("hex")
+        );
         try {
-            if (pojo.eventType.value.toString() === RefreshStartEventType) {
-                return;
-            }
-            if (pojo.eventType.value.toString() === RefreshEndEventType) {
-                return;
-            }
-            if (!pojo.conditionId || !pojo.conditionId.value || pojo.conditionId.dataType === 0) {
+            if (!conditionId || !conditionId.value || conditionId.dataType === DataType.Null) {
                 // not a acknowledgeable condition
+                warningLog(
+                    " not acknowledgeable condition ---- " + eventType.value.toString() + " ",
+                    conditionId,
+                    conditionName?.value,
+                    " " + eventId.value?.toString("hex")
+                );
                 return;
             }
             queueEvent.push(pojo);
@@ -128,10 +136,8 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
                 setTimeout(() => flushQueue(), 10);
             }
         } catch (err) {
-            // tslint:disable-next-line: no-console
-            console.log(JSON.stringify(pojo, r, " "));
-            // tslint:disable-next-line: no-console
-            console.log("Error !!", err);
+            warningLog(JSON.stringify(pojo, r, " "));
+            warningLog("Error !!", err);
         }
 
         // Release 1.04 8 OPC Unified Architecture, Part 9
@@ -150,7 +156,11 @@ export async function installAlarmMonitoring(session: ClientSession): Promise<Cl
     try {
         await callConditionRefresh(subscription);
     } catch (err) {
-        console.log("Server may not implement condition refresh", (<Error>err).message);
+        if ((err as Error).message.match(/BadNothingToDo/)) {
+            /** fine! nothing to do */
+        } else {
+            warningLog("Server may not implement condition refresh", (<Error>err).message);
+        }
     }
     _sessionPriv.$monitoredItemForAlarmList = eventMonitoringItem;