Adds support for nested lookups (#8884)

Author: michaelstaib

src/HotChocolate/Core/src/Types/Types/Composite/Directives/ShareableAttribute.cs

@@ -33,7 +33,10 @@ namespace HotChocolate.Types.Composite;
 /// </para>
 /// </summary>
 [AttributeUsage(
-    AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Property)]
+    AttributeTargets.Class
+    | AttributeTargets.Struct
+    | AttributeTargets.Method
+    | AttributeTargets.Property)]
 public sealed class ShareableAttribute : DescriptorAttribute
 {
     public ShareableAttribute()

src/HotChocolate/Fusion-vnext/src/Fusion.Execution.Types/Completion/CompletionTools.cs

@@ -214,7 +214,8 @@ private static ImmutableArray<Lookup> GetLookupBySchema(
                         lookup.Field.Type.NamedType().Name.Value,
                         lookup.Internal,
                         arguments.ToImmutable(),
-                        fields));
+                        fields,
+                        lookup.Path));
             }
         }
 

src/HotChocolate/Fusion-vnext/src/Fusion.Execution.Types/Directives/LookupDirectiveParser.cs

@@ -48,9 +48,8 @@ public static LookupDirective Parse(DirectiveNode directive)
                 case "path":
                     if (argument.Value is StringValueNode pathValueNode)
                     {
-                        path = pathValueNode.Value.Trim().Split('.').ToImmutableArray();
+                        path = [..pathValueNode.Value.Trim().Split('.')];
                     }
-
                     break;
 
                 case "internal":

src/HotChocolate/Fusion-vnext/src/Fusion.Execution.Types/Metadata/Lookup.cs

@@ -26,6 +26,9 @@ public sealed class Lookup : INeedsCompletion
     /// <param name="isInternal">Whether the lookup is internal or not.</param>
     /// <param name="arguments">The arguments that represent field requirements.</param>
     /// <param name="fields">The paths to the field that are required.</param>
+    /// <param name="path">
+    /// The path to the lookup field relative to the Query type.
+    /// </param>
     /// <exception cref="ArgumentException">
     /// Thrown when the <paramref name="arguments"/> or <paramref name="fields"/> is empty.
     /// </exception>
