[Fusion] Added post-merge validation rule "IsInvalidFieldRule" (#8217)

Author: glen-84

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/Extensions/DirectivesProviderExtensions.cs

@@ -52,6 +52,11 @@ public static bool HasInaccessibleDirective(this IDirectivesProvider type)
         return type.Directives.ContainsName(DirectiveNames.Inaccessible);
     }
 
+    public static bool HasIsDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(DirectiveNames.Is);
+    }
+
     public static bool HasLookupDirective(this IDirectivesProvider type)
     {
         return type.Directives.ContainsName(DirectiveNames.Lookup);

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

@@ -22,6 +22,7 @@ public static class LogEntryCodes
     public const string InterfaceFieldNoImplementation = "INTERFACE_FIELD_NO_IMPLEMENTATION";
     public const string InvalidGraphQL = "INVALID_GRAPHQL";
     public const string InvalidShareableUsage = "INVALID_SHAREABLE_USAGE";
+    public const string IsInvalidField = "IS_INVALID_FIELD";
     public const string IsInvalidFieldType = "IS_INVALID_FIELD_TYPE";
     public const string IsInvalidSyntax = "IS_INVALID_SYNTAX";
     public const string IsInvalidUsage = "IS_INVALID_USAGE";

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

@@ -422,6 +422,26 @@ public static LogEntry InvalidShareableUsage(
             schema);
     }
 
