@machinemetrics/io-adapter-lib 2.34.0 → 2.35.0

package/CHANGELOG.md

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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@machinemetrics/io-adapter-lib",
-  "version": "2.34.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