Introduce Mermaid exporter

Signed-off-by: Ricardo Zanini <[email protected]>

Author: ricardozanini

mermaid/pom.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.serverlessworkflow</groupId>
+        <artifactId>serverlessworkflow-parent</artifactId>
+        <version>8.0.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>serverlessworkflow-mermaid</artifactId>
+    <name>Serverless Workflow :: Mermaid</name>
+    <description>Export a Workflow Definition as a Mermaid Flowchart</description>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.serverlessworkflow</groupId>
+            <artifactId>serverlessworkflow-types</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.serverlessworkflow</groupId>
+            <artifactId>serverlessworkflow-api</artifactId>
+        </dependency>
+
+        <!-- Test Dependencies -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+</project>

mermaid/src/main/java/io/serverlessworkflow/mermaid/DefaultNodeRenderer.java

@@ -0,0 +1,67 @@
+/*
+ * 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.mermaid;
+
+public class DefaultNodeRenderer implements NodeRenderer {
+
+  private final Node node;
+  protected String renderedArrow = "-->";
+
+  public DefaultNodeRenderer(Node node) {
+    this.node = node;
+  }
+
+  protected final Node getNode() {
+    return node;
+  }
+
+  @Override
+  public void setRenderedArrow(String renderedArrow) {
+    this.renderedArrow = renderedArrow;
+  }
+
+  public void render(StringBuilder sb, int level) {
+    sb.append(ind(level))
+        .append(node.id)
+        .append("@{ shape: ")
+        .append(node.type.mermaidShape())
+        .append(", label: \"")
+        .append(NodeRenderer.escNodeLabel(node.label))
+        .append("\" }\n");
+    this.renderBody(sb, level);
+    this.renderNext(sb, level);
+  }
+
+  protected void renderBody(StringBuilder sb, int level) {
+    if (!this.node.branches.isEmpty()) {
+      MermaidRenderer.render(this.getNode().getBranches(), sb, level + 1);
+    }
+  }
+
+  protected void renderNext(StringBuilder sb, int level) {
+    if (node.getNext() != null) {
+      sb.append(ind(level))
+          .append(node.getId())
+          .append(renderedArrow)
+          .append(node.getNext().getId())
+          .append("\n");
+    }
+  }
+
+  protected String ind(int level) {
+    return " ".repeat(level * 4); // 4 spaces per level
+  }
+}

mermaid/src/main/java/io/serverlessworkflow/mermaid/EmitNode.java

@@ -0,0 +1,38 @@
+/*
+ * 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.mermaid;
+
+import io.serverlessworkflow.api.types.EmitTask;
+import io.serverlessworkflow.api.types.TaskItem;
+
+public class EmitNode extends TaskNode {
+
+  public EmitNode(TaskItem task) {
+    super("emit", task, NodeType.EMIT);
+
+    if (task.getTask().getEmitTask() == null) {
+      throw new IllegalStateException("Emit node must have a emit task");
+    }
+
+    EmitTask emitTask = task.getTask().getEmitTask();
+
+    if (emitTask.getEmit().getEvent() == null) {
+      return;
+    }
+
+    this.label = String.format("emit: **%s**", emitTask.getEmit().getEvent().getWith().getType());
+  }
+}

mermaid/src/main/java/io/serverlessworkflow/mermaid/ForNode.java

@@ -0,0 +1,60 @@
+/*
+ * 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.mermaid;
+
+import io.serverlessworkflow.api.types.ForTask;
+import io.serverlessworkflow.api.types.TaskItem;
+
+public class ForNode extends TaskSubgraphNode {
+
+  ForNode(TaskItem task) {
+    super(task, String.format("for: %s", task.getName()));
+
+    if (task.getTask().getForTask() == null) {
+      throw new IllegalStateException("For node must have a for task");
+    }
+
+    final ForTask forTask = task.getTask().getForTask();
+
+    if (forTask.getDo().isEmpty()) {
+      return;
+    }
+
+    String noteLabel =
+        String.format(
+            "• each: %s<br/>• in: %s<br/> • at: %s",
+            forTask.getFor().getEach(), forTask.getFor().getIn(), forTask.getFor().getAt());
+    Node note = NodeBuilder.note(noteLabel);
+    this.addBranch(note.getId(), note);
+
+    Node loop = NodeBuilder.split();
+    this.addBranch(loop.getId(), loop);
+
+    this.branches.putAll(new MermaidGraph().build(forTask.getDo()));
+    final Node firstTask = this.branches.get(forTask.getDo().get(0).getName());
+
+    note.setNext(loop);
+    loop.setNext(firstTask);
+
+    String lastForTask = forTask.getDo().get(forTask.getDo().size() - 1).getName();
+    String renderedArrow = "-. |next| .->";
+    if (forTask.getWhile() != null && !forTask.getWhile().isEmpty()) {
+      renderedArrow = "-. |while: " + NodeRenderer.escNodeLabel(forTask.getWhile()) + "| .->";
+    }
+
+    this.getBranches().get(lastForTask).withNext(loop).setRenderedArrow(renderedArrow);
+  }
+}

mermaid/src/main/java/io/serverlessworkflow/mermaid/ForkNode.java

@@ -0,0 +1,70 @@
+/*
+ * 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.mermaid;
+
+import io.serverlessworkflow.api.types.ForkTask;
+import io.serverlessworkflow.api.types.TaskItem;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ForkNode extends TaskSubgraphNode {
+
+  public ForkNode(TaskItem task) {
+    super(task, String.format("fork: %s", task.getName()));
+
+    if (task.getTask().getForkTask() == null) {
+      throw new IllegalStateException("Fork node must have a fork task");
+    }
+
+    ForkTask fork = task.getTask().getForkTask();
+    this.setDirection("LR");
+
+    // Split and join badges
+    SplitNode split = NodeBuilder.split();
+    String competeLabel = fork.getFork().isCompete() ? "ANY" : "ALL";
+    Node join = new Node(Ids.newId(), competeLabel, NodeType.JUNCTION);
+    this.addBranch(split.getId(), split);
+    this.addBranch(join.getId(), join);
+
+    // Build each branch as its own (sub)graph
+    List<TaskItem> branches = fork.getFork().getBranches();
+    Map<String, Node> branchRoots = new LinkedHashMap<>();
+    for (TaskItem branchTask : branches) {
+      // render branch as a titled subgraph with its inner tasks
+      String branchTitle = branchTask.getName();
+      Node branchNode;
+
+      if (branchTask.getTask().getDoTask() != null) {
+        branchNode =
+            new TaskSubgraphNode(branchTask, branchTitle)
+                .withBranches(branchTask.getTask().getDoTask().getDo());
+      } else {
+        branchNode = NodeBuilder.task(branchTask);
+      }
+      branchRoots.put(branchTitle, branchNode);
+      this.addBranch(branchTitle, branchNode);
+    }
+
+    for (TaskItem branchRoot : branches) {
+      String name = branchRoot.getName();
+      Node branch = branchRoots.get(name);
+      split.addNext(branch);
+      branch.setNext(join);
+      branch.setRenderedArrow("-- |" + competeLabel + "| -->");
+    }
+  }
+}

mermaid/src/main/java/io/serverlessworkflow/mermaid/Ids.java

@@ -0,0 +1,32 @@
+/*
+ * 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.mermaid;
+
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class Ids {
+  private final String salt = Integer.toString(ThreadLocalRandom.current().nextInt(), 36);
+  private final AtomicInteger seq = new AtomicInteger();
+
+  private String build() {
+    return "n_" + salt + "_" + Integer.toString(seq.getAndIncrement(), 36);
+  }
+
+  public static String newId() {
+    return new Ids().build();
+  }
+}

mermaid/src/main/java/io/serverlessworkflow/mermaid/IteratorNode.java

@@ -0,0 +1,46 @@
+/*
+ * 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.mermaid;
+
+import io.serverlessworkflow.api.types.SubscriptionIterator;
+
+public class IteratorNode extends SubgraphNode {
+
+  public IteratorNode(String label, SubscriptionIterator iterator) {
+    super(Ids.newId(), label);
+
+    if (iterator.getDo().isEmpty()) {
+      return;
+    }
+
+    Node note = NodeBuilder.note(String.format("• at: %s", iterator.getAt()));
+    this.addBranch(note.getId(), note);
+
+    Node loop = NodeBuilder.junction();
+    this.addBranch(loop.getId(), loop);
+
+    this.branches.putAll(new MermaidGraph().build(iterator.getDo()));
+    final Node firstTask = this.branches.get(iterator.getDo().get(0).getName());
+
+    note.setNext(loop);
+    loop.setNext(firstTask);
+
+    String lastForTask = iterator.getDo().get(iterator.getDo().size() - 1).getName();
+    String renderedArrow = "-. |next| .->";
+
+    this.getBranches().get(lastForTask).withNext(loop).setRenderedArrow(renderedArrow);
+  }
+}