[Fusion] Miscellaneous changes to composition (part 2)

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

@@ -0,0 +1,37 @@
+using HotChocolate.Skimmed;
+using static HotChocolate.Fusion.WellKnownDirectiveNames;
+
+namespace HotChocolate.Fusion.Extensions;
+
+internal static class DirectivesProviderExtensions
+{
+    public static bool HasExternalDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(External);
+    }
+
+    public static bool HasInaccessibleDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(Inaccessible);
+    }
+
+    public static bool HasInternalDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(Internal);
+    }
+
+    public static bool HasLookupDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(Lookup);
+    }
+
+    public static bool HasOverrideDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(Override);
+    }
+
+    public static bool HasProvidesDirective(this IDirectivesProvider type)
+    {
+        return type.Directives.ContainsName(Provides);
+    }
+}

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

@@ -18,8 +18,8 @@ public static class LogEntryCodes
     public const string KeyInvalidFields = "KEY_INVALID_FIELDS";
     public const string KeyInvalidFieldsType = "KEY_INVALID_FIELDS_TYPE";
     public const string KeyInvalidSyntax = "KEY_INVALID_SYNTAX";
-    public const string LookupMustNotReturnList = "LOOKUP_MUST_NOT_RETURN_LIST";
-    public const string LookupShouldHaveNullableReturnType = "LOOKUP_SHOULD_HAVE_NULLABLE_RETURN_TYPE";
+    public const string LookupReturnsList = "LOOKUP_RETURNS_LIST";
+    public const string LookupReturnsNonNullableType = "LOOKUP_RETURNS_NON_NULLABLE_TYPE";
     public const string OutputFieldTypesNotMergeable = "OUTPUT_FIELD_TYPES_NOT_MERGEABLE";
     public const string OverrideFromSelf = "OVERRIDE_FROM_SELF";
     public const string OverrideOnInterface = "OVERRIDE_ON_INTERFACE";

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

@@ -378,7 +378,7 @@ public static LogEntry KeyInvalidSyntax(
             schema);
     }
 
