@machinemetrics/io-adapter-lib 2.33.0 → 2.35.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [2.35.0]
+- Added data-events config support
+
+## [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

package/lib/config/adapterConfig.js

@@ -100,7 +100,20 @@ class AdapterConfig {
       });
     }).flattenDeep().compact().value();
 
-    return [...dataItems, ...conditions];
+    const dataEvents = _(config['data-events']).map((event, key) => {
+      const exprs = [];
+      if (_.isString(event.payload)) {
+        exprs.push({ path: `data-events.${key}.payload`, expression: event.payload });
+      }
+      _.each(event.triggers, (trigger, i) => {
+        if (_.isString(trigger)) {
+          exprs.push({ path: `data-events.${key}.triggers.${i}`, expression: trigger });
+        }
+      });
+      return exprs;
+    }).flattenDeep().compact().value();
+
+    return [...dataItems, ...conditions, ...dataEvents];
   }
 
   getStringExpressions(config = {}) {
@@ -150,6 +163,7 @@ class AdapterConfig {
   parse(config = {}) {
     this.loadDataItems(config['data-items']);
     this.loadConditions(config.conditions);
+    this.loadDataEvents(config['data-events']);
 
     this.passthroughConditions = _(this.conditions).filter((cond) => {
       return cond.passthroughSource;
@@ -524,6 +538,62 @@ class AdapterConfig {
     };
   }
 
+  loadDataEvents(events) {
+    this.dataEventsByExpression = {};
+    this.dataEvents = _.mapValues(events || {}, (event, key) => {
+      if (!_.isString(event.payload)) {
+        const configErr = new ConfigError(`Data event '${key}' has no payload`);
+        throw configErr.atSection(`data-events.${key}`).atAttribute('payload');
+      }
+
+      let payloadDefn;
+      try {
+        const payloadPath = `data-events.${key}.payload`;
+        const compiledPayload = this.expressionService.compileExpression(event.payload);
+        this.dataEventsByExpression[payloadPath] = key;
+        payloadDefn = {
+          rawExpression: event.payload,
+          expression: compiledPayload,
+        };
+      } catch (err) {
+        const configErr = new ConfigError(`Problem evaluating payload expression: ${err.message}`);
+        throw configErr.atSection(`data-events.${key}`).atAttribute('payload');
+      }
+
+      if (!_.isArray(event.triggers) || _.isEmpty(event.triggers)) {
+        const configErr = new ConfigError(`Data event '${key}' has no triggers`);
+        throw configErr.atSection(`data-events.${key}`).atAttribute('triggers');
+      }
+
+      const triggers = _.map(event.triggers, (trigger, i) => {
+        if (!_.isString(trigger)) {
+          const configErr = new ConfigError(`Data event '${key}' trigger at index ${i} must be a string expression`);
+          throw configErr.atSection(`data-events.${key}.triggers`);
+        }
+
+        try {
+          const triggerPath = `data-events.${key}.triggers.${i}`;
+          const compiledTrigger = this.expressionService.compileExpression(trigger);
+          this.dataEventsByExpression[triggerPath] = key;
+          return {
+            rawExpression: trigger,
+            expression: compiledTrigger,
+            triggerVariables: this.expressionService.expressionTriggers(triggerPath),
+          };
+        } catch (err) {
+          const configErr = new ConfigError(`Problem evaluating trigger expression: ${err.message}`);
+          throw configErr.atSection(`data-events.${key}.triggers`).atAttribute(i);
+        }
+      });
+
+      return {
+        name: key,
+        payload: payloadDefn,
+        triggers,
+      };
+    });
+  }
+
   triggeredDataItems(name) {
     const triggeredPaths = this.expressionService.expressionsTriggeredBy(name);
     return _(triggeredPaths).map(p => this.dataItemsByExpression[p]).compact().uniq().value();
@@ -533,6 +603,11 @@ class AdapterConfig {
     const triggeredPaths = this.expressionService.expressionsTriggeredBy(name);
     return _(triggeredPaths).map(p => this.conditionsByExpression[p]).compact().uniq().value();
   }
+
+  triggeredDataEvents(name) {
+    const triggeredPaths = this.expressionService.expressionsTriggeredBy(name);
+    return _(triggeredPaths).map(p => this.dataEventsByExpression[p]).compact().uniq().value();
+  }
 }
 
 module.exports = AdapterConfig;

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 } = {}) {
@@ -298,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

@@ -72,6 +72,16 @@ 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 = [];

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

package/test/config/data-events.test.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const _ = require('lodash');
+const expect = require('chai').expect;
+const testUtils = require('../util/testUtils');
+
+describe('Data events config tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('data-events.yaml');
+  });
+
+  it('populates dataEventsByExpression table', function () {
+    expect(_.size(config.adapter.dataEventsByExpression)).to.eq(4);
+    expect(config.adapter.dataEventsByExpression['data-events.tool-change-1.payload']).to.eq('tool-change-1');
+    expect(config.adapter.dataEventsByExpression['data-events.tool-change-1.triggers.0']).to.eq('tool-change-1');
+    expect(config.adapter.dataEventsByExpression['data-events.tool-offset-change-1.payload']).to.eq('tool-offset-change-1');
+    expect(config.adapter.dataEventsByExpression['data-events.tool-offset-change-1.triggers.0']).to.eq('tool-offset-change-1');
+  });
+
+  it('parses data event structure', function () {
+    expect(_.size(config.adapter.dataEvents)).to.eq(2);
+
+    const ev1 = config.adapter.dataEvents['tool-change-1'];
+    expect(ev1.name).to.eq('tool-change-1');
+    expect(ev1.payload.rawExpression).to.eq('{}');
+    expect(ev1.payload.expression).to.exist;
+    expect(ev1.triggers).to.have.length(1);
+    expect(ev1.triggers[0].rawExpression).to.eq('tool-change-1');
+    expect(ev1.triggers[0].expression).to.exist;
+    expect(ev1.triggers[0].triggerVariables).to.deep.eq(['tool-change-1']);
+
+    const ev2 = config.adapter.dataEvents['tool-offset-change-1'];
+    expect(ev2.name).to.eq('tool-offset-change-1');
+    expect(ev2.payload.rawExpression).to.eq('{ x: XgeoT1, y: YgeoT1, z: ZgeoT1, xwear: XwearT1, ywear: YwearT1, zwear: ZwearT1 }');
+    expect(ev2.payload.expression).to.exist;
+    expect(ev2.triggers).to.have.length(1);
+    expect(ev2.triggers[0].rawExpression).to.eq('XGeoT1-chg or YGeoT1-chg or ZGeoT1-chg or XWearT1-chg or YWearT1-chg or ZWearT1-chg');
+    expect(ev2.triggers[0].expression).to.exist;
+    expect(ev2.triggers[0].triggerVariables).to.deep.eq([
+      'XGeoT1-chg', 'YGeoT1-chg', 'ZGeoT1-chg', 'XWearT1-chg', 'YWearT1-chg', 'ZWearT1-chg',
+    ]);
+  });
+
+  it('resolves payload trigger variables', function () {
+    const svc = config.expressionService;
+    expect(svc.expressionTriggers('data-events.tool-change-1.payload')).to.deep.eq([]);
+    expect(svc.expressionTriggers('data-events.tool-offset-change-1.payload')).to.deep.eq([
+      'XgeoT1', 'YgeoT1', 'ZgeoT1', 'XwearT1', 'YwearT1', 'ZwearT1',
+    ]);
+  });
+
+  it('resolves triggered data events by trigger variable', function () {
+    expect(config.adapter.triggeredDataEvents('tool-change-1')).to.deep.eq(['tool-change-1']);
+    expect(config.adapter.triggeredDataEvents('XGeoT1-chg')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('YGeoT1-chg')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('ZGeoT1-chg')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('XWearT1-chg')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('YWearT1-chg')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('ZWearT1-chg')).to.deep.eq(['tool-offset-change-1']);
+  });
+
+  it('resolves triggered data events by payload variable', function () {
+    expect(config.adapter.triggeredDataEvents('XgeoT1')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('YgeoT1')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('ZgeoT1')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('XwearT1')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('YwearT1')).to.deep.eq(['tool-offset-change-1']);
+    expect(config.adapter.triggeredDataEvents('ZwearT1')).to.deep.eq(['tool-offset-change-1']);
+  });
+
+  it('returns empty array for variables not referenced in any data event', function () {
+    expect(config.adapter.triggeredDataEvents('unrelated')).to.deep.eq([]);
+  });
+});

