@machinemetrics/io-adapter-lib 2.32.3 → 2.33.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # 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
 

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.3",
+  "version": "2.33.0",
   "description": "Configuration and engine implementation for MachineMetrics AdapterScripts and adapters",
   "main": "index.js",
   "license": "UNLICENSED",

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],
+    ]);
+  });
 });