Adds deprecation of input fields and arguments

src/HotChocolate/Core/src/Abstractions/GraphQLDeprecatedAttribute.cs

@@ -8,6 +8,7 @@ namespace HotChocolate;
 /// </summary>
 [AttributeUsage(AttributeTargets.Field // Required for enum values
     | AttributeTargets.Property
+    | AttributeTargets.Parameter
     | AttributeTargets.Method)]
 public sealed class GraphQLDeprecatedAttribute : Attribute
 {

src/HotChocolate/Core/src/Types/Configuration/Validation/DirectiveValidationRule.cs

@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using System.Linq;
+using HotChocolate.Types;
+using static HotChocolate.Configuration.Validation.TypeValidationHelper;
+using static HotChocolate.Configuration.Validation.ErrorHelper;
+
+namespace HotChocolate.Configuration.Validation;
+
+/// <summary>
+/// Implements directive type validation defined in the spec.
+/// http://spec.graphql.org/draft/#sec-Type-System.Directives.Validation
+/// </summary>
+internal class DirectiveValidationRule : ISchemaValidationRule
+{
+    private const string _twoUnderscores = "__";
+
+    public void Validate(
+        IReadOnlyList<ITypeSystemObject> typeSystemObjects,
+        IReadOnlySchemaOptions options,
+        ICollection<ISchemaError> errors)
+    {
+        if (options.StrictValidation)
+        {
+            foreach (DirectiveType type in typeSystemObjects.OfType<DirectiveType>())
+            {
+                EnsureDirectiveNameIsValid(type, errors);
+                EnsureArgumentNamesAreValid(type, errors);
+                EnsureArgumentDeprecationIsValid(type, errors);
+            }
+        }
+    }
+
+    private static void EnsureDirectiveNameIsValid(
+        DirectiveType type,
+        ICollection<ISchemaError> errors)
+    {
+        if (type.Name.Value.StartsWith(_twoUnderscores))
+        {
+            errors.Add(TwoUnderscoresNotAllowedOnDirectiveName(type));
+        }
+    }
+}

src/HotChocolate/Core/src/Types/Configuration/Validation/ErrorHelper.cs

@@ -9,6 +9,7 @@ internal static class ErrorHelper
     private const string _interfaceTypeValidation = "sec-Interfaces.Type-Validation";
     private const string _objectTypeValidation = "sec-Objects.Type-Validation";
     private const string _inputObjectTypeValidation = "sec-Input-Objects.Type-Validation";
+    private const string _directiveValidation = "sec-Type-System.Directives.Validation";
 
     public static ISchemaError NeedsOneAtLeastField(INamedType type)
         => SchemaErrorBuilder.New()
@@ -47,6 +48,25 @@ public static ISchemaError TwoUnderscoresNotAllowedOnArgument(
             .SetSpecifiedBy(type.Kind)
             .Build();
 
+    public static ISchemaError TwoUnderscoresNotAllowedOnArgument(
+        DirectiveType type,
+        IInputField argument)
+        => SchemaErrorBuilder.New()
+            .SetMessage(
+                "Argument names starting with `__` are reserved for " +
+                " the GraphQL specification.")
+            .SetDirective(type)
+            .SetArgument(argument)
+            .SetSpecifiedBy(TypeKind.Directive)
+            .Build();
+
+    public static ISchemaError TwoUnderscoresNotAllowedOnDirectiveName(DirectiveType type)
+        => SchemaErrorBuilder.New()
+            .SetMessage("Names starting with `__` are reserved for the GraphQL specification.")
+            .SetDirective(type)
+            .SetSpecifiedBy(TypeKind.Directive)
+            .Build();
+
     public static ISchemaError NotTransitivelyImplemented(
         IComplexOutputType type,
         IComplexOutputType implementedType)
@@ -163,13 +183,58 @@ public static ISchemaError OneofInputObjectMustHaveNullableFieldsWithoutDefaults
             .SetSpecifiedBy(type.Kind, rfc: 825)
             .Build();
 
+    public static ISchemaError RequiredArgumentCannotBeDeprecated(
+        IComplexOutputType type,
+        IOutputField field,
+        IInputField argument)
+        => SchemaErrorBuilder.New()
+            .SetMessage(
+                "Required argument {0} cannot be deprecated.",
+                argument.Coordinate.ToString())
+            .SetType(type)
+            .SetField(field)
+            .SetArgument(argument)
+            .SetSpecifiedBy(type.Kind, rfc: 805)
+            .Build();
+
+    public static ISchemaError RequiredArgumentCannotBeDeprecated(
+        DirectiveType directive,
+        IInputField argument)
+        => SchemaErrorBuilder.New()
+            .SetMessage(
+                "Required argument {0} cannot be deprecated.",
+                argument.Coordinate.ToString())
+            .SetDirective(directive)
+            .SetArgument(argument)
+            .SetSpecifiedBy(TypeKind.Directive, rfc: 805)
+            .Build();
+
+    public static ISchemaError RequiredFieldCannotBeDeprecated(
+        IInputObjectType type,
+        IInputField field)
+        => SchemaErrorBuilder.New()
+            .SetMessage(
+                "Required input field {0} cannot be deprecated.",
+                field.Coordinate.ToString())
+            .SetType(type)
+            .SetField(field)
+            .SetSpecifiedBy(TypeKind.InputObject, rfc: 805)
+            .Build();
+
     private static ISchemaErrorBuilder SetType(
         this ISchemaErrorBuilder errorBuilder,
         INamedType type)
         => errorBuilder
             .AddSyntaxNode(type.SyntaxNode)
             .SetTypeSystemObject((TypeSystemObjectBase)type);
 
+    private static ISchemaErrorBuilder SetDirective(
+        this ISchemaErrorBuilder errorBuilder,
+        DirectiveType type)
+        => errorBuilder
+            .AddSyntaxNode(type.SyntaxNode)
+            .SetTypeSystemObject(type);
+
     private static ISchemaErrorBuilder SetField(
         this ISchemaErrorBuilder errorBuilder,
         IField field,
@@ -208,7 +273,8 @@ private static ISchemaErrorBuilder SetSpecifiedBy(
         errorBuilder
             .SpecifiedBy(_interfaceTypeValidation, kind is TypeKind.Interface)
             .SpecifiedBy(_objectTypeValidation, kind is TypeKind.Object)
-            .SpecifiedBy(_inputObjectTypeValidation, kind is TypeKind.InputObject);
+            .SpecifiedBy(_inputObjectTypeValidation, kind is TypeKind.InputObject)
+            .SpecifiedBy(_directiveValidation, kind is TypeKind.Directive);
 
         if (rfc.HasValue)
         {

src/HotChocolate/Core/src/Types/Configuration/Validation/InputObjectTypeValidationRule.cs

@@ -20,6 +20,7 @@ public void Validate(
                 EnsureTypeHasFields(type, errors);
                 EnsureFieldNamesAreValid(type, errors);
                 EnsureOneOfFieldsAreValid(type, errors);
+                EnsureFieldDeprecationIsValid(type, errors);
             }
         }
     }

src/HotChocolate/Core/src/Types/Configuration/Validation/InterfaceTypeValidationRule.cs

@@ -21,6 +21,7 @@ public void Validate(
                 EnsureTypeHasFields(type, errors);
                 EnsureFieldNamesAreValid(type, errors);
                 EnsureInterfacesAreCorrectlyImplemented(type, errors);
+                EnsureArgumentDeprecationIsValid(type, errors);
             }
         }
     }

src/HotChocolate/Core/src/Types/Configuration/Validation/ObjectTypeValidationRule.cs

@@ -25,6 +25,7 @@ public void Validate(
                 EnsureTypeHasFields(type, errors);
                 EnsureFieldNamesAreValid(type, errors);
                 EnsureInterfacesAreCorrectlyImplemented(type, errors);
+                EnsureArgumentDeprecationIsValid(type, errors);
             }
         }
     }

