[Fusion] Added post-merge validation rule InputFieldReferencesInaccessibleTypeRule

Author: danielreynolds1

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

@@ -14,6 +14,7 @@ public static class LogEntryCodes
     public const string ExternalUnused = "EXTERNAL_UNUSED";
     public const string FieldArgumentTypesNotMergeable = "FIELD_ARGUMENT_TYPES_NOT_MERGEABLE";
     public const string InputFieldDefaultMismatch = "INPUT_FIELD_DEFAULT_MISMATCH";
+    public const string InputFieldReferencesInaccessibleType = "INPUT_FIELD_REFERENCES_INACCESSIBLE_TYPE";
     public const string InputFieldTypesNotMergeable = "INPUT_FIELD_TYPES_NOT_MERGEABLE";
     public const string InputWithMissingRequiredFields = "INPUT_WITH_MISSING_REQUIRED_FIELDS";
     public const string InvalidGraphQL = "INVALID_GRAPHQL";

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

@@ -279,6 +279,27 @@ public static LogEntry InputFieldDefaultMismatch(
             schemaA);
     }
 
+    public static LogEntry InputFieldReferencesInaccessibleType(
+        InputFieldDefinition field,
+        string typeName,
+        string referenceTypeName,
+        SchemaDefinition schema)
+    {
+        var coordinate = new SchemaCoordinate(typeName, field.Name);
+
+        return new LogEntry(
+            string.Format(
+                LogEntryHelper_InputFieldReferencesInaccessibleType,
+                field.Name,
+                typeName,
+                referenceTypeName),
+            LogEntryCodes.InputFieldReferencesInaccessibleType,
+            LogSeverity.Error,
+            coordinate,
+            field,
+            schema);
+    }
+
     public static LogEntry InputFieldTypesNotMergeable(
         InputFieldDefinition field,
         string typeName,

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

@@ -0,0 +1,60 @@
+using System.Collections.Immutable;
+using System.Diagnostics;
+using HotChocolate.Fusion.Events;
+using HotChocolate.Fusion.Events.Contracts;
+using HotChocolate.Fusion.Extensions;
+using HotChocolate.Skimmed;
+using static HotChocolate.Fusion.Logging.LogEntryHelper;
+
+namespace HotChocolate.Fusion.PostMergeValidationRules;
+
+/// <summary>
+/// In a composed schema, a field within an input type must only reference types that are exposed.
+/// This requirement guarantees that public types do not reference <c>inaccessible</c> structures
+/// which are intended for internal use.
+/// </summary>
+/// <seealso href="https://graphql.github.io/composite-schemas-spec/draft/#sec-Input-Fields-cannot-reference-inaccessible-type">
+/// Specification
+/// </seealso>
+internal sealed class InputFieldReferencesInaccessibleTypeRule
+    : IEventHandler<SchemaEvent>, IEventHandler<InputFieldEvent>
+{
+    private ImmutableHashSet<string>? _inaccessibleTypes;
+
+    public void Handle(SchemaEvent @event, CompositionContext context)
+    {
+        var builder = ImmutableHashSet.CreateBuilder<string>();
+        foreach (var type in @event.Schema.Types)
+        {
+            if (type.HasInaccessibleDirective())
+            {
+                builder.Add(type.Name);
+            }
+        }
+
+        _inaccessibleTypes = builder.ToImmutable();
+    }
+
+    public void Handle(InputFieldEvent @event, CompositionContext context)
+    {
+        Debug.Assert(_inaccessibleTypes is not null);
+
+        var (field, type, schema) = @event;
+
+        if (field.HasInaccessibleDirective())
+        {
+            return;
+        }
+
+        var fieldTypeName = field.Type.NamedType().Name;
+        if (_inaccessibleTypes.Contains(fieldTypeName))
+        {
+            context.Log.Write(
+                InputFieldReferencesInaccessibleType(
+                    field,
+                    type.Name,
+                    fieldTypeName,
+                    schema));
+        }
+    }
+}