[Fusion] Added source schema validation rule "IsInvalidFieldTypeRule" (#8208)

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 IsFieldInvalidTypeEvent(
+    Directive IsDirective,
+    MutableInputFieldDefinition Argument,
+    MutableOutputFieldDefinition Field,
+    MutableComplexTypeDefinition Type,
+    MutableSchemaDefinition Schema) : IEvent;
+
 internal record KeyFieldEvent(
     MutableOutputFieldDefinition KeyField,
     MutableComplexTypeDefinition KeyFieldDeclaringType,

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 IsInvalidFieldType = "IS_INVALID_FIELD_TYPE";
     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

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

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_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>
   <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

@@ -80,6 +80,7 @@ public CompositionResult<MutableSchemaDefinition> Compose()
         new ExternalOnInterfaceRule(),
         new ExternalUnusedRule(),
         new InvalidShareableUsageRule(),
+        new IsInvalidFieldTypeRule(),
         new KeyDirectiveInFieldsArgumentRule(),
         new KeyFieldsHasArgumentsRule(),
         new KeyFieldsSelectInvalidTypeRule(),

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

@@ -0,0 +1,30 @@
+using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Events.Contracts;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+
+namespace HotChocolate.Fusion.SourceSchemaValidationRules;
+
+/// <summary>
+/// When using the <c>@is</c> directive, the <c>field</c> argument must always be a string that
+/// describes how the arguments can be mapped from the entity type that the lookup field resolves.
+/// If the <c>field</c> argument is provided as a type other than a string (such as an integer,
+/// boolean, or enum), the directive usage is invalid and will cause schema composition to fail.
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Is-Invalid-Field-Type">
+/// Specification
+/// </seealso>
+internal sealed class IsInvalidFieldTypeRule : IEventHandler<IsFieldInvalidTypeEvent>
+{
+    public void Handle(IsFieldInvalidTypeEvent @event, CompositionContext context)
+    {
+        var (isDirective, argument, field, type, schema) = @event;
+
+        context.Log.Write(
+            IsInvalidFieldType(
+                isDirective,
+                argument.Name,
+                field.Name,
+                type.Name,
+                schema));
+    }
+}

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

@@ -73,6 +73,16 @@ private void PublishEvents()
                             PublishEvent(
                                 new FieldArgumentEvent(argument, field, type, schema), context);
 
+                            if (argument.Directives.ContainsName(DirectiveNames.Is))
+                            {
+                                PublishIsEvents(
+                                    argument,
+                                    field,
+                                    complexType,
+                                    schema,
+                                    context);
+                            }
+
                             if (argument.Directives.ContainsName(DirectiveNames.Require))
                             {
                                 PublishRequireEvents(
@@ -242,6 +252,25 @@ private void PublishProvidesEvents(
         }
     }
 
+    private void PublishIsEvents(
+        MutableInputFieldDefinition argument,
+        MutableOutputFieldDefinition field,
+        MutableComplexTypeDefinition type,
+        MutableSchemaDefinition schema,
+        CompositionContext context)
+    {
+        var isDirective =
+            argument.Directives.AsEnumerable().First(d => d.Name == DirectiveNames.Is);
+
+        if (!isDirective.Arguments.TryGetValue(ArgumentNames.Field, out var f)
+            || f is not StringValueNode)
+        {
+            PublishEvent(
+                new IsFieldInvalidTypeEvent(isDirective, argument, field, type, schema),
+                context);
+        }
+    }
+
     private void PublishRequireEvents(
         MutableInputFieldDefinition argument,
         MutableOutputFieldDefinition field,

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 IsInvalidFieldTypeRuleTests
+{
+    private static readonly object s_rule = new IsInvalidFieldTypeRule();
+    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_FIELD_TYPE"));
+        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 string
+            // and satisfies 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[]>
+        {
+            // Since "field" is set to 123 (an integer) instead of a string, this violates the rule
+            // and triggers an IS_INVALID_FIELD_TYPE error.
+            {
+                [
+                    """
+                    type Query {
+                        personById(id: ID! @is(field: 123)): Person @lookup
+                    }
+
+                    type Person {
+                        id: ID!
+                        name: String
+                    }
+                    """
+                ],
+                [
+                    "The @is directive on argument 'Query.personById(id:)' in schema 'A' must " +
+                    "specify a string value for the 'field' argument."
+                ]
+            }
+        };
+    }
+}