+    public static LogEntry IsInvalidField(
+        Directive isDirective,
+        string argumentName,
+        string fieldName,
+        string typeName,
+        MutableSchemaDefinition sourceSchema,
+        ImmutableArray<string> errors)
+    {
+        var coordinate = new SchemaCoordinate(typeName, fieldName, argumentName);
+
+        return new LogEntry(
+            string.Format(LogEntryHelper_IsInvalidField, coordinate, sourceSchema.Name),
+            LogEntryCodes.IsInvalidField,
+            LogSeverity.Error,
+            coordinate,
+            isDirective,
+            sourceSchema,
+            errors);
+    }
+
     public static LogEntry IsInvalidFieldType(
         Directive isDirective,
         string argumentName,

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

@@ -0,0 +1,63 @@
+using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Events.Contracts;
+using HotChocolate.Fusion.Extensions;
+using HotChocolate.Fusion.Info;
+using HotChocolate.Fusion.Language;
+using HotChocolate.Fusion.Validators;
+using HotChocolate.Types;
+using HotChocolate.Types.Mutable;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+using static HotChocolate.Fusion.WellKnownArgumentNames;
+using static HotChocolate.Fusion.WellKnownDirectiveNames;
+
+namespace HotChocolate.Fusion.PostMergeValidationRules;
+
+/// <summary>
+/// Even if the field selection map for <c>@is(field: "…")</c> is syntactically valid, its contents
+/// must also be valid within the composed schema. Fields must exist on the parent type for them to
+/// be referenced by <c>@is</c>. In addition, fields referencing unknown fields break the valid
+/// usage of <c>@is</c>, leading to an <c>IS_INVALID_FIELD</c> error.
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Is-Invalid-Field">
+/// Specification
+/// </seealso>
+internal sealed class IsInvalidFieldRule : IEventHandler<SchemaEvent>
+{
+    public void Handle(SchemaEvent @event, CompositionContext context)
+    {
+        var schema = @event.Schema;
+
+        var sourceArgumentGroup = context.SchemaDefinitions
+            .SelectMany(s => s.Types.OfType<MutableObjectTypeDefinition>(), (s, o) => (s, o))
+            .SelectMany(x => x.o.Fields.AsEnumerable(), (x, f) => (x.s, x.o, f))
+            .SelectMany(
+                x => x.f.Arguments.AsEnumerable().Where(a => a.HasIsDirective()),
+                (x, a) => new FieldArgumentInfo(a, x.f, x.o, x.s));
+
+        var validator = new FieldSelectionMapValidator(schema);
+
+        foreach (var (sourceArgument, sourceField, sourceType, sourceSchema) in sourceArgumentGroup)
+        {
+            var isDirective = sourceArgument.Directives[Is].First();
+            var fieldArgumentValue = (string)isDirective.Arguments[Field].Value!;
+            var fieldSelectionMapParser = new FieldSelectionMapParser(fieldArgumentValue);
+            var fieldSelectionMap = fieldSelectionMapParser.Parse();
+            var inputType = schema.Types[sourceArgument.Type.AsTypeDefinition().Name];
+            var outputType = schema.Types[sourceField.Type.AsTypeDefinition().Name];
+
+            var errors = validator.Validate(fieldSelectionMap, inputType, outputType);
+
+            if (errors.Any())
+            {
+                context.Log.Write(
+                    IsInvalidField(
+                        isDirective,
+                        sourceArgument.Name,
+                        sourceField.Name,
+                        sourceType.Name,
+                        sourceSchema,
+                        errors));
+            }
+        }
+    }
+}

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

@@ -207,6 +207,9 @@
   <data name="LogEntryHelper_InvalidShareableUsage" xml:space="preserve">
     <value>The interface field '{0}' in schema '{1}' must not be marked as shareable.</value>
   </data>
+  <data name="LogEntryHelper_IsInvalidField" xml:space="preserve">
+    <value>The @is directive on argument '{0}' in schema '{1}' specifies an invalid field selection against the composed schema.</value>
+  </data>
   <data name="LogEntryHelper_IsInvalidFieldType" xml:space="preserve">
     <value>The @is directive on argument '{0}' in schema '{1}' must specify a string value for the 'field' argument.</value>
   </data>

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

@@ -132,6 +132,7 @@ public CompositionResult<MutableSchemaDefinition> Compose()
         new EmptyMergedUnionTypeRule(),
         new EnumTypeDefaultValueInaccessibleRule(),
         new InterfaceFieldNoImplementationRule(),
+        new IsInvalidFieldRule(),
         new NonNullInputFieldIsInaccessibleRule(),
         new NoQueriesRule(),
         new RequireInvalidFieldsRule()

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

@@ -0,0 +1,102 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Logging;
+using static HotChocolate.Fusion.CompositionTestHelper;
+
+namespace HotChocolate.Fusion.PostMergeValidationRules;
+
+public sealed class IsInvalidFieldRuleTests
+{
+    private static readonly object s_rule = new IsInvalidFieldRule();
+    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 == "IS_INVALID_FIELD"));
+        Assert.True(_log.All(e => e.Severity == LogSeverity.Error));
+    }
+
+    public static TheoryData<string[]> ValidExamplesData()
+    {
+        return new TheoryData<string[]>
+        {
+            // In the following example, the @is directive’s "field" argument is a valid field
+            // selection map and satisfies the rule.
+            {
+                [
+                    """
+                    # Schema A
+                    type Query {
+                        personById(id: ID! @is(field: "id")): Person @lookup
+                    }
+
+                    type Person {
+                        id: ID!
+                        name: String
+                    }
+                    """
+                ]
+            }
+        };
+    }
+
+    public static TheoryData<string[], string[]> InvalidExamplesData()
+    {
+        return new TheoryData<string[], string[]>
+        {
+            // In this example, the @is directive references a field ("unknownField") that does
+            // not exist on the return type ("Person"), causing an IS_INVALID_FIELD error.
+            {
+                [
+                    """
+                    # Schema A
+                    type Query {
+                        personById(id: ID! @is(field: "unknownField")): Person @lookup
+                    }
+
+                    type Person {
+                        id: ID!
+                        name: String
+                    }
+                    """
+                ],
+                [
+                    "The @is directive on argument 'Query.personById(id:)' in schema 'A' " +
+                    "specifies an invalid field selection against the composed schema."
+                ]
+            }
+        };
+    }
+}