@@ -40,7 +43,8 @@ public Lookup(
         string fieldType,
         bool isInternal,
         ImmutableArray<LookupArgument> arguments,
-        ImmutableArray<IValueSelectionNode> fields)
+        ImmutableArray<IValueSelectionNode> fields,
+        ImmutableArray<string> path)
     {
         ArgumentException.ThrowIfNullOrEmpty(schemaName);
         ArgumentException.ThrowIfNullOrEmpty(declaringTypeName);
@@ -64,6 +68,7 @@ public Lookup(
         IsInternal = isInternal;
         Arguments = arguments;
         Fields = fields;
+        Path = path;
     }
 
     /// <summary>
@@ -96,6 +101,11 @@ public Lookup(
     /// </summary>
     public ImmutableArray<IValueSelectionNode> Fields { get; }
 
+    /// <summary>
+    /// Gets the path to the lookup field relative to the Query type.
+    /// </summary>
+    public ImmutableArray<string> Path { get; set; }
+
     /// <summary>
     /// Gets the data requirements for this lookup field.
     /// </summary>

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/OperationDefinitionBuilder.cs

@@ -76,6 +76,14 @@ public OperationDefinitionBuilder SetSelectionSet(SelectionSetNode selectionSet)
 
         if (_lookup is not null && _lookupArguments is not null && _typeToLookup is not null)
         {
+            if (!_lookup.Path.IsEmpty)
+            {
+                foreach (var fieldName in _lookup.Path)
+                {
+                    selectionPathBuilder.AppendField(fieldName);
+                }
+            }
+
             selectionPathBuilder.AppendField(_lookup.FieldName);
 
             var lookupSelectionSet = selectionSet;
@@ -111,6 +119,17 @@ public OperationDefinitionBuilder SetSelectionSet(SelectionSetNode selectionSet)
                 _lookupArguments,
                 lookupSelectionSet);
 
+            if (!_lookup.Path.IsEmpty)
+            {
+                for (var i = _lookup.Path.Length - 1; i >= 0; i--)
+                {
+                    var fieldName = _lookup.Path[i];
+                    var fieldSelectionSet = new SelectionSetNode(null, [lookupField]);
+                    lookupField = new FieldNode(fieldName, fieldSelectionSet);
+                    indexBuilder.Register(fieldSelectionSet);
+                }
+            }
+
             selectionSet = new SelectionSetNode(null, [lookupField]);
         }
 

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Planning/OperationPlanner.BuildExecutionTree.cs

@@ -705,6 +705,22 @@ public static bool AreAllProvidedSelectionsConditional(this OperationPlanStep st
         {
             FieldNode? lookupFieldNode = null;
 
+            if (!step.Lookup.Path.IsEmpty)
+            {
+                foreach (var fieldName in step.Lookup.Path)
+                {
+                    var fieldNode = selectionSetNode.Selections.FirstOrDefault(
+                        selection => selection is FieldNode fieldNode && fieldNode.Name.Value == fieldName);
+
+                    if (fieldNode is not FieldNode { SelectionSet: { } nextSelectionSetNode })
+                    {
+                        throw new InvalidOperationException("Unable to resolve the lookup path.");
+                    }
+
+                    selectionSetNode = nextSelectionSetNode;
+                }
+            }
+
             foreach (var selection in selectionSetNode.Selections)
             {
                 if (selection is FieldNode fieldNode && fieldNode.Name.Value == step.Lookup.FieldName)

src/HotChocolate/Fusion-vnext/test/Fusion.AspNetCore.Tests/LookupTests.cs

@@ -0,0 +1,107 @@
+using HotChocolate.Transport;
+using HotChocolate.Transport.Http;
+using HotChocolate.Types;
+using HotChocolate.Types.Composite;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace HotChocolate.Fusion;
+
+public class LookupTests : FusionTestBase
+{
+    [Fact]
+    public async Task Fetch_From_Nested_Internal_Lookup()
+    {
+        // arrange
+        using var server1 = CreateSourceSchema(
+            "a",
+            b => b.AddQueryType<NestedLookups.SourceSchema1.Query>());
+
+        using var server2 = CreateSourceSchema(
+            "b",
+            b => b.AddQueryType<NestedLookups.SourceSchema2.Query>());
+
+        using var gateway = await CreateCompositeSchemaAsync(
+        [
+            ("a", server1),
+            ("b", server2)
+        ]);
+
+        // act
+        using var client = GraphQLHttpClient.Create(gateway.CreateClient());
+
+        var request = new OperationRequest(
+            """
+            {
+              books {
+                author {
+                  name
+                }
+              }
+            }
+            """);
+
+        using var result = await client.PostAsync(
+            request,
+            new Uri("http://localhost:5000/graphql"));
+
+        // assert
+        await MatchSnapshotAsync(gateway, request, result);
+    }
+
+    public static class NestedLookups
+    {
+        public static class SourceSchema1
+        {
+            public record Book(int Id, string Title, [property: Shareable] Author Author);
+
+            [EntityKey("id")]
+            public record Author(int Id);
+
+            public class Query
+            {
+                private readonly OrderedDictionary<int, Book> _books =
+                    new()
+                    {
+                        [1] = new Book(1, "C# in Depth", new Author(1)),
+                        [2] = new Book(2, "The Lord of the Rings", new Author(2)),
+                        [3] = new Book(3, "The Hobbit", new Author(2)),
+                        [4] = new Book(4, "The Silmarillion", new Author(2))
+                    };
+
+                public IEnumerable<Book> GetBooks()
+                    => _books.Values;
+            }
+        }
+
+        public static class SourceSchema2
+        {
+            public record Author(int Id, string Name);
+
+            public class Query
+            {
+                [Internal]
+                public InternalLookups Lookups { get; } = new();
+            }
+
+            [Internal]
+            public class InternalLookups
+            {
+                private readonly OrderedDictionary<int, Author> _authors = new()
+                {
+                    [1] = new Author(1, "Jon Skeet"),
+                    [2] = new Author(2, "JRR Tolkien")
+                };
+
+                [Lookup]
+                public Author GetAuthorById(int id)
+                    => _authors[id];
+            }
+
+            public record Book(int Id, [property: Shareable] Author Author)
+            {
+                public string IdAndTitle([Require] string title)
+                    => $"{Id} - {title}";
+            }
+        }
+    }
+}