[Fusion] Add InterfaceObject support (#10079)

Author: michaelstaib

src/All.slnx

@@ -229,6 +229,7 @@
     <Project Path="HotChocolate/Fusion/src/Fusion.SourceSchema.Packaging/HotChocolate.Fusion.SourceSchema.Packaging.csproj" />
   </Folder>
   <Folder Name="/HotChocolate/Fusion/test/">
+    <Project Path="HotChocolate/Fusion/test/Fusion.Aspire.Tests/HotChocolate.Fusion.Aspire.Tests.csproj" />
     <Project Path="HotChocolate/Fusion/test/Fusion.AspNetCore.Tests/HotChocolate.Fusion.AspNetCore.Tests.csproj" />
     <Project Path="HotChocolate/Fusion/test/Fusion.Composition.Tests/HotChocolate.Fusion.Composition.Tests.csproj" />
     <Project Path="HotChocolate/Fusion/test/Fusion.Composition.ApolloFederation.Tests/HotChocolate.Fusion.Composition.ApolloFederation.Tests.csproj" />

src/HotChocolate/Core/src/Execution.Operation.Abstractions/ISelectionSet.cs

@@ -35,9 +35,13 @@ public interface ISelectionSet
     bool HasIncrementalParts { get; }
 
     /// <summary>
-    /// Gets the type that declares this selection set.
+    /// Gets the complex type that declares this selection set.
     /// </summary>
-    IObjectTypeDefinition Type { get; }
+    /// <remarks>
+    /// This is typically an object type. It can be an interface type when the concrete runtime
+    /// type of a selection set is not yet known.
+    /// </remarks>
+    IComplexTypeDefinition Type { get; }
 
     /// <summary>
     /// Gets the selections that shall be executed.

src/HotChocolate/Core/src/Types/Execution/Processing/SelectionSet.cs

@@ -67,6 +67,8 @@ internal SelectionSet(
     /// </summary>
     public IObjectTypeDefinition Type { get; }
 
+    IComplexTypeDefinition ISelectionSet.Type => Type;
+
     /// <summary>
     /// Gets the declaring operation.
     /// </summary>

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

@@ -0,0 +1,39 @@
+namespace HotChocolate.Types.Composite;
+
+/// <summary>
+/// <para>
+/// The @external directive indicates that a field is recognized by the current source schema but is
+/// not directly contributed (resolved) by it. Instead, the source schema references the field for
+/// specific composition purposes, for example as part of a @requires selection.
+/// </para>
+/// <para>
+/// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--external"/>
+/// </para>
+/// <code>
+/// type User @key(fields: "id") {
+///   id: ID!
+///   name: String! @external
+///   username: String! @requires(fields: "name")
+/// }
+///
+/// directive @external on FIELD_DEFINITION
+/// </code>
+/// </summary>
+[DirectiveType(
+    DirectiveNames.External.Name,
+    DirectiveLocation.FieldDefinition,
+    IsRepeatable = false)]
+public sealed class External
+{
+    private External()
+    {
+    }
+
+    /// <inheritdoc />
+    public override string ToString() => "@external";
+
+    /// <summary>
+    /// The singleton instance of the <see cref="External"/> directive.
+    /// </summary>
+    public static External Instance { get; } = new();
+}

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

@@ -0,0 +1,39 @@
+namespace HotChocolate.Types.Composite;
+
+/// <summary>
+/// <para>
+/// The @implement directive marks a field as an explicit implementation that intentionally replaces
+/// a default field implementation contributed to an interface by an @interfaceObject stand-in. It is
+/// required on an implementing type's field, or on a more specific interface's own stand-in field,
+/// that collides with an applicable default.
+/// </para>
+/// <para>
+/// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--implement"/>
+/// </para>
+/// <code>
+/// type Chair implements Product {
+///   id: ID!
+///   taxRate: Float! @implement
+/// }
+///
+/// directive @implement on FIELD_DEFINITION
+/// </code>
+/// </summary>
+[DirectiveType(
+    DirectiveNames.Implement.Name,
+    DirectiveLocation.FieldDefinition,
+    IsRepeatable = false)]
+public sealed class Implement
+{
+    private Implement()
+    {
+    }
+
+    /// <inheritdoc />
+    public override string ToString() => "@implement";
+
+    /// <summary>
+    /// The singleton instance of the <see cref="Implement"/> directive.
+    /// </summary>
+    public static Implement Instance { get; } = new();
+}

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

@@ -0,0 +1,39 @@
+namespace HotChocolate.Types.Composite;
+
+/// <summary>
+/// <para>
+/// The @interfaceObject directive is used within a source schema to declare an object type that
+/// acts as a stand-in for an interface defined in another source schema. The stand-in carries the
+/// same name as the interface and allows a source schema to contribute fields to that interface
+/// without defining any of its implementing types.
+/// </para>
+/// <para>
+/// <see href="https://graphql.github.io/composite-schemas-spec/draft/#sec--interfaceObject"/>
+/// </para>
+/// <code>
+/// type Media @interfaceObject @key(fields: "id") {
+///   id: ID!
+///   reviews: [Review!]!
+/// }
+///
+/// directive @interfaceObject on OBJECT
+/// </code>
+/// </summary>
+[DirectiveType(
+    DirectiveNames.InterfaceObject.Name,
+    DirectiveLocation.Object,
+    IsRepeatable = false)]
+public sealed class InterfaceObject
+{
+    private InterfaceObject()
+    {
+    }
+
+    /// <inheritdoc />
+    public override string ToString() => "@interfaceObject";
+
+    /// <summary>
+    /// The singleton instance of the <see cref="InterfaceObject"/> directive.
+    /// </summary>
+    public static InterfaceObject Instance { get; } = new();
+}

src/HotChocolate/Core/test/Execution.Tests/Processing/OperationCompilerTests.cs

@@ -34,6 +34,33 @@ public void Prepare_One_Field()
         MatchSnapshot(document, operation);
     }
 
+    [Fact]
+    public void Compile_Should_ExposeObjectSelectionSetThroughPublicContract()
+    {
+        // arrange
+        var schema = SchemaBuilder.New()
+            .AddQueryType(
+                c => c
+                    .Name("Query")
+                    .Field("foo")
+                    .Type<StringType>()
+                    .Resolve("foo"))
+            .Create();
+        var document = Utf8GraphQLParser.Parse("{ foo }");
+
+        // act
+        var operation = OperationCompiler.Compile("opid", document, schema);
+        ISelectionSet selectionSet = operation.RootSelectionSet;
+
+        // assert
+        Assert.Equal("Query", selectionSet.Type.Name);
+        Assert.IsAssignableFrom<IObjectTypeDefinition>(selectionSet.Type);
+
+        var selection = Assert.Single(selectionSet.GetSelections());
+        Assert.Equal("Query", selection.DeclaringSelectionSet.Type.Name);
+        Assert.IsAssignableFrom<IObjectTypeDefinition>(selection.DeclaringSelectionSet.Type);
+    }
+
     [Fact]
     public void Prepare_Duplicate_Field()
     {

src/HotChocolate/Fusion/HotChocolate.Fusion.slnx

@@ -23,6 +23,7 @@
     <Project Path="src/Fusion.Utilities/HotChocolate.Fusion.Utilities.csproj" />
   </Folder>
   <Folder Name="/test/">
+    <Project Path="test/Fusion.Aspire.Tests/HotChocolate.Fusion.Aspire.Tests.csproj" />
     <Project Path="test/Fusion.AspNetCore.Tests/HotChocolate.Fusion.AspNetCore.Tests.csproj" />
     <Project Path="test/Fusion.Composition.Tests/HotChocolate.Fusion.Composition.Tests.csproj" />
     <Project Path="test/Fusion.Composition.ApolloFederation.Tests/HotChocolate.Fusion.Composition.ApolloFederation.Tests.csproj" />

src/HotChocolate/Fusion/src/Fusion.Aspire/AspireCompositionHelper.cs

@@ -21,12 +21,7 @@ public static async Task<bool> TryComposeAsync(
 
         var compositionLog = new CompositionLog();
         var environment = settings.EnvironmentName ?? "Aspire";
-        var compositionSettings = new CompositionSettings
-        {
-            Merger = { EnableGlobalObjectIdentification = settings.EnableGlobalObjectIdentification },
-            Satisfiability = { IncludeSatisfiabilityPaths = settings.IncludeSatisfiabilityPaths },
-            Preprocessor = { ExcludeByTag = settings.ExcludeByTag?.ToHashSet() }
-        };
+        var compositionSettings = CreateCompositionSettings(settings);
         var sourceSchemas = newSourceSchemas.ToDictionary(
             s => s.Name,
             s => (s.Schema, s.SchemaSettings));
@@ -67,6 +62,26 @@ public static async Task<bool> TryComposeAsync(
         return true;
     }
 
+    internal static CompositionSettings CreateCompositionSettings(
+        GraphQLCompositionSettings settings)
+    {
+        return new CompositionSettings
+        {
+            Merger =
+            {
+                EnableGlobalObjectIdentification = settings.EnableGlobalObjectIdentification,
+                NodeResolution = settings.NodeResolution
+            },
+            Satisfiability = { IncludeSatisfiabilityPaths = settings.IncludeSatisfiabilityPaths },
+            ApolloFederationCompatibility =
+            {
+                AllowNonResolvableInterfaceObjects = settings.AllowNonResolvableInterfaceObjects,
+                ShareableFieldRuntimeTypeRouting = settings.ShareableFieldRuntimeTypeRouting
+            },
+            Preprocessor = { ExcludeByTag = settings.ExcludeByTag?.ToHashSet() }
+        };
+    }
+
     /// <summary>
     /// Since we're prefixing the message with an emoji and space before printing,
     /// we need to also indent each line of a multiline message by three spaces to fix the alignment.

src/HotChocolate/Fusion/src/Fusion.Aspire/GraphQLCompositionSettings.cs

@@ -10,12 +10,29 @@ public struct GraphQLCompositionSettings
     /// </summary>
     public bool? EnableGlobalObjectIdentification { get; set; }
 
+    /// <summary>
+    /// Gets or sets how the gateway resolves the <c>Query.node</c> field.
+    /// </summary>
+    public NodeResolution? NodeResolution { get; set; }
+
     /// <summary>
     /// Gets or sets a value indicating whether satisfiability paths should be included in the
     /// composed schema.
     /// </summary>
     public bool? IncludeSatisfiabilityPaths { get; set; }
 
+    /// <summary>
+    /// Gets or sets whether Apollo Federation non-resolvable interface objects are accepted and
+    /// unresolved projected fields are reported as field errors at runtime.
+    /// </summary>
+    public bool? AllowNonResolvableInterfaceObjects { get; set; }
+
+    /// <summary>
+    /// Gets or sets how runtime types are routed for Apollo Federation shareable fields whose
+    /// result type is abstract.
+    /// </summary>
+    public ShareableFieldRuntimeTypeRouting? ShareableFieldRuntimeTypeRouting { get; set; }
+
     /// <summary>
     /// Gets or sets the set of tags whose annotated schema elements shall be excluded from
     /// composition.