[Fusion] Added source schema validation rule "IsInvalidUsageRule" (#8214)

Author: glen-84

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

@@ -34,6 +34,13 @@ internal record InterfaceTypeEvent(
     MutableInterfaceTypeDefinition InterfaceType,
     MutableSchemaDefinition Schema) : IEvent;
 
+internal record IsDirectiveEvent(
+    Directive IsDirective,
+    MutableInputFieldDefinition Argument,
+    MutableOutputFieldDefinition Field,
+    MutableComplexTypeDefinition Type,
+    MutableSchemaDefinition Schema) : IEvent;
+
 internal record IsFieldInvalidSyntaxEvent(
     Directive IsDirective,
     MutableInputFieldDefinition Argument,

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

@@ -24,6 +24,7 @@ public static class LogEntryCodes
     public const string InvalidShareableUsage = "INVALID_SHAREABLE_USAGE";
     public const string IsInvalidFieldType = "IS_INVALID_FIELD_TYPE";
     public const string IsInvalidSyntax = "IS_INVALID_SYNTAX";
+    public const string IsInvalidUsage = "IS_INVALID_USAGE";
     public const string KeyDirectiveInFieldsArg = "KEY_DIRECTIVE_IN_FIELDS_ARG";
     public const string KeyFieldsHasArgs = "KEY_FIELDS_HAS_ARGS";
     public const string KeyFieldsSelectInvalidType = "KEY_FIELDS_SELECT_INVALID_TYPE";

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

@@ -458,6 +458,24 @@ public static LogEntry IsInvalidSyntax(
             schema);
     }
 
+    public static LogEntry IsInvalidUsage(
+        Directive isDirective,
+        string argumentName,
+        string fieldName,
+        string typeName,
+        MutableSchemaDefinition schema)
+    {
+        var coordinate = new SchemaCoordinate(typeName, fieldName, argumentName);
+
+        return new LogEntry(
+            string.Format(LogEntryHelper_IsInvalidUsage, coordinate, schema.Name),
+            LogEntryCodes.IsInvalidUsage,
+            LogSeverity.Error,
+            coordinate,
+            isDirective,
+            schema);
+    }
+
     public static LogEntry KeyDirectiveInFieldsArgument(
         string typeName,
         Directive keyDirective,

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

@@ -213,6 +213,9 @@
   <data name="LogEntryHelper_IsInvalidSyntax" xml:space="preserve">
     <value>The @is directive on argument '{0}' in schema '{1}' contains invalid syntax in the 'field' argument.</value>
   </data>
+  <data name="LogEntryHelper_IsInvalidUsage" xml:space="preserve">
+    <value>The @is directive on argument '{0}' in schema '{1}' is invalid because the declaring field is not a lookup field.</value>
+  </data>
   <data name="LogEntryHelper_KeyDirectiveInFieldsArgument" xml:space="preserve">
     <value>A @key directive on type '{0}' in schema '{1}' references field '{2}', which must not include directive applications.</value>
   </data>

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

@@ -82,6 +82,7 @@ public CompositionResult<MutableSchemaDefinition> Compose()
         new InvalidShareableUsageRule(),
         new IsInvalidFieldTypeRule(),
         new IsInvalidSyntaxRule(),
+        new IsInvalidUsageRule(),
         new KeyDirectiveInFieldsArgumentRule(),
         new KeyFieldsHasArgumentsRule(),
         new KeyFieldsSelectInvalidTypeRule(),

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

@@ -0,0 +1,32 @@
+using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Events.Contracts;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+using static HotChocolate.Fusion.WellKnownDirectiveNames;
+
+namespace HotChocolate.Fusion.SourceSchemaValidationRules;
+
+/// <summary>
+/// When using the <c>@is</c> directive, the field declaring the argument must be a lookup field
+/// (i.e. have the <c>@lookup</c> directive applied).
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Is-Invalid-Usage">
+/// Specification
+/// </seealso>
+internal sealed class IsInvalidUsageRule : IEventHandler<IsDirectiveEvent>
+{
+    public void Handle(IsDirectiveEvent @event, CompositionContext context)
+    {
+        var (isDirective, argument, field, type, schema) = @event;
+
+        if (!field.Directives.ContainsName(Lookup))
+        {
+            context.Log.Write(
+                IsInvalidUsage(
+                    isDirective,
+                    argument.Name,
+                    field.Name,
+                    type.Name,
+                    schema));
+        }
+    }
+}

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

@@ -262,6 +262,8 @@ private void PublishIsEvents(
         var isDirective =
             argument.Directives.AsEnumerable().First(d => d.Name == DirectiveNames.Is);
 
+        PublishEvent(new IsDirectiveEvent(isDirective, argument, field, type, schema), context);
+
         if (!isDirective.Arguments.TryGetValue(ArgumentNames.Field, out var f)
             || f is not StringValueNode fieldArgument)
         {

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

@@ -0,0 +1,96 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Logging;
+using static HotChocolate.Fusion.CompositionTestHelper;
+
+namespace HotChocolate.Fusion.SourceSchemaValidationRules;
+
+public sealed class IsInvalidUsageRuleTests
+{
+    private static readonly object s_rule = new IsInvalidUsageRule();
+    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 == "IS_INVALID_USAGE"));
+        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 is applied to an argument declared on a
+            // field with the @lookup directive, satisfying the rule.
+            {
+                [
+                    """
+                    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 the following example, the @is directive is applied to an argument declared on a
+            // field without the @lookup directive, violating the rule.
+            {
+                [
+                    """
+                    type Query {
+                        personById(id: ID! @is(field: "id")): Person
+                    }
+
+                    type Person {
+                        id: ID!
+                        name: String
+                    }
+                    """
+                ],
+                [
+                    "The @is directive on argument 'Query.personById(id:)' in schema 'A' is " +
+                    "invalid because the declaring field is not a lookup field."
+                ]
+            }
+        };
+    }
+}