Introduce if predicate to Func Fluent

experimental/lambda/src/main/java/io/serverlessworkflow/impl/expressions/func/JavaExpressionFactory.java

@@ -24,6 +24,7 @@
 import io.serverlessworkflow.impl.WorkflowModelFactory;
 import io.serverlessworkflow.impl.expressions.Expression;
 import io.serverlessworkflow.impl.expressions.ExpressionFactory;
+import io.serverlessworkflow.impl.expressions.TaskMetadataKeys;
 import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
@@ -32,7 +33,6 @@
 
 public class JavaExpressionFactory implements ExpressionFactory {
 
-  public static final String IF_PREDICATE = "if_predicate";
   private final WorkflowModelFactory modelFactory = new JavaModelFactory();
   private final Expression dummyExpression =
       new Expression() {
@@ -74,7 +74,8 @@ private WorkflowFilter fromPredicate(Predicate pred) {
   public Optional<WorkflowFilter> buildIfFilter(TaskBase task) {
     TaskMetadata metadata = task.getMetadata();
     return metadata != null
-            && metadata.getAdditionalProperties().get(IF_PREDICATE) instanceof Predicate pred
+            && metadata.getAdditionalProperties().get(TaskMetadataKeys.IF_PREDICATE)
+                instanceof Predicate pred
         ? Optional.of(fromPredicate(pred))
         : ExpressionFactory.super.buildIfFilter(task);
   }

experimental/lambda/src/test/java/io/serverless/workflow/impl/CallTest.java

@@ -33,7 +33,7 @@
 import io.serverlessworkflow.api.types.func.SwitchCaseFunction;
 import io.serverlessworkflow.impl.WorkflowApplication;
 import io.serverlessworkflow.impl.WorkflowDefinition;
-import io.serverlessworkflow.impl.expressions.func.JavaExpressionFactory;
+import io.serverlessworkflow.impl.expressions.TaskMetadataKeys;
 import java.util.Collection;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
@@ -168,7 +168,7 @@ void testIf() throws InterruptedException, ExecutionException {
   private <T> CallJava withPredicate(CallJava call, Predicate<T> pred) {
     return (CallJava)
         call.withMetadata(
-            new TaskMetadata().withAdditionalProperty(JavaExpressionFactory.IF_PREDICATE, pred));
+            new TaskMetadata().withAdditionalProperty(TaskMetadataKeys.IF_PREDICATE, pred));
   }
 
   public static boolean isEven(Object model, Integer number) {

experimental/lambda/src/test/java/io/serverless/workflow/impl/FluentDSLCallTest.java

@@ -54,7 +54,7 @@ void testForLoop() throws InterruptedException, ExecutionException {
           FuncWorkflowBuilder.workflow()
               .tasks(
                   t ->
-                      t.forFn(
+                      t.forEach(
                           f ->
                               f.whileC(CallTest::isEven)
                                   .collection(v -> (Collection<?>) v)
@@ -80,9 +80,9 @@ void testSwitch() throws InterruptedException, ExecutionException {
               .tasks(
                   tasks ->
                       tasks
-                          .switchFn(
+                          .switchCase(
                               switchOdd ->
-                                  switchOdd.items(
+                                  switchOdd.functions(
                                       item ->
                                           item.when(CallTest::isOdd).then(FlowDirectiveEnum.END)))
                           .callFn(callJava -> callJava.function(CallTest::zero)))

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/HasDelegate.java → experimental/types/src/main/java/io/serverlessworkflow/impl/expressions/TaskMetadataKeys.java

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.serverlessworkflow.fluent.spec;
+package io.serverlessworkflow.impl.expressions;
 
-public interface HasDelegate {
+public final class TaskMetadataKeys {
 
-  Object delegate();
+  /** Metadata entry name for the DSL’s “when”/“if” predicate. */
+  public static final String IF_PREDICATE = "if_predicate";
 }

fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncCallTaskBuilder.java

@@ -17,11 +17,14 @@
 
 import io.serverlessworkflow.api.types.func.CallJava;
 import io.serverlessworkflow.api.types.func.CallTaskJava;
+import io.serverlessworkflow.fluent.func.spi.ConditionalTaskBuilder;
+import io.serverlessworkflow.fluent.func.spi.FuncTransformations;
 import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
 import java.util.function.Function;
 
 public class FuncCallTaskBuilder extends TaskBaseBuilder<FuncCallTaskBuilder>
-    implements FuncTransformations<FuncCallTaskBuilder> {
+    implements FuncTransformations<FuncCallTaskBuilder>,
+        ConditionalTaskBuilder<FuncCallTaskBuilder> {
 
   private CallTaskJava callTaskJava;
 

fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncDoTaskBuilder.java

@@ -15,11 +15,16 @@
  */
 package io.serverlessworkflow.fluent.func;
 
+import io.serverlessworkflow.fluent.func.spi.ConditionalTaskBuilder;
+import io.serverlessworkflow.fluent.func.spi.FuncDoFluent;
+import io.serverlessworkflow.fluent.func.spi.FuncTransformations;
 import io.serverlessworkflow.fluent.spec.BaseDoTaskBuilder;
+import java.util.function.Consumer;
 
 public class FuncDoTaskBuilder extends BaseDoTaskBuilder<FuncDoTaskBuilder, FuncTaskItemListBuilder>
     implements FuncTransformations<FuncDoTaskBuilder>,
-        DelegatingFuncDoTaskFluent<FuncDoTaskBuilder> {
+        ConditionalTaskBuilder<FuncDoTaskBuilder>,
+        FuncDoFluent<FuncDoTaskBuilder> {
 
   public FuncDoTaskBuilder() {
     super(new FuncTaskItemListBuilder());
@@ -29,4 +34,47 @@ public FuncDoTaskBuilder() {
   public FuncDoTaskBuilder self() {
     return this;
   }
+
+  @Override
+  public FuncDoTaskBuilder emit(String name, Consumer<FuncEmitTaskBuilder> itemsConfigurer) {
+    this.listBuilder().emit(name, itemsConfigurer);
+    return this;
+  }
+
+  @Override
+  public FuncDoTaskBuilder forEach(String name, Consumer<FuncForTaskBuilder> itemsConfigurer) {
+    this.listBuilder().forEach(name, itemsConfigurer);
+    return this;
+  }
+
+  @Override
+  public FuncDoTaskBuilder set(String name, Consumer<FuncSetTaskBuilder> itemsConfigurer) {
+    this.listBuilder().set(name, itemsConfigurer);
+    return this;
+  }
+
+  @Override
+  public FuncDoTaskBuilder set(String name, String expr) {
+    this.listBuilder().set(name, expr);
+    return this;
+  }
+
+  @Override
+  public FuncDoTaskBuilder switchCase(
+      String name, Consumer<FuncSwitchTaskBuilder> itemsConfigurer) {
+    this.listBuilder().switchCase(name, itemsConfigurer);
+    return this;
+  }
+
+  @Override
+  public FuncDoTaskBuilder callFn(String name, Consumer<FuncCallTaskBuilder> cfg) {
+    this.listBuilder().callFn(name, cfg);
+    return this;
+  }
+
+  @Override
+  public FuncDoTaskBuilder fork(String name, Consumer<FuncForkTaskBuilder> itemsConfigurer) {
+    this.listBuilder().fork(name, itemsConfigurer);
+    return this;
+  }
 }

fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncEmitTaskBuilder.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.fluent.func;
+
+import io.serverlessworkflow.fluent.func.spi.ConditionalTaskBuilder;
+import io.serverlessworkflow.fluent.spec.EmitTaskBuilder;
+
+public class FuncEmitTaskBuilder extends EmitTaskBuilder
+    implements ConditionalTaskBuilder<FuncSetTaskBuilder> {
+  FuncEmitTaskBuilder() {
+    super();
+  }
+}

fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncForTaskBuilder.java

@@ -21,7 +21,10 @@
 import io.serverlessworkflow.api.types.func.CallJava;
 import io.serverlessworkflow.api.types.func.CallTaskJava;
 import io.serverlessworkflow.api.types.func.ForTaskFunction;
+import io.serverlessworkflow.fluent.func.spi.ConditionalTaskBuilder;
+import io.serverlessworkflow.fluent.func.spi.FuncTransformations;
 import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
+import io.serverlessworkflow.fluent.spec.spi.ForEachTaskFluent;
 import io.serverlessworkflow.impl.expressions.LoopFunction;
 import io.serverlessworkflow.impl.expressions.LoopPredicate;
 import io.serverlessworkflow.impl.expressions.LoopPredicateIndex;
@@ -33,7 +36,9 @@
 import java.util.function.Function;
 
 public class FuncForTaskBuilder extends TaskBaseBuilder<FuncForTaskBuilder>
-    implements FuncTransformations<FuncForTaskBuilder> {
+    implements FuncTransformations<FuncForTaskBuilder>,
+        ConditionalTaskBuilder<FuncForTaskBuilder>,
+        ForEachTaskFluent<FuncForTaskBuilder, FuncTaskItemListBuilder> {
 
   private final ForTaskFunction forTaskFunction;
   private final List<TaskItem> items;
@@ -81,6 +86,30 @@ public <T, V, R> FuncForTaskBuilder tasks(LoopFunction<T, V, R> function) {
     return this.tasks(UUID.randomUUID().toString(), function);
   }
 
+  @Override
+  public FuncForTaskBuilder each(String each) {
+    this.forTaskFunction.getFor().withEach(each);
+    return this;
+  }
+
+  @Override
+  public FuncForTaskBuilder in(String in) {
+    this.forTaskFunction.getFor().withIn(in);
+    return this;
+  }
+
+  @Override
+  public FuncForTaskBuilder at(String at) {
+    this.forTaskFunction.getFor().withAt(at);
+    return this;
+  }
+
+  @Override
+  public FuncForTaskBuilder whileC(String expression) {
+    this.forTaskFunction.setWhile(expression);
+    return this;
+  }
+
   public FuncForTaskBuilder tasks(Consumer<FuncTaskItemListBuilder> consumer) {
     final FuncTaskItemListBuilder builder = new FuncTaskItemListBuilder();
     consumer.accept(builder);

fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncForkTaskBuilder.java

@@ -21,15 +21,20 @@
 import io.serverlessworkflow.api.types.TaskItem;
 import io.serverlessworkflow.api.types.func.CallJava;
 import io.serverlessworkflow.api.types.func.CallTaskJava;
+import io.serverlessworkflow.fluent.func.spi.ConditionalTaskBuilder;
+import io.serverlessworkflow.fluent.func.spi.FuncTransformations;
 import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
+import io.serverlessworkflow.fluent.spec.spi.ForkTaskFluent;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
 public class FuncForkTaskBuilder extends TaskBaseBuilder<FuncForkTaskBuilder>
-    implements FuncTransformations<FuncForkTaskBuilder> {
+    implements FuncTransformations<FuncForkTaskBuilder>,
+        ConditionalTaskBuilder<FuncForkTaskBuilder>,
+        ForkTaskFluent<FuncForkTaskBuilder, FuncTaskItemListBuilder> {
 
   private final ForkTask forkTask;
   private final List<TaskItem> items;
@@ -55,18 +60,21 @@ public <T, V> FuncForkTaskBuilder branch(Function<T, V> function) {
     return this.branch(UUID.randomUUID().toString(), function);
   }
 
+  @Override
   public FuncForkTaskBuilder branches(Consumer<FuncTaskItemListBuilder> consumer) {
     final FuncTaskItemListBuilder builder = new FuncTaskItemListBuilder();
     consumer.accept(builder);
     this.items.addAll(builder.build());
     return this;
   }
 
+  @Override
   public FuncForkTaskBuilder compete(boolean compete) {
     this.forkTask.getFork().setCompete(compete);
     return this;
   }
 
+  @Override
   public ForkTask build() {
     this.forkTask.getFork().setBranches(this.items);
     return forkTask;