Preserve typing information during expression compilation

TouK · Sep 23, 2024 · 03d4a47 · 03d4a47
1 parent 627c288
commit 03d4a47
Show file tree

Hide file tree

Showing 4 changed files with 37 additions and 20 deletions.
diff --git a/docs/Changelog.md b/docs/Changelog.md
@@ -54,6 +54,7 @@
   * Jackson 2.15.4 -> 2.17.2
   * cats 2.10 -> 2.12
 * [#6805](https://github.com/TouK/nussknacker/pull/6805) Support for Flink 1.19.1
+* [#6925](https://github.com/TouK/nussknacker/pull/6925) Fix situation when preset labels were presented as `null` when node didn't pass the validation.
 
 ## 1.17
 

diff --git a/...compiler/src/main/scala/pl/touk/nussknacker/engine/compile/ComponentExecutorFactory.scala b/...compiler/src/main/scala/pl/touk/nussknacker/engine/compile/ComponentExecutorFactory.scala
@@ -1,6 +1,6 @@
 package pl.touk.nussknacker.engine.compile
 
-import cats.data.ValidatedNel
+import cats.data.IorNel
 import com.typesafe.scalalogging.LazyLogging
 import pl.touk.nussknacker.engine.api.context.ProcessCompilationError
 import pl.touk.nussknacker.engine.api.definition.Parameter
@@ -24,7 +24,7 @@ class ComponentExecutorFactory(parameterEvaluator: ParameterEvaluator) extends L
   )(
       implicit nodeId: NodeId,
       metaData: MetaData
-  ): ValidatedNel[ProcessCompilationError, ComponentExecutor] = {
+  ): IorNel[ProcessCompilationError, ComponentExecutor] = {
     NodeValidationExceptionHandler.handleExceptions {
       doCreateComponentExecutor[ComponentExecutor](
         component,
@@ -34,7 +34,7 @@ class ComponentExecutorFactory(parameterEvaluator: ParameterEvaluator) extends L
         componentUseCase,
         nonServicesLazyParamStrategy
       )
-    }
+    }.toIor
   }
 
   private def doCreateComponentExecutor[ComponentExecutor](

diff --git a/scenario-compiler/src/main/scala/pl/touk/nussknacker/engine/compile/ExpressionCompiler.scala b/scenario-compiler/src/main/scala/pl/touk/nussknacker/engine/compile/ExpressionCompiler.scala
@@ -1,7 +1,7 @@
 package pl.touk.nussknacker.engine.compile
 
-import cats.data.Validated.{Valid, invalid, invalidNel, valid}
-import cats.data.{NonEmptyList, Validated, ValidatedNel}
+import cats.data.Validated.{Invalid, Valid, invalid, invalidNel, valid}
+import cats.data.{Ior, IorNel, NonEmptyList, Validated, ValidatedNel}
 import cats.instances.list._
 import pl.touk.nussknacker.engine.ModelData
 import pl.touk.nussknacker.engine.api.{MetaData, NodeId}
@@ -125,7 +125,7 @@ class ExpressionCompiler(
   )(
       implicit nodeId: NodeId,
       metaData: MetaData
-  ): ValidatedNel[PartSubGraphCompilationError, List[CompiledParameter]] = {
+  ): IorNel[PartSubGraphCompilationError, List[CompiledParameter]] = {
     compileNodeParameters(
       parameterDefinitions,
       nodeParameters,
@@ -152,7 +152,7 @@ class ExpressionCompiler(
   )(
       implicit nodeId: NodeId,
       metaData: MetaData
-  ): ValidatedNel[PartSubGraphCompilationError, List[(TypedParameter, Parameter)]] = {
+  ): IorNel[PartSubGraphCompilationError, List[(TypedParameter, Parameter)]] = {
 
     val redundantMissingValidation = Validations.validateRedundantAndMissingParameters(
       parameterDefinitions,
@@ -178,9 +178,15 @@ class ExpressionCompiler(
     }
     val allCompiledParams = (compiledParams ++ compiledBranchParams).sequence
 
-    allCompiledParams
-      .andThen(allParams => Validations.validateWithCustomValidators(allParams, paramValidatorsMap))
-      .combine(redundantMissingValidation.map(_ => List()))
+    for {
+      compiledParams <- allCompiledParams.toIor
+      paramsAfterValidation = Validations.validateWithCustomValidators(compiledParams, paramValidatorsMap) match {
+        case Valid(a) => Ior.right(a)
+        // We want to preserve typing information from allCompiledParams even if custom validators give us some errors
+        case Invalid(e) => Ior.both(e, compiledParams)
+      }
+      combinedParams <- redundantMissingValidation.map(_ => List()).toIor.combine(paramsAfterValidation)
+    } yield combinedParams
   }
 
   private def parameterValidatorsMap(parameterDefinitions: List[Parameter], globalVariables: Map[String, TypingResult])(

diff --git a/...iler/src/main/scala/pl/touk/nussknacker/engine/compile/nodecompilation/NodeCompiler.scala b/...iler/src/main/scala/pl/touk/nussknacker/engine/compile/nodecompilation/NodeCompiler.scala
@@ -281,16 +281,18 @@ class NodeCompiler(
       }
     val validParams =
       expressionCompiler.compileExecutorComponentNodeParameters(validParamDefs.value, ref.parameters, ctx)
-    val validParamsCombinedErrors = validParams.combine(
-      NonEmptyList
-        .fromList(validParamDefs.written)
-        .map(invalid)
-        .getOrElse(valid(List.empty[CompiledParameter]))
-    )
+    val validParamsCombinedErrors = validParams
+      .fold(Invalid(_), Valid(_), (a, _) => Invalid(a))
+      .combine(
+        NonEmptyList
+          .fromList(validParamDefs.written)
+          .map(invalid)
+          .getOrElse(valid(List.empty[CompiledParameter]))
+      )
     val expressionTypingInfo =
       validParams
         .map(_.map(p => p.name.value -> p.typingInfo).toMap)
-        .valueOr(_ => Map.empty[String, ExpressionTypingInfo])
+        .getOrElse(Map.empty[String, ExpressionTypingInfo])
     NodeCompilationResult(expressionTypingInfo, None, newCtx, validParamsCombinedErrors)
   }
 
@@ -558,7 +560,7 @@ class NodeCompiler(
         ctx,
         branchContexts
       )
-      .andThen { compiledParameters =>
+      .flatMap { compiledParameters =>
         factory
           .createComponentExecutor[ComponentExecutor](
             componentDefinition,
@@ -581,7 +583,10 @@ class NodeCompiler(
             (typingInfo, componentExecutor)
           }
       }
-    (compiledObjectWithTypingInfo.map(_._1).valueOr(_ => Map.empty), compiledObjectWithTypingInfo.map(_._2))
+    (
+      compiledObjectWithTypingInfo.map(_._1).getOrElse(Map.empty),
+      compiledObjectWithTypingInfo.map(_._2).fold(Invalid(_), Valid(_), (a, _) => Invalid(a))
+    )
   }
 
   private def contextAfterMethodBasedCreatedComponentExecutor[ComponentExecutor](
@@ -683,7 +688,12 @@ class NodeCompiler(
         )
       }
       val nodeTypingInfo = computedParameters.map(_.map(p => p.name.value -> p.typingInfo).toMap).getOrElse(Map.empty)
-      NodeCompilationResult(nodeTypingInfo, None, outputCtx, serviceRef)
+      NodeCompilationResult(
+        nodeTypingInfo,
+        None,
+        outputCtx,
+        serviceRef.fold(Invalid(_), Valid(_), (a, _) => Invalid(a))
+      )
     }
 
   }