@machinemetrics/io-adapter-lib 2.32.0

package/lib/config/adapterConfig.js

@@ -0,0 +1,535 @@
+'use strict';
+
+const _ = require('lodash');
+const math = require('../math');
+const ConfigError = require('./configError');
+const AllowDenyList = require('./common/allowDenyList');
+
+const allowDenyList = new AllowDenyList();
+
+class AdapterConfig {
+  constructor(expressionService, engineConfig) {
+    this.expressionService = expressionService;
+    this.engineConfig = engineConfig;
+
+    _.each(this.getExpressions(expressionService.config), name => expressionService.addExpression(name));
+    _.each(this.getStringExpressions(expressionService.config), name => expressionService.addStringExpression(name));
+  }
+
+  getExpressionsForDataItem(key, value) {
+    if (!value) {
+      return [];
+    }
+
+    if (_.isString(value)) {
+      return [{
+        path: `data-items.${key}.value`,
+        expression: value,
+      }];
+    }
+
+    if (_.isObject(value)) {
+      return _(value).map((expression, state) => {
+        if (_.isString(expression)) {
+          return {
+            path: `data-items.${key}.value.${state}`,
+            expression,
+          };
+        }
+        return null;
+      }).compact().value();
+    }
+
+    return [];
+  }
+
+  getExpressions(config = {}) {
+    let dataItems = config['data-items'];
+    if (_.isArray(dataItems)) {
+      dataItems = this.convertDataItemsList(dataItems);
+    }
+
+    dataItems = _(dataItems).map((container, key) => {
+      return this.getExpressionsForDataItem(key, container.value);
+    }).flattenDeep().compact().value();
+
+    const conditions = _(config.conditions).map((container, key) => {
+      if (_.isObject(container) && container.source) {
+        if (_.isObject(container.source)) {
+          const exprs = [];
+          if (container.source['code-list']) {
+            exprs.push({
+              path: `conditions.${key}.source.codeList`,
+              expression: container.source['code-list'],
+            });
+          }
+          if (container.source['message-list']) {
+            exprs.push({
+              path: `conditions.${key}.source.messageList`,
+              expression: container.source['message-list'],
+            });
+          }
+          if (container.source['level-list']) {
+            exprs.push({
+              path: `conditions.${key}.source.levelList`,
+              expression: container.source['level-list'],
+            });
+          }
+
+          return exprs;
+        }
+      }
+
+      if (!_.isArray(container)) {
+        container = [container];
+      }
+
+      return _.map(container, (subContainer) => {
+        if (_.isObject(subContainer)) {
+          return _.map(subContainer.value, (expression, state) => {
+            if (_.isString(expression)) {
+              return {
+                path: `conditions.${key}.${subContainer.code || key}.value.${state}`,
+                expression,
+              };
+            }
+            return null;
+          });
+        }
+        return null;
+      });
+    }).flattenDeep().compact().value();
+
+    return [...dataItems, ...conditions];
+  }
+
+  getStringExpressions(config = {}) {
+    return _(config.conditions).map((container, key) => {
+      if (!_.isArray(container)) {
+        container = [container];
+      }
+
+      return _.map(container, (subContainer) => {
+        if (_.isObject(subContainer)) {
+          const result = [];
+          if (_.isString(subContainer.code)) {
+            result.push({
+              path: `conditions.${key}.${subContainer.code || key}.code`,
+              string: subContainer.code,
+            });
+          }
+          if (_.isString(subContainer.message)) {
+            result.push({
+              path: `conditions.${key}.${subContainer.code || key}.message`,
+              string: subContainer.message,
+            });
+          }
+          _.each(subContainer.overrides, (override, index) => {
+            if (_.isString(override['override-code'])) {
+              result.push({
+                path: `conditions.${key}.overrides.${index}.override-code`,
+                string: override['override-code'],
+                withThis: true,
+              });
+            }
+            if (_.isString(override['override-message'])) {
+              result.push({
+                path: `conditions.${key}.overrides.${index}.override-message`,
+                string: override['override-message'],
+                withThis: true,
+              });
+            }
+          });
+          return result;
+        }
+        return null;
+      });
+    }).flattenDeep().compact().value();
+  }
+
+  parse(config = {}) {
+    this.loadDataItems(config['data-items']);
+    this.loadConditions(config.conditions);
+
+    this.passthroughConditions = _(this.conditions).filter((cond) => {
+      return cond.passthroughSource;
+    }).groupBy('passthroughSource').value();
+
+    this.verboseShdr = config['verbose-shdr'];
+  }
+
+  convertDataItemsList(items) {
+    const reformed = {};
+
+    const checkDup = (name) => {
+      if (reformed[name]) {
+        // Could be relaxed to a warning in the future
+        const configErr = new ConfigError(`Repeated symbol '${name}' in data-items list`);
+        throw configErr.atSection('data-items');
+      }
+    };
+
+    _.each(items, (entry) => {
+      if (_.isString(entry)) {
+        checkDup(entry);
+        if (!this.expressionService.isNameDefined(entry)) {
+          const configErr = new ConfigError(`Unknown symbol '${entry}' in data-items list`);
+          throw configErr.atSection('data-items');
+        }
+
+        reformed[entry] = { value: entry };
+      } else if (_.isObject(entry)) {
+        if (_.size(entry) !== 1) {
+          const configErr = new ConfigError('Unexpected object in data-items list');
+          throw configErr.atSection('data-items');
+        }
+
+        const name = Object.keys(entry)[0];
+        checkDup(name);
+
+        reformed[name] = { value: entry[name] };
+      }
+    });
+
+    return reformed;
+  }
+
+  loadDataItems(items) {
+    this.dataItemsByExpression = {};
+
+    // Abbreviated list format...
+    // data-items:
+    //   - exec1
+    //   - part_count
+    //   - etc
+
+    // ...and shorthand expression list format...
+    // data-items:
+    //   - exec1: some.value
+    //   - part_count: part + expres
+
+    if (_.isArray(items)) {
+      items = this.convertDataItemsList(items);
+    }
+
+    // ...maps to legacy dictionary format
+    // data-items:
+    //   exec1:
+    //     value: exec1
+    //   part_count:
+    //     value: part_count
+    //   etc:
+    //     value: etc # or more complex expressions
+    this.dataItems = {};
+
+    _.each(items, (item, key) => {
+      this.loadDataItemInternal(key, item.value);
+    });
+  }
+
+  loadDataItem(key, value) {
+    this.loadDataItemInternal(key, value);
+
+    const exprs = this.getExpressionsForDataItem(key, value);
+    _.each(exprs, name => this.expressionService.addExpression(name));
+  }
+
+  loadDataItemInternal(key, value) {
+    const itemDefn = {
+      name: key,
+    };
+
+    if (_.isEmpty(value)) {
+      const configErr = new ConfigError(`Data item '${key}' has no value`);
+      throw configErr.atSection(`data-items.${key}`).atAttribute('value');
+    } else if (_.isString(value)) {
+      try {
+        const expr = value.toString();
+        const compiledExpr = this.expressionService.compileExpression(expr);
+        const exprPath = `data-items.${key}.value`;
+
+        this.dataItemsByExpression[exprPath] = key;
+
+        itemDefn.rule = {
+          rawExpression: expr,
+          expression: compiledExpr,
+          triggers: this.expressionService.expressionTriggers(exprPath),
+        };
+      } catch (err) {
+        const configErr = new ConfigError(`Problem evaluating expression: ${err.message}`);
+        throw configErr.atSection(`data-items.${key}`).atAttribute('value');
+      }
+    } else if (_.isObject(value)) {
+      const keys = Object.getOwnPropertyNames(value);
+      itemDefn.stateRules = _.map(keys, (name) => {
+        try {
+          const expr = value[name].toString();
+          const compiledExpr = this.expressionService.compileExpression(expr);
+          const exprPath = `data-items.${key}.value.${name}`;
+
+          this.dataItemsByExpression[exprPath] = key;
+
+          return {
+            value: name,
+            expression: compiledExpr,
+            triggers: this.expressionService.expressionTriggers(exprPath),
+          };
+        } catch (err) {
+          const configErr = new ConfigError(`Problem evaluating expression: ${err.message}`);
+          throw configErr.atSection(`data-items.${key}`).atAttribute(name);
+        }
+      });
+    } else {
+      const configErr = new ConfigError(`Data item '${key}' has unexpected value: ${value}`);
+      throw configErr.atSection(`data-items.${key}`).atAttribute('value');
+    }
+
+    this.dataItems[key] = itemDefn;
+  }
+
+  loadConditions(conditions) {
+    this.conditionsByExpression = {};
+    this.conditions = _.mapValues(conditions || {}, (item, key) => {
+      if (item.source) {
+        let source = {};
+        if (_.isString(item.source)) {
+          if (!this.expressionService.isNameDefined(item.source)) {
+            const configErr = new ConfigError(`Unknown symbol ${item.source} as condition source.`);
+            throw configErr.atSection(`conditions.${key}`).atAttribute('source');
+          }
+
+          source = {
+            name: key,
+            passthroughSource: item.source,
+          };
+        } else if (_.isObject(item.source)) {
+          if (item.source['code-list'] || item.source['message-list']) {
+            const codeList = item.source['code-list'];
+            if (!_.isString(codeList) || !this.expressionService.isNameDefined(codeList)) {
+              const configErr = new ConfigError(`Unknown symbol ${codeList} as condition source code list.`);
+              throw configErr.atSection(`conditions.${key}.source`).atAttribute('code-list');
+            }
+
+            const messageList = item.source['message-list'];
+            if (!_.isString(messageList) || !this.expressionService.isNameDefined(messageList)) {
+              const configErr = new ConfigError(`Unknown symbol ${messageList} as condition source message list.`);
+              throw configErr.atSection(`conditions.${key}.source`).atAttribute('message-list');
+            }
+
+            // Levels are optional
+            const levelList = item.source['level-list'];
+            if (levelList && (!_.isString(levelList) || !this.expressionService.isNameDefined(levelList))) {
+              const configErr = new ConfigError(`Unknown symbol ${levelList} as condition source level list.`);
+              throw configErr.atSection(`conditions.${key}.source`).atAttribute('level-list');
+            }
+
+            source = {
+              name: key,
+              arraySource: {
+                codeList,
+                messageList,
+                levelList,
+              },
+            };
+
+            this.conditionsByExpression[`conditions.${key}.source.codeList`] = key;
+            this.conditionsByExpression[`conditions.${key}.source.messageList`] = key;
+            this.conditionsByExpression[`conditions.${key}.source.levelList`] = key;
+          }
+        }
+
+        if (item['allow-codes']) {
+          source.allowCodes = allowDenyList.parseWildcardKeyList(item['allow-codes'], `conditions.${key}.allow-codes`);
+        }
+        if (item['deny-codes']) {
+          source.denyCodes = allowDenyList.parseWildcardKeyList(item['deny-codes'], `conditions.${key}.deny-codes`);
+        }
+        if (item['reclassify-warning']) {
+          source.reclassifyWarning = allowDenyList.parseWildcardKeyList(item['reclassify-warning'], `conditions.${key}.reclassify-warning-codes`);
+        }
+        if (item['reclassify-fault']) {
+          source.reclassifyFault = allowDenyList.parseWildcardKeyList(item['reclassify-fault'], `conditions.${key}.reclassify-fault-codes`);
+        }
+
+        if (item.overrides) {
+          if (!_.isArray(item.overrides)) {
+            const configErr = new ConfigError('Overrides must be a list');
+            throw configErr.atSection(`conditions.${key}`).atAttribute('overrides');
+          }
+
+          source.overrides = _.map(item.overrides, (override, index) => {
+            const defn = {};
+            if (override['match-code']) {
+              defn.matchCode = allowDenyList.parseWildcardKey(override['match-code'], `conditions.${key}.overrides.match-code`, 1);
+            }
+            if (override['match-message']) {
+              defn.matchMessage = allowDenyList.parseWildcardKey(override['match-message'], `conditions.${key}.overrides.match-message`, 1);
+            }
+
+            if (override['override-code']) {
+              defn.code = override['override-code'];
+              defn.codePath = `conditions.${key}.overrides.${index}.override-code`;
+              defn.codeIsStatic = this.expressionService.isStaticExpression(defn.codePath);
+              defn.codeResolver = this.expressionResolver(defn.code, defn.codePath);
+              defn.codeResolverTriggers = this.expressionService.expressionTriggers(defn.codePath);
+              this.conditionsByExpression[defn.codePath] = key;
+            }
+
+            if (override['override-message']) {
+              defn.message = override['override-message'];
+              defn.messagePath = `conditions.${key}.overrides.${index}.override-message`;
+              defn.messageIsStatic = this.expressionService.isStaticExpression(defn.messagePath);
+              defn.messageResolver = this.expressionResolver(defn.code, defn.messagePath);
+              defn.messageResolverTriggers = this.expressionService.expressionTriggers(defn.messagePath);
+              this.conditionsByExpression[defn.messagePath] = key;
+            }
+
+            return defn;
+          });
+        }
+
+        if (!source.name) {
+          const configErr = new ConfigError('Incomplete condition source definition.');
+          throw configErr.atSection(`conditions.${key}`).atAttribute('source');
+        }
+
+        return source;
+      }
+
+      if (!_.isArray(item)) {
+        item = [item];
+      }
+
+      const codesByTrigger = {};
+      const codes = _.map(item, (item) => {
+        const code = this.parseConditionCodes(item, key);
+
+        const ruleTriggers = _.flatten(_.map(code.stateRules, 'triggers'));
+        const triggers = _.union(ruleTriggers, code.codeResolverTriggers, code.messageResolverTriggers);
+
+        _.each(triggers, (trigger) => {
+          const codeList = codesByTrigger[trigger] ?? [];
+          codeList.push(code);
+          codesByTrigger[trigger] = codeList;
+        });
+
+        return code;
+      });
+
+      return {
+        name: key,
+        codes,
+        codesByTrigger,
+      };
+    });
+  }
+
+  expressionResolver(item, itemPath) {
+    return (engine, thisItem) => {
+      if (this.expressionService.hasStringExpression(itemPath)) {
+        try {
+          if (engine.getState) {
+            const sources = this.expressionService.expressionTriggers(itemPath);
+            const localState = {};
+            const unavailTerm = sources.reduce((res, name) => {
+              const val = engine.getState(name);
+              localState[name] = val?.value;
+              return res || !val || !val.available;
+            }, false);
+
+            if (unavailTerm) {
+              return null;
+            }
+
+            if (thisItem !== undefined) {
+              localState.this = thisItem;
+            }
+
+            return this.expressionService.computeStringExpression(itemPath, localState);
+          }
+        } catch (err) {
+          // If compute failed, return the raw template string
+          // TODO: Log or present failure through other means
+          return item;
+        }
+      }
+      return item;
+    };
+  }
+
+  parseConditionCodes(item, key) {
+    const conditionKeys = [];
+    if (item.value.FAULT) {
+      conditionKeys.push('FAULT');
+    }
+    if (item.value.WARNING) {
+      conditionKeys.push('WARNING');
+    }
+
+    const stateRules = _.map(conditionKeys, (name) => {
+      try {
+        const expr = item.value[name].toString();
+        const compiledExpr = this.expressionService.compileExpression(expr);
+        const exprPath = `conditions.${key}.${item.code || key}.value.${name}`;
+
+        this.conditionsByExpression[exprPath] = key;
+
+        return {
+          value: name,
+          expression: compiledExpr,
+          triggers: this.expressionService.expressionTriggers(exprPath),
+        };
+      } catch (err) {
+        const configErr = new ConfigError(`Problem evaluating expression: ${err.message}`);
+        throw configErr.atSection(`conditions.${key}.${name}`).atAttribute('value');
+      }
+    });
+
+    stateRules.push({
+      value: 'NORMAL',
+      expression: math.compile('true'),
+      triggers: [],
+    });
+
+    const code = item.code || key;
+    const codePath = `conditions.${key}.${code}.code`;
+    if (this.conditionsByExpression[codePath]) {
+      const configErr = new ConfigError(`Duplicate condition code '${code}' for key '${key}'`);
+      throw configErr.atSection(`conditions.${key}`);
+    }
+
+    const codeLookup = this.expressionResolver(code, codePath);
+    this.conditionsByExpression[codePath] = key;
+
+    const message = item.message || 'Condition triggered';
+    const messagePath = `conditions.${key}.${code}.message`;
+    const messageLookup = this.expressionResolver(message, messagePath);
+    this.conditionsByExpression[messagePath] = key;
+
+    return {
+      codePath,
+      messagePath,
+      code,
+      codeIsStatic: this.expressionService.isStaticExpression(codePath),
+      codeResolver: codeLookup,
+      codeResolverTriggers: this.expressionService.expressionTriggers(codePath),
+      message,
+      messageIsStatic: this.expressionService.isStaticExpression(messagePath),
+      messageResolver: messageLookup,
+      messageResolverTriggers: this.expressionService.expressionTriggers(messagePath),
+      stateRules,
+    };
+  }
+
+  triggeredDataItems(name) {
+    const triggeredPaths = this.expressionService.expressionsTriggeredBy(name);
+    return _(triggeredPaths).map(p => this.dataItemsByExpression[p]).compact().uniq().value();
+  }
+
+  triggeredConditions(name) {
+    const triggeredPaths = this.expressionService.expressionsTriggeredBy(name);
+    return _(triggeredPaths).map(p => this.conditionsByExpression[p]).compact().uniq().value();
+  }
+}
+
+module.exports = AdapterConfig;

