@discipl/law-reg/dist/services/expressionChecker.js

Discipl Law and Regulation Compliance Library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ExpressionChecker = void 0;

var _logging_util = require("../utils/logging_util");

var _andExpressionChecker = require("../expressions/andExpressionChecker");

var _createExpressionChecker = require("../expressions/createExpressionChecker");

var _equalExpressionChecker = require("../expressions/equalExpressionChecker");

var _isExpressionChecker = require("../expressions/isExpressionChecker");

var _lessThanExpressionChecker = require("../expressions/lessThanExpressionChecker");

var _listExpressionChecker = require("../expressions/listExpressionChecker");

var _literalExpressionChecker = require("../expressions/literalExpressionChecker");

var _maxExpressionChecker = require("../expressions/maxExpressionChecker");

var _minExpressionChecker = require("../expressions/minExpressionChecker");

var _notExpressionChecker = require("../expressions/notExpressionChecker");

var _orExpressionChecker = require("../expressions/orExpressionChecker");

var _productExpressionChecker = require("../expressions/productExpressionChecker");

var _projectionExpressionChecker = require("../expressions/projectionExpressionChecker");

var _sumExpressionChecker = require("../expressions/sumExpressionChecker");

class ExpressionChecker {
  /**
   * Create a ExpressionChecker
   * @param {ServiceProvider} serviceProvider
   */
  constructor(serviceProvider) {
    this.logger = (0, _logging_util.getDiscplLogger)();
    this.serviceProvider = serviceProvider;
    this.subExpressionCheckers = {
      'AND': new _andExpressionChecker.AndExpressionChecker(this.serviceProvider),
      'CREATE': new _createExpressionChecker.CreateExpressionChecker(this.serviceProvider),
      'EQUAL': new _equalExpressionChecker.EqualExpressionChecker(this.serviceProvider),
      'IS': new _isExpressionChecker.IsExpressionChecker(this.serviceProvider),
      'LESS_THAN': new _lessThanExpressionChecker.LessThanExpressionChecker(this.serviceProvider),
      'LIST': new _listExpressionChecker.ListExpressionChecker(this.serviceProvider),
      'LITERAL': new _literalExpressionChecker.LiteralExpressionChecker(this.serviceProvider),
      'MAX': new _maxExpressionChecker.MaxExpressionChecker(this.serviceProvider),
      'MIN': new _minExpressionChecker.MinExpressionChecker(this.serviceProvider),
      'NOT': new _notExpressionChecker.NotExpressionChecker(this.serviceProvider),
      'OR': new _orExpressionChecker.OrExpressionChecker(this.serviceProvider),
      'PRODUCT': new _productExpressionChecker.ProductExpressionChecker(this.serviceProvider),
      'PROJECTION': new _projectionExpressionChecker.ProjectionExpressionChecker(this.serviceProvider),
      'SUM': new _sumExpressionChecker.SumExpressionChecker(this.serviceProvider)
    };
  }
  /**
   * Get fact checker
   * @return {FactChecker}
   * @private
   */


  _getFactChecker() {
    return this.serviceProvider.factChecker;
  }
  /**
   * Get context explainer
   * @return {ContextExplainer}
   * @private
   */


  _getContextExplainer() {
    return this.serviceProvider.contextExplainer;
  }
  /**
   * Checks a parsed expression by considering the atomic parts and evaluating them
   *
   * @param {ParsedExpression|string} fact - Parsed fact object (might be string if the object is an atomic fact)
   * @param {object} ssid - Identity doing the checking
   * @param {Context} context - Context of the check
   * @returns {Promise<boolean>}
   */


  async checkExpression(fact, ssid, context) {
    const expr = fact.expression;
    this.logger.debug(`Handling: ${expr}`);
    const expressionChecker = this.subExpressionCheckers[expr];

    if (context.explanation && fact.expression) {
      context.explanation.expression = fact.expression;
    }

    if (expressionChecker) {
      return expressionChecker.checkSubExpression(fact, ssid, context);
    } else {
      if (typeof fact === 'string') {
        // Purposely do not alter context for explanation, this happens in checkFact
        const result = await this._getFactChecker().checkFact(fact, ssid, context);

        this._getContextExplainer().extendContextExplanationWithResult(context, result);

        return result;
      }

      throw new Error('Unknown expression type ' + expr);
    }
  }

}

exports.ExpressionChecker = ExpressionChecker;