@machinemetrics/io-adapter-lib 2.32.2 → 2.33.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [2.33.0]
+- Added support for numeric indexing in expressions
+- Fixed map not allowing any transforms to be chained beyond it
+
+## [2.32.3]
+- Added opcua-conditions options for code format and allow/deny nodes
+
 ## [2.32.2]
 - Add support to reclassify conditions to NORMAL
 

package/lib/config/device/opcuaConfig.js

@@ -2,6 +2,9 @@
 
 const _ = require('lodash');
 const ConfigError = require('../configError');
+const AllowDenyList = require('../common/allowDenyList');
+
+const allowDenyList = new AllowDenyList();
 
 // Pattern to match valid OPC-UA node ID paths, as supported by node-opcua
 // Our validation may be slightly stricter on some value validation.
@@ -144,6 +147,28 @@ class OpcuaConfig {
         result.warningThreshold = warningThreshold;
       }
 
+      result.codeFormat = '{conditionName}_{conditionIdHash}';
+      if (_.has(conditions, 'code-format')) {
+        const codeFormat = conditions['code-format'];
+        if (_.isEmpty(codeFormat) || !_.isString(codeFormat)) {
+          throw new ConfigError('code-format cannot be empty').atAttribute('code-format');
+        }
+        result.codeFormat = codeFormat;
+      }
+
+      if (_.has(conditions, 'allow-condition-nodes')) {
+        result.allowConditionNodes = allowDenyList.parseWildcardKeyList(conditions['allow-condition-nodes'], 'allow-condition-nodes');
+      }
+      if (_.has(conditions, 'deny-condition-nodes')) {
+        result.denyConditionNodes = allowDenyList.parseWildcardKeyList(conditions['deny-condition-nodes'], 'deny-condition-nodes');
+      }
+      if (_.has(conditions, 'allow-source-nodes')) {
+        result.allowSourceNodes = allowDenyList.parseWildcardKeyList(conditions['allow-source-nodes'], 'allow-source-nodes');
+      }
+      if (_.has(conditions, 'deny-source-nodes')) {
+        result.denySourceNodes = allowDenyList.parseWildcardKeyList(conditions['deny-source-nodes'], 'deny-source-nodes');
+      }
+
       return result;
     } catch (error) {
       if (error instanceof ConfigError) {

package/lib/expressionService.js

@@ -196,7 +196,7 @@ class ExpressionService {
   }
 
   findCompoundIdentifiers(str) {
-    const matches = str.match(/[A-Za-z_][A-Za-z0-9_-]*(?:(?:\.[A-Za-z][A-Za-z0-9_-]*)|(?:\['[^'"]+'\]))+/g);
+    const matches = str.match(/[A-Za-z_][A-Za-z0-9_-]*(?:(?:\.[A-Za-z][A-Za-z0-9_-]*)|(?:\[('[^'"]+'|\d+)\]))+/g);
     return matches ?? [];
   }
 
@@ -216,7 +216,13 @@ class ExpressionService {
           rest.push(match[1]);
           compound = compound.substr(match[0].length);
         } else {
-          break;
+          match = compound.match(/^\[(\d+)\]/);
+          if (match) {
+            rest.push(+match[1]);
+            compound = compound.substr(match[0].length);
+          } else {
+            break;
+          }
         }
       }
     }
@@ -249,6 +255,12 @@ class ExpressionService {
             const first = tokens[0];
             if (first === 'this' || this.channelsLookup[first]) {
               accum[first] = _.reduceRight(_.tail(tokens), (sub, item) => {
+                if (_.isNumber(item)) {
+                  return [
+                    ..._.times(Math.max(0, item - 1), () => 0),
+                    sub,
+                  ];
+                }
                 return { [item]: sub };
               }, 0);
             } else {
@@ -261,7 +273,11 @@ class ExpressionService {
         try {
           return this.compileInnerExpression(expression, { ...scope, ...addedScope });
         } catch (err) {
-          throw new Error(`Problem evaluating expression: ${errMessage}`);
+          let message = err.message;
+          if (message.startsWith('Index out')) {
+            message = `${message}. Indexes in expressions start at 1`;
+          }
+          throw new Error(`Problem evaluating expression: ${message}`);
         }
       }
 

package/lib/transform/map.js

@@ -47,7 +47,7 @@ class MapFilter extends TransformState {
   constructor({ engine, /* path, rootPath, baseTransform, */ args: { transforms } }, builder) {
     super();
 
-    this.chain = builder.createTransformChain(engine, transforms);
+    this.innerChain = builder.createTransformChain(engine, transforms);
 
     this.makeChain = () => {
       return new MapChain(builder.createTransformChain(engine, transforms));
@@ -78,7 +78,7 @@ class MapFilter extends TransformState {
   }
 
   supportsPendingChanges() {
-    return this.chain.supportsPendingChanges();
+    return this.innerChain.supportsPendingChanges();
   }
 
   updateChainList(size) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machinemetrics/io-adapter-lib",
-  "version": "2.32.2",
+  "version": "2.33.0",
   "description": "Configuration and engine implementation for MachineMetrics AdapterScripts and adapters",
   "main": "index.js",
   "license": "UNLICENSED",

package/test/config/opcua.test.js

@@ -8,11 +8,13 @@ describe('OPC-UA config tests', function () {
   let config;
   let defaultConfig;
   let conditionsConfig;
+  let conditionsDefaultConfig;
 
   before(async () => {
     defaultConfig = await testUtils.loadConfig('device/opcua-default.yml');
     config = await testUtils.loadConfig('device/opcua-std.yml');
     conditionsConfig = await testUtils.loadConfig('device/opcua-conditions.yml');
+    conditionsDefaultConfig = await testUtils.loadConfig('device/opcua-conditions-default.yml');
   });
 
   it('loads minimal config with defaults', async function () {
@@ -104,12 +106,27 @@ describe('OPC-UA config tests', function () {
     testPath('nsu=http://test.org/UA/Data/;i=10853');
   });
 
+  it('loads opcua-conditions with default properties', async function () {
+    expect(conditionsDefaultConfig.device.opcuaConditions.key).to.eq('system');
+    expect(conditionsDefaultConfig.device.opcuaConditions.faultThreshold).to.eq(undefined);
+    expect(conditionsDefaultConfig.device.opcuaConditions.warningThreshold).to.eq(undefined);
+    expect(conditionsDefaultConfig.device.opcuaConditions.codeFormat).to.eq('{conditionName}_{conditionIdHash}');
+    expect(conditionsDefaultConfig.device.opcuaConditions.allowConditionNodes).to.eq(undefined);
+    expect(conditionsDefaultConfig.device.opcuaConditions.denyConditionNodes).to.eq(undefined);
+    expect(conditionsDefaultConfig.device.opcuaConditions.allowSourceNodes).to.eq(undefined);
+    expect(conditionsDefaultConfig.device.opcuaConditions.denySourceNodes).to.eq(undefined);
+    expect(conditionsDefaultConfig.device.conditionKey).to.eq('system');
+  });
+
   it('loads opcua-conditions with all properties', async function () {
-    expect(conditionsConfig.device.opcuaConditions).to.deep.eq({
-      key: 'system',
-      faultThreshold: 100,
-      warningThreshold: 50,
-    });
+    expect(conditionsConfig.device.opcuaConditions.key).to.eq('system');
+    expect(conditionsConfig.device.opcuaConditions.faultThreshold).to.eq(100);
+    expect(conditionsConfig.device.opcuaConditions.warningThreshold).to.eq(50);
+    expect(conditionsConfig.device.opcuaConditions.codeFormat).to.eq('{conditionName}');
+    expect(conditionsConfig.device.opcuaConditions.allowConditionNodes).to.have.lengthOf(1);
+    expect(conditionsConfig.device.opcuaConditions.denyConditionNodes).to.have.lengthOf(1);
+    expect(conditionsConfig.device.opcuaConditions.allowSourceNodes).to.have.lengthOf(1);
+    expect(conditionsConfig.device.opcuaConditions.denySourceNodes).to.have.lengthOf(1);
     expect(conditionsConfig.device.conditionKey).to.eq('system');
   });
 });

package/test/configFiles/device/opcua-conditions-default.yml

@@ -0,0 +1,5 @@
+version: 2
+device: opc-ua
+endpoint: opc.tcp://localhost:4840
+opcua-conditions:
+  key: system

package/test/configFiles/device/opcua-conditions.yml

@@ -5,3 +5,12 @@ opcua-conditions:
   key: system
   fault-threshold: 100
   warning-threshold: 50
+  code-format: "{conditionName}"
+  allow-condition-nodes:
+    - ns=2;s=Flames/*
+  deny-condition-nodes:
+    - ns=2;s=Flames/ControlledFacilityComponents/*
+  allow-source-nodes:
+    - ns=2;s=Flames/*
+  deny-source-nodes:
+    - ns=2;s=Flames/ControlledFacilityComponents/*

package/test/configFiles/transform/map.yml

@@ -7,6 +7,7 @@ declare-keys:
   - counter
   - program
   - complex
+  - complex2
 variables:
   var1:
     - source: counter
@@ -17,3 +18,8 @@ variables:
     - source: complex
     - map:
       - expression: this.subkey
+  var3:
+    - source: complex2
+    - map:
+      - expression: this.subkey
+    - expression: this[1]

package/test/expressionService.test.js

@@ -80,6 +80,42 @@ describe('ExpressionService tests', function () {
     expect(() => exprsvc.compileExpression('this + 1')).to.throw('Undefined symbol this');
   });
 
+  it('parses expressions with compound identifiers', function () {
+    const exprsvc = new ExpressionService();
+
+    const context1 = { this: 5 };
+    const expr1 = exprsvc.compileExpression('this', context1);
+    expect(expr1.evaluate(context1)).to.eq(5);
+
+    const context2 = { this: { subkey: 5 } };
+    const expr2 = exprsvc.compileExpression('this.subkey', context2);
+    expect(expr2.evaluate(context2)).to.eq(5);
+
+    const context3 = { this: { subkey: { secondary: 5 } } };
+    const expr3 = exprsvc.compileExpression('this.subkey.secondary', context3);
+    expect(expr3.evaluate(context3)).to.eq(5);
+
+    const context4 = { this: { subkey: { secondary: 5 } } };
+    const expr4 = exprsvc.compileExpression('this.subkey[\'secondary\']', context4);
+    expect(expr4.evaluate(context4)).to.eq(5);
+
+    const context5 = { this: { subkey: [0, 0, 5] } };
+    const expr5 = exprsvc.compileExpression('this.subkey[3]', context5);
+    expect(expr5.evaluate(context5)).to.eq(5);
+
+    const context6 = { this: [0, 0, 5] };
+    const expr6 = exprsvc.compileExpression('this[3]', context6);
+    expect(expr6.evaluate(context6)).to.eq(5);
+
+    const context7 = { this: { subkey: [0, 0, { bar: 5 }] } };
+    const expr7 = exprsvc.compileExpression('this.subkey[3].bar', context7);
+    expect(expr7.evaluate(context7)).to.eq(5);
+
+    const context8 = { this: { subkey: [0, 0, { bar: [0, { baz: 5 }] }] } };
+    const expr8 = exprsvc.compileExpression('this.subkey[3].bar[2].baz', context8);
+    expect(expr8.evaluate(context8)).to.eq(5);
+  });
+
   /* eslint-disable no-template-curly-in-string */
 
   it('parses string expressions', function () {

package/test/transform/map.test.js

@@ -39,4 +39,19 @@ describe('map full engine config file tests', function () {
       [[10, 20], 0],
     ]);
   });
+
+  it('transform chained after map', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var3, source);
+
+    source.sendValue('complex2', [{ subkey: 10, xx: 15 }, { subkey: 20, xx: 30 }], 0);
+
+    engine.validateFilter([
+      [10, 0],
+    ]);
+  });
 });