@tier0/opcua-client 0.6.3 → 0.6.4

package/README.md

@@ -364,13 +364,25 @@ Messages contain payload.level, event, message, time (ISO 8601), nodeId,
 connectionId, operation, retrying and optional statusCode/counts. Subscription
 recovery includes rebuilt and dataGapPossible. The envelope contains
 opcua.operation = "diagnostic". No input values, endpoint URLs, credentials,
-certificates or raw SDK error text are copied to this output. Existing runtime
-logs and Catch handling remain unchanged; output 2 is additional reporting.
+certificates or raw SDK error text are copied to this output.
+
+Background connection and subscription startup/recovery failures also call
+`node.error(error, msg)` on each affected operation node. Connect a Catch node
+in the same flow to Debug or your error-handling logic; scope Catch to the UA
+operation nodes as needed. The shared Connection configuration no longer emits
+duplicate state/fault warnings. A continuing background failure is reported to
+Catch once per operation node until recovery. Connection recovery re-arms
+connection errors; subscription errors require successful reconciliation.
+Failed input requests still call `done(error)` for each request, preserving the
+original message. A concurrent connection failure reported by that input does
+not also generate a background Catch error. Point-level non-Good results remain
+available on output 2; configuration advice and cleanup warnings remain warnings.
 
 Identical event/status-code pairs are emitted at most once per 30 seconds per
 node. The next emitted matching event includes suppressed repeats; there is
 no delayed timer flush. Connection restoration resets this suppression window.
-This limit applies only to diagnostic output, not the existing runtime logs.
+This 30-second limit applies only to diagnostic output; background Catch errors
+use the recovery-based rule above.
 
 For Subscribe, **Status messages → Both outputs (legacy compatible)** is the
 default: existing subscription-status messages remain on output 1 and the new

package/lib/diagnostics.js

