Added default binding behavior option.

build.cake

@@ -222,28 +222,21 @@ Task("RedisTests")
     .IsDependentOn("EnvironmentSetup")
     .Does(() =>
 {
-    var buildSettings = new DotNetCoreBuildSettings
-    {
-        Configuration = "Debug"
-    };
-
     int i = 0;
     var testSettings = new DotNetCoreTestSettings
     {
         Configuration = "Debug",
         ResultsDirectory = $"./{testOutputDir}",
         Logger = "trx",
-        NoRestore = true,
-        NoBuild = true,
+        NoRestore = false,
+        NoBuild = false,
         ArgumentCustomization = args => args
             .Append("/p:CollectCoverage=true")
             .Append("/p:Exclude=[xunit.*]*")
             .Append("/p:CoverletOutputFormat=opencover")
             .Append($"/p:CoverletOutput=\"../../{testOutputDir}/core_{i++}\" --blame")
     };
 
-    DotNetCoreBuild("./tools/Build.Core.sln", buildSettings);
-
     foreach(var file in GetFiles("./src/**/*.Tests.csproj"))
     {
         if(file.FullPath.Contains("Redis"))
@@ -257,28 +250,21 @@ Task("MongoTests")
     .IsDependentOn("EnvironmentSetup")
     .Does(() =>
 {
-    var buildSettings = new DotNetCoreBuildSettings
-    {
-        Configuration = "Debug"
-    };
-
     int i = 0;
     var testSettings = new DotNetCoreTestSettings
     {
         Configuration = "Debug",
         ResultsDirectory = $"./{testOutputDir}",
         Logger = "trx",
-        NoRestore = true,
-        NoBuild = true,
+        NoRestore = false,
+        NoBuild = false,
         ArgumentCustomization = args => args
             .Append("/p:CollectCoverage=true")
             .Append("/p:Exclude=[xunit.*]*")
             .Append("/p:CoverletOutputFormat=opencover")
             .Append($"/p:CoverletOutput=\"../../{testOutputDir}/core_{i++}\" --blame")
     };
 
-    DotNetCoreBuild("./tools/Build.Core.sln", buildSettings);
-
     foreach(var file in GetFiles("./src/**/*.Tests.csproj"))
     {
         if(file.FullPath.Contains("Mongo"))

src/Core/Types.Filters/FilterFieldDescriptorBase.cs

@@ -24,6 +24,8 @@ protected FilterFieldDescriptorBase(
             Definition.Description = context.Naming.GetMemberDescription(
                 property, MemberKind.InputObjectField);
             Definition.Type = context.Inspector.GetInputReturnType(property);
+            Definition.Filters.BindingBehavior =
+                context.Options.DefaultBindingBehavior;
         }
 
         protected override FilterFieldDefintion Definition { get; } =

src/Core/Types.Filters/FilterInputTypeDescriptor.cs

@@ -32,6 +32,8 @@ protected FilterInputTypeDescriptor(
             // TODO : should we rework get type description?
             Definition.Description = context.Naming.GetTypeDescription(
                 entityType, TypeKind.Object);
+            Definition.Fields.BindingBehavior =
+                context.Options.DefaultBindingBehavior;
         }
 
         protected override FilterInputTypeDefinition Definition { get; } =

src/Core/Types.Tests/Configuration/ReadOnlySchemaOptionsTests.cs

@@ -0,0 +1,57 @@
+using HotChocolate.Types;
+using Xunit;
+using Snapshooter.Xunit;
+using HotChocolate.Configuration;
+using System;
+
+namespace HotChocolate
+{
+    public class ReadOnlySchemaOptionsTests
+    {
+        [Fact]
+        public void Copy_Options()
+        {
+            // arrange
+            var options = new SchemaOptions
+            {
+                QueryTypeName = "A",
+                MutationTypeName = "B",
+                SubscriptionTypeName = "C",
+                StrictValidation = false,
+                UseXmlDocumentation = false,
+                DefaultBindingBehavior = BindingBehavior.Explicit,
+                FieldMiddleware = FieldMiddlewareApplication.AllFields
+            };
+
+            // act
+            var copied = new ReadOnlySchemaOptions(options);
+
+            // assert
+            copied.MatchSnapshot();
+        }
+
+        [Fact]
+        public void Copy_Options_Defaults()
+        {
+            // arrange
+            var options = new SchemaOptions();
+
+            // act
+            var copied = new ReadOnlySchemaOptions(options);
+
+            // assert
+            copied.MatchSnapshot();
+        }
+
+        [Fact]
+        public void Create_Options_Null()
+        {
+            // arrange
+            // act
+            Action action = () => new ReadOnlySchemaOptions(null);
+
+            // assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+    }
+}

src/Core/Types.Tests/Configuration/__snapshots__/ReadOnlySchemaOptionsTests.Copy_Options.snap

@@ -0,0 +1,9 @@
+{
+  "QueryTypeName": "A",
+  "MutationTypeName": "B",
+  "SubscriptionTypeName": "C",
+  "StrictValidation": false,
+  "UseXmlDocumentation": false,
+  "DefaultBindingBehavior": "Explicit",
+  "FieldMiddleware": "AllFields"
+}

src/Core/Types.Tests/Configuration/__snapshots__/ReadOnlySchemaOptionsTests.Copy_Options_Defaults.snap

@@ -0,0 +1,9 @@
+{
+  "QueryTypeName": "Query",
+  "MutationTypeName": "Mutation",
+  "SubscriptionTypeName": "Subscription",
+  "StrictValidation": true,
+  "UseXmlDocumentation": true,
+  "DefaultBindingBehavior": "Implicit",
+  "FieldMiddleware": "UserDefinedFields"
+}

src/Core/Types.Tests/Types/DirectiveTypeTests.cs

@@ -24,6 +24,40 @@ public void ConfigureTypedDirectiveWithResolver()
             Assert.True(directiveType.IsExecutable);
             Assert.NotEmpty(directiveType.MiddlewareComponents);
             Assert.Equal(typeof(CustomDirective), directiveType.ClrType);
+            Assert.Collection(directiveType.Arguments,
+                t => Assert.Equal("argument", t.Name.Value));
+        }
+
+        [Fact]
+        public void ConfigureTypedDirective_DefaultBinding_Explicit()
+        {
+            // arrange
+            // act
+            DirectiveType directiveType =
+                CreateDirective(new CustomDirectiveType(),
+                    b => b.ModifyOptions(o =>
+                        o.DefaultBindingBehavior = BindingBehavior.Explicit));
+
+            // assert
+            Assert.True(directiveType.IsExecutable);
+            Assert.NotEmpty(directiveType.MiddlewareComponents);
+            Assert.Equal(typeof(CustomDirective), directiveType.ClrType);
+            Assert.Empty(directiveType.Arguments);
+        }
+
+        [Fact]
+        public void ConfigureTypedDirectiveNoArguments()
+        {
+            // arrange
+            // act
+            DirectiveType directiveType =
+                CreateDirective(new Custom2DirectiveType());
+
+            // assert
+            Assert.True(directiveType.IsExecutable);
+            Assert.NotEmpty(directiveType.MiddlewareComponents);
+            Assert.Equal(typeof(CustomDirective), directiveType.ClrType);
+            Assert.Empty(directiveType.Arguments);
         }
 
         [Fact]
@@ -481,6 +515,20 @@ protected override void Configure(
             }
         }
 
+        public class Custom2DirectiveType
+            : DirectiveType<CustomDirective>
+        {
+            protected override void Configure(
+                IDirectiveTypeDescriptor<CustomDirective> descriptor)
+            {
+                descriptor.Name("Custom");
+                descriptor.Location(DirectiveLocation.Enum);
+                descriptor.Location(DirectiveLocation.Field);
+                descriptor.Use(next => context => Task.CompletedTask);
+                descriptor.BindArgumentsImplicitly().BindArgumentsExplicitly();
+            }
+        }
+
         public class DirectiveMiddleware
         {
             private FieldDelegate _next;

src/Core/Types.Tests/Types/EnumTypeTests.cs

@@ -170,6 +170,29 @@ public void ExplicitEnumType_OnlyContainDeclaredValues()
             Assert.Null(value);
         }
 
+         [Fact]
+        public void ExplicitEnumType_OnlyContainDeclaredValues_2()
+        {
+            // act
+            var schema = Schema.Create(c =>
+            {
+                c.RegisterType(new EnumType<Foo>(d =>
+                {
+                    d.BindItemsImplicitly().BindItemsExplicitly();
+                    d.Item(Foo.Bar1);
+                }));
+                c.Options.StrictValidation = false;
+            });
+
+            // assert
+            EnumType type = schema.GetType<EnumType>("Foo");
+            Assert.NotNull(type);
+            Assert.True(type.TryGetValue("BAR1", out object value));
+            Assert.Equal(Foo.Bar1, value);
+            Assert.False(type.TryGetValue("BAR2", out value));
+            Assert.Null(value);
+        }
+
         [Fact]
         public void ImplicitEnumType_OnlyBar1HasCustomName()
         {

src/Core/Types/Configuration/Contracts/IReadOnlySchemaOptions.cs

@@ -1,4 +1,6 @@
-namespace HotChocolate.Configuration
+using HotChocolate.Types;
+
+namespace HotChocolate.Configuration
 {
     public interface IReadOnlySchemaOptions
     {
@@ -12,6 +14,11 @@ public interface IReadOnlySchemaOptions
 
         bool UseXmlDocumentation { get; }
 
+        /// <summary>
+        /// Defines the default binding behavior.
+        /// </summary>
+        BindingBehavior DefaultBindingBehavior { get; }
+
         /// <summary>
         /// Defines on which fields a middleware pipeline can be applied on.
         /// </summary>

src/Core/Types/Configuration/Contracts/ISchemaOptions.cs

@@ -1,4 +1,6 @@
-namespace HotChocolate.Configuration
+using HotChocolate.Types;
+
+namespace HotChocolate.Configuration
 {
     public interface ISchemaOptions
         : IReadOnlySchemaOptions
@@ -13,6 +15,8 @@ public interface ISchemaOptions
 
         new bool UseXmlDocumentation { get; set; }
 
+        new BindingBehavior DefaultBindingBehavior { get; set; }
+
         new FieldMiddlewareApplication FieldMiddleware { get; set; }
     }
 }

src/Core/Types/Configuration/ReadOnlySchemaOptions.cs

@@ -1,4 +1,5 @@
 using System;
+using HotChocolate.Types;
 
 namespace HotChocolate.Configuration
 {
@@ -20,6 +21,7 @@ public ReadOnlySchemaOptions(IReadOnlySchemaOptions options)
                 ?? "Subscription";
             StrictValidation = options.StrictValidation;
             UseXmlDocumentation = options.UseXmlDocumentation;
+            DefaultBindingBehavior = options.DefaultBindingBehavior;
             FieldMiddleware = options.FieldMiddleware;
         }
 
@@ -33,6 +35,8 @@ public ReadOnlySchemaOptions(IReadOnlySchemaOptions options)
 
         public bool UseXmlDocumentation { get; }
 
+        public BindingBehavior DefaultBindingBehavior { get; }
+
         public FieldMiddlewareApplication FieldMiddleware { get; }
     }
 }

src/Core/Types/Configuration/SchemaOptions.cs

@@ -1,3 +1,5 @@
+using HotChocolate.Types;
+
 namespace HotChocolate.Configuration
 {
     public class SchemaOptions
@@ -13,6 +15,9 @@ public class SchemaOptions
 
         public bool UseXmlDocumentation { get; set; } = true;
 
+        public BindingBehavior DefaultBindingBehavior { get; set; } =
+            BindingBehavior.Implicit;
+
         public FieldMiddlewareApplication FieldMiddleware
         {
             get;
@@ -28,7 +33,8 @@ public static SchemaOptions FromOptions(IReadOnlySchemaOptions options)
                 SubscriptionTypeName = options.SubscriptionTypeName,
                 StrictValidation = options.StrictValidation,
                 UseXmlDocumentation = options.UseXmlDocumentation,
-                FieldMiddleware = options.FieldMiddleware
+                FieldMiddleware = options.FieldMiddleware,
+                DefaultBindingBehavior = options.DefaultBindingBehavior
             };
         }
     }

src/Core/Types/Types/Descriptors/Contracts/IDirectiveTypeDescriptor~1.cs

@@ -59,6 +59,16 @@ IDirectiveTypeDescriptor<T> SyntaxNode(
         IDirectiveTypeDescriptor<T> BindArguments(
             BindingBehavior behavior);
 
+        /// <summary>
+        /// Defines that all arguments have to be specified explicitly.
+        /// </summary>
+        IDirectiveTypeDescriptor<T> BindArgumentsExplicitly();
+
+        /// <summary>
+        /// The directive type will add arguments for all compatible properties.
+        /// </summary>
+        IDirectiveTypeDescriptor<T> BindArgumentsImplicitly();
+
         /// <summary>
         /// Specifies a directive argument.
         /// </summary>

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

@@ -44,6 +44,17 @@ IEnumValueDescriptor Value<T>(
         IEnumTypeDescriptor BindItems(
             BindingBehavior behavior);
 
+        /// <summary>
+        /// Defines that all enum values have to be specified explicitly.
+        /// </summary>
+        IEnumTypeDescriptor BindItemsExplicitly();
+
+        /// <summary>
+        /// Defines that all enum values shall be infered
+        /// from the associated .Net type,
+        /// </summary>
+        IEnumTypeDescriptor BindItemsImplicitly();
+
         IEnumTypeDescriptor Directive<T>(
             T directiveInstance)
             where T : class;

src/Core/Types/Types/Descriptors/Contracts/IEnumTypeDescriptor~1.cs

@@ -39,6 +39,17 @@ IEnumTypeDescriptor<T> SyntaxNode(
 
         IEnumTypeDescriptor<T> BindItems(BindingBehavior behavior);
 
+        /// <summary>
+        /// Defines that all enum values have to be specified explicitly.
+        /// </summary>
+        IEnumTypeDescriptor<T> BindItemsExplicitly();
+
+        /// <summary>
+        /// Defines that all enum values shall be infered
+        /// from the associated .Net type,
+        /// </summary>
+        IEnumTypeDescriptor<T> BindItemsImplicitly();
+
         IEnumTypeDescriptor<T> Directive<TDirective>(
             TDirective directiveInstance)
             where TDirective : class;