[NO-ISSUE] Add wait to DSL

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/BaseTaskItemListBuilder.java

@@ -42,6 +42,7 @@ public abstract class BaseTaskItemListBuilder<SELF extends BaseTaskItemListBuild
   protected final String TYPE_LISTEN = "listen";
   protected final String TYPE_EMIT = "emit";
   protected final String TYPE_TRY = "try";
+  protected final String TYPE_WAIT = "wait";
   protected final String TYPE_HTTP = "http";
   protected final String TYPE_OPENAPI = "openapi";
   protected final String TYPE_WORKFLOW = "workflow";

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/DoTaskBuilder.java

@@ -79,6 +79,12 @@ public DoTaskBuilder set(String name, String expr) {
     return this;
   }
 
+  @Override
+  public DoTaskBuilder wait(String name, Consumer<WaitTaskBuilder> itemsConfigurer) {
+    this.listBuilder().wait(name, itemsConfigurer);
+    return this;
+  }
+
   @Override
   public DoTaskBuilder switchCase(String name, Consumer<SwitchTaskBuilder> itemsConfigurer) {
     this.listBuilder().switchCase(name, itemsConfigurer);

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/ForkTaskBuilder.java

@@ -15,11 +15,15 @@
  */
 package io.serverlessworkflow.fluent.spec;
 
+import io.serverlessworkflow.api.types.DoTask;
 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.fluent.spec.spi.ForkTaskFluent;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
 
 public class ForkTaskBuilder extends TaskBaseBuilder<ForkTaskBuilder>
@@ -58,14 +62,39 @@ public ForkTaskBuilder branches(Consumer<TaskItemListBuilder> branchesConsumer)
     if (existingBranches == null || existingBranches.isEmpty()) {
       this.forkTaskConfiguration.setBranches(newBranches);
     } else {
-      List<TaskItem> merged = new java.util.ArrayList<>(existingBranches);
+      List<TaskItem> merged = new ArrayList<>(existingBranches);
       merged.addAll(newBranches);
       this.forkTaskConfiguration.setBranches(merged);
     }
 
     return this;
   }
 
