Add @deprecated support (graphql-dotnet#528)

* Add @deprecated support

GH: graphql-dotnet#498

Author: joemcbride

src/GraphQL.Tests/Utilities/SchemaBuilderTests.cs

@@ -311,6 +311,125 @@ directive @myDirective(
             });
         }
 
+        [Fact]
+        public void custom_deprecation_on_type_field()
+        {
+            var definitions = @"
+                type Query {
+                  stars: Int @deprecated(reason: ""a reason"")
+                }
+            ";
+
+            var schema = Schema.For(definitions);
+            schema.Initialize();
+
+            var type = schema.FindType("Query") as IObjectGraphType;
+            type.ShouldNotBeNull();
+            type.Fields.Count().ShouldBe(1);
+            type.Fields.Single().DeprecationReason.ShouldBe("a reason");
+        }
+
+        [Fact]
+        public void default_deprecation_on_type_field()
+        {
+            var definitions = @"
+                type Query {
+                  stars: Int @deprecated
+                }
+            ";
+
+            var schema = Schema.For(definitions);
+            schema.Initialize();
+
+            var type = schema.FindType("Query") as IObjectGraphType;
+            type.ShouldNotBeNull();
+            type.Fields.Count().ShouldBe(1);
+            type.Fields.Single().DeprecationReason.ShouldBe("No longer supported");
+        }
+
+        [Fact]
+        public void default_deprecation_on_interface_field()
+        {
+            var definitions = @"
+                interface Movie {
+                  stars: Int @deprecated
+                }
+            ";
+
+            var schema = Schema.For(definitions);
+            schema.Initialize();
+
+            var type = schema.FindType("Movie") as IInterfaceGraphType;
+            type.ShouldNotBeNull();
+            type.Fields.Count().ShouldBe(1);
+            type.Fields.Single().DeprecationReason.ShouldBe("No longer supported");
+        }
+
+        [Fact]
+        public void deprecate_enum_value()
+        {
+            var definitions = @"
+                enum PetKind {
+                    CAT @deprecated(reason: ""dogs rule"")
+                    DOG
+                }
+            ";
+
+            var schema = Schema.For(definitions);
+            schema.Initialize();
+
+            var type = schema.FindType("PetKind") as EnumerationGraphType;
+            type.ShouldNotBeNull();
+
+            var cat = type.Values.Single(x => x.Name == "CAT");
+            cat.DeprecationReason.ShouldBe("dogs rule");
+        }
+
+        [Fact]
+        public void default_deprecation_on_input_field()
+        {
+            var definitions = @"
+                input MovieInput {
+                  stars: Int @deprecated
+                }
+            ";
+
+            var schema = Schema.For(definitions);
+            schema.Initialize();
+
+            var type = schema.FindType("MovieInput") as IInputObjectGraphType;
+            type.ShouldNotBeNull();
+            type.Fields.Count().ShouldBe(1);
+            type.Fields.Single().DeprecationReason.ShouldBe("No longer supported");
+        }
+
+        [Fact]
+        public void deprecated_prefers_metadata_values()
+        {
+            var definitions = @"
+                type Movie {
+                  movies: Int @deprecated
+                }
+            ";
+
+            var schema = Schema.For(definitions, _ => _.Types.Include<Movie>());
+            schema.Initialize();
+
+            var type = schema.FindType("Movie") as IObjectGraphType;
+            type.ShouldNotBeNull();
+            type.Fields.Count().ShouldBe(1);
+            type.Fields.Single().DeprecationReason.ShouldBe("my reason");
+        }
+
+        class Movie
+        {
+            [GraphQLMetadata("movies", DeprecationReason = "my reason")]
+            public int Movies()
+            {
+                return 0;
+            }
+        }
+
         class CustomScalarType : ScalarGraphType
         {
             public CustomScalarType()

src/GraphQL/Utilities/SchemaBuilder.cs

@@ -161,9 +161,13 @@ protected virtual IObjectGraphType ToObjectGraphType(GraphQLObjectTypeDefinition
             var type = new ObjectGraphType();
             type.Name = astType.Name.Value;
             type.Description = typeConfig.Description;
-            type.DeprecationReason = typeConfig.DeprecationReason;
             type.IsTypeOf = typeConfig.IsTypeOfFunc;
 
+            ApplyDeprecatedDirective(astType.Directives, reason =>
+            {
+                type.DeprecationReason = typeConfig.DeprecationReason ?? reason;
+            });
+
             CopyMetadata(type, typeConfig);
 
             var fields = astType.Fields.Select(f => ToFieldType(type.Name, f));
@@ -189,7 +193,6 @@ protected virtual FieldType ToFieldType(string parentTypeName, GraphQLFieldDefin
             var field = new FieldType();
             field.Name = fieldDef.Name.Value;
             field.Description = fieldConfig.Description;
-            field.DeprecationReason = fieldConfig.DeprecationReason;
             field.ResolvedType = ToGraphType(fieldDef.Type);
             field.Resolver = fieldConfig.Resolver;
 
@@ -198,16 +201,50 @@ protected virtual FieldType ToFieldType(string parentTypeName, GraphQLFieldDefin
             var args = fieldDef.Arguments.Select(ToArguments);
             field.Arguments = new QueryArguments(args);
 
+            ApplyDeprecatedDirective(fieldDef.Directives, reason =>
+            {
+                field.DeprecationReason = fieldConfig.DeprecationReason ?? reason;
+            });
+
             return field;
         }
 
-        protected virtual FieldType ToFieldType(GraphQLInputValueDefinition inputDef)
+        private static string DeprecatedDefaultValue = DirectiveGraphType.Deprecated.Arguments.Find("reason").DefaultValue.ToString();
+        private void ApplyDeprecatedDirective(IEnumerable<GraphQLDirective> directives, Action<string> apply)
+        {
+            var deprecated = directives.Directive("deprecated");
+
+            if(deprecated != null)
+            {
+                var arg = deprecated.Arguments.Argument("reason");
+                var value = "";
+
+                if(arg != null)
+                {
+                    value = ToValue(arg.Value).ToString();
+                }
+
+                if(string.IsNullOrWhiteSpace(value))
+                {
+                    value = DeprecatedDefaultValue;
+                }
+
+                apply(value);
+            }
+        }
+
+        protected virtual FieldType ToFieldType(string parentTypeName, GraphQLInputValueDefinition inputDef)
         {
             var field = new FieldType();
             field.Name = inputDef.Name.Value;
             field.ResolvedType = ToGraphType(inputDef.Type);
             field.DefaultValue = ToValue(inputDef.DefaultValue);
 
+            ApplyDeprecatedDirective(inputDef.Directives, reason =>
+            {
+                field.DeprecationReason = reason;
+            });
+
             return field;
         }
 
@@ -220,6 +257,11 @@ protected virtual InterfaceGraphType ToInterfaceType(GraphQLInterfaceTypeDefinit
             type.Description = typeConfig.Description;
             type.ResolveType = typeConfig.ResolveType;
 
+            ApplyDeprecatedDirective(interfaceDef.Directives, reason =>
+            {
+                type.DeprecationReason = typeConfig.DeprecationReason ?? reason;
+            });
+
             CopyMetadata(type, typeConfig);
 
             var fields = interfaceDef.Fields.Select(f => ToFieldType(type.Name, f));
@@ -237,6 +279,11 @@ protected virtual UnionGraphType ToUnionType(GraphQLUnionTypeDefinition unionDef
             type.Description = typeConfig.Description;
             type.ResolveType = typeConfig.ResolveType;
 
+            ApplyDeprecatedDirective(unionDef.Directives, reason =>
+            {
+                type.DeprecationReason = typeConfig.DeprecationReason ?? reason;
+            });
+
             CopyMetadata(type, typeConfig);
 
             var possibleTypes = unionDef.Types.Select(x => GetType(x.Name.Value));
@@ -248,8 +295,13 @@ protected virtual InputObjectGraphType ToInputObjectType(GraphQLInputObjectTypeD
         {
             var type = new InputObjectGraphType();
             type.Name = inputDef.Name.Value;
-            var fields = inputDef.Fields.Select(ToFieldType);
 
+            ApplyDeprecatedDirective(inputDef.Directives, reason =>
+            {
+                type.DeprecationReason = reason;
+            });
+
+            var fields = inputDef.Fields.Select(x => ToFieldType(type.Name, x));
             fields.Apply(f => type.AddField(f));
 
             return type;
@@ -259,6 +311,12 @@ protected virtual EnumerationGraphType ToEnumerationType(GraphQLEnumTypeDefiniti
         {
             var type = new EnumerationGraphType();
             type.Name = enumDef.Name.Value;
+
+            ApplyDeprecatedDirective(enumDef.Directives, reason =>
+            {
+                type.DeprecationReason = reason;
+            });
+
             var values = enumDef.Values.Select(ToEnumValue);
             values.Apply(type.AddValue);
             return type;
@@ -292,6 +350,12 @@ private EnumValueDefinition ToEnumValue(GraphQLEnumValueDefinition valDef)
             var val = new EnumValueDefinition();
             val.Value = valDef.Name.Value;
             val.Name = valDef.Name.Value;
+
+            ApplyDeprecatedDirective(valDef.Directives, reason =>
+            {
+                val.DeprecationReason = reason;
+            });
+
             return val;
         }
 
@@ -413,4 +477,19 @@ protected virtual void CopyMetadata(IProvideMetadata target, IProvideMetadata so
             });
         }
     }
+
+    internal static class SchemaExtensions
+    {
+        public static GraphQLDirective Directive(this IEnumerable<GraphQLDirective> directives, string name)
+        {
+            return directives?.FirstOrDefault(
+                x => string.Equals(x.Name.Value, name, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public static GraphQLArgument Argument(this IEnumerable<GraphQLArgument> arguments, string name)
+        {
+            return arguments?.FirstOrDefault(
+                x => string.Equals(x.Name.Value, name, StringComparison.OrdinalIgnoreCase));
+        }
+    }
 }