[NU-2106] Fix spel template evaluation in runtime (#7764)

Author: lukasz-bigorajski

components-api/src/main/scala/pl/touk/nussknacker/engine/api/TemplateEvaluationResult.scala

@@ -5,11 +5,11 @@ case class TemplateEvaluationResult(renderedParts: List[TemplateRenderedPart]) {
 }
 
 sealed trait TemplateRenderedPart {
-  def value: String
+  def value: AnyRef
 }
 
 object TemplateRenderedPart {
   case class RenderedLiteral(value: String) extends TemplateRenderedPart
 
-  case class RenderedSubExpression(value: String) extends TemplateRenderedPart
+  case class RenderedSubExpression(value: AnyRef) extends TemplateRenderedPart
 }

docs/Changelog.md

@@ -131,6 +131,8 @@
     static values.
   * JsonDefaultExpression and AvroDefaultExpression default string values changed to SpEL template.
   * For now on, default values are provided for dry run parameters.
+* [#7764](https://github.com/TouK/nussknacker/pull/7764) Fix SpEL template evaluation on runtime. For now on, there is
+  no need to pass .toString on variable in SpEL template expression. 
 
 ## 1.18
 

scenario-compiler/src/main/scala/pl/touk/nussknacker/engine/spel/SpelExpression.scala

@@ -142,8 +142,7 @@ class SpelExpression(
     def renderExpression(expression: Expression): List[TemplateRenderedPart] = expression match {
       case literal: LiteralExpression => List(RenderedLiteral(literal.getExpressionString))
       case spelExpr: org.springframework.expression.spel.standard.SpelExpression =>
-        // TODO: Should we use the same trick with re-parsing after ClassCastException as we use in ParsedSpelExpression?
-        List(RenderedSubExpression(spelExpr.getValue[String](evaluationContext, classOf[String])))
+        List(RenderedSubExpression(spelExpr.getValue(evaluationContext)))
       case composite: CompositeStringExpression => composite.getExpressions.toList.flatMap(renderExpression)
       case other =>
         throw new IllegalArgumentException(
@@ -310,7 +309,7 @@ object SpelExpressionParser extends LazyLogging {
       classDefinitionSet: ClassDefinitionSet,
   ): SpelExpressionParser = {
 
-    val parser = new org.springframework.expression.spel.standard.SpelExpressionParser(
+    val parser = new AdjustingTemplateExpressionSpringSpelExpressionParser(
       // we have to pass classloader, because default contextClassLoader can be sth different than we expect...
       new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, classLoader)
     )
@@ -328,4 +327,24 @@ object SpelExpressionParser extends LazyLogging {
     )
   }
 
+  private class AdjustingTemplateExpressionSpringSpelExpressionParser(configuration: SpelParserConfiguration)
+      extends org.springframework.expression.spel.standard.SpelExpressionParser(configuration) {
+
+    // Override for: org.springframework.expression.common.TemplateAwareExpressionParser.parseTemplate, because
+    // the spring should return only the StringExpression for a template
+    override def parseExpression(expressionString: String, context: ParserContext): Expression = {
+      val expression = super.parseExpression(expressionString, context)
+      if (context != null && context.isTemplate) {
+        expression match {
+          case l: LiteralExpression         => l
+          case s: CompositeStringExpression => s
+          case other                        => new CompositeStringExpression(expressionString, Array(other))
+        }
+      } else {
+        expression
+      }
+    }
+
+  }
+
 }

scenario-compiler/src/test/scala/pl/touk/nussknacker/engine/spel/SpelExpressionSpec.scala

@@ -2288,6 +2288,19 @@ class SpelExpressionSpec extends AnyFunSuite with Matchers with ValidatedValuesD
     Await.result(firstFailureOrCompletion, 15.seconds)
   }
 
+  test("should evaluate spelTemplate without passing .toString on input") {
+    forAll(
+      Table(
+        ("expression", "result"),
+        ("#{ #mapValue } #{ #obj }", "{foo=bar} Test(1,2,[Test(3,4,[],0), Test(5,6,[],0)],4187338076)"),
+        ("#{ #mapValue }", "{foo=bar}"),
+      )
+    ) { (expression, result) =>
+      val parsed = parse[String](expr = expression, flavour = SpelExpressionParser.Template).validValue
+      parsed.evaluateSync[String]() shouldBe result
+    }
+  }
+
 }
 
 case class SampleObject(list: java.util.List[SampleValue])