[Fusion] Added pre-merge validation rule "TypeKindMismatchRule" (#7965)

Author: glen-84

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Logging/LogEntryCodes.cs

@@ -37,4 +37,5 @@ public static class LogEntryCodes
     public const string RootMutationUsed = "ROOT_MUTATION_USED";
     public const string RootQueryUsed = "ROOT_QUERY_USED";
     public const string RootSubscriptionUsed = "ROOT_SUBSCRIPTION_USED";
+    public const string TypeKindMismatch = "TYPE_KIND_MISMATCH";
 }

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Logging/LogEntryHelper.cs

@@ -700,4 +700,26 @@ public static LogEntry RootSubscriptionUsed(SchemaDefinition schema)
             member: schema,
             schema: schema);
     }
+
+    public static LogEntry TypeKindMismatch(
+        INamedTypeDefinition type,
+        SchemaDefinition schemaA,
+        string typeKindA,
+        SchemaDefinition schemaB,
+        string typeKindB)
+    {
+        return new LogEntry(
+            string.Format(
+                LogEntryHelper_TypeKindMismatch,
+                type.Name,
+                schemaA.Name,
+                typeKindA,
+                schemaB.Name,
+                typeKindB),
+            LogEntryCodes.TypeKindMismatch,
+            LogSeverity.Error,
+            new SchemaCoordinate(type.Name),
+            type,
+            schemaA);
+    }
 }

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/TypeKindMismatchRule.cs

@@ -0,0 +1,47 @@
+using HotChocolate.Fusion.Events;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+
+namespace HotChocolate.Fusion.PreMergeValidation.Rules;
+
+/// <summary>
+/// <para>
+/// Each named type must represent the <b>same</b> kind of GraphQL type across all source schemas.
+/// For instance, a type named <c>User</c> must consistently be an object type, or consistently be
+/// an interface, and so forth. If one schema defines <c>User</c> as an object type, while another
+/// schema declares <c>User</c> as an interface (or input object, union, etc.), the schema
+/// composition process cannot merge these definitions coherently.
+/// </para>
+/// <para>
+/// This rule ensures semantic consistency: a single type name cannot serve multiple, incompatible
+/// purposes in the final composed schema.
+/// </para>
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Type-Kind-Mismatch">
+/// Specification
+/// </seealso>
+internal sealed class TypeKindMismatchRule : IEventHandler<TypeGroupEvent>
+{
+    public void Handle(TypeGroupEvent @event, CompositionContext context)
+    {
+        var (_, typeGroup) = @event;
+
+        for (var i = 0; i < typeGroup.Length - 1; i++)
+        {
+            var typeInfoA = typeGroup[i];
+            var typeInfoB = typeGroup[i + 1];
+            var typeKindA = typeInfoA.Type.Kind;
+            var typeKindB = typeInfoB.Type.Kind;
+
+            if (typeKindA != typeKindB)
+            {
+                context.Log.Write(
+                    TypeKindMismatch(
+                        typeInfoA.Type,
+                        typeInfoA.Schema,
+                        typeKindA.ToString(),
+                        typeInfoB.Schema,
+                        typeKindB.ToString()));
+            }
+        }
+    }
+}

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Properties/CompositionResources.Designer.cs

@@ -144,4 +144,7 @@
   <data name="LogEntryHelper_RootSubscriptionUsed" xml:space="preserve">
     <value>The root subscription type in schema '{0}' must be named 'Subscription'.</value>
   </data>
+  <data name="LogEntryHelper_TypeKindMismatch" xml:space="preserve">
+    <value>The type '{0}' has a different kind in schema '{1}' ({2}) than it does in schema '{3}' ({4}).</value>
+  </data>
 </root>

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Properties/CompositionResources.resx

@@ -112,7 +112,8 @@ public CompositionResult<SchemaDefinition> Compose()
         new InputFieldDefaultMismatchRule(),
         new InputFieldTypesMergeableRule(),
         new InputWithMissingRequiredFieldsRule(),
-        new OutputFieldTypesMergeableRule()
+        new OutputFieldTypesMergeableRule(),
+        new TypeKindMismatchRule()
     ];
 
     private static readonly ImmutableArray<object> s_postMergeValidationRules = [];

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

@@ -0,0 +1,112 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Logging;
+
+namespace HotChocolate.Fusion.PreMergeValidation.Rules;
+
+public sealed class TypeKindMismatchRuleTests : CompositionTestBase
+{
+    private static readonly object s_rule = new TypeKindMismatchRule();
+    private static readonly ImmutableArray<object> s_rules = [s_rule];
+    private readonly CompositionLog _log = new();
+
+    [Theory]
+    [MemberData(nameof(ValidExamplesData))]
+    public void Examples_Valid(string[] sdl)
+    {
+        // arrange
+        var schemas = CreateSchemaDefinitions(sdl);
+        var validator = new PreMergeValidator(schemas, s_rules, _log);
+
+        // act
+        var result = validator.Validate();
+
+        // assert
+        Assert.True(result.IsSuccess);
+        Assert.True(_log.IsEmpty);
+    }
+
+    [Theory]
+    [MemberData(nameof(InvalidExamplesData))]
+    public void Examples_Invalid(string[] sdl, string[] errorMessages)
+    {
+        // arrange
+        var schemas = CreateSchemaDefinitions(sdl);
+        var validator = new PreMergeValidator(schemas, s_rules, _log);
+
+        // act
+        var result = validator.Validate();
+
+        // assert
+        Assert.True(result.IsFailure);
+        Assert.Equal(errorMessages, _log.Select(e => e.Message).ToArray());
+        Assert.True(_log.All(e => e.Code == "TYPE_KIND_MISMATCH"));
+        Assert.True(_log.All(e => e.Severity == LogSeverity.Error));
+    }
+
+    public static TheoryData<string[]> ValidExamplesData()
+    {
+        return new TheoryData<string[]>
+        {
+            // All schemas agree that "User" is an object type.
+            {
+                [
+                    """
+                    # Schema A
+                    type User {
+                        id: ID!
+                        name: String
+                    }
+                    """,
+                    """
+                    # Schema B
+                    type User {
+                        id: ID!
+                        email: String
+                    }
+                    """
+                ]
+            }
+        };
+    }
+
+    public static TheoryData<string[], string[]> InvalidExamplesData()
+    {
+        return new TheoryData<string[], string[]>
+        {
+            // In the following example, "User" is defined as an object type in Schema A, an
+            // interface type in Schema B, and an input object type in Schema C. This violates the
+            // rule.
+            {
+                [
+                    """
+                    # Schema A
+                    type User {
+                        id: ID!
+                        name: String
+                    }
+                    """,
+                    """
+                    # Schema B
+                    interface User {
+                        id: ID!
+                        friends: [User!]!
+                    }
+                    """,
+                    """
+                    # Schema C
+                    input User {
+                        id: ID!
+                    }
+                    """
+                ],
+                [
+                    "The type 'User' has a different kind in schema 'A' (Object) than it does in " +
+                    "schema 'B' (Interface).",
+
+                    "The type 'User' has a different kind in schema 'B' (Interface) than it does " +
+                    "in schema 'C' (InputObject)."
+                ]
+            }
+        };
+    }
+}