opcjs-client 0.1.20-alpha → 0.1.26-alpha

package/dist/index.cjs

@@ -3,11 +3,38 @@
 var opcjsBase = require('opcjs-base');
 
 // src/client.ts
+var SessionInvalidError = class extends Error {
+  statusCode;
+  constructor(statusCode) {
+    super(`Session is no longer valid: ${opcjsBase.StatusCodeToString(statusCode)} (0x${statusCode.toString(16).toUpperCase()})`);
+    this.name = "SessionInvalidError";
+    this.statusCode = statusCode;
+  }
+};
+
+// src/services/serviceBase.ts
 var ServiceBase = class {
   constructor(authToken, secureChannel) {
     this.authToken = authToken;
     this.secureChannel = secureChannel;
   }
+  /**
+   * Validates the `serviceResult` value from a response header.
+   *
+   * Throws `SessionInvalidError` for session-related status codes so callers
+   * can detect a dropped session and act accordingly (e.g. reconnect).
+   * Throws a generic `Error` for all other non-Good codes.
+   *
+   * @param result  - The `serviceResult` value from the response header.
+   * @param context - Short description used in the error message (e.g. "ReadRequest").
+   */
+  checkServiceResult(result, context) {
+    if (result === void 0 || result === opcjsBase.StatusCode.Good) return;
+    if (result === opcjsBase.StatusCode.BadSessionIdInvalid || result === opcjsBase.StatusCode.BadSessionClosed) {
+      throw new SessionInvalidError(result);
+    }
+    throw new Error(`${context} failed: ${opcjsBase.StatusCodeToString(result)} (${opcjsBase.StatusCodeToStringNumber(result)})`);
+  }
   createRequestHeader() {
     const requestHeader = new opcjsBase.RequestHeader();
     requestHeader.authenticationToken = this.authToken;
@@ -213,10 +240,7 @@ var AttributeService = class extends ServiceBase {
     request.nodesToRead = readValueIds;
     this.logger.debug("Sending ReadRequest...");
     const response = await this.secureChannel.issueServiceRequest(request);
-    const serviceResult = response.responseHeader?.serviceResult;
-    if (serviceResult !== void 0 && serviceResult !== opcjsBase.StatusCode.Good) {
-      throw new Error(`ReadRequest failed: ${opcjsBase.StatusCodeToString(serviceResult)} (${opcjsBase.StatusCodeToStringNumber(serviceResult)})`);
-    }
+    this.checkServiceResult(response.responseHeader?.serviceResult, "ReadRequest");
     const results = new Array();
     for (const dataValue of response.results ?? []) {
       results.push({
@@ -250,6 +274,8 @@ var SubscriptionHandlerEntry = class {
 };
 
 // src/subscriptionHandler.ts
+var NODE_ID_DATA_CHANGE_NOTIFICATION = 811;
+var NODE_ID_STATUS_CHANGE_NOTIFICATION = 818;
 var SubscriptionHandler = class {
   constructor(subscriptionService, monitoredItemService) {
     this.subscriptionService = subscriptionService;
@@ -258,6 +284,7 @@ var SubscriptionHandler = class {
   logger = opcjsBase.getLogger("SubscriptionHandler");
   entries = new Array();
   nextHandle = 0;
+  isRunning = false;
   async subscribe(ids, callback) {
     if (this.entries.length > 0) {
       throw new Error("Subscribing more than once is not implemented");
@@ -265,54 +292,66 @@ var SubscriptionHandler = class {
     const subscriptionId = await this.subscriptionService.createSubscription();
     const items = [];
     for (const id of ids) {
-      const entry = new SubscriptionHandlerEntry(
-        subscriptionId,
-        this.nextHandle++,
-        id,
-        callback
-      );
+      const entry = new SubscriptionHandlerEntry(subscriptionId, this.nextHandle++, id, callback);
       this.entries.push(entry);
-      const item = {
-        id,
-        handle: entry.handle
-      };
-      items.push(item);
+      items.push({ id, handle: entry.handle });
     }
     await this.monitoredItemService.createMonitoredItems(subscriptionId, items);
-    this.publish([]);
-  }
-  async publish(acknowledgeSequenceNumbers) {
-    const acknowledgements = [];
-    for (let i = 0; i < acknowledgeSequenceNumbers.length; i++) {
-      const acknowledgement = new opcjsBase.SubscriptionAcknowledgement();
-      acknowledgement.subscriptionId = this.entries[i].subscriptionId;
-      acknowledgement.sequenceNumber = acknowledgeSequenceNumbers[i];
-      acknowledgements.push(acknowledgement);
+    this.isRunning = true;
+    void this.publishLoop([]);
+  }
+  // https://reference.opcfoundation.org/Core/Part4/v105/docs/5.14.5
+  async publishLoop(pendingAcknowledgements) {
+    if (!this.isRunning) return;
+    let response;
+    try {
+      response = await this.subscriptionService.publish(pendingAcknowledgements);
+    } catch (err) {
+      this.logger.error(`Publish failed, stopping publish loop: ${err}`);
+      this.isRunning = false;
+      return;
+    }
+    const { subscriptionId, availableSequenceNumbers, moreNotifications, notificationMessage } = response;
+    const notificationDatas = notificationMessage?.notificationData ?? [];
+    const seqNumber = notificationMessage?.sequenceNumber;
+    const nextAcknowledgements = [];
+    const isKeepAlive = notificationDatas.length === 0;
+    if (!isKeepAlive && seqNumber !== void 0) {
+      const isAvailable = !availableSequenceNumbers || availableSequenceNumbers.includes(seqNumber);
+      if (isAvailable) {
+        const ack = new opcjsBase.SubscriptionAcknowledgement();
+        ack.subscriptionId = subscriptionId;
+        ack.sequenceNumber = seqNumber;
+        nextAcknowledgements.push(ack);
+      }
     }
-    const response = await this.subscriptionService.publish(acknowledgements);
-    const messagesToAcknowledge = response.notificationMessage.sequenceNumber;
-    const notificationDatas = response.notificationMessage.notificationData;
     for (const notificationData of notificationDatas) {
       const decodedData = notificationData.data;
       const typeNodeId = notificationData.typeId;
-      if (typeNodeId.namespace === 0 && typeNodeId.identifier === 811) {
+      if (typeNodeId.namespace === 0 && typeNodeId.identifier === NODE_ID_DATA_CHANGE_NOTIFICATION) {
         const dataChangeNotification = decodedData;
         for (const item of dataChangeNotification.monitoredItems) {
-          const clientHandle = item.clientHandle;
-          const value = item.value;
-          const entry = this.entries.find((e) => e.handle == clientHandle);
-          entry?.callback([{
-            id: entry.id,
-            value: value.value?.value
-          }]);
+          const entry = this.entries.find((e) => e.handle === item.clientHandle);
+          entry?.callback([{ id: entry.id, value: item.value.value?.value }]);
         }
+      } else if (typeNodeId.namespace === 0 && typeNodeId.identifier === NODE_ID_STATUS_CHANGE_NOTIFICATION) {
+        const statusChange = decodedData;
+        this.logger.warn(
+          `Subscription ${subscriptionId} status changed: 0x${statusChange.status?.toString(16).toUpperCase()}`
+        );
+        this.isRunning = false;
+        return;
       } else {
-        this.logger.warn(`Notification data type ${typeNodeId.namespace}:${typeNodeId.identifier} is not supported.`);
+        this.logger.warn(
+          `Notification data type ${typeNodeId.namespace}:${typeNodeId.identifier} is not supported.`
+        );
       }
     }
-    setTimeout(() => {
-      this.publish([messagesToAcknowledge]);
-    }, 500);
+    if (moreNotifications) {
+      void this.publishLoop(nextAcknowledgements);
+    } else {
+      setTimeout(() => void this.publishLoop(nextAcknowledgements), 0);
+    }
   }
 };
 var SubscriptionService = class extends ServiceBase {
@@ -426,10 +465,7 @@ var MethodService = class extends ServiceBase {
     request.methodsToCall = methodsToCall;
     this.logger.debug("Sending CallRequest...");
     const response = await this.secureChannel.issueServiceRequest(request);
-    const serviceResult = response.responseHeader?.serviceResult;
-    if (serviceResult !== void 0 && serviceResult !== opcjsBase.StatusCode.Good) {
-      throw new Error(`CallRequest failed: ${opcjsBase.StatusCodeToString(serviceResult)} (${opcjsBase.StatusCodeToStringNumber(serviceResult)})`);
-    }
+    this.checkServiceResult(response.responseHeader?.serviceResult, "CallRequest");
     return response.results.map((result) => ({
       statusCode: result.statusCode ?? opcjsBase.StatusCode.Good,
       value: result.outputArguments.map((arg) => arg.value)
@@ -466,10 +502,7 @@ var BrowseService = class extends ServiceBase {
     request.nodesToBrowse = nodesToBrowse;
     this.logger.debug("Sending BrowseRequest...");
     const response = await this.secureChannel.issueServiceRequest(request);
-    const serviceResult = response.responseHeader?.serviceResult;
-    if (serviceResult !== void 0 && serviceResult !== opcjsBase.StatusCode.Good) {
-      throw new Error(`BrowseRequest failed: ${opcjsBase.StatusCodeToString(serviceResult)}`);
-    }
+    this.checkServiceResult(response.responseHeader?.serviceResult, "BrowseRequest");
     return response.results ?? [];
   }
   /**
@@ -485,10 +518,7 @@ var BrowseService = class extends ServiceBase {
     request.continuationPoints = continuationPoints;
     this.logger.debug("Sending BrowseNextRequest...");
     const response = await this.secureChannel.issueServiceRequest(request);
-    const serviceResult = response.responseHeader?.serviceResult;
-    if (serviceResult !== void 0 && serviceResult !== opcjsBase.StatusCode.Good) {
-      throw new Error(`BrowseNextRequest failed: ${opcjsBase.StatusCodeToString(serviceResult)}`);
-    }
+    this.checkServiceResult(response.responseHeader?.serviceResult, "BrowseNextRequest");
     return response.results ?? [];
   }
   constructor(authToken, secureChannel) {
@@ -525,12 +555,50 @@ var Client = class {
   session;
   subscriptionHandler;
   logger;
+  // Stored after connect() so that refreshSession() can recreate services.
+  secureChannel;
+  sessionHandler;
   getSession() {
     if (!this.session) {
       throw new Error("No session available");
     }
     return this.session;
   }
+  /**
+   * (Re-)initialises all session-scoped services from the current `this.session`.
+   * Called both after the initial `connect()` and after a session refresh.
+   */
+  initServices() {
+    const authToken = this.session.getAuthToken();
+    const sc = this.secureChannel;
+    this.attributeService = new AttributeService(authToken, sc);
+    this.methodService = new MethodService(authToken, sc);
+    this.browseService = new BrowseService(authToken, sc);
+    this.subscriptionHandler = new SubscriptionHandler(
+      new SubscriptionService(authToken, sc),
+      new MonitoredItemService(authToken, sc)
+    );
+  }
+  /**
+   * Executes `fn` and, if it throws a `SessionInvalidError`, creates a fresh
+   * session and retries the operation exactly once.
+   *
+   * This covers the reactive case: a service call reveals that the server has
+   * already dropped the session (e.g. due to timeout). The new session is
+   * established transparently before re-running the original operation.
+   */
+  async withSessionRefresh(fn) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (!(err instanceof SessionInvalidError)) throw err;
+      this.logger.info(`Session invalid (${err.statusCode.toString(16)}), refreshing session...`);
+      this.session = await this.sessionHandler.createNewSession(this.identity);
+      this.initServices();
+      this.logger.info("Session refreshed, retrying operation.");
+      return await fn();
+    }
+  }
   async connect() {
     const wsOptions = { endpoint: this.endpointUrl };
     const ws = new opcjsBase.WebSocketFascade(wsOptions);
@@ -575,24 +643,21 @@ var Client = class {
     await sc.openSecureChannel();
     this.logger.debug("Secure channel established.");
     this.logger.debug("Creating session...");
-    const sessionHandler = new SessionHandler(sc, this.configuration);
-    this.session = await sessionHandler.createNewSession(this.identity);
+    this.sessionHandler = new SessionHandler(sc, this.configuration);
+    this.secureChannel = sc;
+    this.session = await this.sessionHandler.createNewSession(this.identity);
     this.logger.debug("Session created.");
     this.logger.debug("Initializing services...");
-    this.attributeService = new AttributeService(this.session.getAuthToken(), sc);
-    this.methodService = new MethodService(this.session.getAuthToken(), sc);
-    this.browseService = new BrowseService(this.session.getAuthToken(), sc);
-    this.subscriptionHandler = new SubscriptionHandler(
-      new SubscriptionService(this.session.getAuthToken(), sc),
-      new MonitoredItemService(this.session.getAuthToken(), sc)
-    );
+    this.initServices();
   }
   async disconnect() {
     this.logger.info("Disconnecting from OPC UA server...");
   }
   async read(ids) {
-    const result = await this.attributeService?.ReadValue(ids);
-    return result?.map((r) => new ReadValueResult(r.value, r.statusCode)) || [];
+    return this.withSessionRefresh(async () => {
+      const result = await this.attributeService?.ReadValue(ids);
+      return result?.map((r) => new ReadValueResult(r.value, r.statusCode)) ?? [];
+    });
   }
   /**
    * Method for calling a single method on the server.
@@ -602,17 +667,21 @@ var Client = class {
    * @returns The CallMethodResult for the invoked method.
    */
   async callMethod(objectId, methodId, inputArguments = []) {
-    const request = new opcjsBase.CallMethodRequest();
-    request.objectId = objectId;
-    request.methodId = methodId;
-    request.inputArguments = inputArguments.map((arg) => opcjsBase.Variant.newFrom(arg));
-    const responses = await this.methodService.call([request]);
-    const response = responses[0];
-    return new CallMethodResult(response.value, response.statusCode);
+    return this.withSessionRefresh(async () => {
+      const request = new opcjsBase.CallMethodRequest();
+      request.objectId = objectId;
+      request.methodId = methodId;
+      request.inputArguments = inputArguments.map((arg) => opcjsBase.Variant.newFrom(arg));
+      const responses = await this.methodService.call([request]);
+      const response = responses[0];
+      return new CallMethodResult(response.value, response.statusCode);
+    });
   }
   async browse(nodeId, recursive = false) {
-    const visited = /* @__PURE__ */ new Set();
-    return this.browseRecursive(nodeId, recursive, visited);
+    return this.withSessionRefresh(() => {
+      const visited = /* @__PURE__ */ new Set();
+      return this.browseRecursive(nodeId, recursive, visited);
+    });
   }
   async browseRecursive(nodeId, recursive, visited) {
     const nodeKey = `${nodeId.namespace}:${nodeId.identifier}`;
@@ -761,6 +830,7 @@ var UserIdentity = class _UserIdentity {
 exports.BrowseNodeResult = BrowseNodeResult;
 exports.Client = Client;
 exports.ConfigurationClient = ConfigurationClient;
+exports.SessionInvalidError = SessionInvalidError;
 exports.UserIdentity = UserIdentity;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map