node-opcua-address-space 2.70.3 → 2.72.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.70.3",
+    "version": "2.72.1",
     "description": "pure nodejs OPCUA SDK - module -address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -17,54 +17,54 @@
     },
     "dependencies": {
         "@types/lodash": "4.14.182",
-        "async": "^3.2.3",
+        "async": "^3.2.4",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.70.3",
+        "node-opcua-address-space-base": "2.72.1",
         "node-opcua-assert": "2.66.0",
-        "node-opcua-basic-types": "2.70.0",
-        "node-opcua-client-dynamic-extension-object": "2.70.3",
+        "node-opcua-basic-types": "2.72.1",
+        "node-opcua-client-dynamic-extension-object": "2.72.1",
         "node-opcua-constants": "2.70.0",
-        "node-opcua-data-access": "2.70.3",
-        "node-opcua-data-model": "2.70.0",
-        "node-opcua-data-value": "2.70.0",
-        "node-opcua-date-time": "2.69.0",
-        "node-opcua-debug": "2.69.0",
-        "node-opcua-enum": "2.69.0",
-        "node-opcua-factory": "2.70.0",
-        "node-opcua-nodeid": "2.70.0",
-        "node-opcua-nodeset-ua": "2.70.3",
-        "node-opcua-numeric-range": "2.70.0",
-        "node-opcua-object-registry": "2.69.0",
-        "node-opcua-pseudo-session": "2.70.3",
-        "node-opcua-schemas": "2.70.3",
-        "node-opcua-service-browse": "2.70.3",
-        "node-opcua-service-call": "2.70.3",
-        "node-opcua-service-filter": "2.70.3",
-        "node-opcua-service-history": "2.70.3",
-        "node-opcua-service-translate-browse-path": "2.70.3",
-        "node-opcua-service-write": "2.70.3",
-        "node-opcua-status-code": "2.70.0",
-        "node-opcua-types": "2.70.3",
-        "node-opcua-utils": "2.69.0",
-        "node-opcua-variant": "2.70.0",
-        "node-opcua-xml2json": "2.70.3",
+        "node-opcua-data-access": "2.72.1",
+        "node-opcua-data-model": "2.72.1",
+        "node-opcua-data-value": "2.72.1",
+        "node-opcua-date-time": "2.71.0",
+        "node-opcua-debug": "2.71.0",
+        "node-opcua-enum": "2.71.0",
+        "node-opcua-factory": "2.72.1",
+        "node-opcua-nodeid": "2.71.0",
+        "node-opcua-nodeset-ua": "2.72.1",
+        "node-opcua-numeric-range": "2.72.1",
+        "node-opcua-object-registry": "2.71.0",
+        "node-opcua-pseudo-session": "2.72.1",
+        "node-opcua-schemas": "2.72.1",
+        "node-opcua-service-browse": "2.72.1",
+        "node-opcua-service-call": "2.72.1",
+        "node-opcua-service-filter": "2.72.1",
+        "node-opcua-service-history": "2.72.1",
+        "node-opcua-service-translate-browse-path": "2.72.1",
+        "node-opcua-service-write": "2.72.1",
+        "node-opcua-status-code": "2.71.0",
+        "node-opcua-types": "2.72.1",
+        "node-opcua-utils": "2.71.0",
+        "node-opcua-variant": "2.72.1",
+        "node-opcua-xml2json": "2.71.0",
         "semver": "^7.3.7",
         "set-prototype-of": "^1.0.0",
         "thenify": "^3.3.1",
         "xml-writer": "^1.7.0"
     },
     "devDependencies": {
-        "@types/semver": "7.3.9",
+        "@types/semver": "7.3.10",
         "humanize": "0.0.9",
-        "node-opcua-benchmarker": "2.69.0",
-        "node-opcua-binary-stream": "2.69.0",
-        "node-opcua-extension-object": "2.70.0",
-        "node-opcua-leak-detector": "2.69.0",
-        "node-opcua-nodesets": "2.70.3",
-        "node-opcua-packet-analyzer": "2.70.0",
-        "node-opcua-test-fixtures": "2.69.0",
+        "node-opcua-benchmarker": "2.71.0",
+        "node-opcua-binary-stream": "2.71.0",
+        "node-opcua-extension-object": "2.72.1",
+        "node-opcua-leak-detector": "2.71.0",
+        "node-opcua-nodesets": "2.71.0",
+        "node-opcua-packet-analyzer": "2.72.1",
+        "node-opcua-test-fixtures": "2.71.0",
         "should": "^13.2.3",
         "sinon": "^14.0.0",
         "source-map-support": "^0.5.21"
@@ -84,5 +84,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "08b5465af631fd010bc48843c951b2e556270de4"
+    "gitHead": "ba98dd91a9eada9815268c66c98ca5391bc884e7"
 }

