[Fusion] Added post-merge validation rule "EmptyMergedUnionTypeRule" (#7979)

Author: danielreynolds1

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Events/SchemaEvents.cs

@@ -129,3 +129,7 @@ internal record SchemaEvent(SchemaDefinition Schema) : IEvent;
 internal record TypeEvent(
     INamedTypeDefinition Type,
     SchemaDefinition Schema) : IEvent;
+
+internal record UnionTypeEvent(
+    UnionTypeDefinition UnionType,
+    SchemaDefinition Schema) : IEvent;

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

@@ -5,6 +5,7 @@ public static class LogEntryCodes
     public const string DisallowedInaccessible = "DISALLOWED_INACCESSIBLE";
     public const string EmptyMergedEnumType = "EMPTY_MERGED_ENUM_TYPE";
     public const string EmptyMergedObjectType = "EMPTY_MERGED_OBJECT_TYPE";
+    public const string EmptyMergedUnionType = "EMPTY_MERGED_UNION_TYPE";
     public const string EnumValuesMismatch = "ENUM_VALUES_MISMATCH";
     public const string ExternalArgumentDefaultMismatch = "EXTERNAL_ARGUMENT_DEFAULT_MISMATCH";
     public const string ExternalMissingOnBase = "EXTERNAL_MISSING_ON_BASE";

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

@@ -126,6 +126,19 @@ public static LogEntry EmptyMergedObjectType(
             schema);
     }
 
+    public static LogEntry EmptyMergedUnionType(
+        UnionTypeDefinition unionType,
+        SchemaDefinition schema)
+    {
+        return new LogEntry(
+            string.Format(LogEntryHelper_EmptyMergedUnionType, unionType.Name),
+            LogEntryCodes.EmptyMergedUnionType,
+            LogSeverity.Error,
+            new SchemaCoordinate(unionType.Name),
+            unionType,
+            schema);
+    }
+
     public static LogEntry EnumValuesMismatch(
         EnumTypeDefinition enumType,
         string enumValue,

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PostMergeValidationRules/EmptyMergedUnionTypeRule.cs

@@ -0,0 +1,32 @@
+using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Events.Contracts;
+using HotChocolate.Fusion.Extensions;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+
+namespace HotChocolate.Fusion.PostMergeValidationRules;
+
+/// <summary>
+/// TODO: Summary
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Empty-Merged-Union-Type">
+/// Specification
+/// </seealso>
+internal sealed class EmptyMergedUnionTypeRule : IEventHandler<UnionTypeEvent>
+{
+    public void Handle(UnionTypeEvent @event, CompositionContext context)
+    {
+        var (unionType, schema) = @event;
+
+        if (unionType.HasInaccessibleDirective())
+        {
+            return;
+        }
+
+        var accessibleTypes = unionType.Types.Where(t => !t.HasInaccessibleDirective());
+
+        if (!accessibleTypes.Any())
+        {
+            context.Log.Write(EmptyMergedUnionType(unionType, schema));
+        }
+    }
+}

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

@@ -54,6 +54,10 @@ private void PublishEvents()
                 case ObjectTypeDefinition objectType:
                     PublishEvent(new ObjectTypeEvent(objectType, mergedSchema), context);
                     break;
+
+                case UnionTypeDefinition unionType:
+                    PublishEvent(new UnionTypeEvent(unionType, mergedSchema), context);
+                    break;
             }
 
             if (type is ComplexTypeDefinition complexType)

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

@@ -51,6 +51,9 @@
   <data name="LogEntryHelper_EmptyMergedObjectType" xml:space="preserve">
     <value>The merged object type '{0}' is empty.</value>
   </data>
+  <data name="LogEntryHelper_EmptyMergedUnionType" xml:space="preserve">
+    <value>The merged union type '{0}' is empty.</value>
+  </data>
   <data name="LogEntryHelper_EnumValuesMismatch" xml:space="preserve">
     <value>The enum type '{0}' in schema '{1}' must define the value '{2}'.</value>
   </data>

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

@@ -121,6 +121,7 @@ public CompositionResult<SchemaDefinition> Compose()
     private static readonly ImmutableArray<object> s_postMergeRules =
     [
         new EmptyMergedEnumTypeRule(),
-        new EmptyMergedObjectTypeRule()
+        new EmptyMergedObjectTypeRule(),
+        new EmptyMergedUnionTypeRule()
     ];
 }

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

@@ -0,0 +1,145 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Logging;
+
+namespace HotChocolate.Fusion.PostMergeValidationRules;
+
+public sealed class EmptyMergedUnionTypeRuleTests : CompositionTestBase
+{
+    private static readonly object s_rule = new EmptyMergedUnionTypeRule();
+    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 merger = new SourceSchemaMerger(schemas);
+        var mergeResult = merger.Merge();
+        var validator = new PostMergeValidator(mergeResult.Value, s_rules, schemas, _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 merger = new SourceSchemaMerger(schemas);
+        var mergeResult = merger.Merge();
+        var validator = new PostMergeValidator(mergeResult.Value, s_rules, schemas, _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 == "EMPTY_MERGED_UNION_TYPE"));
+        Assert.True(_log.All(e => e.Severity == LogSeverity.Error));
+    }
+
+    public static TheoryData<string[]> ValidExamplesData()
+    {
+        return new TheoryData<string[]>
+        {
+            // TODO: Use examples from spec
+            {
+                [
+                    """
+                    # Schema A
+                    type A {
+                        name: String
+                    }
+
+                    type B {
+                        id: Int!
+                    }
+
+                    union C = A | B
+                    """,
+                    """
+                    # Schema B
+                    type A {
+                        name: String
+                    }
+
+                    union C = A
+                    """
+                ]
+            },
+            // If the @inaccessible directive is applied to a union type itself, the entire merged
+            // union type is excluded from the composite schema, and it is not required to contain
+            // any types.
+            {
+                [
+                    """
+                    # Schema A
+                    type A {
+                        name: String
+                    }
+
+                    type B {
+                        id: Int!
+                    }
+
+                    union C @inaccessible = A | B
+                    """,
+                    """
+                    # Schema B
+                    type A {
+                        name: String
+                    }
+
+                    union C = A
+                    """
+                ]
+            }
+        };
+    }
+
+    public static TheoryData<string[], string[]> InvalidExamplesData()
+    {
+        return new TheoryData<string[], string[]>
+        {
+            // This example demonstrates an invalid merged union type. In this case, "C" is defined
+            // in two source schemas, but all member types are marked as @inaccessible in at least
+            // one of the source schemas, resulting in an empty merged union type.
+            {
+                [
+                    """
+                    # Schema A
+                    type A {
+                        name: String
+                    }
+
+                    type B @inaccessible {
+                        id: Int!
+                    }
+
+                    union C = A | B
+                    """,
+                    """
+                    # Schema B
+                    type A @inaccessible {
+                        name: String
+                    }
+
+                    union C = A
+                    """
+                ],
+                [
+                    "The merged union type 'C' is empty."
+                ]
+            }
+        };
+    }
+}