Restructured Fusion Projects

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/FieldPlanNode.cs

@@ -1,10 +1,14 @@
+using System.Collections.Immutable;
+using System.Diagnostics;
 using HotChocolate.Fusion.Types;
 using HotChocolate.Language;
 
-namespace HotChocolate.Fusion.Planning;
+namespace HotChocolate.Fusion.Planning.Nodes;
 
-public class FieldPlanNode : SelectionPlanNode
+public sealed class FieldPlanNode : SelectionPlanNode
 {
+    private List<ArgumentAssignment>? _arguments;
+
     public FieldPlanNode(
         FieldNode fieldNode,
         CompositeOutputField field)
@@ -20,4 +24,24 @@ public FieldPlanNode(
     public FieldNode FieldNode { get; }
 
     public CompositeOutputField Field { get; }
+
+    public IReadOnlyList<ArgumentAssignment> Arguments
+        => _arguments ?? (IReadOnlyList<ArgumentAssignment>)Array.Empty<ArgumentAssignment>();
+
+    public void AddArgument(ArgumentAssignment argument)
+    {
+        ArgumentNullException.ThrowIfNull(argument);
+        _arguments ??= [];
+        _arguments.Add(argument);
+    }
+
+    public FieldNode ToSyntaxNode()
+    {
+        return new FieldNode(
+            new NameNode(Field.Name),
+            Field.Name.Equals(ResponseName) ? null : new NameNode(ResponseName),
+            Directives.ToSyntaxNode(),
+            Arguments.ToSyntaxNode(),
+            Selections.Count == 0 ? null : Selections.ToSyntaxNode());
+    }
 }

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/IOperationPlanNodeProvider.cs

@@ -1,4 +1,4 @@
-namespace HotChocolate.Fusion.Planning;
+namespace HotChocolate.Fusion.Planning.Nodes;
 
 public interface IOperationPlanNodeProvider
 {

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/InlineFragmentPlanNode.cs

@@ -0,0 +1,23 @@
+using HotChocolate.Fusion.Types;
+using HotChocolate.Language;
+
+namespace HotChocolate.Fusion.Planning.Nodes;
+
+public sealed class InlineFragmentPlanNode : SelectionPlanNode
+{
+    public InlineFragmentPlanNode(
+        ICompositeNamedType declaringType,
+        IReadOnlyList<ISelectionNode> selectionNodes)
+        : base(declaringType, selectionNodes)
+    {
+    }
+
+    public InlineFragmentNode ToSyntaxNode()
+    {
+        return new InlineFragmentNode(
+            null,
+            new NamedTypeNode(DeclaringType.Name),
+            Directives.ToSyntaxNode(),
+            Selections.ToSyntaxNode());
+    }
+}

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/OperationPlanNode.cs

@@ -1,7 +1,7 @@
 using HotChocolate.Fusion.Types;
 using HotChocolate.Language;
 
-namespace HotChocolate.Fusion.Planning;
+namespace HotChocolate.Fusion.Planning.Nodes;
 
 /// <summary>
 /// Represents an operation to resolve data from a specific source schema.
@@ -34,6 +34,9 @@ public OperationPlanNode(
 
     public string SchemaName { get; }
 
+    // todo: variable representations are missing.
+    // todo: how to we represent state?
+
     public IReadOnlyList<OperationPlanNode> Operations
         => _operations ?? (IReadOnlyList<OperationPlanNode>)Array.Empty<OperationPlanNode>();
 
@@ -43,4 +46,15 @@ public void AddOperation(OperationPlanNode operation)
         (_operations ??= []).Add(operation);
         operation.Parent = this;
     }
+
+    public OperationDefinitionNode ToSyntaxNode()
+    {
+        return new OperationDefinitionNode(
+            null,
+            null,
+            OperationType.Query,
+            Array.Empty<VariableDefinitionNode>(),
+            Directives.ToSyntaxNode(),
+            Selections.ToSyntaxNode());
+    }
 }

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/PlanNode.cs

@@ -1,4 +1,4 @@
-namespace HotChocolate.Fusion.Planning;
+namespace HotChocolate.Fusion.Planning.Nodes;
 
 public abstract class PlanNode
 {

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/RootPlanNode.cs

@@ -1,6 +1,9 @@
-namespace HotChocolate.Fusion.Planning;
+using System.Collections.Immutable;
+using HotChocolate.Language;
 
-public class RootPlanNode : PlanNode, IOperationPlanNodeProvider
+namespace HotChocolate.Fusion.Planning.Nodes;
+
+public sealed class RootPlanNode : PlanNode, IOperationPlanNodeProvider
 {
     private readonly List<OperationPlanNode> _operations = new();
 
@@ -13,4 +16,27 @@ public void AddOperation(OperationPlanNode operation)
         _operations.Add(operation);
         operation.Parent = this;
     }
+
+    public DocumentNode ToSyntaxNode()
+    {
+        var backlog = new Queue<OperationPlanNode>();
+        var definitions = ImmutableArray.CreateBuilder<IDefinitionNode>();
+
+        foreach(var operation in _operations)
+        {
+            backlog.Enqueue(operation);
+        }
+
+        while(backlog.TryDequeue(out var operation))
+        {
+            definitions.Add(operation.ToSyntaxNode());
+
+            foreach(var child in operation.Operations)
+            {
+                backlog.Enqueue(child);
+            }
+        }
+
+        return new DocumentNode(definitions.ToImmutable());
+    }
 }

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/SelectionPlanNode.cs

@@ -1,7 +1,7 @@
 using HotChocolate.Fusion.Types;
 using HotChocolate.Language;
 
-namespace HotChocolate.Fusion.Planning;
+namespace HotChocolate.Fusion.Planning.Nodes;
 
 /// <summary>
 /// The base class for plan nodes that can have child selections.
@@ -65,6 +65,13 @@ public IReadOnlyList<SelectionPlanNode> Selections
     public void AddSelection(SelectionPlanNode selection)
     {
         ArgumentNullException.ThrowIfNull(selection);
+
+        if(selection is OperationPlanNode)
+        {
+            throw new NotSupportedException(
+                "An operation cannot be a child of a selection.");
+        }
+
         (_selections ??= []).Add(selection);
         selection.Parent = this;
     }

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/Nodes/SyntaxNodeHelpers.cs

@@ -0,0 +1,49 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Types;
+using HotChocolate.Language;
+
+namespace HotChocolate.Fusion.Planning.Nodes;
+
+internal static class SyntaxNodeHelpers
+{
+    public static SelectionSetNode ToSyntaxNode(this IReadOnlyList<SelectionPlanNode> selections)
+    {
+        var selectionSet = ImmutableArray.CreateBuilder<ISelectionNode>();
+
+        foreach (var selection in selections)
+        {
+            selectionSet.Add(selection switch
+            {
+                FieldPlanNode field => field.ToSyntaxNode(),
+                InlineFragmentPlanNode inlineFragment => inlineFragment.ToSyntaxNode(),
+                _ => throw new InvalidOperationException()
+            });
+        }
+
+        return new SelectionSetNode(null, selectionSet.ToImmutable());
+    }
+
+    public static IReadOnlyList<DirectiveNode> ToSyntaxNode(this IReadOnlyList<CompositeDirective> directives)
+    {
+        var directiveNodes = ImmutableArray.CreateBuilder<DirectiveNode>();
+
+        foreach (var directive in directives)
+        {
+            directiveNodes.Add(directive.ToSyntaxNode());
+        }
+
+        return directiveNodes.ToImmutable();
+    }
+
+    public static IReadOnlyList<ArgumentNode> ToSyntaxNode(this IReadOnlyList<ArgumentAssignment> arguments)
+    {
+        var argumentNodes = ImmutableArray.CreateBuilder<ArgumentNode>();
+
+        foreach (var argument in arguments)
+        {
+            argumentNodes.Add(argument.ToSyntaxNode());
+        }
+
+        return argumentNodes.ToImmutable();
+    }
+}