[Fusion] Added source schema validation rule "ExternalRequireCollisionRule" (#8787)

Author: glen-84

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

@@ -15,6 +15,7 @@ public static class LogEntryCodes
     public const string ExternalOnInterface = "EXTERNAL_ON_INTERFACE";
     public const string ExternalOverrideCollision = "EXTERNAL_OVERRIDE_COLLISION";
     public const string ExternalProvidesCollision = "EXTERNAL_PROVIDES_COLLISION";
+    public const string ExternalRequireCollision = "EXTERNAL_REQUIRE_COLLISION";
     public const string ExternalUnused = "EXTERNAL_UNUSED";
     public const string FieldArgumentTypesNotMergeable = "FIELD_ARGUMENT_TYPES_NOT_MERGEABLE";
     public const string FieldWithMissingRequiredArgument = "FIELD_WITH_MISSING_REQUIRED_ARGUMENT";

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

@@ -292,6 +292,22 @@ public static LogEntry ExternalProvidesCollision(
             schema);
     }
 
+    public static LogEntry ExternalRequireCollision(
+        MutableOutputFieldDefinition externalField,
+        ITypeDefinition type,
+        MutableSchemaDefinition schema)
+    {
+        var coordinate = new SchemaCoordinate(type.Name, externalField.Name);
+
+        return new LogEntry(
+            string.Format(LogEntryHelper_ExternalRequireCollision, coordinate, schema.Name),
+            LogEntryCodes.ExternalRequireCollision,
+            LogSeverity.Error,
+            coordinate,
+            externalField,
+            schema);
+    }
+
     public static LogEntry ExternalUnused(
         MutableOutputFieldDefinition externalField,
         ITypeDefinition type,

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

@@ -219,6 +219,9 @@
   <data name="LogEntryHelper_ExternalProvidesCollision" xml:space="preserve">
     <value>The external field '{0}' in schema '{1}' must not be annotated with the @provides directive.</value>
   </data>
+  <data name="LogEntryHelper_ExternalRequireCollision" xml:space="preserve">
+    <value>The external field '{0}' in schema '{1}' must not have arguments that are annotated with the @require directive.</value>
+  </data>
   <data name="LogEntryHelper_ExternalUnused" xml:space="preserve">
     <value>The external field '{0}' in schema '{1}' is not referenced by a @provides directive in the schema.</value>
   </data>

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

@@ -116,6 +116,7 @@ public CompositionResult<MutableSchemaDefinition> Compose()
         new ExternalOnInterfaceRule(),
         new ExternalOverrideCollisionRule(),
         new ExternalProvidesCollisionRule(),
+        new ExternalRequireCollisionRule(),
         new ExternalUnusedRule(),
         new InvalidShareableUsageRule(),
         new IsInvalidFieldTypeRule(),

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

@@ -0,0 +1,31 @@
+using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Events.Contracts;
+using HotChocolate.Fusion.Extensions;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+
+namespace HotChocolate.Fusion.SourceSchemaValidationRules;
+
+/// <summary>
+/// The <c>@external</c> directive indicates that a field is <b>defined</b> in a different source
+/// schema, and the current schema merely references it. Therefore, a field marked with
+/// <c>@external</c> must <b>not</b> simultaneously carry directives that assume local ownership or
+/// resolution responsibility, such as <c>@require</c>, which specifies dependencies on other fields
+/// to resolve this field. Since <c>@external</c> fields are not locally resolved, there is no need
+/// for <c>@require</c>.
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-External-Require-Collision">
+/// Specification
+/// </seealso>
+internal sealed class ExternalRequireCollisionRule : IEventHandler<OutputFieldEvent>
+{
+    public void Handle(OutputFieldEvent @event, CompositionContext context)
+    {
+        var (field, type, schema) = @event;
+
+        if (field.HasExternalDirective()
+            && field.Arguments.AsEnumerable().Any(a => a.HasRequireDirective()))
+        {
+            context.Log.Write(ExternalRequireCollision(field, type, schema));
+        }
+    }
+}

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/SourceSchemaValidationRules/ExternalRequireCollisionRule.cs

@@ -48,23 +48,22 @@ public static TheoryData<string[]> ValidExamplesData()
     {
         return new TheoryData<string[]>
         {
-            // In this example, "method" is only annotated with @external in Schema B, without any
-            // other directive. This usage is valid.
+            // In this example, "description" is only annotated with @provides in Schema B, without
+            // any other directive. This usage is valid.
             {
                 [
                     """
                     # Source Schema A
-                    type Payment {
+                    type Invoice {
                         id: ID!
-                        method: String
+                        description: String
                     }
                     """,
                     """
                     # Source Schema B
-                    type Payment {
+                    type Invoice {
                         id: ID!
-                        # This field is external, defined in Schema A.
-                        method: String @external
+                        description: String @provides(fields: "length")
                     }
                     """
                 ]

src/HotChocolate/Fusion-vnext/test/Fusion.Composition.Tests/SourceSchemaValidationRules/ExternalProvidesCollisionRuleTests.cs

@@ -0,0 +1,107 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Logging;
+using static HotChocolate.Fusion.CompositionTestHelper;
+
+namespace HotChocolate.Fusion.SourceSchemaValidationRules;
+
+public sealed class ExternalRequireCollisionRuleTests
+{
+    private static readonly object s_rule = new ExternalRequireCollisionRule();
+    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 SourceSchemaValidator(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 SourceSchemaValidator(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 == "EXTERNAL_REQUIRE_COLLISION"));
+        Assert.True(_log.All(e => e.Severity == LogSeverity.Error));
+    }
+
+    public static TheoryData<string[]> ValidExamplesData()
+    {
+        return new TheoryData<string[]>
+        {
+            // In this example, "title" has arguments annotated with @require in Schema B, but is
+            // not marked as @external. This usage is valid.
+            {
+                [
+                    """
+                    # Source Schema A
+                    type Book {
+                        id: ID!
+                        title: String
+                        subtitle: String
+                    }
+                    """,
+                    """
+                    # Source Schema B
+                    type Book {
+                        id: ID!
+                        title(subtitle: String @require(field: "subtitle")): String
+                    }
+                    """
+                ]
+            }
+        };
+    }
+
+    public static TheoryData<string[], string[]> InvalidExamplesData()
+    {
+        return new TheoryData<string[], string[]>
+        {
+            // The following example is invalid, since "title" is marked with @external and has an
+            // argument that is annotated with @require. This conflict leads to an
+            // EXTERNAL_REQUIRE_COLLISION error.
+            {
+                [
+                    """
+                    # Source Schema A
+                    type Book {
+                        id: ID!
+                        title: String
+                        subtitle: String
+                    }
+                    """,
+                    """
+                    # Source Schema B
+                    type Book {
+                        id: ID!
+                        title(subtitle: String @require(field: "subtitle")): String @external
+                    }
+                    """
+                ],
+                [
+                    "The external field 'Book.title' in schema 'B' must not have arguments that "
+                    + "are annotated with the @require directive."
+                ]
+            }
+        };
+    }
+}