@machinemetrics/io-adapter-lib 2.35.1 → 2.37.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [2.37.0]
+- Brother config changes in support of d00 (c00<->d00 may not be the exact cutoff)
+
+## [2.36.0]
+- Added if / else-if / else branch transform
+
 ## [2.35.1]
 - Fixed value-increase and value-decrease to not emit true when coming back from UNAVAILABLE
 - Behavior change: value-decrease does not emit true on start

package/lib/config/branchPreprocessor.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('./configError');
+
+const BRANCH_KEYS = ['if', 'else-if', 'else'];
+
+function isBranchKey(key) {
+  return BRANCH_KEYS.includes(key);
+}
+
+function getBranchKey(item) {
+  if (!_.isObject(item) || _.isArray(item)) {
+    return null;
+  }
+  const keys = _.keys(item);
+  if (keys.length !== 1) {
+    return null;
+  }
+  const key = keys[0];
+  return isBranchKey(key) ? key : null;
+}
+
+/**
+ * Preprocesses a variable's transform list to collapse consecutive if/else-if/else
+ * into a single branch transform. The user-facing YAML syntax allows:
+ *
+ *   - if:
+ *     - condition: this == 1
+ *     - op1
+ *   - else-if:
+ *     - condition: this == 2
+ *     - op1
+ *   - else:
+ *     - op1
+ *
+ * This gets rewritten to:
+ *
+ *   - branch:
+ *     - if: [...]
+ *     - else-if: [...]
+ *     - else: [...]
+ */
+function preprocessBranchTransforms(transformList, sectionPath) {
+  if (!_.isArray(transformList)) {
+    return transformList;
+  }
+
+  const result = [];
+  let i = 0;
+
+  while (i < transformList.length) {
+    const key = getBranchKey(transformList[i]);
+
+    if (key !== 'if') {
+      result.push(transformList[i]);
+      i += 1;
+    } else {
+      const branchComponents = [];
+      let seenElse = false;
+
+      while (i < transformList.length) {
+        const currentKey = getBranchKey(transformList[i]);
+
+        if (currentKey === null) {
+          break;
+        }
+
+        if (currentKey === 'if') {
+          if (branchComponents.length > 0) {
+            break;
+          }
+          const item = transformList[i];
+          const body = item[currentKey];
+          const condition = body[0];
+          const chainTransforms = preprocessBranchTransforms(body.slice(1), `${sectionPath}.${i}.if`);
+          branchComponents.push({ [currentKey]: [condition, ...chainTransforms] });
+          i += 1;
+        } else if (currentKey === 'else-if') {
+          if (branchComponents.length === 0) {
+            throw new ConfigError('else-if must follow if or else-if')
+              .atPath(sectionPath);
+          }
+          if (seenElse) {
+            throw new ConfigError('else-if cannot follow else')
+              .atPath(sectionPath);
+          }
+          const item = transformList[i];
+          const body = item[currentKey];
+          const condition = body[0];
+          const chainTransforms = preprocessBranchTransforms(body.slice(1), `${sectionPath}.${i}.else-if`);
+          branchComponents.push({ [currentKey]: [condition, ...chainTransforms] });
+          i += 1;
+        } else if (currentKey === 'else') {
+          if (branchComponents.length === 0) {
+            throw new ConfigError('else must follow if or else-if')
+              .atPath(sectionPath);
+          }
+          if (seenElse) {
+            throw new ConfigError('only one else allowed per branch')
+              .atPath(sectionPath);
+          }
+          seenElse = true;
+          const item = transformList[i];
+          const body = item[currentKey];
+          const chainTransforms = preprocessBranchTransforms(body, `${sectionPath}.${i}.else`);
+          branchComponents.push({ [currentKey]: chainTransforms });
+          i += 1;
+        } else {
+          break;
+        }
+      }
+
+      result.push({ branch: branchComponents });
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  preprocessBranchTransforms,
+};

package/lib/config/device/brotherHTTPConfig.js

@@ -16,7 +16,10 @@ class BrotherHTTPConfig {
     };
 
     const mode = expressionService.config['collection-mode'];
-    const defaultMode = this.DataCollectionModes.MIXED;
+    const deviceName = expressionService.config.device;
+    const defaultMode = deviceName === 'brother-ftp'
+      ? this.DataCollectionModes.FTP
+      : this.DataCollectionModes.MIXED;
     if (mode === undefined) this.dataCollectionMode = defaultMode;
     else if (mode.toLowerCase() === 'http') this.dataCollectionMode = this.DataCollectionModes.HTTP;
     else if (mode.toLowerCase() === 'ftp') this.dataCollectionMode = this.DataCollectionModes.FTP;
@@ -141,15 +144,23 @@ class BrotherHTTPConfig {
 
     /** Configuration indicates how to collect data:
     *  HTTP only,
-    *  FTP only (default),
+    *  FTP only (default for device brother-ftp),
     *  HTTP + FTP for program headers
     */
-    let mode = config['collection-mode'] ?? '';
-    if (_.isString(mode)) {
-      mode = mode.toLowerCase();
+    const isBrotherFtp = config.device === 'brother-ftp';
+    let mode = config['collection-mode'];
+    if (mode === undefined || mode === null || mode === '') {
+      mode = isBrotherFtp ? 'ftp' : '';
+    }
+    if (!_.isString(mode)) {
+      throw new ConfigError('collection-mode must be a string').atAttribute('collection-mode');
+    }
+    mode = mode.toLowerCase();
+    if (isBrotherFtp && mode !== 'ftp') {
+      throw new ConfigError('device brother-ftp requires collection-mode ftp').atAttribute('collection-mode');
     }
     if (!_.includes(['http', 'ftp', 'mixed'], mode)) {
-      throw new ConfigError('collection-mode must be one of: {http, ftp, mixed}').atAttribute('macros');
+      throw new ConfigError('collection-mode must be one of: {http, ftp, mixed}').atAttribute('collection-mode');
     }
 
     let keysThatAlreadyExist = '';
@@ -191,6 +202,36 @@ class BrotherHTTPConfig {
         throw new ConfigError(`The value of macros key ${key} must be a valid integer`).atAttribute(key);
       }
     });
+
+    this.assignOptionalRelativePath(config, 'memory-path', 'memoryPath');
+    this.assignOptionalRelativePath(config, 'production-path', 'productionPath');
+    this.assignOptionalRelativePath(config, 'panel-path', 'panelPath');
+    this.assignOptionalRelativePath(config, 'position-path', 'positionPath');
+    this.assignOptionalRelativePath(config, 'work-counter-path', 'workCounterPath');
+    this.assignOptionalRelativePath(config, 'alarm-path', 'alarmPath');
+    this.assignOptionalRelativePath(config, 'macro-path', 'macroPath');
+
+    if (_.has(config, 'cnc-version')) {
+      const cncVersion = config['cnc-version'];
+      if (cncVersion !== 'legacy' && cncVersion !== 'd00') {
+        throw new ConfigError('cnc-version must be one of: legacy, d00').atAttribute('cnc-version');
+      }
+      this.cncVersion = cncVersion;
+    }
+  }
+
+  assignOptionalRelativePath(config, yamlKey, propertyName) {
+    if (!_.has(config, yamlKey)) {
+      return;
+    }
+    const value = config[yamlKey];
+    if (!_.isString(value) || value.trim() === '') {
+      throw new ConfigError(`${yamlKey} must be a non-empty string`).atAttribute(yamlKey);
+    }
+    if (value.includes('..')) {
+      throw new ConfigError(`${yamlKey} must not contain '..'`).atAttribute(yamlKey);
+    }
+    this[propertyName] = value;
   }
 
   checkScanInterval(config) {

package/lib/config/engineConfigV2.js

@@ -3,6 +3,7 @@
 const _ = require('lodash');
 const ConfigError = require('./configError');
 const TransformConfigUtil = require('./transformConfigUtil');
+const { preprocessBranchTransforms } = require('./branchPreprocessor');
 
 class EngineConfig {
   constructor(expressionService, config = {}, device = {}) {
@@ -48,6 +49,10 @@ class EngineConfig {
       return variable;
     });
 
+    this.config.variables = _.mapValues(this.config.variables, (variable, name) => {
+      return preprocessBranchTransforms(variable, `variables.${name}`);
+    });
+
     _.each(this.getExpressions(this.config), name => expressionService.addExpression(name));
     _.each(this.getStringExpressions(this.config), name => expressionService.addStringExpression(name));
   }

package/lib/config/index.js

@@ -204,6 +204,7 @@ class Config {
         return new OPCUAConfig(expressionService);
       case 'brother':
       case 'brother-http':
+      case 'brother-ftp':
         return new BrotherHTTPConfig(expressionService);
       case 'adam-6052':
         return new AdamConfig(expressionService);
@@ -315,6 +316,7 @@ class Config {
       'opc-ua',
       'brother',
       'brother-http',
+      'brother-ftp',
       'adam-6052',
       'mtconnect',
       'mtconnect-haas',

package/lib/expressionService.js

@@ -259,7 +259,7 @@ class ExpressionService {
           if (tokens) {
             const first = tokens[0];
             if (first === 'this' || this.channelsLookup[first]) {
-              accum[first] = _.reduceRight(_.tail(tokens), (sub, item) => {
+              const nested = _.reduceRight(_.tail(tokens), (sub, item) => {
                 if (_.isNumber(item)) {
                   return [
                     ..._.times(Math.max(0, item - 1), () => 0),
@@ -268,6 +268,11 @@ class ExpressionService {
                 }
                 return { [item]: sub };
               }, 0);
+              if (_.isArray(nested) || _.isArray(accum[first])) {
+                accum[first] = nested;
+              } else {
+                accum[first] = _.merge(accum[first] || {}, nested);
+              }
             } else {
               accum[first] = 0;
             }

package/lib/transform/branch.js

@@ -0,0 +1,274 @@
+'use strict';
+
+const _ = require('lodash');
+const TransformState = require('./transformState');
+
+class BranchChain {
+  constructor(chain) {
+    this.chain = chain;
+    this.opResult = null;
+
+    const end = this.chain.chainEnd();
+    end.on('update', (value) => {
+      this.opResult = value;
+    });
+    end.on('unavailable', () => {
+      this.opResult = null;
+    });
+  }
+
+  update(context, value, time) {
+    this.chain.update(context, value, time);
+    return this.opResult;
+  }
+
+  probe(context, time) {
+    this.chain.probe(context, time);
+  }
+
+  probeOrForward(context, time) {
+    this.chain.probeOrForward(context, time);
+  }
+
+  setUnavailable(context, time) {
+    this.chain.setUnavailable(context, time);
+  }
+}
+
+/**
+ * Conditional branching transform. Evaluates conditions in sequence and runs the first
+ * matching branch's transform chain. Analogous to if/else-if/else.
+ *
+ * Config format (after preprocessing):
+ *   - branch:
+ *     - if:
+ *       - condition: this == 1 or x > y
+ *       - op1
+ *       - op2
+ *     - else-if:
+ *       - condition: this == 2
+ *       - op1
+ *     - else:
+ *       - op1
+ */
+class BranchFilter extends TransformState {
+  constructor({ engine, args: { conditions, branchChains, elseChain } }, builder) {
+    super();
+
+    this.engine = engine;
+    this.conditions = conditions;
+    this.branchChains = _.map(branchChains, (transforms) => {
+      const chain = builder.createTransformChain(engine, transforms);
+      return new BranchChain(chain);
+    });
+    this.elseChain = elseChain
+      ? new BranchChain(builder.createTransformChain(engine, elseChain))
+      : null;
+  }
+
+  static op = 'branch';
+
+  static create(args) {
+    return new BranchFilter(args, args.builder);
+  }
+
+  static parseConfig(configUtil, defn) {
+    const components = defn.args;
+    if (!_.isArray(components)) {
+      configUtil.throwConfigError('branch must contain a list of if/else-if/else components', this.op);
+    }
+
+    const conditions = [];
+    const branchChains = [];
+    let elseChain = null;
+    let lastWasConditional = false;
+
+    components.forEach((comp, i) => {
+      if (!_.isObject(comp) || _.isArray(comp)) {
+        configUtil.throwConfigError('Invalid branch component', this.op);
+      }
+
+      const key = _.first(_.keys(comp));
+      const body = comp[key];
+
+      if (!_.isArray(body)) {
+        configUtil.throwConfigError(`${key} must contain a list of transforms`, this.op);
+      }
+
+      if (key === 'if' || key === 'else-if') {
+        if (body.length === 0) {
+          configUtil.throwConfigError(`${key} must have at least a condition`, this.op);
+        }
+
+        const first = body[0];
+        let conditionExpr = null;
+        if (_.isObject(first) && !_.isArray(first) && _.has(first, 'condition')) {
+          conditionExpr = first.condition;
+          if (_.isObject(conditionExpr) && _.has(conditionExpr, 'expression')) {
+            conditionExpr = conditionExpr.expression;
+          }
+          conditionExpr = conditionExpr.toString();
+        }
+
+        if (!conditionExpr) {
+          configUtil.throwConfigError(`${key} first element must be condition: <expression>`, this.op);
+        }
+
+        const compiledExpression = configUtil.compileExpression(conditionExpr, this.op, { this: 0 });
+        conditions.push({
+          expression: conditionExpr,
+          compiledExpression,
+          expressionSources: configUtil.expressionService.expressionTriggers(`${defn.path}.${i}.condition`),
+          hasThis: configUtil.expressionService.findName(conditionExpr, 'this'),
+          sourceCache: {},
+        });
+
+        const chainTransforms = body.slice(1);
+        const { transform } = configUtil.loadTransformList(chainTransforms, `${defn.path}.${i}.${key}`, false);
+        branchChains.push(transform);
+        lastWasConditional = true;
+      } else if (key === 'else') {
+        if (!lastWasConditional) {
+          configUtil.throwConfigError('else must follow if or else-if', this.op);
+        }
+        if (elseChain !== null) {
+          configUtil.throwConfigError('only one else allowed per branch', this.op);
+        }
+
+        const { transform } = configUtil.loadTransformList(body, `${defn.path}.${i}.else`, false);
+        elseChain = transform;
+        lastWasConditional = false;
+      } else {
+        configUtil.throwConfigError(`Unknown branch component: ${key}`, this.op);
+      }
+    });
+
+    defn.args = {
+      conditions,
+      branchChains,
+      elseChain,
+    };
+  }
+
+  static getExpressions(configUtil, body, info) {
+    const { varName, index, attribute } = info;
+    const parts = [];
+
+    if (!_.isArray(body)) {
+      return [];
+    }
+
+    _.each(body, (comp, compIndex) => {
+      if (!_.isObject(comp) || _.isArray(comp)) {
+        return;
+      }
+
+      const key = _.first(_.keys(comp));
+      const compBody = comp[key];
+
+      if (key === 'if' || key === 'else-if') {
+        if (_.isArray(compBody) && compBody.length > 0) {
+          const first = compBody[0];
+          if (_.isObject(first) && _.has(first, 'condition')) {
+            const expr = first.condition?.toString?.() ?? first.condition;
+            if (expr) {
+              parts.push({
+                path: `variables.${varName}.${index}.${attribute}.${compIndex}.condition`,
+                expression: expr,
+              }, {
+                path: `variables.${varName}`,
+                expression: expr,
+              });
+            }
+          }
+        }
+      }
+
+      if (key === 'if' || key === 'else-if' || key === 'else') {
+        const chainTransforms = key === 'else'
+          ? compBody
+          : compBody.slice(1);
+        const normalized = _.map(chainTransforms, (t) => (_.isString(t) ? { [t]: [] } : t));
+        // Include key (if/else-if/else) so expression paths match loadTransformList (used by parseConfig)
+        const chainVarName = `${varName}.${index}.${attribute}.${compIndex}.${key}`;
+        const chainExprs = configUtil.getExpressionsFromChain(
+          normalized,
+          chainVarName,
+          [...(info.ancestorVars || []), varName]
+        );
+        parts.push(..._.flatten(chainExprs));
+      }
+    });
+
+    return parts;
+  }
+
+  supportsPendingChanges() {
+    const chains = [...this.branchChains, this.elseChain].filter(Boolean);
+    return _.some(chains, (c) => c.chain.chainSupportsPendingChange?.());
+  }
+
+  selectBranch(context, value, time) {
+    for (let i = 0; i < this.conditions.length; i += 1) {
+      const rule = this.conditions[i];
+
+      if (rule.hasThis) {
+        rule.sourceCache.this = value;
+      }
+
+      const unavailTerm = _.reduce(rule.expressionSources, (res, name) => {
+        const state = this.engine.getState(name);
+        if (state) {
+          rule.sourceCache[name] = state.value;
+        }
+        return res || !state || !state.available;
+      }, false);
+
+      if (unavailTerm) {
+        return -1;
+      }
+
+      try {
+        if (rule.compiledExpression.evaluate(rule.sourceCache)) {
+          return i;
+        }
+      } catch (err) {
+        this.recordError(context, err, time);
+      }
+    }
+
+    return this.elseChain !== null ? this.conditions.length : -1;
+  }
+
+  update(context, value, time) {
+    if (value === 'UNAVAILABLE') {
+      this.setUnavailable(context, time);
+    } else {
+      super.update(context, value, time);
+    }
+  }
+
+  filter(context, value, time) {
+    const branchIndex = this.selectBranch(context, value, time);
+
+    if (branchIndex < 0) {
+      this.commitValue(context, value, time);
+      return;
+    }
+
+    const chain = branchIndex < this.branchChains.length ? this.branchChains[branchIndex] : this.elseChain;
+
+    const result = chain.update(context, value, time);
+    if (result !== null && result !== undefined) {
+      this.commitValue(context, result, time);
+    } else {
+      this.setUnavailable(context, time);
+    }
+  }
+
+  setUnavailable(context, time) {
+    super.setUnavailable(context, time);
+  }
+}
+
+module.exports = BranchFilter;

package/lib/transform/index.js

@@ -2,6 +2,7 @@
 
 const AccumulateFilter = require('./accumulate');
 const AverageFilter = require('./average');
+const BranchFilter = require('./branch');
 const DebounceFilter = require('./debounce');
 const DownsampleFilter = require('./downsample');
 const EdgeFilter = require('./edge');
@@ -48,6 +49,7 @@ const WindowCountFilter = require('./windowCount');
 module.exports = {
   accumulate: AccumulateFilter,
   average: AverageFilter,
+  branch: BranchFilter,
   debounce: DebounceFilter,
   downsample: DownsampleFilter,
   edge: EdgeFilter,

package/package.json

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

package/test/config/brother-ftp.test.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const expect = require('chai').expect;
+const ConfigError = require('../../lib/config/configError');
+const testUtils = require('../util/testUtils');
+
+describe('Brother FTP device config', function () {
+  it('accepts brother-ftp without collection-mode (defaults to ftp)', async function () {
+    const cfg = await testUtils.loadConfig('device/brother-ftp-minimal.yml');
+    expect(cfg.deviceName).to.eq('brother-ftp');
+    expect(cfg.device.dataCollectionMode).to.eq(cfg.device.DataCollectionModes.FTP);
+  });
+
+  it('passes through optional FTP paths and cnc-version', async function () {
+    const cfg = await testUtils.loadConfig('device/brother-ftp-paths.yml');
+    expect(cfg.device.cncVersion).to.eq('d00');
+    expect(cfg.device.memoryPath).to.eq('_DAT/MEM.NC');
+    expect(cfg.device.productionPath).to.eq('_PRD/PRDD2.NC');
+    expect(cfg.device.panelPath).to.eq('_DAT/PANEL.NC');
+    expect(cfg.device.positionPath).to.eq('_DAT/PDSP.NC');
+    expect(cfg.device.workCounterPath).to.eq('_DAT/WKCNTR.NC');
+    expect(cfg.device.alarmPath).to.eq('_DAT/ALARM.NC');
+    expect(cfg.device.macroPath).to.eq('_DAT/MCRNI1.NC');
+  });
+
+  it('does not set path properties when keys are omitted', async function () {
+    const cfg = await testUtils.loadConfig('device/brother-ftp-minimal.yml');
+    expect(cfg.device.memoryPath).to.eq(undefined);
+    expect(cfg.device.cncVersion).to.eq(undefined);
+  });
+
+  it('accepts cnc-version legacy', async function () {
+    const cfg = await testUtils.loadConfig('device/brother-ftp-cnc-legacy.yml');
+    expect(cfg.device.cncVersion).to.eq('legacy');
+  });
+
+  it('rejects invalid cnc-version', async function () {
+    try {
+      await testUtils.loadConfig('device/brother-ftp-bad-cnc.yml');
+      expect.fail('Expected ConfigError');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+    }
+  });
+
+  it('rejects paths containing ..', async function () {
+    try {
+      await testUtils.loadConfig('device/brother-ftp-bad-path.yml');
+      expect.fail('Expected ConfigError');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+    }
+  });
+
+  it('rejects brother-ftp with non-ftp collection-mode', async function () {
+    try {
+      await testUtils.loadConfig('device/brother-ftp-bad-mode.yml');
+      expect.fail('Expected ConfigError');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+    }
+  });
+});

package/test/config/brother-http.test.js

@@ -15,5 +15,7 @@ describe('Brother HTTP config tests', function () {
     expect(defaultConfig.device.port).to.eq(21);
     expect(defaultConfig.device.scanInterval).to.eq(1000);
     expect(defaultConfig.device.httpInterval).to.eq(50);
+    expect(defaultConfig.device.memoryPath).to.eq(undefined);
+    expect(defaultConfig.device.cncVersion).to.eq(undefined);
   });
 });

package/test/configFiles/device/brother-ftp-bad-cnc.yml

@@ -0,0 +1,3 @@
+device: brother-ftp
+endpoint: 192.168.1.50
+cnc-version: bogus

package/test/configFiles/device/brother-ftp-bad-mode.yml

@@ -0,0 +1,3 @@
+device: brother-ftp
+endpoint: 192.168.1.50
+collection-mode: http

package/test/configFiles/device/brother-ftp-bad-path.yml

@@ -0,0 +1,3 @@
+device: brother-ftp
+endpoint: 192.168.1.50
+memory-path: _DAT/../MEM.NC

package/test/configFiles/device/brother-ftp-cnc-legacy.yml

@@ -0,0 +1,3 @@
+device: brother-ftp
+endpoint: 192.168.1.50
+cnc-version: legacy

package/test/configFiles/device/brother-ftp-minimal.yml

@@ -0,0 +1,2 @@
+device: brother-ftp
+endpoint: 192.168.1.50

package/test/configFiles/device/brother-ftp-paths.yml

@@ -0,0 +1,11 @@
+device: brother-ftp
+endpoint: 192.168.1.50
+collection-mode: ftp
+cnc-version: d00
+memory-path: _DAT/MEM.NC
+production-path: _PRD/PRDD2.NC
+panel-path: _DAT/PANEL.NC
+position-path: _DAT/PDSP.NC
+work-counter-path: _DAT/WKCNTR.NC
+alarm-path: _DAT/ALARM.NC
+macro-path: _DAT/MCRNI1.NC

package/test/configFiles/transform/branch.yml

@@ -0,0 +1,117 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+  - x
+  - y
+  - z
+  - obj
+variables:
+  branch1:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else-if:
+      - condition: this == 2
+      - expression: 200
+    - else:
+      - expression: 0
+  branch2simple:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 10
+    - else:
+      - expression: 0
+  branch3:
+    - source: counter
+    - if:
+      - condition: x > y
+      - expression: 1
+    - else-if:
+      - condition: x < y
+      - expression: -1
+    - else:
+      - expression: 0
+  ifOnly:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+  ifElseIf:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else-if:
+      - condition: this == 2
+      - expression: 200
+  twoElseIfs:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 10
+    - else-if:
+      - condition: this == 2
+      - expression: 20
+    - else-if:
+      - condition: this == 3
+      - expression: 30
+    - else:
+      - expression: 0
+  ifElseIfConsecutive:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else:
+      - expression: 2
+    - if:
+      - condition: counter == 2
+      - expression: 200
+  branchWithThis:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else:
+      - expression: this
+  branchUnavailable:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: x + 1
+    - else:
+      - expression: this
+  branchWithInnerVar:
+    - source: counter
+    - if:
+      - condition: obj.a > 5
+      - expression: obj.a
+    - else:
+      - expression: obj.b
+  nested:
+    - source: counter
+    - if:
+      - condition: this > 0
+      - if:
+        - condition: this > 2
+        - expression: z
+      - else:
+        - expression: y
+    - else:
+      - expression: x
+  nestedInnerVar:
+    - source: counter
+    - if:
+      - condition: this > 0
+      - if:
+        - condition: obj.a > obj.b
+        - expression: obj.a + obj.b
+      - else:
+        - expression: y
+    - else:
+      - expression: x

package/test/configFiles/transform/invalid-branch-else-only.yml

@@ -0,0 +1,11 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - else:
+      - expression: 0

package/test/configFiles/transform/invalid-branch-elseif-no-condition.yml

@@ -0,0 +1,14 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - else-if:
+      - expression: 200

package/test/configFiles/transform/invalid-branch-elseif-only.yml

@@ -0,0 +1,12 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - else-if:
+      - condition: this == 1
+      - expression: 100

package/test/configFiles/transform/invalid-branch-if-no-condition.yml

@@ -0,0 +1,11 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - if:
+      - expression: 100

package/test/configFiles/transform/invalid-branch-unrelated-op.yml

@@ -0,0 +1,18 @@
+version: 2
+device: mtconnect-adapter
+endpoint: localhost:8001
+mtconnect-port: 8002
+declare-keys:
+  - counter
+variables:
+  badVar:
+    - source: counter
+    - if:
+      - condition: this == 1
+      - expression: 100
+    - invert
+    - else-if:
+      - condition: this == 2
+      - expression: 200
+    - else:
+      - expression: 0

package/test/transform/branch-invalid.test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const expect = require('chai').expect;
+const ConfigError = require('../../lib/config/configError');
+const testUtils = require('../util/testUtils');
+
+describe('branch transform invalid config tests', function () {
+  it('rejects else by itself', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-else-only.yml');
+      expect.fail('Config with else by itself should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('else');
+    }
+  });
+
+  it('rejects else-if by itself', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-elseif-only.yml');
+      expect.fail('Config with else-if by itself should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('else-if');
+    }
+  });
+
+  it('rejects if without condition as first transform', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-if-no-condition.yml');
+      expect.fail('Config with if without condition should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('condition');
+    }
+  });
+
+  it('rejects else-if without condition as first transform', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-elseif-no-condition.yml');
+      expect.fail('Config with else-if without condition should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.include('condition');
+    }
+  });
+
+  it('rejects unrelated op between if/else-if/else', async function () {
+    try {
+      await testUtils.loadConfig('transform/invalid-branch-unrelated-op.yml');
+      expect.fail('Config with unrelated op between if/else-if/else should have thrown');
+    } catch (err) {
+      expect(err).to.be.instanceof(ConfigError);
+      expect(err.message).to.match(/else-if|else|Unsupported/);
+    }
+  });
+});

package/test/transform/branch.test.js

@@ -0,0 +1,357 @@
+'use strict';
+
+const expect = require('chai').expect;
+const EngineV2 = require('../../lib/engine/engineV2');
+const Builder = require('../../lib/engine/transformBuilderV2');
+const testUtils = require('../util/testUtils');
+
+describe('branch transform tests', function () {
+  let config;
+  before(async () => {
+    config = await testUtils.loadConfig('transform/branch.yml');
+  });
+
+  it('selects if branch when condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch1, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [100, 0],
+    ]);
+  });
+
+  it('selects else-if branch when condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch1, source);
+
+    source.sendValue('counter', 2, 0);
+
+    engine.validateFilter([
+      [200, 0],
+    ]);
+  });
+
+  it('selects else branch when no condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch1, source);
+
+    source.sendValue('counter', 5, 0);
+
+    engine.validateFilter([
+      [0, 0],
+    ]);
+  });
+
+  it('evaluates constant expression in branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch2simple, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [10, 0],
+    ]);
+  });
+
+  it('uses external variables in conditions', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch3, source);
+
+    source.sendValue('x', 10, 0);
+    source.sendValue('y', 5, 0);
+    source.sendValue('counter', 0, 0);
+
+    engine.validateFilter([
+      [1, 0],
+    ]);
+  });
+
+  it('selects else-if when x < y', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch3, source);
+
+    source.sendValue('x', 5, 0);
+    source.sendValue('y', 10, 0);
+    source.sendValue('counter', 0, 0);
+
+    engine.validateFilter([
+      [-1, 0],
+    ]);
+  });
+
+  it('selects else when x == y', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branch3, source);
+
+    source.sendValue('x', 5, 0);
+    source.sendValue('y', 5, 0);
+    source.sendValue('counter', 0, 0);
+
+    engine.validateFilter([
+      [0, 0],
+    ]);
+  });
+
+  it('if only: selects branch when condition matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifOnly, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [100, 0],
+    ]);
+  });
+
+  it('if only: passes through when condition does not match', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifOnly, source);
+
+    source.sendValue('counter', 5, 0);
+
+    engine.validateFilter([
+      [5, 0],
+    ]);
+  });
+
+  it('if/else-if without else: selects first branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIf, source);
+
+    source.sendValue('counter', 1, 0);
+
+    engine.validateFilter([
+      [100, 0],
+    ]);
+  });
+
+  it('if/else-if without else: selects second branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIf, source);
+
+    source.sendValue('counter', 2, 0);
+
+    engine.validateFilter([
+      [200, 0],
+    ]);
+  });
+
+  it('if/else-if without else: passes through when neither matches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIf, source);
+
+    source.sendValue('counter', 5, 0);
+
+    engine.validateFilter([
+      [5, 0],
+    ]);
+  });
+
+  it('two else-ifs: selects each branch correctly', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.twoElseIfs, source);
+
+    source.sendValue('counter', 1, 0);
+    source.sendValue('counter', 2, 1);
+    source.sendValue('counter', 3, 2);
+    source.sendValue('counter', 5, 3);
+
+    engine.validateFilter([[10, 0], [20, 1], [30, 2], [0, 3]]);
+  });
+
+  it('if/else/if: two consecutive branches', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.ifElseIfConsecutive, source);
+
+    source.sendValue('counter', 1, 0);
+    source.sendValue('counter', 2, 1);
+    source.sendValue('counter', 3, 2);
+
+    engine.validateFilter([[100, 0], [200, 1], [2, 2]]);
+  });
+
+  it('expression: this in else branch passes through input value', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branchWithThis, source);
+
+    source.sendValue('counter', 1, 0);
+    source.sendValue('counter', 5, 1);
+
+    engine.validateFilter([[100, 0], [5, 1]]);
+  });
+
+  it('unavailable in taken branch propagates; unavailable in not-taken branch has no effect', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    engine.addValueSource(source);
+
+    const filterUpdates = [];
+    const endFilter = engine.variablePool.branchUnavailable.chainEnd();
+    endFilter.on('update', (value, time) => {
+      filterUpdates.push({ time, value });
+    });
+    endFilter.on('unavailable', (time) => {
+      filterUpdates.push({ time, value: 'UNAVAILABLE' });
+    });
+
+    const expectFilter = (expected) => {
+      const ref = expected.map(([value, time]) => ({ time, value }));
+      expect(filterUpdates.length).to.eq(ref.length);
+      ref.forEach((r, i) => {
+        expect(filterUpdates[i].time).to.be.closeTo(r.time, 0.000001);
+        expect(filterUpdates[i].value).to.deep.eq(r.value);
+      });
+    };
+
+    source.sendValue('x', 10, 0);
+    source.sendValue('counter', 1, 0);
+    source.sendValue('x', 'UNAVAILABLE', 1);
+    source.sendValue('counter', 5, 2);
+    source.sendValue('x', 'UNAVAILABLE', 2);
+
+    expectFilter([['UNAVAILABLE', 0], [11, 0], ['UNAVAILABLE', 1], ['UNAVAILABLE', 1], [5, 2]]);
+  });
+
+  it('nested if/else inside branch', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.nested, source);
+
+    source.sendValue('x', 0, 0);
+    source.sendValue('y', 150, 0);
+    source.sendValue('z', 200, 0);
+
+    source.sendValue('counter', 0, 0);
+    source.sendValue('counter', 1, 1);
+    source.sendValue('counter', 2, 2);
+    source.sendValue('counter', 3, 3);
+
+    engine.validateFilter([[0, 0], [150, 1], [150, 2], [200, 3]]);
+  });
+
+  it('nested branch re-evaluates when expression variable in taken path updates', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.nested, source);
+
+    source.sendValue('x', 0, 0);
+    source.sendValue('y', 150, 0);
+    source.sendValue('z', 200, 0);
+
+    source.sendValue('counter', 0, 0);
+    source.sendValue('x', 1, 1);
+    source.sendValue('counter', 1, 2);
+    source.sendValue('y', 151, 3);
+    source.sendValue('counter', 3, 4);
+    source.sendValue('z', 201, 5);
+
+    engine.validateFilter([[0, 0], [1, 1], [150, 2], [151, 3], [200, 4], [201, 5]]);
+  });
+
+  it('branchWithInnerVar selects branch by obj.a and emits obj.a or obj.b', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.branchWithInnerVar, source);
+
+    source.sendValue('obj', { a: 10, b: 1 }, 0);
+    source.sendValue('counter', 1, 0);
+    source.sendValue('obj', { a: 3, b: 2 }, 1);
+    source.sendValue('counter', 2, 1);
+
+    engine.validateFilter([[10, 0], [2, 1]]);
+  });
+
+  it('nestedInnerVar selects nested branches by this and obj.a, obj.b', function () {
+    const engine = new EngineV2(config);
+    const builder = new Builder(config);
+    builder.build(engine);
+
+    const source = testUtils.valueSource();
+    testUtils.attachEngineTransformValidator(engine, engine.variablePool.nestedInnerVar, source);
+
+    source.sendValue('x', 0, 0);
+    source.sendValue('y', 150, 0);
+    source.sendValue('obj', { a: 10, b: 5 }, 0);
+
+    source.sendValue('counter', 0, 0);
+    source.sendValue('counter', 1, 1);
+    source.sendValue('obj', { a: 3, b: 8 }, 2);
+    source.sendValue('counter', 2, 2);
+
+    engine.validateFilter([[0, 0], [15, 1], [150, 2]]);
+  });
+});