@@ -26,6 +26,9 @@ function createDiagnostics(node, config, operation) {
   const recent = new Map();
   let closed = false;
   let interrupted = false;
+  const activeFailures = new Set();
+  const pendingFailures = new Map();
+  let inputs = 0;
   const client = node.connection?.client;
   function emit(level, event, message, details = {}, send) {
     if (closed) return;
@@ -76,6 +79,50 @@ function createDiagnostics(node, config, operation) {
   function failure(error, send, event = `${operation}_failed`, retrying = false) {
     emit('error', event, `OPC UA ${operation} failed`, { statusCode: statusCode(error), retrying }, send);
   }
+  // Background failures have no input message/done callback. Report from the
+  // operation node so Catch can scope the error to its flow. Retries belong to
+  // one failure episode, reset only by the corresponding recovery.
+  function backgroundFailure(error, event, group = 'subscription') {
+    if (closed) return;
+    if (interrupted) group = 'connection';
+    if (activeFailures.has(group)) return;
+    if (inputs) {
+      if (!pendingFailures.has(group)) pendingFailures.set(group, { error, event });
+      return;
+    }
+    activeFailures.add(group);
+    const code = statusCode(error);
+    const caught = new Error(`OPC UA ${event}: ${code}`);
+    caught.code = code;
+    node.error(caught, {
+      opcua: {
+        operation: 'diagnostic', event, statusCode: code,
+        nodeId: node.id || config.id, connectionId: config.connection,
+      },
+    });
+  }
+  function recovered(group) {
+    activeFailures.delete(group);
+    pendingFailures.delete(group);
+  }
+  function beginInput() {
+    inputs++;
+  }
+  function endInput(error) {
+    if (error) {
+      // done(error) already reports this input's failure to Catch.
+      for (const group of pendingFailures.keys()) activeFailures.add(group);
+      pendingFailures.clear();
+    }
+    inputs--;
+    if (!inputs) {
+      const pending = [...pendingFailures];
+      pendingFailures.clear();
+      for (const [group, failure] of pending) {
+        backgroundFailure(failure.error, failure.event, group);
+      }
+    }
+  }
   function results(items, send, descriptors) {
     const failed = items.filter((item) => item.statusCode && item.statusCode !== 'Good');
     const failures = failed.map((item) => ({
@@ -91,11 +138,13 @@ function createDiagnostics(node, config, operation) {
   }
   const onFault = (error) => {
     interrupted = true;
+    backgroundFailure(error, 'connection_fault', 'connection');
     emit('warn', 'connection_fault', 'OPC UA connection fault', { statusCode: statusCode(error), retrying: true });
   };
   const onState = (state) => {
     if (!state) return;
     if (state.state === 'connected') {
+      recovered('connection');
       if (interrupted) {
         recent.clear();
         emit('info', 'connection_restored', 'OPC UA connection restored; subscription recovery may still be pending');
@@ -103,6 +152,9 @@ function createDiagnostics(node, config, operation) {
       interrupted = false;
     } else if (['reconnecting', 'backoff', 'failed'].includes(state.state)) {
       interrupted = true;
+      if (state.state === 'failed') {
+        backgroundFailure(state.statusCode || 'OPCUA_CONNECTION_FAILED', 'connection_failed', 'connection');
+      }
       emit(state.state === 'failed' ? 'error' : 'warn', `connection_${state.state}`,
         'OPC UA connection unavailable; recovery pending', {
           retrying: true, ...(state.statusCode && state.statusCode !== 'Good' ? { statusCode: statusCode(state.statusCode) } : {}),
@@ -114,10 +166,12 @@ function createDiagnostics(node, config, operation) {
   node.on('close', () => {
     closed = true;
     recent.clear();
+    activeFailures.clear();
+    pendingFailures.clear();
     client?.removeListener?.('fault', onFault);
     client?.removeListener?.('state', onState);
   });
-  return { emit, failure, results };
+  return { emit, failure, backgroundFailure, recovered, beginInput, endInput, results };
 }
 
 module.exports = { createDiagnostics, statusCode };

package/nodes/browse.js

@@ -1,160 +1,165 @@
-'use strict';
-
-const { createDiagnostics } = require('../lib/diagnostics');
-
-const { chunks } = require('../lib/points');
-const { buildBrowseTree, selectedVariables } = require('../lib/browse-tree');
-
-const activeEditorBrowses = new Set();
-
-function positiveInteger(value, fallback, maximum) {
-  const number = Number(value);
-  if (!Number.isFinite(number) || number <= 0) return fallback;
-  return Math.min(Math.floor(number), maximum);
-}
-
-module.exports = function registerBrowseNode(RED) {
-  RED.httpAdmin.post(
-    '/opcua-client/browse',
-    RED.auth.needsPermission('opcua-client.browse'),
-    async (req, res) => {
-      const body = req.body || {};
-      const connectionId = String(body.connectionId || '');
-      const connection = RED.nodes.getNode(connectionId);
-      if (!connection?.client) {
-        res.status(404).send({ error: 'Connection is not deployed. Save and deploy it before loading the node tree.' });
-        return;
-      }
-      if (activeEditorBrowses.has(connectionId)) {
-        res.status(409).send({ error: 'A node-tree Browse is already running for this connection.' });
-        return;
-      }
-
-      const rootNodeId = String(body.rootNodeId || 'ns=0;i=85').trim();
-      if (!rootNodeId || rootNodeId.length > 1024) {
-        res.status(400).send({ error: 'Invalid root NodeId.' });
-        return;
-      }
-
-      activeEditorBrowses.add(connectionId);
-      try {
-        connection.markUsed?.('editor-browse');
-        const items = await connection.client.browse({
-          rootNodeId,
-          recursive: true,
-          variablesOnly: false,
-          maxDepth: positiveInteger(body.maxDepth, 10, 50),
-          maxNodes: positiveInteger(body.maxNodes, 10000, 100000),
-          browseBatchSize: positiveInteger(body.browseBatchSize, 100, 5000),
-          referencesPerNode: positiveInteger(body.referencesPerNode, 1000, 10000),
-          attributeBatchSize: positiveInteger(body.attributeBatchSize, 200, 5000),
-        });
-        const tree = buildBrowseTree(items, rootNodeId);
-        res.send({
-          tree, total: items.length, rootNodeId,
-          ...(items.diagnostics || {}),
-        });
-      } catch (error) {
-        const status = error?.code === 'OPCUA_RECONNECTING' ? 503 : 500;
-        res.status(status).send({ error: error.message || String(error) });
-      } finally {
-        activeEditorBrowses.delete(connectionId);
-      }
-    }
-  );
-
-  function OpcUaBrowseNode(config) {
-    RED.nodes.createNode(this, config);
-    const node = this;
-    node.connection = RED.nodes.getNode(config.connection);
-    const diagnostics = createDiagnostics(node, config, 'browse');
-    const consumer = node.connection?.registerConsumer?.('browse', {
-      nodeId: config.id, name: config.name,
-    });
-
-    node.on('input', async (msg, send, done) => {
-      if (!node.connection) {
-        const error = new Error('OPCUA_CONNECTION_NOT_CONFIGURED');
-        diagnostics.failure(error, send);
-        return done(error);
-      }
-
-      try {
-        consumer?.markUsed('browse');
-        const rootNodeId = msg.nodeId || msg.topic || config.rootNodeId || 'ns=0;i=85';
-        node.status({ fill: 'blue', shape: 'dot', text: 'browsing' });
-        const configuredSelection = selectedVariables(config.selectedNodes);
-        const useSelection = configuredSelection.length > 0 && msg.opcua?.liveBrowse !== true;
-        const points = useSelection ? configuredSelection : await node.connection.client.browse({
-            rootNodeId,
-            recursive: config.recursive !== false,
-            maxDepth: Number(config.maxDepth) || 10,
-            maxNodes: Number(config.maxNodes) || 10000,
-            variablesOnly: config.variablesOnly !== false,
-            namespaceIndexes: msg.opcua?.namespaceIndexes || [],
-            browseBatchSize: Number(config.browseBatchSize) || 100,
-            referencesPerNode: Number(config.referencesPerNode) || 1000,
-            attributeBatchSize: Number(config.attributeBatchSize) || 200,
-          });
-        const browseDiagnostics = useSelection ? null : points.diagnostics || null;
-
-        const outputMode = config.outputMode || 'all';
-        if (outputMode === 'paged') {
-          const pages = chunks(points, Number(config.pageSize) || 500);
-          pages.forEach((page, index) => send({
-            ...msg,
-            payload: page,
-            opcua: {
-              ...(msg.opcua || {}),
-              command: index === 0 ? 'replace' : 'add',
-              source: useSelection ? 'browse-selection' : 'browse',
-              rootNodeId,
-              page: index + 1,
-              pages: pages.length,
-              done: index === pages.length - 1,
-              total: points.length,
-              ...(browseDiagnostics ? { browse: browseDiagnostics } : {}),
-            },
-          }));
-        } else {
-          msg.payload = points;
-          msg.opcua = {
-            ...(msg.opcua || {}),
-            command: 'replace',
-            source: useSelection ? 'browse-selection' : 'browse',
-            rootNodeId,
-            done: true,
-            total: points.length,
-            ...(browseDiagnostics ? { browse: browseDiagnostics } : {}),
-          };
-          send(msg);
-        }
-
-        const partial = browseDiagnostics?.truncated || browseDiagnostics?.failures?.length;
-        if (partial) diagnostics.emit('warn', 'browse_partial', 'OPC UA Browse returned partial results', {
-          failed: browseDiagnostics?.failures?.length || 0, total: points.length,
-          failures: browseDiagnostics?.failures || [],
-        }, send);
-        node.status({
-          fill: partial ? 'yellow' : 'green', shape: partial ? 'ring' : 'dot',
-          text: `${points.length} points` +
-            (browseDiagnostics?.truncated
-              ? ` / truncated: ${browseDiagnostics.truncationReason}` : ''),
-        });
-        done();
-      } catch (error) {
-        node.status({ fill: 'red', shape: 'ring', text: error.message });
-        diagnostics.failure(error, send);
-        done(error);
-      }
-    });
-
-    node.on('close', (removed, done) => {
-      if (typeof removed === 'function') done = removed;
-      consumer?.release();
-      done?.();
-    });
-  }
-
-  RED.nodes.registerType('tier0-opcua-browse', OpcUaBrowseNode);
-};
+'use strict';
+
+const { createDiagnostics } = require('../lib/diagnostics');
+
+const { chunks } = require('../lib/points');
+const { buildBrowseTree, selectedVariables } = require('../lib/browse-tree');
+
+const activeEditorBrowses = new Set();
+
+function positiveInteger(value, fallback, maximum) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return fallback;
+  return Math.min(Math.floor(number), maximum);
+}
+
+module.exports = function registerBrowseNode(RED) {
+  RED.httpAdmin.post(
+    '/opcua-client/browse',
+    RED.auth.needsPermission('opcua-client.browse'),
+    async (req, res) => {
+      const body = req.body || {};
+      const connectionId = String(body.connectionId || '');
+      const connection = RED.nodes.getNode(connectionId);
+      if (!connection?.client) {
+        res.status(404).send({ error: 'Connection is not deployed. Save and deploy it before loading the node tree.' });
+        return;
+      }
+      if (activeEditorBrowses.has(connectionId)) {
+        res.status(409).send({ error: 'A node-tree Browse is already running for this connection.' });
+        return;
+      }
+
+      const rootNodeId = String(body.rootNodeId || 'ns=0;i=85').trim();
+      if (!rootNodeId || rootNodeId.length > 1024) {
+        res.status(400).send({ error: 'Invalid root NodeId.' });
+        return;
+      }
+
+      activeEditorBrowses.add(connectionId);
+      try {
+        connection.markUsed?.('editor-browse');
+        const items = await connection.client.browse({
+          rootNodeId,
+          recursive: true,
+          variablesOnly: false,
+          maxDepth: positiveInteger(body.maxDepth, 10, 50),
+          maxNodes: positiveInteger(body.maxNodes, 10000, 100000),
+          browseBatchSize: positiveInteger(body.browseBatchSize, 100, 5000),
+          referencesPerNode: positiveInteger(body.referencesPerNode, 1000, 10000),
+          attributeBatchSize: positiveInteger(body.attributeBatchSize, 200, 5000),
+        });
+        const tree = buildBrowseTree(items, rootNodeId);
+        res.send({
+          tree, total: items.length, rootNodeId,
+          ...(items.diagnostics || {}),
+        });
+      } catch (error) {
+        const status = error?.code === 'OPCUA_RECONNECTING' ? 503 : 500;
+        res.status(status).send({ error: error.message || String(error) });
+      } finally {
+        activeEditorBrowses.delete(connectionId);
+      }
+    }
+  );
+
+  function OpcUaBrowseNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    node.connection = RED.nodes.getNode(config.connection);
+    const diagnostics = createDiagnostics(node, config, 'browse');
+    const consumer = node.connection?.registerConsumer?.('browse', {
+      nodeId: config.id, name: config.name,
+    });
+
+    node.on('input', async (msg, send, done) => {
+      if (!node.connection) {
+        const error = new Error('OPCUA_CONNECTION_NOT_CONFIGURED');
+        diagnostics.failure(error, send);
+        return done(error);
+      }
+
+      diagnostics.beginInput();
+      let inputError;
+      try {
+        consumer?.markUsed('browse');
+        const rootNodeId = msg.nodeId || msg.topic || config.rootNodeId || 'ns=0;i=85';
+        node.status({ fill: 'blue', shape: 'dot', text: 'browsing' });
+        const configuredSelection = selectedVariables(config.selectedNodes);
+        const useSelection = configuredSelection.length > 0 && msg.opcua?.liveBrowse !== true;
+        const points = useSelection ? configuredSelection : await node.connection.client.browse({
+            rootNodeId,
+            recursive: config.recursive !== false,
+            maxDepth: Number(config.maxDepth) || 10,
+            maxNodes: Number(config.maxNodes) || 10000,
+            variablesOnly: config.variablesOnly !== false,
+            namespaceIndexes: msg.opcua?.namespaceIndexes || [],
+            browseBatchSize: Number(config.browseBatchSize) || 100,
+            referencesPerNode: Number(config.referencesPerNode) || 1000,
+            attributeBatchSize: Number(config.attributeBatchSize) || 200,
+          });
+        const browseDiagnostics = useSelection ? null : points.diagnostics || null;
+
+        const outputMode = config.outputMode || 'all';
+        if (outputMode === 'paged') {
+          const pages = chunks(points, Number(config.pageSize) || 500);
+          pages.forEach((page, index) => send({
+            ...msg,
+            payload: page,
+            opcua: {
+              ...(msg.opcua || {}),
+              command: index === 0 ? 'replace' : 'add',
+              source: useSelection ? 'browse-selection' : 'browse',
+              rootNodeId,
+              page: index + 1,
+              pages: pages.length,
+              done: index === pages.length - 1,
+              total: points.length,
+              ...(browseDiagnostics ? { browse: browseDiagnostics } : {}),
+            },
+          }));
+        } else {
+          msg.payload = points;
+          msg.opcua = {
+            ...(msg.opcua || {}),
+            command: 'replace',
+            source: useSelection ? 'browse-selection' : 'browse',
+            rootNodeId,
+            done: true,
+            total: points.length,
+            ...(browseDiagnostics ? { browse: browseDiagnostics } : {}),
+          };
+          send(msg);
+        }
+
+        const partial = browseDiagnostics?.truncated || browseDiagnostics?.failures?.length;
+        if (partial) diagnostics.emit('warn', 'browse_partial', 'OPC UA Browse returned partial results', {
+          failed: browseDiagnostics?.failures?.length || 0, total: points.length,
+          failures: browseDiagnostics?.failures || [],
+        }, send);
+        node.status({
+          fill: partial ? 'yellow' : 'green', shape: partial ? 'ring' : 'dot',
+          text: `${points.length} points` +
+            (browseDiagnostics?.truncated
+              ? ` / truncated: ${browseDiagnostics.truncationReason}` : ''),
+        });
+        done();
+      } catch (error) {
+        inputError = error;
+        node.status({ fill: 'red', shape: 'ring', text: error.message });
+        diagnostics.failure(error, send);
+        done(error);
+      } finally {
+        diagnostics.endInput(inputError);
+      }
+    });
+
+    node.on('close', (removed, done) => {
+      if (typeof removed === 'function') done = removed;
+      consumer?.release();
+      done?.();
+    });
+  }
+
+  RED.nodes.registerType('tier0-opcua-browse', OpcUaBrowseNode);
+};

package/nodes/connection.js

@@ -235,19 +235,13 @@ module.exports = function registerConnectionNode(RED) {
       );
     }
 
-    const onFault = (error) => node.warn(`OPC UA connection fault: ${error.message}`);
-    const onState = (state) => {
-      if (state.state === 'failed') node.warn(`OPC UA connection failed: ${state.statusCode}`);
-    };
-    node.client.on('fault', onFault);
-    node.client.on('state', onState);
+    // Operation nodes report connection faults to their own flow's Catch nodes.
+    // Logging here too duplicates each shared-connection failure globally.
     node.on('close', async (removed, done) => {
       if (typeof removed === 'function') {
         done = removed;
         removed = false;
       }
-      node.client.off('fault', onFault);
-      node.client.off('state', onState);
       registration.unregister();
       const cleanupResults = await Promise.allSettled(
         [...dependentCleanups].map(runDependentCleanup)