package/source/loader/load_nodeset2.ts

@@ -17,7 +17,7 @@ import {
     UAVariableType
 } from "node-opcua-address-space-base";
 import { assert, renderError } from "node-opcua-assert";
-import { isValidGuid, StatusCodes } from "node-opcua-basic-types";
+import { coerceInt64, coerceUInt64, Int64, isValidGuid, StatusCodes, UInt64 } from "node-opcua-basic-types";
 import { EUInformation } from "node-opcua-data-access";
 import {
     AccessLevelFlag,
@@ -55,6 +55,7 @@ import { NamespacePrivate } from "../../src/namespace_private";
 import { promoteObjectsAndVariables } from "./namespace_post_step";
 import { ensureDatatypeExtracted } from "./ensure_datatype_extracted";
 import { decodeXmlExtensionObject } from "./decode_xml_extension_object";
+import { makeSemverCompatible } from "./make_semver_compatible";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
@@ -248,20 +249,6 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         return namespace;
     }
 
-    /**
-     * take a OPCUA version string and make it compliant with the semver specification
-     * @param version
-     * @returns
-     */
-    function makeSemverCompatible(version?: string): string {
-        version = version || "0.0.0";
-        const version_array = version.split(".").map((a) => parseInt(a, 10));
-
-        if (version_array.length === 2) {
-            version_array.push(0);
-        }
-        return version_array.map((a) => a.toString()).join(".");
-    }
     function _add_namespace(model: Model) {
         if (model.requiredModels.length > 0) {
             // check that required models exist already in the address space
@@ -276,8 +263,18 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
                     );
                     throw new Error("LoadNodeSet : Cannot find namespace for " + requiredModel.modelUri);
                 }
