[Fusion] Refactored RequireInvalidFieldsRule (used source schemas) (#8218)

Author: glen-84

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

@@ -875,23 +875,22 @@ public static LogEntry QueryRootTypeInaccessible(
     }
 
     public static LogEntry RequireInvalidFields(
-        Directive fusionRequiresDirective,
+        Directive requireDirective,
         string argumentName,
         string fieldName,
         string typeName,
-        string sourceSchemaName,
-        MutableSchemaDefinition schema,
+        MutableSchemaDefinition sourceSchema,
         ImmutableArray<string> errors)
     {
         var coordinate = new SchemaCoordinate(typeName, fieldName, argumentName);
 
         return new LogEntry(
-            string.Format(LogEntryHelper_RequireInvalidFields, coordinate, sourceSchemaName),
+            string.Format(LogEntryHelper_RequireInvalidFields, coordinate, sourceSchema.Name),
             LogEntryCodes.RequireInvalidFields,
             LogSeverity.Error,
             coordinate,
-            fusionRequiresDirective,
-            schema,
+            requireDirective,
+            sourceSchema,
             errors);
     }
 

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

@@ -1,13 +1,14 @@
 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.Language;
+using HotChocolate.Types;
+using HotChocolate.Types.Mutable;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 using static HotChocolate.Fusion.WellKnownArgumentNames;
 using static HotChocolate.Fusion.WellKnownDirectiveNames;
-using static HotChocolate.Language.Utf8GraphQLParser.Syntax;
 
 namespace HotChocolate.Fusion.PostMergeValidationRules;
 
@@ -20,62 +21,50 @@ namespace HotChocolate.Fusion.PostMergeValidationRules;
 /// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Require-Invalid-Fields">
 /// Specification
 /// </seealso>
-internal sealed class RequireInvalidFieldsRule : IEventHandler<OutputFieldEvent>
+internal sealed class RequireInvalidFieldsRule : IEventHandler<SchemaEvent>
 {
-    public void Handle(OutputFieldEvent @event, CompositionContext context)
+    public void Handle(SchemaEvent @event, CompositionContext context)
     {
-        var (field, type, schema) = @event;
+        var schema = @event.Schema;
 
-        if (field.HasFusionInaccessibleDirective()
-            || type.HasFusionInaccessibleDirective()
-            || !field.HasFusionRequiresDirective())
-        {
-            return;
-        }
+        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.HasRequireDirective()),
+                (x, a) => new FieldArgumentInfo(a, x.f, x.o, x.s));
 
         var validator = new FieldSelectionMapValidator(schema);
-        var fusionRequiresDirectives = field.Directives[FusionRequires];
 
-        foreach (var fusionRequiresDirective in fusionRequiresDirectives)
+        foreach (var (sourceArgument, sourceField, sourceType, sourceSchema) in sourceArgumentGroup)
         {
-            var sourceSchemaName = (string)fusionRequiresDirective.Arguments[Schema].Value!;
-            var fieldArgumentValue = (string)fusionRequiresDirective.Arguments[Field].Value!;
-            var fieldDefinition = ParseFieldDefinition(fieldArgumentValue);
-            var arguments = fieldDefinition.Arguments;
-            var map = (ListValueNode)fusionRequiresDirective.Arguments[Map];
-
-            for (var i = 0; i < arguments.Count; i++)
-            {
-                var selectionMap = (string?)map.Items[i].Value;
+            var requireDirective = sourceArgument.Directives[Require].First();
+            var fieldArgumentValue = (string)requireDirective.Arguments[Field].Value!;
+            var fieldSelectionMapParser = new FieldSelectionMapParser(fieldArgumentValue);
+            var fieldSelectionMap = fieldSelectionMapParser.Parse();
+            var inputType = schema.Types[sourceArgument.Type.AsTypeDefinition().Name];
+            var outputType = schema.Types[sourceType.Name];
+            var errors =
+                validator.Validate(
+                    fieldSelectionMap,
+                    inputType,
+                    outputType,
+                    out var selectedFields);
 
-                if (selectionMap is null)
-                {
-                    continue;
-                }
+            // A selected field is defined in the same schema as the `require` directive.
+            var selectedFieldSameSchema =
+                selectedFields.Any(f => f.GetSchemaNames().Contains(sourceSchema.Name));
 
-                var fieldSelectionMapParser = new FieldSelectionMapParser(selectionMap);
-                var fieldSelectionMap = fieldSelectionMapParser.Parse();
-                var argument = arguments[i];
-                var inputType = schema.Types[argument.Type.NamedType().Name.Value];
-                var errors =
-                    validator.Validate(fieldSelectionMap, inputType, type, out var selectedFields);
-
-                // A selected field is defined in the same schema as the `require` directive.
-                var selectedFieldSameSchema =
-                    selectedFields.Any(f => f.GetSchemaNames().Contains(sourceSchemaName));
-
-                if (errors.Any() || selectedFieldSameSchema)
-                {
-                    context.Log.Write(
-                        RequireInvalidFields(
-                            fusionRequiresDirective,
-                            argument.Name.Value,
-                            field.Name,
-                            type.Name,
-                            sourceSchemaName,
-                            schema,
-                            errors));
-                }
+            if (errors.Any() || selectedFieldSameSchema)
+            {
+                context.Log.Write(
+                    RequireInvalidFields(
+                        requireDirective,
+                        sourceArgument.Name,
+                        sourceField.Name,
+                        sourceType.Name,
+                        sourceSchema,
+                        errors));
             }
         }
     }