-    public static LogEntry LookupMustNotReturnList(
+    public static LogEntry LookupReturnsList(
         OutputFieldDefinition field,
         INamedTypeDefinition type,
         SchemaDefinition schema)
@@ -387,17 +387,17 @@ public static LogEntry LookupMustNotReturnList(
 
         return new LogEntry(
             string.Format(
-                LogEntryHelper_LookupMustNotReturnList,
+                LogEntryHelper_LookupReturnsList,
                 coordinate,
                 schema.Name),
-            LogEntryCodes.LookupMustNotReturnList,
+            LogEntryCodes.LookupReturnsList,
             LogSeverity.Error,
             coordinate,
             field,
             schema);
     }
 
-    public static LogEntry LookupShouldHaveNullableReturnType(
+    public static LogEntry LookupReturnsNonNullableType(
         OutputFieldDefinition field,
         INamedTypeDefinition type,
         SchemaDefinition schema)
@@ -406,10 +406,10 @@ public static LogEntry LookupShouldHaveNullableReturnType(
 
         return new LogEntry(
             string.Format(
-                LogEntryHelper_LookupShouldHaveNullableReturnType,
+                LogEntryHelper_LookupReturnsNonNullableType,
                 coordinate,
                 schema.Name),
-            LogEntryCodes.LookupShouldHaveNullableReturnType,
+            LogEntryCodes.LookupReturnsNonNullableType,
             LogSeverity.Warning,
             coordinate,
             field,

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

@@ -45,29 +45,29 @@ internal record InputTypeGroupEvent(
     ImmutableArray<InputTypeInfo> InputTypeGroup) : IEvent;
 
 internal record KeyFieldEvent(
-    ComplexTypeDefinition EntityType,
     Directive KeyDirective,
+    ComplexTypeDefinition EntityType,
     OutputFieldDefinition Field,
     ComplexTypeDefinition Type,
     SchemaDefinition Schema) : IEvent;
 
 internal record KeyFieldNodeEvent(
-    ComplexTypeDefinition EntityType,
-    Directive KeyDirective,
     FieldNode FieldNode,
     ImmutableArray<string> FieldNamePath,
+    Directive KeyDirective,
+    ComplexTypeDefinition EntityType,
     SchemaDefinition Schema) : IEvent;
 
 internal record KeyFieldsInvalidReferenceEvent(
-    ComplexTypeDefinition EntityType,
-    Directive KeyDirective,
     FieldNode FieldNode,
     ComplexTypeDefinition Type,
+    Directive KeyDirective,
+    ComplexTypeDefinition EntityType,
     SchemaDefinition Schema) : IEvent;
 
 internal record KeyFieldsInvalidSyntaxEvent(
-    ComplexTypeDefinition EntityType,
     Directive KeyDirective,
+    ComplexTypeDefinition EntityType,
     SchemaDefinition Schema) : IEvent;
 
 internal record KeyFieldsInvalidTypeEvent(
@@ -129,6 +129,13 @@ internal record RequireFieldsInvalidSyntaxEvent(
     ComplexTypeDefinition Type,
     SchemaDefinition Schema) : IEvent;
 
+internal record RequireFieldsInvalidTypeEvent(
+    Directive RequireDirective,
+    InputFieldDefinition Argument,
+    OutputFieldDefinition Field,
+    ComplexTypeDefinition Type,
+    SchemaDefinition Schema) : IEvent;
+
 internal record SchemaEvent(SchemaDefinition Schema) : IEvent;
 
 internal record TypeEvent(

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/PreMergeValidator.cs

@@ -184,8 +184,7 @@ private void PublishEntityEvents(
 
         foreach (var keyDirective in keyDirectives)
         {
-            if (
-                !keyDirective.Arguments.TryGetValue(WellKnownArgumentNames.Fields, out var f)
+            if (!keyDirective.Arguments.TryGetValue(WellKnownArgumentNames.Fields, out var f)
                 || f is not StringValueNode fields)
             {
                 PublishEvent(
@@ -211,7 +210,7 @@ private void PublishEntityEvents(
             catch (SyntaxException)
             {
                 PublishEvent(
-                    new KeyFieldsInvalidSyntaxEvent(entityType, keyDirective, schema),
+                    new KeyFieldsInvalidSyntaxEvent(keyDirective, entityType, schema),
                     context);
             }
         }
@@ -236,10 +235,10 @@ private void PublishKeyFieldEvents(
 
                 PublishEvent(
                     new KeyFieldNodeEvent(
-                        entityType,
-                        keyDirective,
                         fieldNode,
                         [.. fieldNamePath],
+                        keyDirective,
+                        entityType,
                         schema),
                     context);
 
@@ -249,8 +248,8 @@ private void PublishKeyFieldEvents(
                     {
                         PublishEvent(
                             new KeyFieldEvent(
-                                entityType,
                                 keyDirective,
+                                entityType,
                                 field,
                                 parentType,
                                 schema),
@@ -265,10 +264,10 @@ private void PublishKeyFieldEvents(
                     {
                         PublishEvent(
                             new KeyFieldsInvalidReferenceEvent(
-                                entityType,
-                                keyDirective,
                                 fieldNode,
                                 parentType,
+                                keyDirective,
+                                entityType,
                                 schema),
                             context);
 
@@ -302,8 +301,7 @@ private void PublishProvidesEvents(
         var providesDirective =
             field.Directives.First(d => d.Name == WellKnownDirectiveNames.Provides);
 
-        if (
-            !providesDirective.Arguments.TryGetValue(WellKnownArgumentNames.Fields, out var f)
+        if (!providesDirective.Arguments.TryGetValue(WellKnownArgumentNames.Fields, out var f)
             || f is not StringValueNode fields)
         {
             PublishEvent(
@@ -365,8 +363,7 @@ private void PublishProvidesFieldEvents(
 
                 if (parentType?.NullableType() is ComplexTypeDefinition providedType)
                 {
-                    if (
-                        providedType.Fields.TryGetField(
+                    if (providedType.Fields.TryGetField(
                             fieldNode.Name.Value,
                             out var providedField))
                     {
@@ -419,10 +416,13 @@ private void PublishRequireEvents(
         var requireDirective =
             argument.Directives.First(d => d.Name == WellKnownDirectiveNames.Require);
 
-        if (
-            !requireDirective.Arguments.TryGetValue(WellKnownArgumentNames.Fields, out var f)
+        if (!requireDirective.Arguments.TryGetValue(WellKnownArgumentNames.Fields, out var f)
             || f is not StringValueNode fields)
         {
+            PublishEvent(
+                new RequireFieldsInvalidTypeEvent(requireDirective, argument, field, type, schema),
+                context);
+
             return;
         }
 

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/DisallowedInaccessibleElementsRule.cs

@@ -1,4 +1,5 @@
 using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
 using HotChocolate.Skimmed;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 
@@ -25,13 +26,13 @@ public void Handle(TypeEvent @event, CompositionContext context)
 
         // Built-in scalar types must be accessible.
         if (type is ScalarTypeDefinition { IsSpecScalar: true } scalar
-            && !ValidationHelper.IsAccessible(scalar))
+            && scalar.HasInaccessibleDirective())
         {
             context.Log.Write(DisallowedInaccessibleBuiltInScalar(scalar, schema));
         }
 
         // Introspection types must be accessible.
-        if (type.IsIntrospectionType && !ValidationHelper.IsAccessible(type))
+        if (type.IsIntrospectionType && type.HasInaccessibleDirective())
         {
             context.Log.Write(DisallowedInaccessibleIntrospectionType(type, schema));
         }
@@ -42,7 +43,7 @@ public void Handle(OutputFieldEvent @event, CompositionContext context)
         var (field, type, schema) = @event;
 
         // Introspection fields must be accessible.
-        if (type.IsIntrospectionType && !ValidationHelper.IsAccessible(field))
+        if (type.IsIntrospectionType && field.HasInaccessibleDirective())
         {
             context.Log.Write(
                 DisallowedInaccessibleIntrospectionField(
@@ -57,7 +58,7 @@ public void Handle(FieldArgumentEvent @event, CompositionContext context)
         var (argument, field, type, schema) = @event;
 
         // Introspection arguments must be accessible.
-        if (type.IsIntrospectionType && !ValidationHelper.IsAccessible(argument))
+        if (type.IsIntrospectionType && argument.HasInaccessibleDirective())
         {
             context.Log.Write(
                 DisallowedInaccessibleIntrospectionArgument(
@@ -73,7 +74,7 @@ public void Handle(DirectiveArgumentEvent @event, CompositionContext context)
         var (argument, directive, schema) = @event;
 
         // Built-in directive arguments must be accessible.
-        if (BuiltIns.IsBuiltInDirective(directive.Name) && !ValidationHelper.IsAccessible(argument))
+        if (BuiltIns.IsBuiltInDirective(directive.Name) && argument.HasInaccessibleDirective())
         {
             context.Log.Write(
                 DisallowedInaccessibleDirectiveArgument(

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/EnumValuesMismatchRule.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 
 namespace HotChocolate.Fusion.PreMergeValidation.Rules;
@@ -34,7 +35,7 @@ public void Handle(EnumTypeGroupEvent @event, CompositionContext context)
 
         var enumValues = enumGroup
             .SelectMany(e => e.Type.Values)
-            .Where(ValidationHelper.IsAccessible)
+            .Where(v => !v.HasInaccessibleDirective())
             .Select(v => v.Name)
             .ToImmutableHashSet();
 

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/ExternalArgumentDefaultMismatchRule.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
 using HotChocolate.Language;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 
@@ -20,7 +21,7 @@ public void Handle(OutputFieldGroupEvent @event, CompositionContext context)
         var (fieldName, fieldGroup, typeName) = @event;
 
         var externalFields = fieldGroup
-            .Where(i => ValidationHelper.IsExternal(i.Field))
+            .Where(i => i.Field.HasExternalDirective())
             .ToImmutableArray();
 
         if (externalFields.Length == 0)

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/ExternalMissingOnBaseRule.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 
 namespace HotChocolate.Fusion.PreMergeValidation.Rules;
@@ -20,7 +21,7 @@ public void Handle(OutputFieldGroupEvent @event, CompositionContext context)
         var fieldGroup = @event.FieldGroup;
 
         var externalFields = fieldGroup
-            .Where(i => ValidationHelper.IsExternal(i.Field))
+            .Where(i => i.Field.HasExternalDirective())
             .ToImmutableArray();
 
         var nonExternalFieldCount = fieldGroup.Length - externalFields.Length;

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/ExternalOnInterfaceRule.cs

@@ -1,4 +1,5 @@
 using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
 using HotChocolate.Skimmed;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 
@@ -21,7 +22,7 @@ public void Handle(OutputFieldEvent @event, CompositionContext context)
     {
         var (field, type, schema) = @event;
 
-        if (type is InterfaceTypeDefinition && ValidationHelper.IsExternal(field))
+        if (type is InterfaceTypeDefinition && field.HasExternalDirective())
         {
             context.Log.Write(ExternalOnInterface(field, type, schema));
         }

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/ExternalUnusedRule.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
 using HotChocolate.Skimmed;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 
@@ -18,7 +19,7 @@ public void Handle(OutputFieldEvent @event, CompositionContext context)
     {
         var (field, type, schema) = @event;
 
-        if (ValidationHelper.IsExternal(field))
+        if (field.HasExternalDirective())
         {
             var referencingFields =
                 schema.Types

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/PreMergeValidation/Rules/FieldArgumentTypesMergeableRule.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Extensions;
 using static HotChocolate.Fusion.Logging.LogEntryHelper;
 
 namespace HotChocolate.Fusion.PreMergeValidation.Rules;
@@ -24,10 +25,10 @@ public void Handle(FieldArgumentGroupEvent @event, CompositionContext context)
         var argumentGroupVisible = argumentGroup
             .Where(
                 i =>
-                    ValidationHelper.IsAccessible(i.Type)
-                    && !ValidationHelper.IsInternal(i.Type)
-                    && ValidationHelper.IsAccessible(i.Field)
-                    && !ValidationHelper.IsInternal(i.Field))
+                    !i.Type.HasInaccessibleDirective()
+                    && !i.Type.HasInternalDirective()
+                    && !i.Field.HasInaccessibleDirective()
+                    && !i.Field.HasInternalDirective())
             .ToImmutableArray();
 
         for (var i = 0; i < argumentGroupVisible.Length - 1; i++)