package/test/configFiles/data-events.yaml

@@ -0,0 +1,25 @@
+version: 2
+device: local
+declare-keys:
+  - tool-change-1
+  - XgeoT1
+  - YgeoT1
+  - ZgeoT1
+  - XwearT1
+  - YwearT1
+  - ZwearT1
+  - XGeoT1-chg
+  - YGeoT1-chg
+  - ZGeoT1-chg
+  - XWearT1-chg
+  - YWearT1-chg
+  - ZWearT1-chg
+data-events:
+  tool-change-1:
+    payload: "{}"
+    triggers:
+      - tool-change-1
+  tool-offset-change-1:
+    payload: "{ x: XgeoT1, y: YgeoT1, z: ZgeoT1, xwear: XwearT1, ywear: YwearT1, zwear: ZwearT1 }"
+    triggers:
+      - XGeoT1-chg or YGeoT1-chg or ZGeoT1-chg or XWearT1-chg or YWearT1-chg or ZWearT1-chg

package/test/configFiles/transform/map.yml

@@ -8,6 +8,7 @@ declare-keys:
   - program
   - complex
   - complex2
+  - complex3
 variables:
   var1:
     - source: counter
@@ -23,3 +24,7 @@ variables:
     - 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/transform/map.test.js

@@ -54,4 +54,22 @@ describe('map full engine config file tests', function () {
       [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],