WIP: Produce Fusion errors during compose step

src/HotChocolate/Core/src/Execution/Processing/PathHelper.cs

@@ -18,9 +18,11 @@ public static Path CreatePathFromContext(ISelection selection, ResultData parent
             _ => throw new NotSupportedException($"{parent.GetType().FullName} is not a supported parent type."),
         };
 
-    public static Path CombinePath(Path path, JsonElement errorSubPath, int skipSubElements)
+    public static Path CreatePathFromJson(JsonElement errorSubPath)
     {
-        for (var i = skipSubElements; i < errorSubPath.GetArrayLength(); i++)
+        var path = Path.Root;
+
+        for (var i = 0; i < errorSubPath.GetArrayLength(); i++)
         {
             path = errorSubPath[i] switch
             {

src/HotChocolate/Fusion/src/Core/Execution/ErrorTrie.cs

@@ -0,0 +1,158 @@
+using System.Diagnostics;
+using System.Text;
+using HotChocolate.Fusion.Planning;
+
+namespace HotChocolate.Fusion.Execution;
+
+internal class ErrorTrie : Dictionary<object, ErrorTrie>
+{
+    public List<IError>? Errors { get; private set; }
+
+    /// <summary>
+    /// Traverses this <see cref="ErrorTrie"/> and returns the first error it finds.
+    /// </summary>
+    public IError? GetFirstError()
+    {
+        var stack = new Stack<ErrorTrie>();
+        stack.Push(this);
+
+        while (stack.TryPop(out var currentErrorTrie))
+        {
+            if (currentErrorTrie.Errors?.FirstOrDefault() is { } error)
+            {
+                return error;
+            }
+
+            foreach (var value in currentErrorTrie.Values)
+            {
+                stack.Push(value);
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Creates an <see cref="ErrorTrie"/> from the given <paramref name="errors"/>,
+    /// using the <see cref="Path"/> of each error to build the trie.
+    /// </summary>
+    /// <remarks>
+    /// Errors without a path are added to the root of the trie.
+    /// </remarks>
+    public static ErrorTrie FromErrors(List<IError> errors)
+    {
+        var root = new ErrorTrie();
+
+        foreach (var error in errors)
+        {
+            if (error.Path is null)
+            {
+                root.AddError(error);
+                continue;
+            }
+
+            var pathSegments = error.Path.ToList();
+
+            var currentTrie = root;
+            var lastPathIndex = pathSegments.Count - 1;
+
+            for (var i = 0; i < pathSegments.Count; i++)
+            {
+                var pathSegment = pathSegments[i];
+
+                if (currentTrie.TryGetValue(pathSegment, out var trieAtPath))
+                {
+                    currentTrie = trieAtPath;
+                }
+                else
+                {
+                    var newTrie = new ErrorTrie();
+                    currentTrie[pathSegment] = newTrie;
+                    currentTrie = newTrie;
+                }
+
+                if (i == lastPathIndex)
+                {
+                    currentTrie.AddError(error);
+                }
+            }
+        }
+
+        return root;
+    }
+
+    /// <summary>
+    /// Creates a new <see cref="ErrorTrie"/> with an entry for each item in
+    /// <paramref name="rootSelections"/>, containing the specified <paramref name="error"/>.
+    /// </summary>
+    public static ErrorTrie FromSelections(IError error, List<RootSelection> rootSelections)
+    {
+        var errorTrie = new ErrorTrie();
+
+        foreach (var rootSelection in rootSelections)
+        {
+            var errorTrieForSubfield = new ErrorTrie();
+            errorTrieForSubfield.AddError(error);
+
+            errorTrie.Add(rootSelection.Selection.ResponseName, errorTrieForSubfield);
+        }
+
+        return errorTrie;
+    }
+
+    // TODO: Better name and summary
+    /// <summary>
+    ///
+    /// </summary>
+    public static ErrorTrie? FromSelections(
+        ErrorTrie subgraphErrorTrie,
+        List<RootSelection> rootSelections,
+        string[] path)
+    {
+        var firstErrorOnPath = subgraphErrorTrie.GetFirstErrorOnPath(path);
+
+        return firstErrorOnPath is null ? null : FromSelections(firstErrorOnPath, rootSelections);
+    }
+
+    /// <summary>
+    /// Traverses this <see cref="ErrorTrie"/> along the specified
+    /// <paramref name="path"/>. If one of the items along the path has an error,
+    /// the error is returned.
+    /// If the path can't be followed or there are no errors on the path,
+    /// the errors on this <see cref="ErrorTrie"/> are returned (if present).
+    /// </summary>
+    private IError? GetFirstErrorOnPath(string[] path)
+    {
+        var currentErrorTrie = this;
+        foreach (var segment in path)
+        {
+            if (currentErrorTrie.TryGetValue(segment, out var childErrorTrie))
+            {
+                if (childErrorTrie.Errors?.FirstOrDefault() is { } error)
+                {
+                    return error;
+                }
+
+                currentErrorTrie = childErrorTrie;
+            }
+            else
+            {
+                break;
+            }
+        }
+
+        return Errors?.FirstOrDefault();
+    }
+
+    private void AddError(IError error)
+    {
+        if (Errors is null)
+        {
+            Errors = [error];
+        }
+        else
+        {
+            Errors.Add(error);
+        }
+    }
+}

src/HotChocolate/Fusion/src/Core/Execution/ExecutionState.cs

@@ -58,6 +58,11 @@ public ExecutionState(
     /// </summary>
     public bool IsInitialized { get; set; }
 
+    /// <summary>
+    /// Gets the errors that were collected from the subgraphs during execution.
+    /// </summary>
+    public ErrorTrie? ErrorTrie { get; set; }
+
     private string GetDebuggerDisplay()
     {
         var displayName = $"State {SelectionSet.Id}";