package/lib/config/common/allowDenyList.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const _ = require('lodash');
+const ConfigError = require('../configError');
+
+class AllowDenyList {
+  parseWildcardKeyList(keys, attributePath) {
+    if (_.isEmpty(keys)) {
+      return [];
+    }
+    if (!_.isArray(keys)) {
+      throw new ConfigError('list expected').atPath(attributePath);
+    }
+
+    // Check for duplicate entries
+    const duplicates = _(keys)
+      .groupBy()
+      .pickBy(x => x.length > 1)
+      .keys()
+      .value();
+
+    if (duplicates.length > 0) {
+      throw new ConfigError(`duplicate entries found: ${duplicates.join(', ')}`).atPath(attributePath);
+    }
+
+    let line = 0;
+    return _.map(keys, (key) => {
+      line += 1;
+      return this.parseWildcardKey(key, attributePath, line);
+    });
+  }
+
+  parseWildcardKey(key, attributePath, line) {
+    if (!_.isString(key)) {
+      throw new ConfigError(this.formatErrorMessage('Unexpected key pattern', line)).atPath(attributePath);
+    }
+    if (_.first(key) === '/') {
+      const match = key.match(/^\/(.+)\/([imus]*)$/sm);
+      if (match) {
+        const flags = match[2];
+        return new RegExp(key.replace(/^\/\^?/, '^').replace(/\$?\/[imus]*$/, '$'), flags);
+      }
+    }
+
+    /* eslint-disable no-useless-escape, prefer-template */
+    const escapeRegex = str => str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1');
+    return new RegExp('^' + key.split('*').map(escapeRegex).join('.*') + '$');
+  }
+
+  formatErrorMessage(message, line) {
+    if (_.isUndefined(line)) {
+      return message;
+    }
+    return `${message} at entry ${line} of list`;
+  }
+}
+
+module.exports = AllowDenyList;