-
-                if (semver.lt(makeSemverCompatible(existingNamespace.version), makeSemverCompatible(requiredModel.version))) {
+                /**
+                 *  from https://reference.opcfoundation.org/Core/docs/Part6/F.2/
+                 *  The version of the model defined in the UANodeSet.
+                 *  This is a human readable string and not intended for programmatic comparisons.
+                 *
+                 */
+                const isLowerVersion = (existingVersion: string, requiredVersion: string): boolean => {
+                    const existingSemver = makeSemverCompatible(existingVersion);
+                    const requiredSemver = makeSemverCompatible(requiredVersion);
+                    return semver.lt(existingSemver, requiredSemver);
+                };
+                if (isLowerVersion(existingNamespace.version, requiredModel.version)) {
                     errorLog(
                         "Expecting ",
                         requiredModel.modelUri,
@@ -969,6 +966,7 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         return {
             finish(this: any) {
                 this.parent.parent.obj.value = {
+                    arrayType: VariantArrayType.Scalar,
                     dataType: (DataType as any)[type],
                     value: p(this.text)
                 };
@@ -1027,6 +1025,9 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
         };
     }
 
+    const parseUInt64 = (str: string): UInt64 => coerceUInt64(str);
+    const parseInt64 = (str: string): Int64 => coerceInt64(str);
+
     const state_Variant = {
         init: () => {
             /* empty */
@@ -1110,6 +1111,9 @@ export function makeNodeSetParserEngine(addressSpace: IAddressSpace): NodeSet2Pa
             UInt32: parser2("UInt32", parseInt),
             UInt8: parser2("UInt8", parseInt),
 
+            UInt64: parser2("UInt64", parseUInt64),
+            Int64: parser2("Int64", parseInt64),
+
             ByteString: {
                 init(this: any) {
                     this.value = null;

package/source/loader/make_semver_compatible.ts

@@ -0,0 +1,23 @@
+/**
+ * take a OPCUA version string and make it compliant with the semver specification
+ * @param version
+ * @returns
+ */
+export function makeSemverCompatible(version?: string): string {
+    version = version || "0.0.0";
+
+    const matches = version.match(/[0-9]+(\.[0-9]+(\.[0-9]+)?)?/);
+    if (!matches) {
+        return "0.0.0";
+    }
+    version = matches[0];
+    const version_array = version.split(".").map((a) => parseInt(a, 10));
+
+    if (version_array.length === 1) {
+        version_array.push(0);
+    }
+    if (version_array.length === 2) {
+        version_array.push(0);
+    }
+    return version_array.map((a) => a.toString()).join(".");
+}

package/source/loader/make_xml_extension_object_parser.ts

@@ -1,4 +1,4 @@
-import { Byte, Int16, Int32, Int64, SByte, UAString, UInt16, UInt32 } from "node-opcua-basic-types";
+import { Byte, coerceInt64, coerceUInt64, Int16, Int32, Int64, SByte, UAString, UInt16, UInt32, UInt64 } from "node-opcua-basic-types";
 import { LocalizedTextLike, LocalizedTextOptions } from "node-opcua-data-model";
 import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { coerceNodeId, NodeId, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
@@ -82,7 +82,7 @@ const localizedTextReader: ReaderStateParserLike = {
 };
 
 function clamp(value: number, minValue: number, maxValue: number) {
-    if (value < minValue) {
+    if (value< minValue) {
         warningLog(`invalid value range : ${value} < ${minValue} but should be [${minValue} , ${maxValue}]`);
         return minValue;
     }
@@ -95,6 +95,7 @@ function clamp(value: number, minValue: number, maxValue: number) {
 
 interface Parser<T> {
     value: T | null;
+    parent: any;
     text: string;
 }
 const partials: { [key: string]: ReaderStateParserLike } = {
@@ -105,6 +106,15 @@ const partials: { [key: string]: ReaderStateParserLike } = {
             this.value = this.text;
         }
     },
+    Guid: {
+        parser: {
+            String: {
+                finish(this: Parser<string>) {
+                    this.parent.value = this.text;
+                }
+            }
+        }
+    },
 
     Boolean: {
         finish(this: Parser<boolean>) {
@@ -161,8 +171,8 @@ const partials: { [key: string]: ReaderStateParserLike } = {
         }
     },
     Int64: {
-        finish(this: Parser<Int32>) {
-            this.value = parseInt(this.text, 10);
+        finish(this: Parser<Int64>) {
+            this.value = coerceInt64(parseInt(this.text, 10));
         }
     },
 
@@ -185,8 +195,8 @@ const partials: { [key: string]: ReaderStateParserLike } = {
     },
 
     UInt64: {
-        finish(this: Parser<UInt32>) {
-            this.value = parseInt(this.text, 10);
+        finish(this: Parser<UInt64>) {
+            this.value = coerceUInt64(parseInt(this.text, 10));
         }
     },
 

package/src/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -6,7 +6,7 @@ import { assert } from "node-opcua-assert";
 import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
 import { NodeId } from "node-opcua-nodeid";
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
-import { DataType, VariantLike } from "node-opcua-variant";
+import { DataType, VariantLike, VariantOptions } from "node-opcua-variant";
 import { INamespace, RaiseEventData, ISessionContext, UAEventType, UAMethod } from "node-opcua-address-space-base";
 import { CallMethodResultOptions } from "node-opcua-service-call";
 
@@ -16,6 +16,7 @@ import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_sta
 import { _setAckedState } from "./condition";
 import { ConditionSnapshot } from "./condition_snapshot";
 import { UAConditionHelper, UAConditionImpl, UAConditionEx } from "./ua_condition_impl";
+import { InstantiateAlarmConditionOptions } from "./ua_alarm_condition_impl";
 
 export interface UAAcknowledgeableConditionHelper extends UAConditionHelper {
     ///
@@ -53,8 +54,8 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     public static instantiate(
         namespace: INamespace,
         conditionTypeId: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAcknowledgeableConditionImpl {
         const conditionNode = UAConditionImpl.instantiate(
             namespace,
@@ -107,7 +108,9 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     }
 
     public static install_method_handle_on_type(addressSpace: AddressSpacePrivate): void {
-        const acknowledgeableConditionType = addressSpace.findEventType("AcknowledgeableConditionType") as unknown as UAAcknowledgeableCondition_Base;
+        const acknowledgeableConditionType = addressSpace.findEventType(
+            "AcknowledgeableConditionType"
+        ) as unknown as UAAcknowledgeableCondition_Base;
         assert(acknowledgeableConditionType !== null);
         acknowledgeableConditionType.acknowledge.bindMethod(_acknowledge_method);
         acknowledgeableConditionType.confirm?.bindMethod(_confirm_method);
@@ -297,7 +300,11 @@ export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements U
     }
 }
 
-function _acknowledge_method(inputArguments: VariantLike[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) {
+function _acknowledge_method(
+    inputArguments: VariantLike[],
+    context: ISessionContext,
+    callback: CallbackT<CallMethodResultOptions>
+) {
     UAConditionImpl.with_condition_method(
         inputArguments,
         context,
@@ -322,7 +329,7 @@ function _acknowledge_method(inputArguments: VariantLike[], context: ISessionCon
  *
  * @private
  */
-function _confirm_method(inputArguments: VariantLike[], context: ISessionContext,  callback: CallbackT<CallMethodResultOptions>) {
+function _confirm_method(inputArguments: VariantLike[], context: ISessionContext, callback: CallbackT<CallMethodResultOptions>) {
     UAConditionImpl.with_condition_method(
         inputArguments,
         context,

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -8,10 +8,10 @@ import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId, sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes } from "node-opcua-status-code";
-import { DataType } from "node-opcua-variant";
+import { DataType, VariantOptions } from "node-opcua-variant";
 import { UAAlarmCondition_Base } from "node-opcua-nodeset-ua";
+import { BaseNode, INamespace, UAEventType, UAVariable } from "node-opcua-address-space-base";
 
-import { BaseNode, INamespace, UAEventType, UAVariable } from "../../source";
 import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
 import { UAShelvedStateMachineEx, _clear_timer_if_any } from "../state_machine/ua_shelving_state_machine_ex";
 import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
@@ -23,6 +23,7 @@ import {
     UAAcknowledgeableConditionHelper,
     UAAcknowledgeableConditionImpl
 } from "./ua_acknowledgeable_condition_impl";
+import { InstantiateConditionOptions } from "./ua_condition_impl";
 
 function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
     alarmNode.suppressedOrShelved.setValueFromSource({
@@ -32,7 +33,7 @@ function _update_suppressedOrShelved(alarmNode: UAAlarmConditionImpl) {
 }
 export interface UAAlarmConditionHelper extends UAAcknowledgeableConditionHelper {
     activateAlarm(): void;
-    deactivateAlarm(): void;
+    deactivateAlarm(retain?: boolean): void;
     isSuppressedOrShelved(): boolean;
     getSuppressedOrShelved(): boolean;
     setMaxTimeShelved(duration: number): void;
@@ -65,14 +66,18 @@ export declare interface UAAlarmConditionImpl extends UAAlarmConditionEx, UAAckn
     on(eventName: string, eventHandler: any): this;
 }
 
+export interface InstantiateAlarmConditionOptions extends InstantiateConditionOptions {
+    maxTimeShelved?: number;
+    inputNode: BaseNode | NodeId;
+}
 export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl implements UAAlarmConditionEx {
     public static MaxDuration = Math.pow(2, 31);
 
     public static instantiate(
         namespace: INamespace,
         alarmConditionTypeId: UAEventType | string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
     ): UAAlarmConditionImpl {
         const addressSpace = namespace.addressSpace;
         // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
@@ -93,7 +98,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         options.optionals = options.optionals || [];
         if (Object.prototype.hasOwnProperty.call(options, "maxTimeShelved")) {
             options.optionals.push("MaxTimeShelved");
-            assert(isFinite(options.maxTimeShelved));
+            assert(isFinite(options.maxTimeShelved!));
         }
 
         assert(alarmConditionTypeBase === alarmConditionType || alarmConditionType.isSupertypeOf(alarmConditionTypeBase));
@@ -229,16 +234,16 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         branch.setAckedState(false);
     }
 
-    public deactivateAlarm(): void {
+    public deactivateAlarm(retain?: boolean): void {
         const branch = this.currentBranch();
-        branch.setRetain(true);
+        branch.setRetain(retain === undefined ? true : retain);
         branch.setActiveState(false);
     }
 
     /**
      * @deprecated use deactivateAlarm instead (with no s after de-activate)
      */
-    public desactivateAlarm(): void {
+    protected desactivateAlarm(): void {
         this.deactivateAlarm();
     }
 
@@ -325,7 +330,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
         this._onInputDataValueChange(dataValue);
     }
 
-    public _onInputDataValueChange(newValue: DataValue): void {
+    protected _onInputDataValueChange(newValue: DataValue): void {
         // xx console.log("class=",this.constructor.name,this.browseName.toString());
         // xx throw new Error("_onInputDataValueChange must be overridden");
     }

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -1,12 +1,20 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { DateTime } from "node-opcua-basic-types";
-import { DataType } from "node-opcua-variant";
-import { UACertificateExpirationAlarm, UACertificateExpirationAlarm_Base } from "node-opcua-nodeset-ua";
-import { INamespace } from "node-opcua-address-space-base";
+import { Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto";
+import { DateTime, minOPCUADate } from "node-opcua-basic-types";
+import { make_warningLog } from "node-opcua-debug";
+import { DataType, VariantOptions } from "node-opcua-variant";
+import { UACertificateExpirationAlarm_Base } from "node-opcua-nodeset-ua";
+import { INamespace, UAObject } from "node-opcua-address-space-base";
+import { ObjectTypeIds } from "node-opcua-constants";
+import { AccessRestrictionsFlag, makeAccessLevelExFlag } from "node-opcua-data-model";
+import { registerNodePromoter } from "../../source/loader/register_node_promoter";
+import { InstantiateOffNormalAlarmOptions, UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
 import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
 
+const warningLog = make_warningLog("AlarmsAndConditions");
+
 export interface UACertificateExpirationAlarmEx
     extends Omit<
         UACertificateExpirationAlarm_Base,
@@ -20,7 +28,15 @@ export interface UACertificateExpirationAlarmEx
         | "shelvingState"
         | "silenceState"
         | "suppressedState"
-    > {}
+    > {
+    getExpirationDate(): DateTime;
+    setExpirationDate(value: Date): void;
+    getExpirationLimit(): number;
+    setExpirationLimit(value: number): void;
+    setCertificate(certificate: Certificate | null): void;
+    getCertificate(): Certificate | null;
+}
+
 export declare interface UACertificateExpirationAlarmImpl extends UACertificateExpirationAlarmEx, UASystemOffNormalAlarmImpl {}
 /**
  * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server’s
@@ -28,23 +44,123 @@ export declare interface UACertificateExpirationAlarmImpl extends UACertificateE
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
 export class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
-    public static instantiate(namespace: INamespace, options: any, data: any): UACertificateExpirationAlarmImpl {
-        return UASystemOffNormalAlarmImpl.instantiate(
+    public static instantiate(
+        namespace: INamespace,
+        alarmType: "CertificateExpirationAlarmType",
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UACertificateExpirationAlarmImpl {
+        const alarm = UASystemOffNormalAlarmImpl.instantiate(
             namespace,
-            "CertificateExpirationAlarmType",
+            alarmType || "CertificateExpirationAlarmType",
             options,
             data
         ) as UACertificateExpirationAlarmImpl;
+        Object.setPrototypeOf(alarm, UACertificateExpirationAlarmImpl.prototype);
+        alarm._post_initialize();
+        return alarm;
     }
 
     public getExpirationDate(): DateTime {
         return this.expirationDate.readValue().value.value;
     }
 
-    public setExpirationDate(value: Date): void {
-        return this.expirationDate.setValueFromSource({
+    public setExpirationDate(expirationDate: Date): void {
+        this.expirationDate.setValueFromSource({
             dataType: DataType.DateTime,
+            value: expirationDate
+        });
+        const now = new Date();
+        const expirationLimit = this.getExpirationLimit();
+
+        const checkDate = new Date(now.getTime() + +expirationLimit);
+
+        const thumbprint = makeSHA1Thumbprint(this.getCertificate() || Buffer.alloc(0)).toString("hex");
+
+        if (expirationDate.getTime() <= checkDate.getTime()) {
+            if (!this.currentBranch().getActiveState()) {
+                warningLog(
+                    `CertificateExpirationAlarm:  becomes active, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()} expirationLimit=${expirationLimit}`
+                );
+            }
+            // also raise the event
+            if (expirationDate.getTime() <= now.getTime()) {
+                this.updateAlarmState(
+                    true,
+                    `certificate ${thumbprint} has expired : end date is ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
+                );
+            } else {
+                this.updateAlarmState(
+                    true,
+                    `certificate ${thumbprint} is about to expire : end date is ${expirationDate.toString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
+                );
+            }
+        } else {
+            if (this.currentBranch().getActiveState()) {
+                warningLog(
+                    `CertificateExpirationAlarm:  becomes desactivated, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} expirationLimit=${expirationLimit}`
+                );
+            }
+            // also raise the event
+            this.updateAlarmState(
+                false,
+                `certificate ${thumbprint} end date is OK: ${expirationDate.toString()} , expirationLimit=${expirationLimit}`
+            );
+        }
+    }
+
+    public getExpirationLimit(): number {
+        return (this.expirationLimit?.readValue().value.value as number) || 0;
+    }
+
+    public setExpirationLimit(value: number): void {
+        this.expirationLimit?.setValueFromSource({
+            dataType: DataType.Double,
             value
         });
     }
+
+    public getCertificate(): Certificate | null {
+        return (this.certificate.readValue().value.value as Certificate | null) || null;
+    }
+
+    public setCertificate(certificate: Certificate | null): void {
+        if (certificate && certificate.length > 0) {
+            const info = exploreCertificate(certificate);
+            if (info.tbsCertificate.validity.notAfter instanceof Date) {
+                this.setExpirationDate(info.tbsCertificate.validity.notAfter);
+            } else {
+                this.setExpirationDate(minOPCUADate);
+            }
+        } else {
+            this.setExpirationDate(minOPCUADate);
+        }
+        this.certificate.setValueFromSource({
+            dataType: DataType.ByteString,
+            value: certificate
+        });
+    }
+
+    _post_initialize() {
+        if (this.expirationLimit) {
+            this.expirationLimit.accessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
+            this.expirationLimit.userAccessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
+            this.expirationLimit.on("value_changed", (dataValue) => {
+                // make sure we re-evaluate the certificfate
+                const certificate = this.getCertificate();
+                this.setCertificate(certificate);
+            });
+        }
+    }
+}
+
+export function promoteToCertificateExpirationAlarm(node: UAObject): UACertificateExpirationAlarmImpl {
+    if (node instanceof UACertificateExpirationAlarmImpl) {
+        return node; // already promoted
+    }
+    Object.setPrototypeOf(node, UACertificateExpirationAlarmImpl.prototype);
+    const _node = node as unknown as UACertificateExpirationAlarmImpl;
+    _node._post_initialize();
+    return _node;
 }
+registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm);