node-opcua-client 2.168.0 → 2.169.0

package/source/private/client_subscription_impl.ts

@@ -3,14 +3,14 @@
  */
 // tslint:disable:unified-signatures
 
+import { EventEmitter } from "node:events";
 import chalk from "chalk";
-import { EventEmitter } from "events";
 
 import { assert } from "node-opcua-assert";
 import { promoteOpaqueStructureInNotificationData } from "node-opcua-client-dynamic-extension-object";
 import { AttributeIds } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
-import { resolveNodeId } from "node-opcua-nodeid";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import type { ReadValueIdOptions, TimestampsToReturn } from "node-opcua-service-read";
 import {
     CreateSubscriptionRequest,
@@ -19,7 +19,6 @@ import {
     type DeleteMonitoredItemsResponse,
     type DeleteSubscriptionsResponse,
     type EventNotificationList,
-    type ModifySubscriptionRequestOptions,
     type ModifySubscriptionResponse,
     MonitoringMode,
     type MonitoringParametersOptions,
@@ -48,6 +47,10 @@ import { ClientMonitoredItemGroupImpl } from "./client_monitored_item_group_impl
 import { ClientMonitoredItemImpl } from "./client_monitored_item_impl";
 import type { ClientSidePublishEngine } from "./client_publish_engine";
 import type { ClientSessionImpl } from "./client_session_impl";
+
+interface ModifySubscriptionOptionsEx extends ModifySubscriptionOptions {
+    subscriptionId?: SubscriptionId;
+}
 import { detectLongOperation } from "./performance";
 
 const debugLog = make_debugLog("CLIENT_SUBSCRIPTION");
@@ -121,7 +124,7 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
      */
     public get session(): ClientSessionImpl {
         assert(this.hasSession, "expecting a valid session");
-        return this.publishEngine.session! as ClientSessionImpl;
+        return this.publishEngine.session as ClientSessionImpl;
     }
     public get hasSession(): boolean {
         return !!this.publishEngine?.session;
@@ -243,34 +246,39 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         });
     }
 
-    public terminate(...args: any[]): any {
+    public terminate(): Promise<void>;
+    public terminate(callback: ErrorCallback): void;
+    public terminate(callback?: ErrorCallback): Promise<void> | void {
         debugLog("Terminating client subscription ", this.subscriptionId);
-        const callback = args[0];
-        assert(typeof callback === "function", "expecting a callback function");
 
-        if (this.subscriptionId === TERMINATED_SUBSCRIPTION_ID || this.subscriptionId === TERMINATING_SUBSCRIPTION_ID) {
+        if (
+            this.subscriptionId === TERMINATED_SUBSCRIPTION_ID ||
+            this.subscriptionId === TERMINATING_SUBSCRIPTION_ID
+        ) {
             // already terminated... just ignore
-            return callback();
+            callback?.();
+            return;
         }
 
-        if (isFinite(this.subscriptionId)) {
+        if (Number.isFinite(this.subscriptionId)) {
             const subscriptionId = this.subscriptionId;
             this.subscriptionId = TERMINATING_SUBSCRIPTION_ID;
             this.publishEngine.unregisterSubscription(subscriptionId);
 
             if (!this.hasSession) {
-                return this._terminate_step2(callback);
+                this._terminate_step2(callback as ErrorCallback);
+                return;
             }
             const session = this.session;
             if (!session) {
-                return callback(new Error("no session"));
+                return callback?.(new Error("no session"));
             }
             session.deleteSubscriptions(
                 {
                     subscriptionIds: [subscriptionId]
                 },
                 (err: Error | null, response?: DeleteSubscriptionsResponse) => {
-                    if (response && response!.results![0] !== StatusCodes.Good) {
+                    if (response && response?.results?.[0] !== StatusCodes.Good) {
                         debugLog("warning: deleteSubscription returned ", response.results);
                     }
                     if (err) {
@@ -281,13 +289,13 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
                          */
                         this.emit("internal_error", err);
                     }
-                    this._terminate_step2(callback);
+                    this._terminate_step2(callback as ErrorCallback);
                 }
             );
         } else {
             debugLog("subscriptionId is not value ", this.subscriptionId);
             assert(this.subscriptionId === PENDING_SUBSCRIPTION_ID);
-            this._terminate_step2(callback);
+            this._terminate_step2(callback as ErrorCallback);
         }
     }
 
@@ -299,6 +307,11 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         return this.#nextClientHandle;
     }
 
+    public async monitor(
+        itemToMonitor: ReadValueIdOptions,
+        requestedParameters: MonitoringParametersOptions,
+        timestampsToReturn: TimestampsToReturn
+    ): Promise<ClientMonitoredItemBase>;
     public async monitor(
         itemToMonitor: ReadValueIdOptions,
         requestedParameters: MonitoringParametersOptions,
@@ -310,18 +323,26 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         requestedParameters: MonitoringParametersOptions,
         timestampsToReturn: TimestampsToReturn,
         monitoringMode: MonitoringMode,
-        done: Callback<ClientMonitoredItemBase>
+        callback: Callback<ClientMonitoredItemBase>
     ): void;
-    public monitor(...args: any[]): any {
-        const itemToMonitor = args[0] as ReadValueIdOptions;
-        const requestedParameters = args[1] as MonitoringParametersOptions;
-        const timestampsToReturn = args[2] as TimestampsToReturn;
-        const monitoringMode = typeof args[3] === "function" ? MonitoringMode.Reporting : (args[3] as MonitoringMode);
-        const done = (typeof args[3] === "function" ? args[3] : args[4]) as Callback<ClientMonitoredItemBase>;
-
-        assert(typeof done === "function", "expecting a function here");
+    public monitor(
+        itemToMonitor: ReadValueIdOptions,
+        requestedParameters: MonitoringParametersOptions,
+        timestampsToReturn: TimestampsToReturn,
+        monitoringMode?: MonitoringMode | Callback<ClientMonitoredItemBase>,
+        callback?: Callback<ClientMonitoredItemBase>
+    ): Promise<ClientMonitoredItemBase> | undefined {
+
+        // When called with 3 args via the promise API, thenify
+        // injects its callback as the 4th argument (the
+        // monitoringMode slot).  Detect this and shift.
+        if (typeof monitoringMode === "function") {
+            callback = monitoringMode as Callback<ClientMonitoredItemBase>;
+            monitoringMode = MonitoringMode.Reporting;
+        }
+        monitoringMode = monitoringMode ?? MonitoringMode.Reporting;
 
-        itemToMonitor.nodeId = resolveNodeId(itemToMonitor.nodeId!);
+        itemToMonitor.nodeId = resolveNodeId(itemToMonitor.nodeId || NodeId.nullNodeId);
 
         const monitoredItem = ClientMonitoredItem_create(
             this,
@@ -329,13 +350,15 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
             requestedParameters,
             timestampsToReturn,
             monitoringMode,
-            (err1?: Error | null, monitoredItem2?: ClientMonitoredItem) => {
+            (err1?: Error | null, _monitoredItem2?: ClientMonitoredItem) => {
                 if (err1) {
-                    return done && done(err1);
+                    callback?.(err1);
+                    return;
                 }
-                done(err1 || null, monitoredItem);
+                callback?.(null, monitoredItem);
             }
         );
+        return undefined;
     }
 
     public async monitorItems(
@@ -343,35 +366,41 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         requestedParameters: MonitoringParametersOptions,
         timestampsToReturn: TimestampsToReturn
     ): Promise<ClientMonitoredItemGroup>;
-
     public monitorItems(
         itemsToMonitor: ReadValueIdOptions[],
         requestedParameters: MonitoringParametersOptions,
         timestampsToReturn: TimestampsToReturn,
-        done: Callback<ClientMonitoredItemGroup>
+        callback: Callback<ClientMonitoredItemGroup>
     ): void;
-    public monitorItems(...args: any[]): any {
-        const itemsToMonitor = args[0] as ReadValueIdOptions[];
-        const requestedParameters = args[1] as MonitoringParametersOptions;
-        const timestampsToReturn = args[2] as TimestampsToReturn;
-        const done = args[3] as Callback<ClientMonitoredItemGroup>;
+    public monitorItems(
+        itemsToMonitor: ReadValueIdOptions[],
+        requestedParameters: MonitoringParametersOptions,
+        timestampsToReturn: TimestampsToReturn,
+        callback?: Callback<ClientMonitoredItemGroup>
+    ): Promise<ClientMonitoredItemGroup> | undefined {
 
         const monitoredItemGroup = new ClientMonitoredItemGroupImpl(this, itemsToMonitor, requestedParameters, timestampsToReturn);
 
         this._wait_for_subscription_to_be_ready((err?: Error) => {
             if (err) {
-                return done(err);
+                callback?.(err);
+                return;
             }
             monitoredItemGroup._monitor((err1?: Error) => {
                 if (err1) {
-                    return done && done(err1);
+                    callback?.(err1);
+                    return;
                 }
-                done(err1!, monitoredItemGroup);
+                callback?.(null, monitoredItemGroup);
             });
         });
+        return undefined;
     }
 
-    public _delete_monitored_items(monitoredItems: ClientMonitoredItemBase[], callback: ErrorCallback): void {
+    public _delete_monitored_items(
+        monitoredItems: ClientMonitoredItemBase[],
+        callback: ErrorCallback
+    ): void {
         assert(typeof callback === "function");
         assert(Array.isArray(monitoredItems));
 
@@ -383,40 +412,44 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         const session = this.session as ClientSessionImpl;
         session.deleteMonitoredItems(
             {
-                monitoredItemIds: monitoredItems.map((monitoredItem) => monitoredItem.monitoredItemId),
+                monitoredItemIds: monitoredItems.map((monitoredItem) => monitoredItem.monitoredItemId as number),
                 subscriptionId: this.subscriptionId
             },
-            (err: Error | null, response?: DeleteMonitoredItemsResponse) => {
-                callback(err!);
+            (err: Error | null, _response?: DeleteMonitoredItemsResponse) => {
+                callback(err || undefined);
             }
         );
     }
 
     public async setPublishingMode(publishingEnabled: boolean): Promise<StatusCode>;
     public setPublishingMode(publishingEnabled: boolean, callback: Callback<StatusCode>): void;
-    public setPublishingMode(...args: any[]): any {
-        const publishingEnabled = args[0] as boolean;
-        const callback = args[1] as Callback<StatusCode>;
-        assert(typeof callback === "function");
+    public setPublishingMode(
+        publishingEnabled: boolean, callback?: Callback<StatusCode>
+    ): Promise<StatusCode> | undefined {
 
         const session = this.session as ClientSessionImpl;
         if (!session) {
-            return callback(new Error("no session"));
+            callback?.(new Error("no session"));
+            return;
         }
         const subscriptionId = this.subscriptionId as SubscriptionId;
         session.setPublishingMode(publishingEnabled, subscriptionId, (err: Error | null, statusCode?: StatusCode) => {
             if (err) {
-                return callback(err);
+                callback?.(err);
+                return;
             }
             /* c8 ignore next */
             if (!statusCode) {
-                return callback(new Error("Internal Error"));
+                callback?.(new Error("Internal Error"));
+                return;
             }
             if (statusCode.isNotGood()) {
-                return callback(null, statusCode);
+                callback?.(null, statusCode);
+                return;
             }
-            callback(null, StatusCodes.Good);
+            callback?.(null, StatusCodes.Good);
         });
+        return undefined;
     }
 
     /**
@@ -433,23 +466,28 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
         linksToRemove: ClientMonitoredItemBase[] | null,
         callback: Callback<SetTriggeringResponse>
     ): void;
-    public setTriggering(...args: any[]): any {
-        const triggeringItem = args[0] as ClientMonitoredItemBase;
-        const linksToAdd = args[1] as ClientMonitoredItemBase[] | null;
-        const linksToRemove = args[2] as ClientMonitoredItemBase[] | null;
-        const callback = args[3] as Callback<SetTriggeringResponse>;
-        assert(typeof callback === "function");
+    public setTriggering(
+        triggeringItem: ClientMonitoredItemBase,
+        linksToAdd: ClientMonitoredItemBase[] | null,
+        linksToRemove: ClientMonitoredItemBase[] | null,
+        callback?: Callback<SetTriggeringResponse>
+    ): Promise<SetTriggeringResponse> | undefined {
         const session = this.session as ClientSessionImpl;
         if (!session) {
-            return callback(new Error("no session"));
+            callback?.(new Error("no session"));
+            return;
         }
         const subscriptionId = this.subscriptionId;
 
-        const triggeringItemId = triggeringItem.monitoredItemId!;
+        const triggeringItemId = triggeringItem.monitoredItemId;
+        if (!triggeringItemId) {
+            callback?.(new Error("triggeringItem has no monitoredItemId"));
+            return;
+        }
 
         const setTriggeringRequest = new SetTriggeringRequest({
-            linksToAdd: linksToAdd ? linksToAdd.map((i) => i.monitoredItemId!) : null,
-            linksToRemove: linksToRemove ? linksToRemove.map((i) => i.monitoredItemId!) : null,
+            linksToAdd: linksToAdd ? linksToAdd.map((i) => i.monitoredItemId || 0) : null,
+            linksToRemove: linksToRemove ? linksToRemove.map((i) => i.monitoredItemId || 0) : null,
             subscriptionId,
             triggeringItemId
         });
@@ -457,31 +495,37 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
             if (err) {
                 if (response) {
                     // use soft error, no exceptions
-                    return callback(null, response);
+                    callback?.(null, response);
+                    return;
                 } else {
-                    return callback(err);
+                    callback?.(err);
+                    return;
                 }
             }
             // c8 ignore next
             if (!response) {
-                return callback(new Error("Internal Error"));
+                callback?.(new Error("Internal Error"));
+                return;
             }
-            callback(null, response);
+            callback?.(null, response);
         });
+        return undefined;
     }
 
     // public subscription service
     public modify(options: ModifySubscriptionOptions, callback: Callback<ModifySubscriptionResult>): void;
     public modify(options: ModifySubscriptionOptions): Promise<ModifySubscriptionResult>;
-    public modify(...args: any[]): any {
-        const modifySubscriptionRequest = args[0] as ModifySubscriptionRequestOptions;
-        const callback = args[1] as Callback<ModifySubscriptionResult>;
+    public modify(
+        modifySubscriptionRequest: ModifySubscriptionOptions,
+        callback?: Callback<ModifySubscriptionResult>
+    ): Promise<ModifySubscriptionResult> | undefined {
         const session = this.session as ClientSessionImpl;
         if (!session) {
-            return callback(new Error("no session"));
+            callback?.(new Error("no session"));
+            return undefined;
         }
 
-        modifySubscriptionRequest.subscriptionId = this.subscriptionId;
+        (modifySubscriptionRequest as ModifySubscriptionOptionsEx).subscriptionId = this.subscriptionId;
 
         modifySubscriptionRequest.priority =
             modifySubscriptionRequest.priority === undefined ? this.priority : modifySubscriptionRequest.priority;
@@ -504,49 +548,66 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
 
         session.modifySubscription(modifySubscriptionRequest, (err: Error | null, response?: ModifySubscriptionResponse) => {
             if (err || !response) {
-                return callback(err);
+                callback?.(err);
+                return;
             }
             this.publishingInterval = response.revisedPublishingInterval;
             this.lifetimeCount = response.revisedLifetimeCount;
             this.maxKeepAliveCount = response.revisedMaxKeepAliveCount;
-            callback(null, response);
+            callback?.(null, response);
         });
+        return undefined;
     }
 
     public getMonitoredItems(): Promise<MonitoredItemData>;
     public getMonitoredItems(callback: Callback<MonitoredItemData>): void;
-    public getMonitoredItems(...args: any[]): any {
-        this.session.getMonitoredItems(this.subscriptionId, args[0]);
+    public getMonitoredItems(callback?: Callback<MonitoredItemData>): Promise<MonitoredItemData> | undefined {
+        this.session.getMonitoredItems(this.subscriptionId, callback as Callback<MonitoredItemData>);
+        return undefined;
+    }
+
+    public toJSON(): Record<string, string | number | boolean> {
+        return {
+            subscriptionId: this.subscriptionId.toString(),
+            publishingInterval: this.publishingInterval,
+            lifetimeCount: this.lifetimeCount,
+            maxKeepAliveCount: this.maxKeepAliveCount,
+            hasTimedOut: this.hasTimedOut
+        };
     }
 
     public toString(): string {
         let str = "";
-        str += "subscriptionId      : " + this.subscriptionId + "\n";
-        str += "publishingInterval  : " + this.publishingInterval + "\n";
-        str += "lifetimeCount       : " + this.lifetimeCount + "\n";
-        str += "maxKeepAliveCount   : " + this.maxKeepAliveCount + "\n";
-        str += "hasTimedOut         : " + this.hasTimedOut + "\n";
+        str += `subscriptionId      : ${this.subscriptionId}\n`;
+        str += `publishingInterval  : ${this.publishingInterval}\n`;
+        str += `lifetimeCount       : ${this.lifetimeCount}\n`;
+        str += `maxKeepAliveCount   : ${this.maxKeepAliveCount}\n`;
+        str += `hasTimedOut         : ${this.hasTimedOut}\n`;
 
         const timeToLive = this.lifetimeCount * this.publishingInterval;
-        str += "(maxKeepAliveCount*publishingInterval: " + this.publishingInterval * this.maxKeepAliveCount + " ms)\n";
-        str += "(maxLifetimeCount*publishingInterval: " + timeToLive + " ms)\n";
+        str += `(maxKeepAliveCount*publishingInterval: ${this.publishingInterval * this.maxKeepAliveCount} ms)\n`;
+        str += `(maxLifetimeCount*publishingInterval: ${timeToLive} ms)\n`;
 
         const lastRequestSentTime = this.publishEngine.lastRequestSentTime;
-        str += "lastRequestSentTime : " + lastRequestSentTime.toString() + "\n";
+        str += `lastRequestSentTime : ${lastRequestSentTime.toString()}\n`;
         const duration = Date.now() - lastRequestSentTime.getTime();
         const extra =
             duration - timeToLive > 0
-                ? chalk.red(" expired since " + (duration - timeToLive) / 1000 + " seconds")
-                : chalk.green(" valid for " + -(duration - timeToLive) / 1000 + " seconds");
+                ? chalk.red(` expired since ${(duration - timeToLive) / 1000} seconds`)
+                : chalk.green(` valid for ${-(duration - timeToLive) / 1000} seconds`);
 
-        str += "timeSinceLast PR    : " + duration + "ms" + extra + "\n";
-        str += "has expired         : " + (duration > timeToLive) + "\n";
+        str += `timeSinceLast PR    : ${duration}ms${extra}\n`;
+        str += `has expired         : ${duration > timeToLive}\n`;
 
-        str += "(session timeout    : " + this.session.timeout + " ms)\n";
+        str += `(session timeout    : ${this.session.timeout} ms)\n`;
 
         return str;
     }
 
+    public [Symbol.for("nodejs.util.inspect.custom")](): string {
+        return this.toString();
+    }
+
     /**
      * returns the approximated remaining life time of this subscription in milliseconds
      */
@@ -757,8 +818,7 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
                         if (s(this).$_slowNotifCount > 0 && s(this).$_slowNotifCount % 1000 !== 0) return;
                         s(this).$_slowNotifCount++;
                         warningLog(
-                            `[NODE-OPCUA-W32]}: monitored.item event handler takes too much time : operation duration ${duration} ms [repeated ${
-                                s(this).$_slowNotifCount
+                            `[NODE-OPCUA-W32]}: monitored.item event handler takes too much time : operation duration ${duration} ms [repeated ${s(this).$_slowNotifCount
                             } times]\n         please ensure that your monitoredItem event handler is not blocking the event loop.`
                         );
                     }
@@ -805,7 +865,7 @@ export class ClientSubscriptionImpl extends EventEmitter implements ClientSubscr
     }
 
     public _removeGroup(monitoredItemGroup: ClientMonitoredItemGroup): void {
-        (monitoredItemGroup as any)._terminate_and_emit();
+        (monitoredItemGroup as ClientMonitoredItemGroupImpl)._terminate_and_emit();
         this.#monitoredItemGroups = this.#monitoredItemGroups.filter((obj) => obj !== monitoredItemGroup);
     }
     /**
@@ -879,7 +939,7 @@ export function ClientMonitoredItem_create(
 // tslint:disable:max-line-length
 import { withCallback } from "thenify-ex";
 
-const opts = { multiArgs: false };
+const _opts = { multiArgs: false };
 
 ClientSubscriptionImpl.prototype.setPublishingMode = withCallback(ClientSubscriptionImpl.prototype.setPublishingMode);
 ClientSubscriptionImpl.prototype.monitor = withCallback(ClientSubscriptionImpl.prototype.monitor);

package/source/private/opcua_client_impl.ts

@@ -570,6 +570,15 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
         );
     }
 
+    public toJSON(): Record<string, string | number | boolean | undefined> {
+        return {
+            endpointUrl: this.endpointUrl,
+            serverUri: this.serverUri,
+            requestedSessionTimeout: this.requestedSessionTimeout,
+            status: this._internalState
+        };
+    }
+
     public toString(): string {
         let str = ClientBaseImpl.prototype.toString.call(this);
         str += `  requestedSessionTimeout....... ${this.requestedSessionTimeout}\n`;
@@ -578,6 +587,10 @@ export class OPCUAClientImpl extends ClientBaseImpl<OPCUAClientBaseEvents> {
         return str;
     }
 
+    public [Symbol.for("nodejs.util.inspect.custom")](): string {
+        return this.toString();
+    }
+
     /**
      *
      * @example