@tier0/opcua-client 0.4.1 → 0.6.0

package/nodes/subscribe.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { messagePoints } = require('../lib/points');
+const { looksLikePointList, messagePoints } = require('../lib/points');
+const { SIEMENS_WINCC_DEFAULTS, isSiemensWinCC } = require('../lib/compatibility');
 
 const NOTIFICATION_CONFIG_FIELDS = new Set([
   'nodeId',
@@ -55,6 +56,43 @@ function positiveInteger(value, fallback) {
   return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
 }
 
+function monitoringSettings(point, config, siemensWincc = false) {
+  return {
+    samplingInterval: Number(point.samplingInterval) || Number(config.samplingInterval) || 1000,
+    queueSize: positiveInteger(point.queueSize, positiveInteger(config.queueSize, 1)),
+    discardOldest: point.discardOldest !== false,
+    deadbandType: siemensWincc ? 'none' : point.deadbandType || config.deadbandType || 'none',
+    deadbandValue: siemensWincc ? 0 : Number(point.deadbandValue ?? config.deadbandValue) || 0,
+  };
+}
+
+function sameMonitoringSettings(left, right, config, siemensWincc = false) {
+  const leftSettings = monitoringSettings(left, config, siemensWincc);
+  const rightSettings = monitoringSettings(right, config, siemensWincc);
+  return Object.keys(leftSettings).every(
+    (key) => leftSettings[key] === rightSettings[key]
+  );
+}
+
+function numericRange(items, field) {
+  let count = 0;
+  let minimum = Infinity;
+  let maximum = -Infinity;
+  for (const item of items) {
+    if (item[field] == null) continue;
+    const value = Number(item[field]);
+    if (!Number.isFinite(value)) continue;
+    count += 1;
+    minimum = Math.min(minimum, value);
+    maximum = Math.max(maximum, value);
+  }
+  return {
+    count,
+    minimum: count ? minimum : null,
+    maximum: count ? maximum : null,
+  };
+}
+
 module.exports = function registerSubscribeNode(RED) {
   function OpcUaSubscribeNode(config) {
     RED.nodes.createNode(this, config);
@@ -63,6 +101,7 @@ module.exports = function registerSubscribeNode(RED) {
     node.subscriptions = new Map();
     node.desired = new Map();
     node.monitored = new Map();
+    node.failed = new Map();
     node.subscriptionDiagnostics = new Map();
     node.pendingChanges = [];
     node.flushTimer = null;
@@ -73,11 +112,24 @@ module.exports = function registerSubscribeNode(RED) {
     node.closing = false;
     node.lastDropped = 0;
     node.lastStatusAt = 0;
+    node.compatibilityWarningIssued = false;
+    const consumer = node.connection?.registerConsumer?.('subscribe', {
+      nodeId: config.id, name: config.name,
+    });
 
     const batchSize = positiveInteger(config.batchSize, 500);
     const callbackBatchSize = positiveInteger(config.callbackBatchSize, 500);
     const callbackFlushIntervalMs = positiveInteger(config.callbackFlushIntervalMs, 50);
-    const configuredSubscriptionCapacity = positiveInteger(config.maxItemsPerSubscription, 5000);
+    const siemensWincc = isSiemensWinCC(
+      node.connection?.client?.options?.compatibilityProfile
+    );
+    const requestedSubscriptionCapacity = positiveInteger(config.maxItemsPerSubscription, 5000);
+    const configuredSubscriptionCapacity = siemensWincc
+      ? Math.min(
+          requestedSubscriptionCapacity,
+          SIEMENS_WINCC_DEFAULTS.monitoredItemsPerSubscription
+        )
+      : requestedSubscriptionCapacity;
     // Undefined preserves the descriptor-rich output used by Flow JSON created
     // before resultDetail existed. New editor nodes explicitly save compact.
     const resultDetail = ['compact', 'value', 'full'].includes(config.resultDetail)
@@ -88,6 +140,24 @@ module.exports = function registerSubscribeNode(RED) {
       return [...node.subscriptions.keys()];
     }
 
+    function applyCompatibility(points) {
+      if (!siemensWincc) return points;
+      let removedDeadband = false;
+      const compatible = points.map((point) => {
+        const configuredType = point.deadbandType || config.deadbandType || 'none';
+        if (configuredType === 'none') return point;
+        removedDeadband = true;
+        return { ...point, deadbandType: 'none', deadbandValue: 0 };
+      });
+      if (removedDeadband && !node.compatibilityWarningIssued) {
+        node.compatibilityWarningIssued = true;
+        node.warn(
+          'Siemens WinCC does not support OPC UA DataChange Deadband filters; Deadband was disabled.'
+        );
+      }
+      return compatible;
+    }
+
     function primarySubscriptionId() {
       return subscriptionIds()[0] ?? null;
     }
@@ -253,6 +323,9 @@ module.exports = function registerSubscribeNode(RED) {
         id: null,
         monitored: new Map(),
         limit: subscriptionCapacity(),
+        revisedPublishingInterval: null,
+        revisedLifetimeCount: null,
+        revisedMaxKeepAliveCount: null,
       };
       const result = await node.connection.client.createSubscription({
         publishingInterval: Number(config.publishingInterval) || 1000,
@@ -265,6 +338,9 @@ module.exports = function registerSubscribeNode(RED) {
         overflowPolicy: config.overflowPolicy || 'drop-oldest',
       }, (batch) => onNativeBatch(record, batch));
       record.id = result.subscriptionId;
+      record.revisedPublishingInterval = result.revisedPublishingInterval ?? null;
+      record.revisedLifetimeCount = result.revisedLifetimeCount ?? null;
+      record.revisedMaxKeepAliveCount = result.revisedMaxKeepAliveCount ?? null;
       node.subscriptions.set(record.id, record);
       return record;
     }
@@ -278,8 +354,8 @@ module.exports = function registerSubscribeNode(RED) {
           samplingInterval: Number(config.samplingInterval) || 1000,
           queueSize: Number(config.queueSize) || 10,
           discardOldest: config.discardOldest !== false,
-          deadbandType: config.deadbandType || 'none',
-          deadbandValue: Number(config.deadbandValue) || 0,
+          deadbandType: siemensWincc ? 'none' : config.deadbandType || 'none',
+          deadbandValue: siemensWincc ? 0 : Number(config.deadbandValue) || 0,
           timestampMode: config.timestampMode || 'source',
         },
         batchSize
@@ -291,6 +367,8 @@ module.exports = function registerSubscribeNode(RED) {
           subscriptionId: record.id,
           monitoredItemId: result.monitoredItemId,
           clientHandle: result.clientHandle,
+          revisedSamplingInterval: result.revisedSamplingInterval ?? null,
+          revisedQueueSize: result.revisedQueueSize ?? null,
         };
         record.monitored.set(result.nodeId, monitored);
         node.monitored.set(result.nodeId, monitored);
@@ -343,10 +421,10 @@ module.exports = function registerSubscribeNode(RED) {
       return failures;
     }
 
-    async function removeUndesiredPoints() {
+    async function removeMonitoredPoints(nodeIds) {
       const grouped = new Map();
       for (const [nodeId, monitored] of node.monitored) {
-        if (node.desired.has(nodeId)) continue;
+        if (!nodeIds.has(nodeId)) continue;
         if (!grouped.has(monitored.subscriptionId)) grouped.set(monitored.subscriptionId, []);
         grouped.get(monitored.subscriptionId).push({ nodeId, ...monitored });
       }
@@ -367,6 +445,13 @@ module.exports = function registerSubscribeNode(RED) {
       }
     }
 
+    async function removeUndesiredPoints() {
+      const nodeIds = new Set(
+        [...node.monitored.keys()].filter((nodeId) => !node.desired.has(nodeId))
+      );
+      await removeMonitoredPoints(nodeIds);
+    }
+
     async function pruneEmptySubscriptions() {
       const empty = [...node.subscriptions.values()].filter(
         (record) => record.monitored.size === 0
@@ -380,7 +465,10 @@ module.exports = function registerSubscribeNode(RED) {
     }
 
     async function clearSubscriptions(keepDesired = false, ignoreErrors = false) {
-      if (!keepDesired) node.desired.clear();
+      if (!keepDesired) {
+        node.desired.clear();
+        node.failed.clear();
+      }
       discardPendingChanges();
       const records = [...node.subscriptions.values()];
       node.subscriptions.clear();
@@ -403,22 +491,54 @@ module.exports = function registerSubscribeNode(RED) {
       return true;
     }
 
-    function statusPayload(command, failed = 0) {
+    function failurePayload() {
+      const failures = [...node.failed.values()];
+      return {
+        failed: failures.length,
+        failures: failures.slice(0, 100),
+        failuresTruncated: failures.length > 100,
+      };
+    }
+
+    function statusPayload(command) {
       const ids = subscriptionIds();
+      const monitoredValues = [...node.monitored.values()];
+      const revisedSampling = numericRange(monitoredValues, 'revisedSamplingInterval');
+      const revisedQueues = numericRange(monitoredValues, 'revisedQueueSize');
       return {
         command,
         desired: node.desired.size,
         monitored: node.monitored.size,
-        failed,
+        ...failurePayload(),
         subscriptionCount: ids.length,
         subscriptionId: ids[0] ?? null,
         subscriptionIds: ids,
+        revisions: [...node.subscriptions.values()].map((record) => ({
+          subscriptionId: record.id,
+          publishingInterval: record.revisedPublishingInterval,
+          lifetimeCount: record.revisedLifetimeCount,
+          maxKeepAliveCount: record.revisedMaxKeepAliveCount,
+        })),
+        monitoredRevisions: {
+          count: Math.max(revisedSampling.count, revisedQueues.count),
+          samplingIntervalMin: revisedSampling.minimum,
+          samplingIntervalMax: revisedSampling.maximum,
+          queueSizeMin: revisedQueues.minimum,
+          queueSizeMax: revisedQueues.maximum,
+        },
+        compatibility: {
+          profile: siemensWincc ? 'siemens-wincc' : 'standard',
+          deadbandSupported: !siemensWincc,
+          monitoredItemsPerSubscription: configuredSubscriptionCapacity,
+        },
         connectionGovernance: node.connection?.getConnectionGovernance?.(),
+        connectionUsage: node.connection?.getConnectionUsage?.(),
       };
     }
 
     async function reconcileSubscriptions(reason = 'state') {
       if (node.closing) return;
+      consumer?.markUsed('subscribe-reconcile');
       if (!node.desired.size) {
         if (node.subscriptions.size) await clearSubscriptions(true);
         return;
@@ -439,15 +559,21 @@ module.exports = function registerSubscribeNode(RED) {
         (point) => !node.monitored.has(point.nodeId)
       );
       const failures = await addDesiredPoints(additions);
-      await pruneEmptySubscriptions();
-      if (failures.length) {
-        throw new Error(`${failures.length} monitored item(s) failed to reconcile`);
+      for (const point of additions) node.failed.delete(point.nodeId);
+      for (const failure of failures) {
+        node.failed.set(failure.nodeId, {
+          nodeId: failure.nodeId,
+          statusCode: failure.statusCode || 'BadUnexpectedError',
+        });
       }
+      await pruneEmptySubscriptions();
 
       node.reconcileAttempt = 0;
       node.status({
-        fill: 'green', shape: 'dot',
-        text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub`,
+        fill: failures.length ? 'yellow' : 'green',
+        shape: failures.length ? 'ring' : 'dot',
+        text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub` +
+          (failures.length ? ` / ${failures.length} failed` : ''),
       });
       if (reason !== 'command') {
         node.send({
@@ -462,12 +588,25 @@ module.exports = function registerSubscribeNode(RED) {
           },
         });
       }
+      return { rebuilt, failures };
     }
 
     async function replacePoints(points) {
-      node.desired = new Map(points.map((point) => [point.nodeId, point]));
-      await clearSubscriptions(true);
-      await reconcileSubscriptions('command');
+      const nextDesired = new Map(points.map((point) => [point.nodeId, point]));
+      const changed = new Set();
+      for (const [nodeId, monitored] of node.monitored) {
+        const previous = node.desired.get(nodeId);
+        const next = nextDesired.get(nodeId);
+        if (!next || !previous || !sameMonitoringSettings(previous, next, config, siemensWincc)) {
+          changed.add(nodeId);
+        }
+      }
+      node.desired = nextDesired;
+      for (const nodeId of [...node.failed.keys()]) {
+        if (!node.desired.has(nodeId)) node.failed.delete(nodeId);
+      }
+      await removeMonitoredPoints(changed);
+      return reconcileSubscriptions('command');
     }
 
     function runSerialized(task) {
@@ -517,28 +656,49 @@ module.exports = function registerSubscribeNode(RED) {
       if (!node.connection) return done(new Error('OPC UA connection not configured'));
       try {
         const command = msg.opcua?.command || 'replace';
-        const points = command === 'clear' ? [] : messagePoints(msg, config.nodeId, {
+        const dynamicNodeId = msg.nodeId || msg.topic;
+        const configuredPayload = !looksLikePointList(msg.payload) && !Array.isArray(msg.items) &&
+          !dynamicNodeId ? config.pointList : '';
+        const staticNodeId = dynamicNodeId ? '' : config.nodeId;
+        const points = command === 'clear' ? [] : applyCompatibility(messagePoints(msg, staticNodeId, {
           samplingInterval: Number(config.samplingInterval) || 1000,
           queueSize: Number(config.queueSize) || 10,
           discardOldest: config.discardOldest !== false,
-        });
+        }, {
+          configuredPayload,
+          format: 'auto',
+        }));
 
         node.status({ fill: 'blue', shape: 'dot', text: `${command} ${points.length}` });
         await runSerialized(async () => {
           if (command === 'replace') await replacePoints(points);
           else if (command === 'add') {
-            points.forEach((point) => node.desired.set(point.nodeId, point));
+            const changed = new Set();
+            points.forEach((point) => {
+              const previous = node.desired.get(point.nodeId);
+              if (previous && !sameMonitoringSettings(previous, point, config, siemensWincc)) {
+                changed.add(point.nodeId);
+              }
+              node.desired.set(point.nodeId, point);
+              node.failed.delete(point.nodeId);
+            });
+            await removeMonitoredPoints(changed);
             await reconcileSubscriptions('command');
           } else if (command === 'remove') {
-            points.forEach((point) => node.desired.delete(point.nodeId));
+            points.forEach((point) => {
+              node.desired.delete(point.nodeId);
+              node.failed.delete(point.nodeId);
+            });
             await reconcileSubscriptions('command');
           } else if (command === 'clear') await clearSubscriptions();
           else throw new Error(`Unsupported subscription command: ${command}`);
         });
 
+        const failed = node.failed.size;
         node.status({
-          fill: 'green', shape: 'dot',
-          text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub`,
+          fill: failed ? 'yellow' : 'green', shape: failed ? 'ring' : 'dot',
+          text: `${node.monitored.size} monitored / ${node.subscriptions.size} sub` +
+            (failed ? ` / ${failed} failed` : ''),
         });
         send({
           ...msg,
@@ -560,6 +720,8 @@ module.exports = function registerSubscribeNode(RED) {
       node.connection?.client.off('fault', onFault);
       node.connection?.client.off('state', onState);
       node.desired.clear();
+      node.failed.clear();
+      consumer?.release();
       await runSerialized(() => clearSubscriptions());
     }
 
@@ -574,6 +736,39 @@ module.exports = function registerSubscribeNode(RED) {
       }
       done();
     });
+
+    const configuredPoints = String(config.pointList || '').trim() ||
+      String(config.nodeId || '').trim();
+    if (configuredPoints) {
+      setImmediate(() => {
+        if (node.closing) return;
+        let points;
+        try {
+          points = applyCompatibility(messagePoints({}, config.nodeId, {
+            samplingInterval: Number(config.samplingInterval) || 1000,
+            queueSize: Number(config.queueSize) || 10,
+            discardOldest: config.discardOldest !== false,
+          }, {
+            configuredPayload: config.pointList,
+            format: 'auto',
+          }));
+        } catch (error) {
+          node.status({ fill: 'red', shape: 'ring', text: error.message });
+          node.warn(`OPC UA saved subscription point list is invalid: ${error.message}`);
+          return;
+        }
+        void runSerialized(() => replacePoints(points)).then(() => {
+          node.send({
+            payload: statusPayload('startup'),
+            opcua: { operation: 'subscription-status', startup: true },
+          });
+        }).catch((error) => {
+          node.status({ fill: 'yellow', shape: 'ring', text: 'waiting to subscribe' });
+          node.warn(`OPC UA startup subscription failed: ${error.message}`);
+          scheduleReconnect('startup');
+        });
+      });
+    }
   }
 
   RED.nodes.registerType('tier0-opcua-subscribe', OpcUaSubscribeNode);

package/nodes/write.html

@@ -54,6 +54,7 @@
       <li>单点：NodeId 来自节点配置、<code>msg.nodeId</code> 或 <code>msg.topic</code>，写入值来自 <code>msg.payload</code>。</li>
       <li>批量：通过编辑器、JSON 或 CSV 提供 <code>nodeId</code>、<code>value</code> 和可选 <code>dataType</code>。</li>
       <li>CSV 必须包含 <code>nodeId</code> 和 <code>value</code>；未指定类型时使用节点默认类型。</li>
+      <li>Int64/UInt64 建议使用十进制字符串；超范围、小数和不安全的 Number 会在发送前被拒绝。</li>
       <li><code>indexRange</code> 可部分写入数组或矩阵。</li>
     </ul>
     <h4>输出</h4>
@@ -68,6 +69,7 @@
       <li>Single point: NodeId comes from the node setting, <code>msg.nodeId</code>, or <code>msg.topic</code>; the value comes from <code>msg.payload</code>.</li>
       <li>Batch: Supply <code>nodeId</code>, <code>value</code>, and optional <code>dataType</code> through the editor, JSON, or CSV.</li>
       <li>CSV requires <code>nodeId</code> and <code>value</code>. The node default type is used when <code>dataType</code> is omitted.</li>
+      <li>Use decimal strings for Int64/UInt64. Out-of-range, fractional, and unsafe Number values are rejected before transmission.</li>
       <li>Use <code>indexRange</code> for partial array or matrix writes.</li>
     </ul>
     <h4>Output</h4>

package/nodes/write.js

@@ -7,11 +7,15 @@ module.exports = function registerWriteNode(RED) {
     RED.nodes.createNode(this, config);
     const node = this;
     node.connection = RED.nodes.getNode(config.connection);
+    const consumer = node.connection?.registerConsumer?.('write', {
+      nodeId: config.id, name: config.name,
+    });
 
     node.on('input', async (msg, send, done) => {
       if (!node.connection) return done(new Error('OPC UA connection not configured'));
 
       try {
+        consumer?.markUsed('write');
         const points = messageWritePoints(msg, config);
         node.status({ fill: 'blue', shape: 'dot', text: `writing ${points.length}` });
         const results = await node.connection.client.writeMany(
@@ -41,6 +45,12 @@ module.exports = function registerWriteNode(RED) {
         done(error);
       }
     });
+
+    node.on('close', (removed, done) => {
+      if (typeof removed === 'function') done = removed;
+      consumer?.release();
+      done?.();
+    });
   }
 
   RED.nodes.registerType('tier0-opcua-write', OpcUaWriteNode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tier0/opcua-client",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "High-scale OPC UA client nodes for Node-RED powered by open62541",
   "license": "Apache-2.0",
   "repository": {
@@ -38,7 +38,8 @@
     "test:stress": "node test/stress.js",
     "test:nodered": "node test/nodered.integration.js",
     "test:nodered:reconnect": "OPCUA_NODERED_RECONNECT=1 node test/nodered.integration.js",
-    "prepack": "node scripts/verify-offline-package.js"
+    "test:release": "npm test && npm run test:native && npm run test:offline-runtime && npm run test:nodered",
+    "prepack": "npm test && node scripts/verify-offline-package.js"
   },
   "keywords": [
     "node-red",

package/scripts/verify-offline-package.js

@@ -17,4 +17,24 @@ if (missing.length) {
   process.exit(1);
 }
 
-console.log('Offline package inputs verified');
+const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const prebuildSize = fs.statSync(
+  path.join(root, 'prebuilds/linux-x64-musl/opcua_open62541.node')
+).size;
+const sourceSize = fs.statSync(
+  path.join(root, 'vendor/open62541-v1.4.16.tar.gz')
+).size;
+if (!packageJson.files?.includes('prebuilds') || !packageJson.files?.includes('vendor')) {
+  throw new Error('package.json files must include prebuilds and vendor for offline installation');
+}
+if (!packageJson.bundledDependencies?.includes('node-addon-api')) {
+  throw new Error('node-addon-api must remain a bundled dependency');
+}
+if (prebuildSize < 100000 || sourceSize < 1000000) {
+  throw new Error('Bundled native addon or open62541 source archive is unexpectedly small');
+}
+
+console.log(
+  `Offline package inputs verified for ${packageJson.name}@${packageJson.version}: ` +
+  `prebuild=${prebuildSize} bytes, open62541=${sourceSize} bytes`
+);