@machinemetrics/io-adapter-lib 2.32.3 → 2.34.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [2.34.0]
+- Added support for initializing variables from constant source or expression ops
+- Fixed map not recognizing external identifiers in sub-ops
+- Allow string and bool constants in shorthand variable declarations
+
+## [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/config/engineConfigV2.js

@@ -42,7 +42,7 @@ class EngineConfig {
     //     - source: composite.parts
 
     this.config.variables = _.mapValues(this.config.variables, (variable) => {
-      if (_.isString(variable)) {
+      if (_.isString(variable) || _.isNumber(variable) || _.isBoolean(variable)) {
         return [{ source: variable }];
       }
       return variable;

package/lib/config/transformConfigUtil.js

@@ -94,18 +94,22 @@ class TransformConfigUtil {
 
   getExpressionsFromVariables(variables) {
     return _(variables).map((defn, varName) => {
-      return _.map(defn, (transformContainer, index) => {
-        return _.map(transformContainer, (body, attribute) => {
-          if (this.transformMap[attribute]) {
-            return this.transformMap[attribute].getExpressions(this, body, { varName, index, attribute });
-          }
-          return [];
-        });
-      });
+      return this.getExpressionsFromChain(defn, varName);
     }).flattenDeep().compact().value();
   }
 
-  getExpressions(body, { varName, index, attribute, field }, includeDefault = false) {
+  getExpressionsFromChain(chain, varName, ancestorVars = []) {
+    return _.map(chain, (transformContainer, index) => {
+      return _.map(transformContainer, (body, attribute) => {
+        if (this.transformMap[attribute]) {
+          return this.transformMap[attribute].getExpressions(this, body, { varName, index, attribute, ancestorVars });
+        }
+        return [];
+      });
+    });
+  }
+
+  getExpressions(body, { varName, index, attribute, field, ancestorVars }, includeDefault = false) {
     const parts = [];
 
     let expression = '';
@@ -140,6 +144,13 @@ class TransformConfigUtil {
       expression,
     });
 
+    _.each(ancestorVars, (ancestorVar) => {
+      parts.push({
+        path: `variables.${ancestorVar}`,
+        expression,
+      });
+    });
+
     return parts;
   }
 

package/lib/engine/transformBuilderV2.js

@@ -34,6 +34,11 @@ class TransformBuilderV2 {
         engine.addVariable(varName, transform);
       }
     });
+
+    _.each(engine.variablePool, (chain, varName) => {
+      const context = { sourceType: 'init', trigger: varName };
+      chain.init(context, 0);
+    });
   }
 
   createTransformChain(engine, transformList, varName, base = false) {

package/lib/expressionService.js

@@ -9,6 +9,7 @@ class ExpressionService {
     this.availableNamesByChannel = {};
     this.referencedNamesByChannel = {};
     this.referencedNamesByPath = {};
+    this.selfReferencedPaths = {};
     this.pathsByReferenceName = {};
     this.defaultValues = {};
     this.channelsLookup = {};
@@ -117,6 +118,10 @@ class ExpressionService {
         }
       }
     });
+
+    if (this.findName(expression, 'this')) {
+      this.selfReferencedPaths[path] = true;
+    }
   }
 
   addStringExpression({ string, path, withThis } = {}) {
@@ -196,7 +201,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 +221,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 +260,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 +278,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}`);
         }
       }
 
@@ -282,6 +303,10 @@ class ExpressionService {
     return this.referencedNamesByPath[path] || [];
   }
 
+  expressionHasSelfReference(path) {
+    return !!this.selfReferencedPaths[path];
+  }
+
   expressionsTriggeredBy(name) {
     return this.pathsByReferenceName[name] || [];
   }

package/lib/transform/expression.js

@@ -30,6 +30,18 @@ class ExpressionFilter extends TransformState {
     this.engine = engine;
     this.compiledExpression = compiledExpression;
     this.selfSources = engine.expressionService.expressionTriggers(path);
+    this.hasSelfReference = engine.expressionService.expressionHasSelfReference(path);
+
+    // If there's no variables in the expression, it's a constant that can be evaluated once
+    if (_.isEmpty(this.selfSources) && !this.hasSelfReference) {
+      try {
+        this.constantSource = true;
+        this.constantValue = this.compiledExpression.evaluate();
+        this.lastSuppliedValue = this.constantValue;
+      } catch (err) {
+        // Oh well
+      }
+    }
   }
 
   static op = 'expression';
@@ -49,6 +61,12 @@ class ExpressionFilter extends TransformState {
     return configUtil.getExpressions(body, info);
   }
 
+  init(context, time) {
+    if (this.constantSource) {
+      this.update(context, this.lastSuppliedValue, time);
+    }
+  }
+
   update(context, value, time) {
     if (value === 'UNAVAILABLE') {
       this.setUnavailable(context, time);
@@ -58,7 +76,11 @@ class ExpressionFilter extends TransformState {
   }
 
   filter(context, value, time) {
-    if (this.constantSource || this.simpleSource) {
+    if (this.constantSource) {
+      this.commitValue(context, this.constantValue, time);
+      return;
+    }
+    if (this.simpleExpression) {
       this.commitValue(context, value, time);
       return;
     }

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));
@@ -72,13 +72,23 @@ class MapFilter extends TransformState {
     defn.args = { transforms };
   }
 
+  static getExpressions(configUtil, body, info) {
+    const varName = `${info.varName}.${info.index}.${info.attribute}`;
+    const ancestorVars = [
+      ...info.ancestorVars,
+      info.varName,
+    ];
+
+    return configUtil.getExpressionsFromChain(body, varName, ancestorVars);
+  }
+
   initReset() {
     this.chainList = [];
     this.value = [];
   }
 
   supportsPendingChanges() {
-    return this.chain.supportsPendingChanges();
+    return this.innerChain.supportsPendingChanges();
   }
 
   updateChainList(size) {

package/lib/transform/source.js

@@ -40,8 +40,9 @@ class SourceFilter extends TransformState {
     // If there's no variables in the expression, it's a constant that can be evaluated once
     if (_.isEmpty(this.selfSources)) {
       try {
-        this.lastSuppliedValue = this.compiledExpression.evaluate();
         this.constantSource = true;
+        this.constantValue = this.compiledExpression.evaluate();
+        this.lastSuppliedValue = this.constantValue;
       } catch (err) {
         // Oh well
       }
@@ -77,6 +78,12 @@ class SourceFilter extends TransformState {
     return configUtil.getExpressions(body, info);
   }
 
+  init(context, time) {
+    if (this.constantSource) {
+      this.update(context, this.lastSuppliedValue, time);
+    }
+  }
+
   update(context, value, time) {
     if (value === 'UNAVAILABLE') {
       this.setUnavailable(context, time);
@@ -86,7 +93,9 @@ class SourceFilter extends TransformState {
   }
 
   filter(context, value, time) {
-    if (this.constantSource || this.simpleSource) {
+    if (this.constantSource) {
+      this.commitValue(context, this.constantValue, time);
+    } else if (this.simpleSource) {
       this.commitValue(context, value, time);
     } else {
       const localState = {};

package/lib/transform/transformState.js

@@ -56,6 +56,9 @@ class TransformState extends EventEmitter {
     return this.pendingChangeTime;
   }
 
+  // Called after all varaibles have been added to the engine.
+  init(_context, _time) { }
+
   update(context, value, time) {
     if (!this.available) {
       this.available = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machinemetrics/io-adapter-lib",
-  "version": "2.32.3",
+  "version": "2.34.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,8 @@ declare-keys:
   - counter
   - program
   - complex
+  - complex2
+  - complex3
 variables:
   var1:
     - source: counter
@@ -17,3 +19,12 @@ variables:
     - source: complex
     - map:
       - expression: this.subkey
+  var3:
+    - source: complex2
+    - map:
+      - expression: this.subkey
+    - expression: this[1]
+  var4:
+    - source: complex3
+    - map:
+      - expression: this.subkey + counter

package/test/configFiles/transform/source.yml

@@ -18,3 +18,15 @@ variables:
     - expression: this + yact
   var5:
     - source: execution != 'MANUAL'
+  const1:
+    - source: 10
+  const2:
+    - source: true
+  const3:
+    - source: "'ACTIVE'"
+  const4:
+    - source: max(4, 5, 6)
+  var6:
+    - source: const1 + (const2 ? 20:30)
+  var7:
+    - source: xact + const1

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,37 @@ 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],
+    ]);
+  });
+
+  it('subkey map with external ref', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.var4, source);
+
+    source.sendValue('counter', 100, 0);
+    source.sendValue('complex3', [{ subkey: 10, xx: 15 }, { subkey: 20, xx: 30 }], 0);
+    source.sendValue('counter', 200, 2);
+
+    engine.validateFilter([
+      [[110, 120], 0],
+      [[210, 220], 2],
+    ]);
+  });
 });

package/test/transform/source.test.js

@@ -128,6 +128,20 @@ describe('source full engine config file tests', async function () {
       [true, 0],
     ]);
   });
+
+  it('calculates constant values correctly', async function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = new ValueSource();
+    engine.addValueSource(source);
+
+    expect(engine.getState('const1').value).to.eq(10);
+    expect(engine.getState('const2').value).to.eq(true);
+    expect(engine.getState('const3').value).to.eq('ACTIVE');
+    expect(engine.getState('const4').value).to.eq(6);
+  });
 });
 
 class ValueSource extends EventEmitter {

package/test/transform/state.test.js

@@ -136,6 +136,9 @@ describe('expression transform tests', function () {
     const source = testUtils.valueSource();
     testUtils.attachEngineTransformValidator(engine, engine.variablePool.test5, source);
 
+    // Set by const init
+    expect(engine.getState('test5').value).to.eq('READY');
+
     source.sendValue('exec', 'ACTIVE', 0);
     source.sendValue('in-fault', false, 2);
     source.sendValue('in-fault', false, 4);
@@ -144,7 +147,7 @@ describe('expression transform tests', function () {
     source.sendValue('in-fault', false, 10);
 
     engine.validateFilter([
-      ['READY', 0],
+      // ['READY', 0], // Initial value doesn't come through because chain starts with constant
       ['ACTIVE', 2],
       ['ACTIVE', 4],
       ['STOPPED', 6],