refactor: move decision/BKM loading to evaluation

Remove the resolve() function of the references. Instead, load imported models during the evaluation.

Handle missing models during the evaluation by returning a failure.

Refine and simplify the parsed types.

Author: saig0

src/main/scala/org/camunda/dmn/DmnEngine.scala

@@ -156,19 +156,21 @@ class DmnEngine(configuration: DmnEngine.Configuration =
   val parser = new DmnParser(
     configuration = configuration,
     feelParser = feelEngine.parseExpression(_).toEither.left.map(_.message),
-    feelUnaryTestsParser = feelEngine.parseUnaryTests(_).toEither.left.map(_.message),
-    dmnRepository = dmnRepository
+    feelUnaryTestsParser = feelEngine.parseUnaryTests(_).toEither.left.map(_.message)
   )
 
-  val decisionEval = new DecisionEvaluator(eval = this.evalExpression,
-                                           evalBkm = bkmEval.createFunction)
+  val decisionEval = new DecisionEvaluator(
+    eval = this.evalExpression,
+    evalBkm = bkmEval.createFunction,
+    repository = dmnRepository
+  )
 
   val literalExpressionEval = new LiteralExpressionEvaluator(feelEngine)
 
   val decisionTableEval = new DecisionTableEvaluator(
     literalExpressionEval.evalExpression)
 
-  val bkmEval = new BusinessKnowledgeEvaluator(this.evalExpression, valueMapper)
+  val bkmEval = new BusinessKnowledgeEvaluator(this.evalExpression, valueMapper, dmnRepository)
 
   val contextEval = new ContextEvaluator(this.evalExpression)
 
@@ -178,7 +180,9 @@ class DmnEngine(configuration: DmnEngine.Configuration =
 
   val invocationEval = new InvocationEvaluator(
     eval = literalExpressionEval.evalExpression,
-    evalBkm = bkmEval.eval)
+    evalBkm = bkmEval.eval,
+    repository = dmnRepository
+  )
 
   val functionDefinitionEval = new FunctionDefinitionEvaluator(
     literalExpressionEval.evalExpression)

src/main/scala/org/camunda/dmn/evaluation/BusinessKnowledgeEvaluator.scala

@@ -17,21 +17,20 @@ package org.camunda.dmn.evaluation
 
 import org.camunda.dmn.DmnEngine._
 import org.camunda.dmn.FunctionalHelper._
-import org.camunda.dmn.parser.{
-  ParsedBusinessKnowledgeModel,
-  ParsedDecisionLogic
-}
+import org.camunda.dmn.parser.{DmnRepository, EmbeddedBusinessKnowledgeModel, ExpressionFailure, ImportedBusinessKnowledgeModel, ParsedBusinessKnowledgeModel, ParsedBusinessKnowledgeModelFailure, ParsedBusinessKnowledgeModelReference, ParsedDecisionLogic}
 import org.camunda.feel.syntaxtree.{Val, ValError, ValFunction}
 import org.camunda.feel.valuemapper.ValueMapper
 
 class BusinessKnowledgeEvaluator(
     eval: (ParsedDecisionLogic, EvalContext) => Either[Failure, Val],
-    valueMapper: ValueMapper) {
+    valueMapper: ValueMapper,
+    repository: DmnRepository) {
 
   def eval(bkm: ParsedBusinessKnowledgeModel,
            context: EvalContext): Either[Failure, Val] = {
 
-    evalRequiredKnowledge(bkm.requiredBkms.map(_.resolve()), context)
+    resolveRequiredBkms(bkm)
+      .flatMap(evalRequiredKnowledge(_, context))
       .flatMap(functions => {
 
         val evalContext =
@@ -43,11 +42,21 @@ class BusinessKnowledgeEvaluator(
       })
   }
 
+  private def resolveRequiredBkms(bkm: ParsedBusinessKnowledgeModel): Either[Failure, Iterable[ParsedBusinessKnowledgeModel]] = {
+    mapEither[ParsedBusinessKnowledgeModelReference, ParsedBusinessKnowledgeModel](bkm.requiredBkms, {
+      case ImportedBusinessKnowledgeModel(namespace, id, _) => repository.getBusinessKnowledgeModel(namespace = namespace, bkmId = id)
+      case ParsedBusinessKnowledgeModelFailure(_, _, failureMessage) => Left(Failure(failureMessage))
+      case bkm: EmbeddedBusinessKnowledgeModel => Right(bkm)
+    })
+  }
+
   def createFunction(
       bkm: ParsedBusinessKnowledgeModel,
       context: EvalContext): Either[Failure, (String, ValFunction)] = {
 
-    evalRequiredKnowledge(bkm.requiredBkms.map(_.resolve()), context).map(functions => {
+    resolveRequiredBkms(bkm)
+      .flatMap(evalRequiredKnowledge(_, context))
+      .map(functions => {
 
       val evalContext = context.copy(variables = context.variables ++ functions,
                                      currentElement = bkm)

src/main/scala/org/camunda/dmn/evaluation/DecisionEvaluator.scala

@@ -18,19 +18,14 @@ package org.camunda.dmn.evaluation
 import org.camunda.dmn.DmnEngine._
 import org.camunda.dmn.FunctionalHelper._
 import org.camunda.feel.syntaxtree.{Val, ValContext, ValFunction}
-import org.camunda.dmn.parser.{
-  ParsedBusinessKnowledgeModel,
-  ParsedBusinessKnowledgeModelReference,
-  ParsedDecision,
-  ParsedDecisionReference,
-  ParsedDecisionLogic,
-  ParsedDecisionLogicContainerReference}
+import org.camunda.dmn.parser.{DmnRepository, EmbeddedBusinessKnowledgeModel, EmbeddedDecision, ImportedBusinessKnowledgeModel, ImportedDecision, ParsedBusinessKnowledgeModel, ParsedBusinessKnowledgeModelFailure, ParsedBusinessKnowledgeModelReference, ParsedDecision, ParsedDecisionFailure, ParsedDecisionLogic, ParsedDecisionReference}
 import org.camunda.feel.context.Context.StaticContext
 
 class DecisionEvaluator(
     eval: (ParsedDecisionLogic, EvalContext) => Either[Failure, Val],
     evalBkm: (ParsedBusinessKnowledgeModel,
-              EvalContext) => Either[Failure, (String, ValFunction)]) {
+              EvalContext) => Either[Failure, (String, ValFunction)],
+    repository: DmnRepository) {
 
   def eval(decision: ParsedDecision,
            context: EvalContext): Either[Failure, Val] = {
@@ -67,34 +62,43 @@ class DecisionEvaluator(
   private def evalRequiredDecisions(
     requiredDecisions: Iterable[ParsedDecisionReference],
     context: EvalContext): Either[Failure, List[(String, Val)]] = {
-    mapEither(requiredDecisions,
-      (decisionRef: ParsedDecisionReference) => evalDecision(decisionRef.resolve(), context)
-      .map(maybeWrapResult(decisionRef, _)))
+    mapEither[ParsedDecisionReference, (String, Val)](requiredDecisions, {
+          case ImportedDecision(namespace, decisionId, importName) =>
+            repository.getDecision(namespace = namespace, decisionId = decisionId)
+              .flatMap(evalDecision(_, context))
+              .map { case (name, result) =>
+                importName -> ValContext(StaticContext(
+                  variables = Map(name -> result),
+                  functions = Map.empty
+                ))
+              }
+
+          case ParsedDecisionFailure(_, _, failureMessage) => Left(Failure(failureMessage))
+          case decision: EmbeddedDecision => evalDecision(decision, context)
+        }
+    )
   }
 
   private def evalRequiredKnowledge(
     requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference],
     context: EvalContext): Either[Failure, List[(String, Val)]] = {
-    mapEither(requiredBkms,
-      (bkmRef: ParsedBusinessKnowledgeModelReference) => evalBkm(bkmRef.resolve(), context)
-        .map(maybeWrapResult(bkmRef, _)))
-  }
+    mapEither[ParsedBusinessKnowledgeModelReference, (String, Val)](requiredBkms, {
+          case ImportedBusinessKnowledgeModel(namespace, id, importName) =>
+            repository.getBusinessKnowledgeModel(namespace = namespace, bkmId = id)
+            .flatMap(evalBkm(_, context))
+            .map { case (name, resultFunction) =>
+              importName -> ValContext(
+                StaticContext(
+                  variables = Map.empty,
+                  functions = Map(name -> List(resultFunction))
+                )
+              )
+            }
 
-  private def maybeWrapResult(
-    reference: ParsedDecisionLogicContainerReference[_], result: (String, Val)) =
-    reference.importedModelName match {
-      case Some(importName) =>
-        val ctx = result._2 match {
-          case func: ValFunction => StaticContext(
-            variables = Map.empty,
-            functions = Map(result._1 -> List(func))
-          )
-          case _ => StaticContext(
-            variables = Map(result._1 -> result._2),
-            functions = Map.empty
-          )
+          case ParsedBusinessKnowledgeModelFailure(_, _, failureMessage) => Left(Failure(failureMessage))
+          case bkm: EmbeddedBusinessKnowledgeModel => evalBkm(bkm, context)
         }
-        importName -> ValContext(ctx)
-      case _ => result
-    }
+    )
+  }
+
 }

src/main/scala/org/camunda/dmn/evaluation/InvocationEvaluator.scala

@@ -17,29 +17,35 @@ package org.camunda.dmn.evaluation
 
 import org.camunda.dmn.DmnEngine._
 import org.camunda.dmn.FunctionalHelper._
-import org.camunda.dmn.parser.{
-  ParsedBusinessKnowledgeModel,
-  ParsedExpression,
-  ParsedInvocation
-}
+import org.camunda.dmn.parser.{DmnRepository, EmbeddedBusinessKnowledgeModel, ImportedBusinessKnowledgeModel, ParsedBusinessKnowledgeModel, ParsedBusinessKnowledgeModelFailure, ParsedBusinessKnowledgeModelReference, ParsedExpression, ParsedInvocation}
 import org.camunda.feel.syntaxtree.Val
 
 class InvocationEvaluator(
     eval: (ParsedExpression, EvalContext) => Either[Failure, Val],
-    evalBkm: (ParsedBusinessKnowledgeModel, EvalContext) => Either[Failure, Val]) {
+    evalBkm: (ParsedBusinessKnowledgeModel, EvalContext) => Either[Failure, Val],
+    repository: DmnRepository) {
 
   def eval(invocation: ParsedInvocation,
            context: EvalContext): Either[Failure, Val] = {
 
     val result = evalParameters(invocation.bindings, context).flatMap { p =>
       val ctx = context.copy(variables = context.variables ++ p.toMap)
-      evalBkm(invocation.invocation, ctx)
+
+      resolveBkm(invocation.invocation).flatMap(evalBkm(_, ctx))
     }
 
     context.audit(invocation, result)
     result
   }
 
+  private def resolveBkm(bkmRef: ParsedBusinessKnowledgeModelReference): Either[Failure, ParsedBusinessKnowledgeModel] = {
+    bkmRef match {
+      case ImportedBusinessKnowledgeModel(namespace, id, _) => repository.getBusinessKnowledgeModel(namespace = namespace, bkmId = id)
+      case ParsedBusinessKnowledgeModelFailure(_, _, failureMessage) => Left(Failure(failureMessage))
+      case bkm: EmbeddedBusinessKnowledgeModel => Right(bkm)
+    }
+  }
+
   private def evalParameters(
       bindings: Iterable[(String, ParsedExpression)],
       context: EvalContext): Either[Failure, List[(String, Any)]] = {

src/main/scala/org/camunda/dmn/parser/DmnParser.scala

@@ -72,8 +72,7 @@ class DmnParser(
   configuration: Configuration,
   feelParser: String => Either[String, feel.syntaxtree.ParsedExpression],
   feelUnaryTestsParser: String => Either[String,
-    feel.syntaxtree.ParsedExpression],
-  dmnRepository: DmnRepository) {
+    feel.syntaxtree.ParsedExpression]) {
 
   import DmnParser._
 
@@ -147,8 +146,8 @@ class DmnParser(
 
         val parsedDmn = ParsedDmn(
           model = model,
-          decisions = ctx.decisions.values.filter(_.isEmbedded).map(_.resolve()),
-          bkms = ctx.bkms.values.filter(_.isEmbedded).map(_.resolve()),
+          decisions = ctx.decisions.values.collect{ case decision: ParsedDecision => decision },
+          bkms = ctx.bkms.values.collect { case bkm: ParsedBusinessKnowledgeModel => bkm },
           namespace = definitions.getNamespace)
 
         if (ctx.failures.isEmpty) {
@@ -315,11 +314,11 @@ class DmnParser(
     } else {
       ctx.importedModels
         .find(importedModel => reference.namespace == importedModel.namespace)
-        .map(importedModel => ImportedDecision(dmnRepository, reference.namespace, reference.id, Some(importedModel.name)))
+        .map(importedModel => ImportedDecision(reference.namespace, reference.id, importedModel.name))
         .getOrElse {
           val failure = Failure(s"No import found for namespace '${reference.namespace}'.")
           ctx.failures += failure
-          ParsedDecisionFailure(reference.id, reference.namespace, ExpressionFailure(failure.message))
+          ParsedDecisionFailure(reference.id, reference.namespace, failure.message)
         }
     }
   }
@@ -336,12 +335,11 @@ class DmnParser(
     } else {
       ctx.importedModels
         .find(importedModel => reference.namespace == importedModel.namespace)
-        .map(importedModel => ImportedBusinessKnowledgeModel(
-          dmnRepository, reference.namespace, reference.id, Some(importedModel.name)))
+        .map(importedModel => ImportedBusinessKnowledgeModel(reference.namespace, reference.id, importedModel.name))
         .getOrElse {
           val failure = Failure(s"No import found for namespace '${reference.namespace}'.")
           ctx.failures += failure
-          ParsedBusinessKnowledgeModelFailure(reference.id, reference.namespace, ExpressionFailure(failure.message))
+          ParsedBusinessKnowledgeModelFailure(reference.id, reference.namespace, failure.message)
         }
     }
   }
@@ -554,7 +552,7 @@ class DmnParser(
         ctx.bkms
           .get(expression)
           .map(bkmRef => {
-            ParsedInvocation(bindings, bkmRef.resolve())
+            ParsedInvocation(bindings, bkmRef)
           })
           .getOrElse {
             ctx.failures += Failure(s"no BKM found with name '$expression'")

src/main/scala/org/camunda/dmn/parser/ParsedDmn.scala

@@ -58,14 +58,10 @@ trait ParsedDecision extends ParsedDecisionLogicContainer {
   val requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference]
 }
 
-trait ParsedDecisionLogicContainerReference[T <: ParsedDecisionLogicContainer] {
-  val importedModelName: Option[String] = None
-  def resolve(): T
+trait ParsedDecisionReference {
   def isEmbedded: Boolean
-  def isImported: Boolean = !isEmbedded
-}
 
-trait ParsedDecisionReference extends ParsedDecisionLogicContainerReference[ParsedDecision] {
+  def isImported: Boolean = !isEmbedded
 }
 
 case class EmbeddedDecision(
@@ -77,26 +73,11 @@ case class EmbeddedDecision(
   requiredDecisions: Iterable[ParsedDecisionReference],
   requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference]
 ) extends ParsedDecision with ParsedDecisionReference {
-  override def resolve(): ParsedDecision = this
 
   override def isEmbedded: Boolean = true
 }
 
-trait ImportedParsedDecisionLogicFailure[T <: ParsedDecisionLogicContainer]
-  extends ParsedDecisionLogicContainerReference[T] {
-  val id: String
-  val namespace: String
-  val expressionFailure: ExpressionFailure
-  override def resolve(): T = throw new RuntimeException(expressionFailure.failure)
-
-  override def isEmbedded: Boolean = false
-}
-
-case class ImportedDecision(repository: DmnRepository, namespace: String, id: String, override val importedModelName: Option[String]) extends ParsedDecisionReference {
-  override def resolve(): ParsedDecision = repository.getDecision(namespace, id) match {
-    case Right(found) => found
-    case Left(failure) => ParsedDecisionFailure(id, namespace, ExpressionFailure(failure.message)).resolve()
-  }
+case class ImportedDecision(namespace: String, id: String, importedModelName: String) extends ParsedDecisionReference {
 
   override def isEmbedded: Boolean = false
 
@@ -107,7 +88,11 @@ sealed trait ParsedBusinessKnowledgeModel extends ParsedDecisionLogicContainer {
   val requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference]
 }
 
-trait ParsedBusinessKnowledgeModelReference extends ParsedDecisionLogicContainerReference[ParsedBusinessKnowledgeModel]
+trait ParsedBusinessKnowledgeModelReference {
+  def isEmbedded: Boolean
+
+  def isImported: Boolean = !isEmbedded
+}
 
 
 case class EmbeddedBusinessKnowledgeModel(
@@ -118,36 +103,28 @@ case class EmbeddedBusinessKnowledgeModel(
   requiredBkms: Iterable[ParsedBusinessKnowledgeModelReference]) extends
 ParsedBusinessKnowledgeModel with ParsedBusinessKnowledgeModelReference {
 
-  override def resolve(): ParsedBusinessKnowledgeModel = this
-
   override def isEmbedded: Boolean = true
 }
 
-case class ImportedBusinessKnowledgeModel(
-  repository: DmnRepository,
-  namespace: String, id: String,
-  override val importedModelName: Option[String]) extends ParsedBusinessKnowledgeModelReference {
-  override def resolve(): ParsedBusinessKnowledgeModel = repository.getBusinessKnowledgeModel(namespace, id) match {
-    case Right(found) => found
-    case Left(failure) =>
-      ParsedBusinessKnowledgeModelFailure(id, namespace, ExpressionFailure(failure.message)).resolve()
-  }
+case class ImportedBusinessKnowledgeModel(namespace: String, id: String, importedModelName: String) extends ParsedBusinessKnowledgeModelReference {
 
   override def isEmbedded: Boolean = false
 }
 
-case class ParsedBusinessKnowledgeModelFailure(id: String, namespace: String, expressionFailure: ExpressionFailure)
-  extends ImportedParsedDecisionLogicFailure[ParsedBusinessKnowledgeModel]
-  with ParsedBusinessKnowledgeModelReference
+case class ParsedBusinessKnowledgeModelFailure(id: String, namespace: String, failureMessage: String)
+ extends ParsedBusinessKnowledgeModelReference {
+  override def isEmbedded: Boolean = false
+}
 
-case class ParsedDecisionFailure(id: String, namespace: String, expressionFailure: ExpressionFailure)
-  extends ImportedParsedDecisionLogicFailure[ParsedDecision]
-    with ParsedDecisionReference
+case class ParsedDecisionFailure(id: String, namespace: String, failureMessage: String)
+  extends ParsedDecisionReference {
+  override def isEmbedded: Boolean = false
+}
 
 sealed trait ParsedDecisionLogic
 
 case class ParsedInvocation(bindings: Iterable[(String, ParsedExpression)],
-                            invocation: ParsedBusinessKnowledgeModel)
+                            invocation: ParsedBusinessKnowledgeModelReference)
     extends ParsedDecisionLogic
 
 case class ParsedContext(entries: Iterable[(String, ParsedDecisionLogic)],