src/HotChocolate/Core/src/Types/Configuration/Validation/SchemaValidator.cs

@@ -12,6 +12,7 @@ internal static class SchemaValidator
         new ObjectTypeValidationRule(),
         new InterfaceTypeValidationRule(),
         new InputObjectTypeValidationRule(),
+        new DirectiveValidationRule(),
         new InterfaceHasAtLeastOneImplementationRule()
     };
 

src/HotChocolate/Core/src/Types/Configuration/Validation/TypeValidationHelper.cs

@@ -22,6 +22,54 @@ public static void EnsureTypeHasFields(
         }
     }
 
+    public static void EnsureFieldDeprecationIsValid(
+        IInputObjectType type,
+        ICollection<ISchemaError> errors)
+    {
+        for (var i = 0; i < type.Fields.Count; i++)
+        {
+            IInputField field = type.Fields[i];
+
+            if (field.IsDeprecated && field.Type.IsNonNullType())
+            {
+                errors.Add(RequiredFieldCannotBeDeprecated(type, field));
+            }
+        }
+    }
+
+    public static void EnsureArgumentDeprecationIsValid(
+        IComplexOutputType type,
+        ICollection<ISchemaError> errors)
+    {
+        for (var i = 0; i < type.Fields.Count; i++)
+        {
+            IOutputField field = type.Fields[i];
+            for (var j = 0; j < field.Arguments.Count; j++)
+            {
+                IInputField argument = field.Arguments[j];
+
+                if (argument.IsDeprecated && argument.Type.IsNonNullType())
+                {
+                    errors.Add(RequiredArgumentCannotBeDeprecated(type, field, argument));
+                }
+            }
+        }
+    }
+
+    public static void EnsureArgumentDeprecationIsValid(
+        DirectiveType type,
+        ICollection<ISchemaError> errors)
+    {
+        for (var i = 0; i < type.Arguments.Count; i++)
+        {
+            Argument argument = type.Arguments[i];
+            if (argument.IsDeprecated && argument.Type.IsNonNullType())
+            {
+                errors.Add(RequiredArgumentCannotBeDeprecated(type, argument));
+            }
+        }
+    }
+
     public static void EnsureTypeHasFields(
         InputObjectType type,
         ICollection<ISchemaError> errors)
