@serverlessworkflow/sdk 1.0.0 → 1.0.1

package/systemjs/index.systemjs.js

@@ -3,6 +3,11 @@ System.register([], (function (exports) {
   return {
     execute: (function () {
 
+      exports({
+        buildGraph: buildGraph,
+        convertToMermaidCode: convertToMermaidCode
+      });
+
       /*
        * Copyright 2021-Present The Serverless Workflow Specification Authors
        *
@@ -138,6 +143,17 @@ System.register([], (function (exports) {
           d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
       }
 
+      var __assign = function() {
+          __assign = Object.assign || function __assign(t) {
+              for (var s, i = 1, n = arguments.length; i < n; i++) {
+                  s = arguments[i];
+                  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+              }
+              return t;
+          };
+          return __assign.apply(this, arguments);
+      };
+
       typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
           var e = new Error(message);
           return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -18094,7 +18110,7 @@ System.register([], (function (exports) {
        * Represents a FlowDirective with methods for validation and normalization.
        * Inherits from ObjectHydrator which provides functionality for hydrating the state based on a model.
        */
-      var FlowDirective = /** @class */ (function (_super) {
+      var FlowDirective$1 = /** @class */ (function (_super) {
           __extends(FlowDirective, _super);
           /**
            * Instanciates a new instance of the FlowDirective class.
@@ -18129,7 +18145,7 @@ System.register([], (function (exports) {
           };
           return FlowDirective;
       }(ObjectHydrator));
-      var _FlowDirective = FlowDirective;
+      var _FlowDirective = FlowDirective$1;
 
       /*
        * Copyright 2021-Present The Serverless Workflow Specification Authors
@@ -24819,6 +24835,541 @@ System.register([], (function (exports) {
       var load                = loader.load;
       var dump                = dumper.dump;
 
+      var entrySuffix = '-entry-node';
+      var exitSuffix = '-exit-node';
+      var rooId = 'root';
+      var doReference = '/do';
+      var forReference = '/for';
+      var catchReference = '/catch';
+      var branchReference = '/fork/branches';
+      var tryReference = '/try';
+      /**
+       * Enumeration of possible node types in a graph.
+       */
+      var GraphNodeType; exports('GraphNodeType', GraphNodeType);
+      (function (GraphNodeType) {
+          GraphNodeType["Root"] = "root";
+          GraphNodeType["Start"] = "start";
+          GraphNodeType["End"] = "end";
+          GraphNodeType["Entry"] = "entry";
+          GraphNodeType["Exit"] = "exit";
+          GraphNodeType["Call"] = "call";
+          GraphNodeType["Catch"] = "catch";
+          GraphNodeType["Do"] = "do";
+          GraphNodeType["Emit"] = "emit";
+          GraphNodeType["For"] = "for";
+          GraphNodeType["Fork"] = "fork";
+          GraphNodeType["Listen"] = "listen";
+          GraphNodeType["Raise"] = "raise";
+          GraphNodeType["Run"] = "run";
+          GraphNodeType["Set"] = "set";
+          GraphNodeType["Switch"] = "switch";
+          GraphNodeType["Try"] = "try";
+          GraphNodeType["TryCatch"] = "try-catch";
+          GraphNodeType["Wait"] = "wait";
+      })(GraphNodeType || (exports('GraphNodeType', GraphNodeType = {})));
+      /**
+       * Enumeration of possible workflow flow directives.
+       */
+      var FlowDirective;
+      (function (FlowDirective) {
+          FlowDirective["Exit"] = "exit";
+          FlowDirective["End"] = "end";
+          FlowDirective["Continue"] = "continue";
+      })(FlowDirective || (FlowDirective = {}));
+      /**
+       * Converts an array of TaskItem objects into a Map for easy lookup.
+       *
+       * @param tasksList An array of TaskItem objects.
+       * @returns A map where keys are task names and values are Task objects.
+       */
+      function mapTasks(tasksList) {
+          return (tasksList || []).reduce(function (acc, item) {
+              var _a = Object.entries(item)[0], key = _a[0], task = _a[1];
+              acc.set(key, task);
+              return acc;
+          }, new Map());
+      }
+      /**
+       * Initializes a graph with default entry and exit nodes.
+       *
+       * @param type The type of the graph node.
+       * @param id Unique identifier for the graph.
+       * @param label Optional label for the graph.
+       * @param parent Optional parent graph if this is a subgraph.
+       * @returns A newly created Graph instance.
+       */
+      function initGraph(type, id, label, parent) {
+          if (id === void 0) { id = rooId; }
+          if (label === void 0) { label = undefined; }
+          if (parent === void 0) { parent = undefined; }
+          var entryNode = {
+              type: id === rooId ? GraphNodeType.Start : GraphNodeType.Entry,
+              id: "".concat(id).concat(entrySuffix),
+          };
+          var exitNode = {
+              type: id === rooId ? GraphNodeType.End : GraphNodeType.Exit,
+              id: "".concat(id).concat(exitSuffix),
+          };
+          var graph = {
+              id: id,
+              label: label,
+              type: type,
+              parent: parent,
+              entryNode: entryNode,
+              exitNode: exitNode,
+              nodes: [entryNode, exitNode],
+              edges: [],
+          };
+          if (parent)
+              parent.nodes.push(graph);
+          return graph;
+      }
+      /**
+       * Constructs a graph representation based on the given workflow.
+       *
+       * @param workflow The workflow to be converted into a graph structure.
+       * @returns A graph representation of the workflow.
+       */
+      function buildGraph(workflow) {
+          var graph = initGraph(GraphNodeType.Root);
+          buildTransitions(graph.entryNode, {
+              graph: graph,
+              reference: doReference,
+              taskList: mapTasks(workflow.do),
+              taskReference: doReference,
+          });
+          return graph;
+      }
+      /**
+       * Gets the next task to be executed in the workflow
+       * @param tasksList The list of task to resolve the next task from
+       * @param taskName The current task name, if any
+       * @param transition A specific transition, if any
+       * @returns
+       */
+      function getNextTask(tasksList, taskName, transition) {
+          if (taskName === void 0) { taskName = undefined; }
+          if (transition === void 0) { transition = undefined; }
+          if (!(tasksList === null || tasksList === void 0 ? void 0 : tasksList.size))
+              throw new Error('The task list cannot be empty. No tasks list to get the next task from.');
+          var currentTask = tasksList.get(taskName || '');
+          transition = transition || (currentTask === null || currentTask === void 0 ? void 0 : currentTask.then) || '';
+          if (transition == FlowDirective.End || transition == FlowDirective.Exit) {
+              return {
+                  name: transition,
+                  index: -1,
+              };
+          }
+          var index = 0;
+          if (transition && transition != FlowDirective.Continue) {
+              index = Array.from(tasksList.keys()).indexOf(transition);
+          }
+          else if (currentTask) {
+              index = Array.from(tasksList.values()).indexOf(currentTask) + 1;
+              if (index >= tasksList.size) {
+                  return {
+                      name: FlowDirective.End,
+                      index: -1,
+                  };
+              }
+          }
+          var taskEntry = Array.from(tasksList.entries())[index];
+          return {
+              index: index,
+              name: taskEntry[0],
+              task: taskEntry[1],
+          };
+      }
+      /**
+       * Builds the provided transition from the source node
+       * @param sourceNode The node to build the transition from
+       * @param transition The transition to follow
+       * @param context The context in which the transition is built
+       */
+      function buildTransition(sourceNode, transition, context) {
+          var exitAnchor = sourceNode.exitNode || sourceNode;
+          if (transition.index != -1) {
+              var destinationNode = buildTaskNode(__assign(__assign({}, context), { taskReference: "".concat(context.reference, "/").concat(transition.index, "/").concat(transition.name), taskName: transition.name }));
+              buildEdge(context.graph, exitAnchor, destinationNode.entryNode || destinationNode, transition.label);
+          }
+          else if (transition.name === FlowDirective.Exit) {
+              buildEdge(context.graph, exitAnchor, context.graph.exitNode, transition.label);
+          }
+          else if (transition.name === FlowDirective.End) {
+              buildEdge(context.graph, exitAnchor, context.graph.exitNode, transition.label);
+          }
+          else
+              throw new Error('Invalid transition');
+      }
+      /**
+       * Builds all the possible transitions from the provided node in the provided context
+       * @param sourceNode The node to build the transitions from
+       * @param context The context in which the transitions are built
+       */
+      function buildTransitions(sourceNode, context) {
+          var _a, _b;
+          var transitions = [];
+          var nextTransition = getNextTask(context.taskList, context.taskName);
+          transitions.push(nextTransition);
+          while ((_a = nextTransition === null || nextTransition === void 0 ? void 0 : nextTransition.task) === null || _a === void 0 ? void 0 : _a.if) {
+              nextTransition.label = (_b = nextTransition === null || nextTransition === void 0 ? void 0 : nextTransition.task) === null || _b === void 0 ? void 0 : _b.if;
+              nextTransition = getNextTask(context.taskList, nextTransition.name, FlowDirective.Continue);
+              transitions.push(nextTransition);
+          }
+          transitions
+              .filter(function (transition, index) {
+              return transitions.findIndex(function (t) { return t.index === transition.index && t.name === transition.name && t.task === transition.task; }) === index;
+          })
+              .forEach(function (transition) { return buildTransition(sourceNode, transition, context); });
+      }
+      /**
+       * Builds a graph representation of a task
+       * @param context The context to build the graph/node for
+       * @returns A graph or node for the provided context
+       */
+      function buildTaskNode(context) {
+          var task = context.taskList.get(context.taskName);
+          if (!task)
+              throw new Error("Unabled to find the task '".concat(context.taskName, "' in the current context"));
+          if (task.call)
+              return buildCallTaskNode(task, context);
+          if (task.catch)
+              return buildTryCatchTaskNode(task, context);
+          if (task.emit)
+              return buildEmitTaskNode(task, context);
+          if (task.for)
+              return buildForTaskNode(task, context);
+          if (task.fork)
+              return buildForkTaskNode(task, context);
+          if (task.listen)
+              return buildListenTaskNode(task, context);
+          if (task.raise)
+              return buildRaiseTaskNode(task, context);
+          if (task.run)
+              return buildRunTaskNode(task, context);
+          if (task.set)
+              return buildSetTaskNode(task, context);
+          if (task.switch)
+              return buildSwitchTaskNode(task, context);
+          if (task.wait)
+              return buildWaitTaskNode(task, context);
+          if (task.do)
+              return buildDoTaskNode(task, context);
+          throw new Error("Unable to defined task type of task named '".concat(context.taskName, "'"));
+      }
+      /**
+       * Builds a graph node with the provided type and context
+       * @param type The type of the node
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided context
+       */
+      function buildGenericTaskNode(type, context) {
+          var node = {
+              type: type,
+              id: context.taskReference,
+              label: context.taskName,
+          };
+          context.graph.nodes.push(node);
+          buildTransitions(node, context);
+          return node;
+      }
+      /**
+       * Builds a graph node for the provided call task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildCallTaskNode(task, context) {
+          var node = buildGenericTaskNode(GraphNodeType.Call, context);
+          // TODO: add some details about the task?
+          return node;
+      }
+      /**
+       * Builds a graph for the provided do task
+       * @param task The task to build the graph for
+       * @param context The context to build the graph for
+       * @returns A graph for the provided task
+       */
+      function buildDoTaskNode(task, context) {
+          var subgraph = initGraph(GraphNodeType.Do, context.taskReference, context.taskName, context.graph);
+          var doContext = __assign(__assign({}, context), { graph: subgraph, reference: context.taskReference + doReference, taskList: mapTasks(task.do), taskName: null });
+          buildTransitions(subgraph.entryNode, doContext);
+          buildTransitions(subgraph, context);
+          return subgraph;
+      }
+      /**
+       * Builds a graph node for the provided emit task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildEmitTaskNode(task, context) {
+          var node = buildGenericTaskNode(GraphNodeType.Emit, context);
+          // TODO: add some details about the task?
+          return node;
+      }
+      /**
+       * Builds a graph for the provided for task
+       * @param task The task to build the graph for
+       * @param context The context to build the graph for
+       * @returns A graph for the provided task
+       */
+      function buildForTaskNode(task, context) {
+          var subgraph = initGraph(GraphNodeType.For, context.taskReference, context.taskName, context.graph);
+          var forContext = __assign(__assign({}, context), { graph: subgraph, reference: subgraph.id + forReference + doReference, taskList: mapTasks(task.do), taskName: null });
+          buildTransitions(subgraph.entryNode, forContext);
+          buildTransitions(subgraph, context);
+          return subgraph;
+      }
+      /**
+       * Builds a graph for the provided fork task
+       * @param task The task to build the graph for
+       * @param context The context to build the graph for
+       * @returns A graph for the provided task
+       */
+      function buildForkTaskNode(task, context) {
+          var _a, _b;
+          var subgraph = initGraph(GraphNodeType.Fork, context.taskReference, context.taskName, context.graph);
+          for (var i = 0, c = ((_a = task.fork) === null || _a === void 0 ? void 0 : _a.branches.length) || 0; i < c; i++) {
+              var branchItem = (_b = task.fork) === null || _b === void 0 ? void 0 : _b.branches[i];
+              if (!branchItem)
+                  continue;
+              var branchName = Object.entries(branchItem)[0][0];
+              var branchContext = __assign(__assign({}, context), { graph: subgraph, reference: "".concat(context.taskReference).concat(branchReference), taskList: mapTasks([branchItem]), taskReference: "".concat(context.taskReference).concat(branchReference, "/").concat(i, "/").concat(branchName), taskName: branchName });
+              var branchNode = buildTaskNode(branchContext);
+              buildEdge(subgraph, subgraph.entryNode, branchNode.entryNode || branchNode);
+              buildEdge(subgraph, branchNode.exitNode || branchNode, subgraph.exitNode);
+          }
+          buildTransitions(subgraph, context);
+          return subgraph;
+      }
+      /**
+       * Builds a graph node for the provided listen task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildListenTaskNode(task, context) {
+          var node = buildGenericTaskNode(GraphNodeType.Listen, context);
+          // TODO: add some details about the task?
+          return node;
+      }
+      /**
+       * Builds a graph node for the provided rasie task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildRaiseTaskNode(task, context) {
+          var node = buildGenericTaskNode(GraphNodeType.Raise, context);
+          // TODO: add some details about the task?
+          return node;
+      }
+      /**
+       * Builds a graph node for the provided run task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildRunTaskNode(task, context) {
+          var node = buildGenericTaskNode(GraphNodeType.Run, context);
+          // TODO: add some details about the task?
+          return node;
+      }
+      /**
+       * Builds a graph node for the provided set task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildSetTaskNode(task, context) {
+          var node = buildGenericTaskNode(GraphNodeType.Set, context);
+          // TODO: add some details about the task?
+          return node;
+      }
+      /**
+       * Builds a graph node for the provided switch task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildSwitchTaskNode(task, context) {
+          var _a;
+          var node = buildGenericTaskNode(GraphNodeType.Switch, context);
+          var hasDefaultCase = false;
+          (_a = task.switch) === null || _a === void 0 ? void 0 : _a.forEach(function (switchItem) {
+              var _a = Object.entries(switchItem)[0], caseName = _a[0], switchCase = _a[1];
+              if (!switchCase.when)
+                  hasDefaultCase = true;
+              var transition = getNextTask(context.taskList, context.taskName, switchCase.then);
+              transition.label = caseName;
+              buildTransition(node, transition, context);
+          });
+          if (!hasDefaultCase) {
+              buildTransitions(node, context);
+          }
+          return node;
+      }
+      /**
+       * Builds a graph for the provided try/catch task
+       * @param task The task to build the graph for
+       * @param context The context to build the graph for
+       * @returns A graph for the provided task
+       */
+      function buildTryCatchTaskNode(task, context) {
+          var _a, _b;
+          var containerSubgraph = initGraph(GraphNodeType.TryCatch, context.taskReference, context.taskName, context.graph);
+          var trySubgraph = initGraph(GraphNodeType.Try, context.taskReference + tryReference, context.taskName + ' (try)', containerSubgraph);
+          buildEdge(containerSubgraph, containerSubgraph.entryNode, trySubgraph.entryNode);
+          var tryContext = __assign(__assign({}, context), { graph: trySubgraph, reference: trySubgraph.id, taskList: mapTasks(task.try), taskName: null });
+          buildTransitions(trySubgraph.entryNode, tryContext);
+          if (!((_b = (_a = task.catch) === null || _a === void 0 ? void 0 : _a.do) === null || _b === void 0 ? void 0 : _b.length)) {
+              var catchNode = {
+                  type: GraphNodeType.Catch,
+                  id: context.taskReference + catchReference,
+                  label: context.taskName + ' (catch)',
+              };
+              containerSubgraph.nodes.push(catchNode);
+              buildEdge(containerSubgraph, trySubgraph.exitNode, catchNode);
+              buildEdge(containerSubgraph, catchNode, containerSubgraph.exitNode);
+          }
+          else {
+              var catchSubgraph = initGraph(GraphNodeType.Catch, context.taskReference + catchReference + doReference, context.taskName + ' (catch)', containerSubgraph);
+              buildEdge(containerSubgraph, trySubgraph.exitNode, catchSubgraph.entryNode);
+              var catchContext = __assign(__assign({}, context), { graph: catchSubgraph, reference: catchSubgraph.id, taskList: mapTasks(task.catch.do), taskName: null });
+              buildTransitions(catchSubgraph.entryNode, catchContext);
+              buildEdge(containerSubgraph, catchSubgraph.exitNode, containerSubgraph.exitNode);
+          }
+          buildTransitions(containerSubgraph, context);
+          return containerSubgraph;
+      }
+      /**
+       * Builds a graph node for the provided wait task
+       * @param task The task to build the graph node for
+       * @param context The context to build the graph node for
+       * @returns A graph node for the provided task
+       */
+      function buildWaitTaskNode(task, context) {
+          var node = buildGenericTaskNode(GraphNodeType.Wait, context);
+          // TODO: add some details about the task?
+          return node;
+      }
+      /**
+       * Builds an edge between two elements
+       * @param graph The graph element containing the nodes
+       * @param source The origin node
+       * @param destination The destination node
+       * @param label The edge label, if any
+       */
+      function buildEdge(graph, source, destination, label) {
+          if (label === void 0) { label = ''; }
+          var edge = graph.edges.find(function (e) { return e.sourceId === source.id && e.destinationId === destination.id; });
+          if (edge) {
+              if (label) {
+                  edge.label = edge.label + (edge.label ? ' / ' : '') + label;
+              }
+              return edge;
+          }
+          edge = {
+              label: label,
+              id: "".concat(source.id, "-").concat(destination.id).concat(label ? "-".concat(label) : ''),
+              sourceId: source.id,
+              destinationId: destination.id,
+          };
+          graph.edges.push(edge);
+      }
+
+      /**
+       * Adds indentation to each line of the provided code
+       * @param code The code to indent
+       * @returns The indented code
+       */
+      var indent = function (code) {
+          return code
+              .split('\n')
+              .map(function (line) { return "    ".concat(line); })
+              .join('\n');
+      };
+      /**
+       * Converts a graph to Mermaid code
+       * @param graph The graph to convert
+       * @returns The converted graph
+       */
+      function convertGraphToCode(graph) {
+          var isRoot = graph.id === 'root';
+          var code = "".concat(isRoot ? 'flowchart TD' : "subgraph ".concat(graph.id, " [\"").concat(graph.label || graph.id, "\"]"), "\n").concat(indent(graph.nodes.map(function (node) { return convertNodeToCode(node); }).join('\n')), "\n").concat(indent(graph.edges.map(function (edge) { return convertEdgeToCode(edge); }).join('\n')), "\n").concat(isRoot ? '' : 'end');
+          return code;
+      }
+      /**
+       * Converts a node to Mermaid code
+       * @param node The node to convert
+       * @returns The converted node
+       */
+      function convertNodeToCode(node) {
+          var _a;
+          var code = '';
+          if ((_a = node.nodes) === null || _a === void 0 ? void 0 : _a.length) {
+              code = convertGraphToCode(node);
+          }
+          else {
+              code = node.id;
+              switch (node.type) {
+                  case GraphNodeType.Entry:
+                  case GraphNodeType.Exit:
+                      code += ':::hidden';
+                      break;
+                  case GraphNodeType.Start:
+                      code += '(( ))'; // alt '@{ shape: circle, label: " "}';
+                      break;
+                  case GraphNodeType.End:
+                      code += '((( )))'; // alt '@{ shape: dbl-circ, label: " "}';
+                      break;
+                  default:
+                      code += "[\"".concat(node.label, "\"]"); // alt `@{ label: "${node.label}" }`
+              }
+          }
+          return code;
+      }
+      /**
+       * Converts an edge to Mermaid code
+       * @param edge The edge to convert
+       * @returns The converted edge
+       */
+      function convertEdgeToCode(edge) {
+          var ignoreEndArrow = !edge.destinationId.startsWith('root') &&
+              (edge.destinationId.endsWith('-entry-node') || edge.destinationId.endsWith('-exit-node'));
+          var code = "".concat(edge.sourceId, " ").concat(edge.label ? "--\"".concat(edge.label, "\"") : '', "--").concat(ignoreEndArrow ? '-' : '>', " ").concat(edge.destinationId);
+          return code;
+      }
+      /**
+       * Converts the provided workflow to Mermaid code
+       * @param workflow The workflow to convert
+       * @returns The Mermaid diagram
+       */
+      function convertToMermaidCode(workflow) {
+          var graph = buildGraph(workflow);
+          return (convertGraphToCode(graph) +
+              "\n\nclassDef hidden display: none;");
+      }
+      /**
+       * Represents a Mermaid diagram generator for a given workflow.
+       * This class takes a workflow definition and converts it into a Mermaid.js-compatible diagram.
+       */
+      var MermaidDiagram = exports('MermaidDiagram', /** @class */ (function () {
+          function MermaidDiagram(workflow) {
+              this.workflow = workflow;
+          }
+          /**
+           * Generates the Mermaid code representation of the workflow.
+           * @returns The Mermaid diagram source code as a string.
+           */
+          MermaidDiagram.prototype.sourceCode = function () {
+              return convertToMermaidCode(this.workflow);
+          };
+          return MermaidDiagram;
+      }()));
+
       /*
        * Copyright 2021-Present The Serverless Workflow Specification Authors
        *
@@ -24904,6 +25455,12 @@ System.register([], (function (exports) {
               }
               return dump(normalized);
           };
+          Workflow.toGraph = function (model) {
+              return buildGraph(model);
+          };
+          Workflow.toMermaidCode = function (model) {
+              return convertToMermaidCode(model);
+          };
           /**
            * Serializes the workflow to YAML or JSON
            * @param format The format, 'yaml' or 'json', default is 'yaml'
@@ -24915,6 +25472,20 @@ System.register([], (function (exports) {
               if (normalize === void 0) { normalize = true; }
               return Workflow.serialize(this, format, normalize);
           };
+          /**
+           * Creates a directed graph representation of the workflow
+           * @returns A directed graph of the workflow
+           */
+          Workflow.prototype.toGraph = function () {
+              return Workflow.toGraph(this);
+          };
+          /**
+           * Generates the MermaidJS code corresponding to the workflow
+           * @returns The MermaidJS code
+           */
+          Workflow.prototype.toMermaidCode = function () {
+              return Workflow.toMermaidCode(this);
+          };
           return Workflow;
       }(ObjectHydrator));
       var _Workflow = Workflow;