package/lib/config/common/jsonPath.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const ConfigError = require('../configError');
+
+// https://machinemetrics.atlassian.net/wiki/spaces/~279526106/pages/492404812/Documentation+Extended+JSON+Path+Syntax
+const checkJsonPropPath = (path, name) => {
+  if (!path) {
+    throw new ConfigError('Malformed prop definition.  Missing path.').atAttribute(name);
+  }
+
+  const pathSegments = path.split('.');
+
+  // Validate each segment in the path
+  pathSegments.forEach((segment) => {
+    const findMatch = segment.match(/\[([a-zA-Z0-9_]+)=([a-zA-Z0-9_]+)]/);
+
+    // If find notation is detected
+    if (findMatch) {
+      const [, key, rawValue] = findMatch;
+      const baseSegment = segment.replace(findMatch[0], '');
+
+      // Check that the base segment (if present) is a non-empty string
+      if (baseSegment && baseSegment.length === 0) {
+        throw new ConfigError('Malformed prop definition.  Invalid path segment.').atAttribute(name);
+      }
+
+      // Validate key (should be a non-empty string)
+      if (key.length === 0) {
+        throw new ConfigError('Malformed prop definition.  Invalid key in segment.').atAttribute(name);
+      }
+
+      // Validate value (should be a string or a number)
+      if (!/^[\d]+([.][\d]+)?$/g.test(rawValue) && rawValue.length === 0) {
+        throw new ConfigError('Malformed prop definition.  Invalid value in segment.').atAttribute(name);
+      }
+    } else if (segment.length === 0) {
+      throw new ConfigError('Malformed prop definition.  Invalid path segment.').atAttribute(name);
+    }
+  });
+};
+
+module.exports = {
+  checkJsonPropPath,
+};