Improvements on the DSL to make it more extensible

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

@@ -34,7 +34,7 @@ void testJavaFunction() throws InterruptedException, ExecutionException {
     try (WorkflowApplication app = WorkflowApplication.builder().build()) {
       final Workflow workflow =
           FuncWorkflowBuilder.workflow("testJavaCall")
-              .tasks(tasks -> tasks.callFn(f -> f.fn(JavaFunctions::getName)))
+              .tasks(tasks -> tasks.callFn(f -> f.function(JavaFunctions::getName)))
               .build();
       assertThat(
               app.workflowDefinition(workflow)
@@ -85,7 +85,7 @@ void testSwitch() throws InterruptedException, ExecutionException {
                                   switchOdd.items(
                                       item ->
                                           item.when(CallTest::isOdd).then(FlowDirectiveEnum.END)))
-                          .callFn(callJava -> callJava.fn(CallTest::zero)))
+                          .callFn(callJava -> callJava.function(CallTest::zero)))
               .build();
 
       WorkflowDefinition definition = app.workflowDefinition(workflow);

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

@@ -0,0 +1,86 @@
+/*
+ * 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.spec.HasDelegate;
+import java.util.function.Consumer;
+
+/**
+ * Mixin that implements {@link FuncDoTaskFluent} by forwarding to another instance.
+ *
+ * @param <SELF> concrete builder type
+ */
+public interface DelegatingFuncDoTaskFluent<SELF extends DelegatingFuncDoTaskFluent<SELF>>
+    extends FuncDoTaskFluent<SELF>, HasDelegate {
+
+  @SuppressWarnings("unchecked")
+  default SELF self() {
+    return (SELF) this;
+  }
+
+  @SuppressWarnings("unchecked")
+  private FuncDoTaskFluent<SELF> d() {
+    return (FuncDoTaskFluent<SELF>) this.delegate();
+  }
+
+  @Override
+  default SELF callFn(String name, Consumer<FuncCallTaskBuilder> cfg) {
+    d().callFn(name, cfg);
+    return self();
+  }
+
+  @Override
+  default SELF callFn(Consumer<FuncCallTaskBuilder> cfg) {
+    d().callFn(cfg);
+    return self();
+  }
+
+  @Override
+  default SELF forFn(String name, Consumer<FuncForTaskBuilder> cfg) {
+    d().forFn(name, cfg);
+    return self();
+  }
+
+  @Override
+  default SELF forFn(Consumer<FuncForTaskBuilder> cfg) {
+    d().forFn(cfg);
+    return self();
+  }
+
+  @Override
+  default SELF switchFn(String name, Consumer<FuncSwitchTaskBuilder> cfg) {
+    d().switchFn(name, cfg);
+    return self();
+  }
+
+  @Override
+  default SELF switchFn(Consumer<FuncSwitchTaskBuilder> cfg) {
+    d().switchFn(cfg);
+    return self();
+  }
+
+  @Override
+  default SELF forkFn(String name, Consumer<FuncForkTaskBuilder> cfg) {
+    d().forkFn(name, cfg);
+    return self();
+  }
+
+  @Override
+  default SELF forkFn(Consumer<FuncForkTaskBuilder> cfg) {
+    d().forkFn(cfg);
+    return self();
+  }
+}

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

@@ -35,7 +35,7 @@ protected FuncCallTaskBuilder self() {
     return this;
   }
 
-  public <T, V> FuncCallTaskBuilder fn(Function<T, V> function) {
+  public <T, V> FuncCallTaskBuilder function(Function<T, V> function) {
     this.callTaskJava = new CallTaskJava(CallJava.function(function));
     super.setTask(this.callTaskJava.getCallJava());
     return this;

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

@@ -16,47 +16,17 @@
 package io.serverlessworkflow.fluent.func;
 
 import io.serverlessworkflow.fluent.spec.BaseDoTaskBuilder;
-import java.util.function.Consumer;
 
 public class FuncDoTaskBuilder extends BaseDoTaskBuilder<FuncDoTaskBuilder, FuncTaskItemListBuilder>
-    implements FuncTransformations<FuncDoTaskBuilder> {
+    implements FuncTransformations<FuncDoTaskBuilder>,
+        DelegatingFuncDoTaskFluent<FuncDoTaskBuilder> {
 
-  FuncDoTaskBuilder() {
+  public FuncDoTaskBuilder() {
     super(new FuncTaskItemListBuilder());
   }
 
   @Override
-  protected FuncDoTaskBuilder self() {
-    return this;
-  }
-
-  public FuncDoTaskBuilder callFn(String name, Consumer<FuncCallTaskBuilder> consumer) {
-    this.innerListBuilder().callJava(name, consumer);
-    return this;
-  }
-
-  public FuncDoTaskBuilder callFn(Consumer<FuncCallTaskBuilder> consumer) {
-    this.innerListBuilder().callJava(consumer);
-    return this;
-  }
-
-  public FuncDoTaskBuilder forFn(String name, Consumer<FuncForTaskBuilder> consumer) {
-    this.innerListBuilder().forFn(name, consumer);
-    return this;
-  }
-
-  public FuncDoTaskBuilder forFn(Consumer<FuncForTaskBuilder> consumer) {
-    this.innerListBuilder().forFn(consumer);
-    return this;
-  }
-
-  public FuncDoTaskBuilder switchFn(String name, Consumer<FuncSwitchTaskBuilder> consumer) {
-    this.innerListBuilder().switchFn(name, consumer);
-    return this;
-  }
-
-  public FuncDoTaskBuilder switchFn(Consumer<FuncSwitchTaskBuilder> consumer) {
-    this.innerListBuilder().switchFn(consumer);
+  public FuncDoTaskBuilder self() {
     return this;
   }
 }

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

@@ -0,0 +1,37 @@
+/*
+ * 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 java.util.function.Consumer;
+
+public interface FuncDoTaskFluent<SELF extends FuncDoTaskFluent<SELF>> {
+
+  SELF callFn(String name, Consumer<FuncCallTaskBuilder> cfg);
+
+  SELF callFn(Consumer<FuncCallTaskBuilder> cfg);
+
+  SELF forFn(String name, Consumer<FuncForTaskBuilder> cfg);
+
+  SELF forFn(Consumer<FuncForTaskBuilder> cfg);
+
+  SELF switchFn(String name, Consumer<FuncSwitchTaskBuilder> cfg);
+
+  SELF switchFn(Consumer<FuncSwitchTaskBuilder> cfg);
+
+  SELF forkFn(String name, Consumer<FuncForkTaskBuilder> cfg);
+
+  SELF forkFn(Consumer<FuncForkTaskBuilder> cfg);
+}

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

@@ -0,0 +1,74 @@
+/*
+ * 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.api.types.ForkTask;
+import io.serverlessworkflow.api.types.ForkTaskConfiguration;
+import io.serverlessworkflow.api.types.Task;
+import io.serverlessworkflow.api.types.TaskItem;
+import io.serverlessworkflow.api.types.func.CallJava;
+import io.serverlessworkflow.api.types.func.CallTaskJava;
+import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
+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> {
+
+  private final ForkTask forkTask;
+  private final List<TaskItem> items;
+
+  FuncForkTaskBuilder() {
+    this.forkTask = new ForkTask();
+    this.forkTask.setFork(new ForkTaskConfiguration());
+    this.items = new ArrayList<>();
+  }
+
+  @Override
+  protected FuncForkTaskBuilder self() {
+    return this;
+  }
+
+  public <T, V> FuncForkTaskBuilder branch(String name, Function<T, V> function) {
+    this.items.add(
+        new TaskItem(name, new Task().withCallTask(new CallTaskJava(CallJava.function(function)))));
+    return this;
+  }
+
+  public <T, V> FuncForkTaskBuilder branch(Function<T, V> function) {
+    return this.branch(UUID.randomUUID().toString(), function);
+  }
+
+  public FuncForkTaskBuilder branches(Consumer<FuncTaskItemListBuilder> consumer) {
+    final FuncTaskItemListBuilder builder = new FuncTaskItemListBuilder();
+    consumer.accept(builder);
+    this.items.addAll(builder.build());
+    return this;
+  }
+
+  public FuncForkTaskBuilder compete(boolean compete) {
+    this.forkTask.getFork().setCompete(compete);
+    return this;
+  }
+
+  public ForkTask build() {
+    this.forkTask.getFork().setBranches(this.items);
+    return forkTask;
+  }
+}

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

@@ -18,15 +18,21 @@
 import io.serverlessworkflow.api.types.Task;
 import io.serverlessworkflow.api.types.TaskItem;
 import io.serverlessworkflow.fluent.spec.BaseTaskItemListBuilder;
+import java.util.List;
 import java.util.UUID;
 import java.util.function.Consumer;
 
-public class FuncTaskItemListBuilder extends BaseTaskItemListBuilder<FuncTaskItemListBuilder> {
+public class FuncTaskItemListBuilder extends BaseTaskItemListBuilder<FuncTaskItemListBuilder>
+    implements FuncDoTaskFluent<FuncTaskItemListBuilder> {
 
-  FuncTaskItemListBuilder() {
+  public FuncTaskItemListBuilder() {
     super();
   }
 
+  public FuncTaskItemListBuilder(final List<TaskItem> list) {
+    super(list);
+  }
+
   @Override
   protected FuncTaskItemListBuilder self() {
     return this;
@@ -37,28 +43,33 @@ protected FuncTaskItemListBuilder newItemListBuilder() {
     return new FuncTaskItemListBuilder();
   }
 
-  public FuncTaskItemListBuilder callJava(String name, Consumer<FuncCallTaskBuilder> consumer) {
+  @Override
+  public FuncTaskItemListBuilder callFn(String name, Consumer<FuncCallTaskBuilder> consumer) {
     this.requireNameAndConfig(name, consumer);
     final FuncCallTaskBuilder callTaskJavaBuilder = new FuncCallTaskBuilder();
     consumer.accept(callTaskJavaBuilder);
     return addTaskItem(new TaskItem(name, new Task().withCallTask(callTaskJavaBuilder.build())));
   }
 
-  public FuncTaskItemListBuilder callJava(Consumer<FuncCallTaskBuilder> consumer) {
-    return this.callJava(UUID.randomUUID().toString(), consumer);
+  @Override
+  public FuncTaskItemListBuilder callFn(Consumer<FuncCallTaskBuilder> consumer) {
+    return this.callFn(UUID.randomUUID().toString(), consumer);
   }
 
+  @Override
   public FuncTaskItemListBuilder forFn(String name, Consumer<FuncForTaskBuilder> consumer) {
     this.requireNameAndConfig(name, consumer);
     final FuncForTaskBuilder forTaskJavaBuilder = new FuncForTaskBuilder();
     consumer.accept(forTaskJavaBuilder);
     return this.addTaskItem(new TaskItem(name, new Task().withForTask(forTaskJavaBuilder.build())));
   }
 
+  @Override
   public FuncTaskItemListBuilder forFn(Consumer<FuncForTaskBuilder> consumer) {
     return this.forFn(UUID.randomUUID().toString(), consumer);
   }
 
+  @Override
   public FuncTaskItemListBuilder switchFn(String name, Consumer<FuncSwitchTaskBuilder> consumer) {
     this.requireNameAndConfig(name, consumer);
     final FuncSwitchTaskBuilder funcSwitchTaskBuilder = new FuncSwitchTaskBuilder();
@@ -67,7 +78,22 @@ public FuncTaskItemListBuilder switchFn(String name, Consumer<FuncSwitchTaskBuil
         new TaskItem(name, new Task().withSwitchTask(funcSwitchTaskBuilder.build())));
   }
 
+  @Override
   public FuncTaskItemListBuilder switchFn(Consumer<FuncSwitchTaskBuilder> consumer) {
     return this.switchFn(UUID.randomUUID().toString(), consumer);
   }
+
+  @Override
+  public FuncTaskItemListBuilder forkFn(Consumer<FuncForkTaskBuilder> cfg) {
+    return this.forkFn(UUID.randomUUID().toString(), cfg);
+  }
+
+  @Override
+  public FuncTaskItemListBuilder forkFn(String name, Consumer<FuncForkTaskBuilder> cfg) {
+    this.requireNameAndConfig(name, cfg);
+    final FuncForkTaskBuilder forkTaskJavaBuilder = new FuncForkTaskBuilder();
+    cfg.accept(forkTaskJavaBuilder);
+    return this.addTaskItem(
+        new TaskItem(name, new Task().withForkTask(forkTaskJavaBuilder.build())));
+  }
 }

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

@@ -22,7 +22,7 @@ public class FuncWorkflowBuilder
     extends BaseWorkflowBuilder<FuncWorkflowBuilder, FuncDoTaskBuilder, FuncTaskItemListBuilder>
     implements FuncTransformations<FuncWorkflowBuilder> {
 
-  private FuncWorkflowBuilder(final String name, final String namespace, final String version) {
+  protected FuncWorkflowBuilder(final String name, final String namespace, final String version) {
     super(name, namespace, version);
   }