+  @Override
+  public ForkTaskBuilder branch(String name, Consumer<TaskItemListBuilder> branchConsumer) {
+    Objects.requireNonNull(branchConsumer, "Branch consumer must not be null");
+
+    List<TaskItem> existingBranches = this.forkTaskConfiguration.getBranches();
+    int currentOffset = (existingBranches == null) ? 0 : existingBranches.size();
+    String branchName = (name == null || name.isBlank()) ? "branch-" + currentOffset : name;
+
+    TaskItemListBuilder branchItems = new TaskItemListBuilder(0);
+    branchConsumer.accept(branchItems);
+
+    TaskItem branchItem =
+        new TaskItem(branchName, new Task().withDoTask(new DoTask().withDo(branchItems.build())));
+
+    if (existingBranches == null || existingBranches.isEmpty()) {
+      this.forkTaskConfiguration.setBranches(List.of(branchItem));
+    } else {
+      List<TaskItem> merged = new ArrayList<>(existingBranches);
+      merged.add(branchItem);
+      this.forkTaskConfiguration.setBranches(merged);
+    }
+
+    return this;
+  }
+
   @Override
   public ForkTask build() {
     return this.forkTask.withFork(this.forkTaskConfiguration);

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/TaskItemListBuilder.java

@@ -56,6 +56,14 @@ public TaskItemListBuilder set(String name, final String expr) {
     return this.set(name, s -> s.expr(expr));
   }
 
+  @Override
+  public TaskItemListBuilder wait(String name, Consumer<WaitTaskBuilder> itemsConfigurer) {
+    name = defaultNameAndRequireConfig(name, itemsConfigurer, TYPE_WAIT);
+    final WaitTaskBuilder waitBuilder = new WaitTaskBuilder();
+    itemsConfigurer.accept(waitBuilder);
+    return addTaskItem(new TaskItem(name, new Task().withWaitTask(waitBuilder.build())));
+  }
+
   @Override
   public TaskItemListBuilder forEach(
       String name, Consumer<ForEachTaskBuilder<TaskItemListBuilder>> itemsConfigurer) {

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/WaitTaskBuilder.java

@@ -0,0 +1,83 @@
+/*
+ * 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.spec;
+
+import io.serverlessworkflow.api.types.DurationInline;
+import io.serverlessworkflow.api.types.TimeoutAfter;
+import io.serverlessworkflow.api.types.WaitTask;
+import java.time.Duration;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+public class WaitTaskBuilder extends TaskBaseBuilder<WaitTaskBuilder> {
+
+  private final WaitTask waitTask;
+
+  public WaitTaskBuilder() {
+    this.waitTask = new WaitTask();
+    setTask(this.waitTask);
+  }
+
+  @Override
+  protected WaitTaskBuilder self() {
+    return this;
+  }
+
+  public WaitTaskBuilder wait(Consumer<TimeoutBuilder> waitConsumer) {
+    final TimeoutBuilder timeoutBuilder = new TimeoutBuilder();
+    waitConsumer.accept(timeoutBuilder);
+    this.waitTask.setWait(timeoutBuilder.build().getAfter());
+    return this;
+  }
+
+  public WaitTaskBuilder wait(String durationExpression) {
+    this.waitTask.setWait(new TimeoutAfter().withDurationExpression(durationExpression));
+    return this;
+  }
+
+  public WaitTaskBuilder wait(Duration duration) {
+    Objects.requireNonNull(duration, "duration must not be null");
+    if (duration.isNegative()) {
+      throw new IllegalArgumentException("duration must not be negative");
+    }
+
+    long millis = duration.toMillis();
+
+    int days = Math.toIntExact(millis / 86_400_000L);
+    millis %= 86_400_000L;
+    int hours = Math.toIntExact(millis / 3_600_000L);
+    millis %= 3_600_000L;
+    int minutes = Math.toIntExact(millis / 60_000L);
+    millis %= 60_000L;
+    int seconds = Math.toIntExact(millis / 1_000L);
+    int milliseconds = Math.toIntExact(millis % 1_000L);
+
+    this.waitTask.setWait(
+        new TimeoutAfter()
+            .withDurationInline(
+                new DurationInline()
+                    .withDays(days)
+                    .withHours(hours)
+                    .withMinutes(minutes)
+                    .withSeconds(seconds)
+                    .withMilliseconds(milliseconds)));
+    return this;
+  }
+
+  public WaitTask build() {
+    return this.waitTask;
+  }
+}

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/dsl/DSL.java

@@ -797,6 +797,52 @@ public static TasksConfigurer listen(String name, ListenConfigurer configurer) {
     return list -> list.listen(name, configurer);
   }
 
+  /**
+   * Create a {@link TasksConfigurer} that adds a {@code wait} task configured with an inline
+   * duration builder.
+   *
+   * @param duration timeout builder consumer
+   * @return a {@link TasksConfigurer} that adds a WaitTask
+   */
+  public static TasksConfigurer wait(Consumer<TimeoutBuilder> duration) {
+    return list -> list.wait(w -> w.wait(duration));
+  }
+
+  /**
+   * Create a {@link TasksConfigurer} that adds a named {@code wait} task configured with an inline
+   * duration builder.
+   *
+   * @param name task name
+   * @param duration timeout builder consumer
+   * @return a {@link TasksConfigurer} that adds a WaitTask
+   */
+  public static TasksConfigurer wait(String name, Consumer<TimeoutBuilder> duration) {
+    return list -> list.wait(name, w -> w.wait(duration));
+  }
+
+  /**
+   * Create a {@link TasksConfigurer} that adds a {@code wait} task configured with a duration
+   * expression.
+   *
+   * @param durationExpression duration expression
+   * @return a {@link TasksConfigurer} that adds a WaitTask
+   */
+  public static TasksConfigurer wait(String durationExpression) {
+    return list -> list.wait(w -> w.wait(durationExpression));
+  }
+
+  /**
+   * Create a {@link TasksConfigurer} that adds a named {@code wait} task configured with a duration
+   * expression.
+   *
+   * @param name task name
+   * @param durationExpression duration expression
+   * @return a {@link TasksConfigurer} that adds a WaitTask
+   */
+  public static TasksConfigurer wait(String name, String durationExpression) {
+    return list -> list.wait(name, w -> w.wait(durationExpression));
+  }
+
   /**
    * Create a {@link TasksConfigurer} that adds a {@code forEach} task.
    *

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/spi/DoFluent.java

@@ -26,6 +26,7 @@
 import io.serverlessworkflow.fluent.spec.SwitchTaskBuilder;
 import io.serverlessworkflow.fluent.spec.TaskItemListBuilder;
 import io.serverlessworkflow.fluent.spec.TryTaskBuilder;
+import io.serverlessworkflow.fluent.spec.WaitTaskBuilder;
 import io.serverlessworkflow.fluent.spec.WorkflowTaskBuilder;
 
 /**
@@ -44,6 +45,7 @@ public interface DoFluent<T>
         ForEachFluent<ForEachTaskBuilder<TaskItemListBuilder>, T>,
         ForkFluent<ForkTaskBuilder, T>,
         ListenFluent<ListenTaskBuilder, T>,
+        WaitFluent<WaitTaskBuilder, T>,
         RaiseFluent<RaiseTaskBuilder, T>,
         CallOpenAPIFluent<CallOpenAPITaskBuilder, T>,
         WorkflowFluent<WorkflowTaskBuilder, T> {}

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/spi/ForkTaskFluent.java

@@ -27,5 +27,11 @@ public interface ForkTaskFluent<
 
   SELF branches(Consumer<L> branchesConsumer);
 
+  default SELF branch(Consumer<L> branchConsumer) {
+    return branch(null, branchConsumer);
+  }
+
+  SELF branch(String name, Consumer<L> branchConsumer);
+
   ForkTask build();
 }

fluent/spec/src/main/java/io/serverlessworkflow/fluent/spec/spi/WaitFluent.java

@@ -0,0 +1,28 @@
+/*
+ * 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.spec.spi;
+
+import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
+import java.util.function.Consumer;
+
+public interface WaitFluent<SELF extends TaskBaseBuilder<?>, LIST> {
+
+  LIST wait(String name, Consumer<SELF> itemsConfigurer);
+
+  default LIST wait(Consumer<SELF> itemsConfigurer) {
+    return this.wait(null, itemsConfigurer);
+  }
+}

fluent/spec/src/test/java/io/serverlessworkflow/fluent/spec/TaskItemDefaultNamingTest.java

@@ -25,6 +25,7 @@
 import io.serverlessworkflow.api.types.TryTask;
 import io.serverlessworkflow.api.types.TryTaskCatch;
 import io.serverlessworkflow.api.types.Workflow;
+import java.time.Duration;
 import java.util.List;
 import org.junit.jupiter.api.Test;
 
@@ -128,6 +129,23 @@ void testNestedForEachTaskAutoNaming() {
     assertEquals("set-1", nestedForItems.get(1).getName());
   }
 
+  @Test
+  void testWaitTaskAutoNamingAndDuration() {
+    Workflow wf =
+        WorkflowBuilder.workflow("flowAutoNameWait")
+            .tasks(d -> d.wait(null, w -> w.wait(Duration.ofSeconds(2).plusMillis(250))))
+            .build();
+
+    List<TaskItem> items = wf.getDo();
+    assertNotNull(items, "Do list must not be null");
+    assertEquals(1, items.size(), "There should be one wait task");
+    assertEquals("wait-0", items.get(0).getName(), "Wait task should be wait-0");
+    assertEquals(
+        2, items.get(0).getTask().getWaitTask().getWait().getDurationInline().getSeconds());
+    assertEquals(
+        250, items.get(0).getTask().getWaitTask().getWait().getDurationInline().getMilliseconds());
+  }
+
   @Test
   void testNestedForkTaskAutoNaming() {
     Workflow wf =
@@ -432,4 +450,45 @@ null, http().GET().endpoint("http://test"))))))
     assertEquals("set-1", nestedTasks.get(1).getName(), "Second tasks() call picks up index 1");
     assertEquals("http-2", nestedTasks.get(2).getName(), "Third tasks() call picks up index 2");
   }
+
+  @Test
+  void testNamedForkBranchesWrapDoTaskAndPreserveBranchName() {
+    Workflow wf =
+        WorkflowBuilder.workflow("flowNamedForkBranch")
+            .tasks(
+                d ->
+                    d.fork(
+                        null,
+                        f ->
+                            f.branch(
+                                    "helloBranch",
+                                    b ->
+                                        b.wait(null, w -> w.wait(Duration.ofMillis(10)))
+                                            .set(null, s -> s.expr("$.value = 1")))
+                                .branch(
+                                    "byeBranch",
+                                    b ->
+                                        b.wait(null, w -> w.wait(Duration.ofMillis(10)))
+                                            .set(null, s -> s.expr("$.value = 2")))))
+            .build();
+
+    List<TaskItem> topItems = wf.getDo();
+    assertEquals(1, topItems.size(), "Should have one top-level fork task");
+
+    ForkTaskConfiguration forkConfig = topItems.get(0).getTask().getForkTask().getFork();
+    assertNotNull(forkConfig, "Fork configuration must not be null");
+
+    List<TaskItem> branches = forkConfig.getBranches();
+    assertEquals(2, branches.size(), "Should have two named branches");
+    assertEquals("helloBranch", branches.get(0).getName());
+    assertEquals("byeBranch", branches.get(1).getName());
+
+    List<TaskItem> helloDo = branches.get(0).getTask().getDoTask().getDo();
+    List<TaskItem> byeDo = branches.get(1).getTask().getDoTask().getDo();
+
+    assertEquals("wait-0", helloDo.get(0).getName());
+    assertEquals("set-1", helloDo.get(1).getName());
+    assertEquals("wait-0", byeDo.get(0).getName());
+    assertEquals("set-1", byeDo.get(1).getName());
+  }
 }

fluent/spec/src/test/java/io/serverlessworkflow/fluent/spec/dsl/DSLTest.java

@@ -116,6 +116,22 @@ public void when_listen_all_then_emit() {
     assertThat(evProps.getDatacontenttype()).isNull();
   }
 
+  @Test
+  public void when_wait_task_from_dsl_helpers() {
+    Workflow wf =
+        WorkflowBuilder.workflow("myFlow", "myNs", "1.2.3")
+            .tasks(DSL.wait("PT5S"), DSL.wait("pause", DSL.timeoutSeconds(2)))
+            .build();
+
+    assertThat(wf.getDo()).hasSize(2);
+    assertThat(wf.getDo().get(0).getTask().getWaitTask()).isNotNull();
+    assertThat(wf.getDo().get(0).getTask().getWaitTask().getWait().getDurationExpression())
+        .isEqualTo("PT5S");
+    assertThat(wf.getDo().get(1).getName()).isEqualTo("pause");
+    assertThat(wf.getDo().get(1).getTask().getWaitTask().getWait().getDurationInline().getSeconds())
+        .isEqualTo(2);
+  }
+
   @Test
   public void when_listen_any_with_until() {
     final String untilExpr = "$.count > 0";