[Fusion] Added source schema validation rule "IsInvalidSyntaxRule" (#8211)

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

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

@@ -23,6 +23,7 @@ public static class LogEntryCodes
     public const string InvalidGraphQL = "INVALID_GRAPHQL";
     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 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

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

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

@@ -210,6 +210,9 @@
   <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_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_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

@@ -81,6 +81,7 @@ public CompositionResult<MutableSchemaDefinition> Compose()
         new ExternalUnusedRule(),
         new InvalidShareableUsageRule(),
         new IsInvalidFieldTypeRule(),
+        new IsInvalidSyntaxRule(),
         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>
+/// The <c>@is</c> directive’s <c>field</c> argument must be syntactically valid GraphQL. If
+/// the selection map string is malformed (e.g., missing closing braces, unbalanced quotes, invalid
+/// tokens), then the schema cannot be composed correctly. In such cases, the error
+/// <c>IS_INVALID_SYNTAX</c> is raised.
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Is-Invalid-Syntax">
+/// Specification
+/// </seealso>
+internal sealed class IsInvalidSyntaxRule : IEventHandler<IsFieldInvalidSyntaxEvent>
+{
+    public void Handle(IsFieldInvalidSyntaxEvent @event, CompositionContext context)
+    {
+        var (isDirective, argument, field, type, schema) = @event;
+
+        context.Log.Write(
+            IsInvalidSyntax(
+                isDirective,
+                argument.Name,
+                field.Name,
+                type.Name,
+                schema));
+    }
+}

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

@@ -263,11 +263,29 @@ private void PublishIsEvents(
             argument.Directives.AsEnumerable().First(d => d.Name == DirectiveNames.Is);
 
         if (!isDirective.Arguments.TryGetValue(ArgumentNames.Field, out var f)
-            || f is not StringValueNode)
+            || f is not StringValueNode fieldArgument)
         {
             PublishEvent(
                 new IsFieldInvalidTypeEvent(isDirective, argument, field, type, schema),
                 context);
+
+            return;
+        }
+
+        try
+        {
+            new FieldSelectionMapParser(fieldArgument.Value).Parse();
+        }
+        catch (FieldSelectionMapSyntaxException)
+        {
+            PublishEvent(
+                new IsFieldInvalidSyntaxEvent(
+                    isDirective,
+                    argument,
+                    field,
+                    type,
+                    schema),
+                context);
         }
     }
 

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

@@ -0,0 +1,98 @@
+using System.Collections.Immutable;
+using HotChocolate.Fusion.Logging;
+using static HotChocolate.Fusion.CompositionTestHelper;
+
+namespace HotChocolate.Fusion.SourceSchemaValidationRules;
+
+public sealed class IsInvalidSyntaxRuleTests
+{
+    private static readonly object s_rule = new IsInvalidSyntaxRule();
+    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_SYNTAX"));
+        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 selection
+            // map and satisfies the rule.
+            {
+                [
+                    """
+                    type User @key(fields: "id") {
+                        id: ID!
+                        profile(name: String! @is(field: "name")): Profile
+                    }
+
+                    type Profile {
+                        id: ID!
+                        name: String
+                    }
+                    """
+                ]
+            }
+        };
+    }
+
+    public static TheoryData<string[], string[]> InvalidExamplesData()
+    {
+        return new TheoryData<string[], string[]>
+        {
+            // In the following example, the @is directive’s "field" argument has invalid syntax
+            // because it is missing a closing brace.
+            {
+                [
+                    """
+                    type User @key(fields: "id") {
+                        id: ID!
+                        profile(name: String! @is(field: "{ name ")): Profile
+                    }
+
+                    type Profile {
+                        id: ID!
+                        name: String
+                    }
+                    """
+                ],
+                [
+                    "The @is directive on argument 'User.profile(name:)' in schema 'A' contains " +
+                    "invalid syntax in the 'field' argument."
+                ]
+            }
+        };
+    }
+}