@@ -54,7 +102,9 @@ public static void EnsureFieldNamesAreValid(
                     if (argument.Name.Value.StartsWith(_twoUnderscores))
                     {
                         errors.Add(TwoUnderscoresNotAllowedOnArgument(
-                            type, field, argument));
+                            type,
+                            field,
+                            argument));
                     }
                 }
             }
@@ -76,6 +126,21 @@ public static void EnsureFieldNamesAreValid(
         }
     }
 
+    public static void EnsureArgumentNamesAreValid(
+        DirectiveType type,
+        ICollection<ISchemaError> errors)
+    {
+        for (var i = 0; i < type.Arguments.Count; i++)
+        {
+            IInputField field = type.Arguments[i];
+
+            if (field.Name.Value.StartsWith(_twoUnderscores))
+            {
+                errors.Add(TwoUnderscoresNotAllowedOnArgument(type, field));
+            }
+        }
+    }
+
     public static void EnsureInterfacesAreCorrectlyImplemented(
         IComplexOutputType type,
         ICollection<ISchemaError> errors)
@@ -133,22 +198,27 @@ private static void ValidateArguments(
                 if (!argument.Type.IsEqualTo(implementedArgument.Type))
                 {
                     errors.Add(InvalidArgumentType(
-                        field, implementedField,
-                        argument, implementedArgument));
+                        field,
+                        implementedField,
+                        argument,
+                        implementedArgument));
                 }
             }
             else if (argument.Type.IsNonNullType())
             {
                 errors.Add(AdditionalArgumentNotNullable(
-                    field, implementedField,
+                    field,
+                    implementedField,
                     argument));
             }
         }
 
         foreach (IInputField? missingArgument in implArgs.Values)
         {
             errors.Add(ArgumentNotImplemented(
-                field, implementedField, missingArgument));
+                field,
+                implementedField,
+                missingArgument));
         }
     }
 
@@ -163,6 +233,7 @@ private static bool IsFullyImplementingInterface(
                 return false;
             }
         }
+
         return true;
     }
 

src/HotChocolate/Core/src/Types/Internal/TypeExtensionHelper.cs

@@ -27,7 +27,13 @@ public static void MergeInputObjectFields(
         IList<InputFieldDefinition> typeFields)
     {
         MergeFields(context, extensionFields, typeFields,
-            (_, _, _) => { });
+             (_, extensionField, typeField) =>
+             {
+                 if (extensionField.IsDeprecated)
+                 {
+                     typeField.DeprecationReason = extensionField.DeprecationReason;
+                 }
+             });
     }
 
     private static void MergeOutputFields<T>(

src/HotChocolate/Core/src/Types/Resolvers/ArgumentValue.cs

@@ -140,5 +140,4 @@ public ArgumentValue(IInputFieldInfo argument, IError error)
     /// If this argument has error this represents the argument error.
     /// </summary>
     public IError? Error { get; }
-
 }

src/HotChocolate/Core/src/Types/SchemaSerializer.cs

@@ -473,14 +473,25 @@ private static void SerializeDeprecationDirective(
     }
 
     private static InputValueDefinitionNode SerializeInputField(
-        IInputField inputValue) =>
-        new(
+        IInputField inputValue)
+    {
+        var directives = inputValue.Directives
+            .Select(SerializeDirective)
+            .ToList();
+
+        SerializeDeprecationDirective(
+            directives,
+            inputValue.IsDeprecated,
+            inputValue.DeprecationReason);
+
+        return new(
             null,
             new NameNode(inputValue.Name),
             SerializeDescription(inputValue.Description),
             SerializeType(inputValue.Type),
             inputValue.DefaultValue,
-            inputValue.Directives.Select(SerializeDirective).ToList());
+            directives);
+    }
 
     private static ITypeNode SerializeType(IType type)
     {

src/HotChocolate/Core/src/Types/Types/Argument.cs

@@ -36,6 +36,9 @@ public Argument(ArgumentDefinition definition, int index)
         {
             Formatter = new AggregateInputValueFormatter(formatters);
         }
+
+        IsDeprecated = !string.IsNullOrEmpty(definition.DeprecationReason);
+        DeprecationReason = definition.DeprecationReason;
     }
 
     /// <summary>
@@ -52,6 +55,12 @@ public Argument(ArgumentDefinition definition, int index)
     /// <inheritdoc />
     public IInputType Type { get; private set; } = default!;
 
+    /// <inheritdoc />
+    public bool IsDeprecated { get; }
+
+    /// <inheritdoc />
+    public string? DeprecationReason { get; }
+
     /// <inheritdoc />
     public override Type RuntimeType => _runtimeType;