[Fusion] Support fulfilling lookups through shared path (#8667)

Author: tobias-tengler

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Satisfiability/RequirementsValidator.cs

@@ -287,7 +287,7 @@ private ImmutableArray<SatisfiabilityError> ValidateSourceSchemaTransition(
         var lookupDirectives =
             schema.GetPossibleFusionLookupDirectives(type, transitionToSchemaName);
 
-        if (!lookupDirectives.Any() && !HasPathInSchema(context.Path, transitionToSchemaName))
+        if (!lookupDirectives.Any() && !CanTransitionToSchemaThroughPath(context.Path, transitionToSchemaName))
         {
             errors.Add(
                 new SatisfiabilityError(
@@ -339,13 +339,31 @@ private ImmutableArray<SatisfiabilityError> ValidateSourceSchemaTransition(
         return [.. errors];
     }
 
-    private bool HasPathInSchema(SatisfiabilityPath path, string schemaName)
+    /// <summary>
+    /// We check whether the path we're currently on exists one-to-one
+    /// on the given schema or whether a type on the path has a lookup
+    /// on the given schema.
+    /// </summary>
+    private bool CanTransitionToSchemaThroughPath(
+        SatisfiabilityPath path,
+        string schemaName)
     {
-        var stack = new Stack<SatisfiabilityPathItem>(path);
-
-        while (stack.TryPop(out var item))
+        foreach (var pathItem in path)
         {
-            if (!item.Field.ExistsInSchema(schemaName))
+            var lookupDirectives =
+                schema.GetPossibleFusionLookupDirectives(
+                    pathItem.Type,
+                    schemaName);
+
+            var hasLookups = lookupDirectives.Count > 0;
+            var fieldExists = pathItem.Field.ExistsInSchema(schemaName);
+
+            if (hasLookups && fieldExists)
+            {
+                return true;
+            }
+
+            if (!fieldExists)
             {
                 return false;
             }

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/SatisfiabilityValidator.cs

@@ -278,7 +278,7 @@ private ImmutableArray<SatisfiabilityError> ValidateSourceSchemaTransition(
         var lookupDirectives =
             schema.GetPossibleFusionLookupDirectives(type, transitionToSchemaName);
 
-        if (!lookupDirectives.Any() && !HasPathInSchema(context.Path, transitionToSchemaName))
+        if (!lookupDirectives.Any() && !CanTransitionToSchemaThroughPath(context.Path, transitionToSchemaName))
         {
             errors.Add(
                 new SatisfiabilityError(
@@ -329,15 +329,31 @@ private ImmutableArray<SatisfiabilityError> ValidateSourceSchemaTransition(
         return [.. errors];
     }
 
-    private bool HasPathInSchema(
+    /// <summary>
+    /// We check whether the path we're currently on exists one-to-one
+    /// on the given schema or whether a type on the path has a lookup
+    /// on the given schema.
+    /// </summary>
+    private bool CanTransitionToSchemaThroughPath(
         SatisfiabilityPath path,
         string schemaName)
     {
-        var stack = new Stack<SatisfiabilityPathItem>(path);
-
-        while (stack.TryPop(out var item))
+        foreach (var pathItem in path)
         {
-            if (!item.Field.ExistsInSchema(schemaName))
+            var lookupDirectives =
+                schema.GetPossibleFusionLookupDirectives(
+                    pathItem.Type,
+                    schemaName);
+
+            var hasLookups = lookupDirectives.Count > 0;
+            var fieldExists = pathItem.Field.ExistsInSchema(schemaName);
+
+            if (hasLookups && fieldExists)
+            {
+                return true;
+            }
+
+            if (!fieldExists)
             {
                 return false;
             }

src/HotChocolate/Fusion-vnext/src/Fusion.Execution.Types/Extensions/CompositeTypeExtensions.cs

@@ -5,7 +5,7 @@ namespace HotChocolate.Fusion.Types;
 /// <summary>
 /// Provides extension methods for <see cref="ISchemaDefinition"/>.
 /// </summary>
-public static class FusionSchemaDefinitionExtensions
+internal static class FusionSchemaDefinitionExtensions
 {
     internal static SchemaEnvironment? TryGetEnvironment(this ISchemaDefinition schema)
         => schema.Features.Get<SchemaEnvironment>();

src/HotChocolate/Fusion-vnext/src/Fusion.Execution.Types/Extensions/FusionSchemaDefinitionExtensions.cs

@@ -0,0 +1,17 @@
+using HotChocolate.Types;
+
+namespace HotChocolate.Fusion.Types;
+
+internal static class TypeDefinitionExtensions
+{
+    public static bool ExistsInSchema(this ITypeDefinition type, string schemaName)
+    {
+        return type switch
+        {
+            FusionObjectTypeDefinition objectType => objectType.Sources.ContainsSchema(schemaName),
+            FusionInterfaceTypeDefinition interfaceType => interfaceType.Sources.ContainsSchema(schemaName),
+            FusionUnionTypeDefinition unionType => unionType.Sources.ContainsSchema(schemaName),
+            _ => false
+        };
+    }
+}

src/HotChocolate/Fusion-vnext/src/Fusion.Execution.Types/Extensions/TypeDefinitionExtensions.cs

@@ -10,7 +10,7 @@ namespace HotChocolate.Fusion.Types.Metadata;
 /// <summary>
 /// Represents a lookup field in a source schema.
 /// </summary>
-[DebuggerDisplay("{FieldName}:{FieldType} ({SchemaName})")]
+[DebuggerDisplay("{FieldName}:{FieldType.Name} ({SchemaName})")]
 public sealed class Lookup : INeedsCompletion
 {
     private readonly string _declaringTypeName;

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

@@ -166,6 +166,20 @@ public static SelectionPath Parse(string s)
         return new SelectionPath(builder.ToImmutable());
     }
 
+    /// <summary>
+    /// Constructs <see cref="SelectionPath"/> from the given <paramref name="segments"/>.
+    /// </summary>
+    /// <param name="segments">
+    /// The segments to initialize the <see cref="SelectionPath"/> with.
+    /// </param>
+    /// <returns>
+    /// A new <see cref="SelectionPath"/> initialized with the <paramref name="segments"/>.
+    /// </returns>
+    public static SelectionPath From(ImmutableArray<Segment> segments)
+    {
+        return new SelectionPath(segments);
+    }
+
     /// <summary>
     /// Returns the portion of this path that comes <em>after</em> <paramref name="basePath"/>.
     /// </summary>

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Execution/Nodes/SelectionPath.cs

@@ -220,16 +220,23 @@ internal void AddPartialResults(
         ReadOnlySpan<SourceSchemaResult> results,
         ReadOnlySpan<string> responseNames)
     {
-       var canExecutionContinue = _resultStore.AddPartialResults(sourcePath, results, responseNames);
+        var canExecutionContinue = _resultStore.AddPartialResults(sourcePath, results, responseNames);
 
-       if (!canExecutionContinue)
-       {
-           ExecutionState.CancelProcessing();
-       }
+        if (!canExecutionContinue)
+        {
+            ExecutionState.CancelProcessing();
+        }
     }
 
     internal void AddPartialResults(ObjectResult result, ReadOnlySpan<Selection> selections)
-        => _resultStore.AddPartialResults(result, selections);
+    {
+        var canExecutionContinue = _resultStore.AddPartialResults(result, selections);
+
+        if (!canExecutionContinue)
+        {
+            ExecutionState.CancelProcessing();
+        }
+    }
 
     internal void AddErrors(IError error, ReadOnlySpan<string> responseNames, params ReadOnlySpan<Path> paths)
     {

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Execution/OperationPlanContext.cs

@@ -122,7 +122,7 @@ public bool AddPartialResults(
         }
     }
 
-    public void AddPartialResults(ObjectResult result, ReadOnlySpan<Selection> selections)
+    public bool AddPartialResults(ObjectResult result, ReadOnlySpan<Selection> selections)
     {
         ObjectDisposedException.ThrowIf(_disposed, this);
         ArgumentNullException.ThrowIfNull(result);
@@ -145,8 +145,15 @@ public void AddPartialResults(ObjectResult result, ReadOnlySpan<Selection> selec
                     continue;
                 }
 
+                if (_root.IsInvalidated)
+                {
+                    return false;
+                }
+
                 result.MoveFieldTo(selection.ResponseName, _root);
             }
+
+            return true;
         }
         finally
         {

src/HotChocolate/Fusion-vnext/src/Fusion.Execution/Execution/Results/FetchResultStore.cs

@@ -366,13 +366,24 @@ private bool TryCompleteObjectValue(
 
         var operation = selection.DeclaringSelectionSet.DeclaringOperation;
         var selectionSet = operation.GetSelectionSet(selection, objectType);
-        var objectResult = _resultPoolSession.RentObjectResult();
 
-        objectResult.Initialize(_resultPoolSession, selectionSet, _includeFlags);
+        ObjectResult objectResult;
+        // In the case of shared paths, an object result might have already been initialized
+        // by another operation node, so we reuse it.
+        if (parent is ObjectFieldResult { Value: { } existingObjectResult })
+        {
+            objectResult = existingObjectResult;
+        }
+        else
+        {
+            objectResult = _resultPoolSession.RentObjectResult();
 
-        // we set the value early so that in the error case we can correctly
-        // traverse along the parent path and propagate errors.
-        parent.SetNextValue(objectResult);
+            objectResult.Initialize(_resultPoolSession, selectionSet, _includeFlags);
+
+            // we set the value early so that in the error case we can correctly
+            // traverse along the parent path and propagate errors.
+            parent.SetNextValue(objectResult);
+        }
 
         foreach (var property in data.EnumerateObject())
         {