V10 Adds Unignore

src/Core/Types.Tests/Types/Descriptors/ObjectTypeDescriptorTests.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Threading.Tasks;
 using HotChocolate.Execution;
@@ -102,6 +102,26 @@ public void IgnoreOverridenPropertyField()
                 t => Assert.Equal("c", t));
         }
 
+        [Fact]
+        public void UnignoreOverridenPropertyField()
+        {
+            // arrange
+            var descriptor = new ObjectTypeDescriptor<Foo>(Context);
+
+            // act
+            descriptor.Field(t => t.B).Ignore();
+            descriptor.Field(t => t.B).Ignore(false);
+
+            // assert
+            Assert.Collection(
+                descriptor.CreateDefinition().Fields
+                    .Select(t => t.Name)
+                    .OrderBy(t => t),
+                t => Assert.Equal("a", t),
+                t => Assert.Equal("b", t),
+                t => Assert.Equal("c", t));
+        }
+
 
         [Fact]
         public void IgnoreOverridenMethodField()
@@ -123,6 +143,28 @@ public void IgnoreOverridenMethodField()
                 t => Assert.Equal("c", t));
         }
 
+        [Fact]
+        public void UnignoreOverridenMethodField()
+        {
+            // arrange
+            var descriptor = new ObjectTypeDescriptor<Foo>(Context);
+
+            // act
+            IObjectTypeDescriptor<Foo> desc = descriptor;
+            desc.Field(t => t.Equals(default)).Ignore();
+            desc.Field(t => t.Equals(default)).Ignore(false);
+
+            // assert
+            Assert.Collection(
+                descriptor.CreateDefinition().Fields
+                    .Select(t => t.Name)
+                    .OrderBy(t => t),
+                t => Assert.Equal("a", t),
+                t => Assert.Equal("b", t),
+                t => Assert.Equal("c", t),
+                t => Assert.Equal("equals", t));
+        }
+
         [Fact]
         public void DeclareFieldsExplicitly()
         {

src/Core/Types.Tests/Types/InterfaceTypeTests.cs

@@ -162,6 +162,43 @@ public void IgnoreFieldsFromClrInterface()
                 });
         }
 
+        [Fact]
+        public void UnignoreFieldsFromClrInterface()
+        {
+            // arrange
+            // act
+            InterfaceType<IFoo> fooType = CreateType(
+                new InterfaceType<IFoo>(t =>
+                {
+                    t.Ignore(p => p.Bar);
+                    t.Field(p => p.Bar).Ignore(false);
+                }),
+                b => b.ModifyOptions(o => o.StrictValidation = false));
+
+            // assert
+            Assert.Collection(
+                fooType.Fields.Where(t => !t.IsIntrospectionField),
+                t =>
+                {
+                    Assert.Equal("bar", t.Name);
+                    Assert.IsType<BooleanType>(
+                        Assert.IsType<NonNullType>(t.Type).Type);
+                },
+                t =>
+                {
+                    Assert.Equal("baz", t.Name);
+                    Assert.IsType<StringType>(t.Type);
+                },
+                t =>
+                {
+                    Assert.Equal("qux", t.Name);
+                    Assert.IsType<IntType>(
+                        Assert.IsType<NonNullType>(t.Type).Type);
+                    Assert.Collection(t.Arguments,
+                        a => Assert.Equal("a", a.Name));
+                });
+        }
+
         [Fact]
         public void ExplicitInterfaceFieldDeclaration()
         {

src/Core/Types.Tests/Types/ObjectTypeTests.cs

@@ -1207,6 +1207,26 @@ public void IgnoreFieldWithShortcut()
 
         }
 
+        [Fact]
+        public void UnignoreFieldWithShortcut()
+        {
+            // arrange
+            // act
+            ObjectType<Foo> fooType = CreateType(new ObjectType<Foo>(d =>
+            {
+                d.Ignore(t => t.Description);
+                d.Field("foo").Type<StringType>().Resolver("abc");
+                d.Field(t => t.Description).Ignore(false);
+            }));
+
+            // assert
+            Assert.Collection(
+                fooType.Fields.Where(t => !t.IsIntrospectionField),
+                t => Assert.Equal("description", t.Name),
+                t => Assert.Equal("foo", t.Name));
+
+        }
+
         [Fact]
         public void IgnoreField_DescriptorIsNull_ArgumentNullException()
         {

src/Core/Types/Resolvers/Expressions/Arguments/GetEventMessageCompiler.cs

@@ -3,7 +3,6 @@
 using System.Reflection;
 using HotChocolate.Execution;
 using HotChocolate.Resolvers.CodeGeneration;
-using HotChocolate.Subscriptions;
 
 namespace HotChocolate.Resolvers.Expressions.Parameters
 {

src/Core/Types/Types/Descriptors/Contracts/IInterfaceFieldDescriptor.cs

@@ -33,7 +33,7 @@ IInterfaceFieldDescriptor Type<TOutputType>(TOutputType type)
 
         IInterfaceFieldDescriptor Type(Type type);
 
-        IInterfaceFieldDescriptor Ignore();
+        IInterfaceFieldDescriptor Ignore(bool ignore = true);
 
         IInterfaceFieldDescriptor Argument(
             NameString name,

src/Core/Types/Types/Descriptors/Contracts/IObjectFieldDescriptor.cs

@@ -45,7 +45,7 @@ IObjectFieldDescriptor Argument(
             NameString argumentName,
             Action<IArgumentDescriptor> argumentDescriptor);
 
-        IObjectFieldDescriptor Ignore();
+        IObjectFieldDescriptor Ignore(bool ignore = true);
 
         IObjectFieldDescriptor Resolver(
             FieldResolverDelegate fieldResolver);

src/Core/Types/Types/Descriptors/InterfaceFieldDescriptor.cs

@@ -149,9 +149,9 @@ public IInterfaceFieldDescriptor DeprecationReason(string reason) =>
             return this;
         }
 
-        public new IInterfaceFieldDescriptor Ignore()
+        public new IInterfaceFieldDescriptor Ignore(bool ignore = true)
         {
-            base.Ignore();
+            base.Ignore(ignore);
             return this;
         }
 

src/Core/Types/Types/Descriptors/ObjectFieldDescriptor.cs

@@ -171,9 +171,9 @@ public IObjectFieldDescriptor DeprecationReason(string? reason) =>
             return this;
         }
 
-        public new IObjectFieldDescriptor Ignore()
+        public new IObjectFieldDescriptor Ignore(bool ignore = true)
         {
-            base.Ignore();
+            base.Ignore(ignore);
             return this;
         }
 

src/Core/Types/Types/Descriptors/OutputFieldDescriptorBase.cs

@@ -1,10 +1,10 @@
-using System.Collections.Generic;
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using HotChocolate.Language;
 using HotChocolate.Properties;
 using HotChocolate.Types.Descriptors.Definitions;
-using System.Reflection;
-using System.Linq;
 
 namespace HotChocolate.Types.Descriptors
 {
@@ -170,9 +170,9 @@ private void AddDeprectedDirective(string reason)
             }
         }
 
-        protected void Ignore()
+        protected void Ignore(bool ignore = true)
         {
-            Definition.Ignore = true;
+            Definition.Ignore = ignore;
         }
 
         protected void Directive<T>(T directive)