Inputs will infer only arguments. (ChilliCream#4511)

src/HotChocolate/Core/src/Types.Mutations/DependencyInjection/RequestExecutorBuilderExtensions.Errors.cs

@@ -16,7 +16,7 @@ public static class MutationRequestExecutorBuilderExtensions
     /// <exception cref="ArgumentNullException">
     /// The <paramref name="builder"/> is null.
     /// </exception>
-    public static IRequestExecutorBuilder EnableMutationConvention(
+    public static IRequestExecutorBuilder EnableMutationConventions(
         this IRequestExecutorBuilder builder)
     {
         if (builder is null)
@@ -29,7 +29,8 @@ public static IRequestExecutorBuilder EnableMutationConvention(
             .TryAddTypeInterceptor<InputArgumentTypeInterceptor>()
             .TryAddTypeInterceptor<PayloadTypeInterceptor>()
             .Services
-            .AddSingleton<IParameterExpressionBuilder, InputParameterExpressionBuilder>();
+            .AddSingleton<IParameterExpressionBuilder, InputParameterExpressionBuilder>()
+            .AddSingleton<IParameterExpressionBuilder, InputArgumentParameterExpressionBuilder>();
 
         return builder;
     }

src/HotChocolate/Core/src/Types.Mutations/Input/InputArgumentParameterExpressionBuilder.cs

@@ -0,0 +1,9 @@
+namespace HotChocolate.Types;
+
+internal class InputArgumentParameterExpressionBuilder : InputParameterExpressionBuilder
+{
+    public override bool IsDefaultHandler => true;
+
+    public override bool CanHandle(ParameterInfo parameter)
+        => parameter.Member.IsDefined(typeof(InputAttribute));
+}

src/HotChocolate/Core/src/Types.Mutations/Input/InputArgumentTypeInterceptor.cs

@@ -1,8 +1,4 @@
-using System.Collections.Generic;
 using System.Linq;
-using HotChocolate.Configuration;
-using HotChocolate.Types.Descriptors;
-using HotChocolate.Types.Descriptors.Definitions;
 
 #nullable enable
 
@@ -26,8 +22,7 @@ public override void OnBeforeRegisterDependencies(
 
             string? fieldInputName = null;
             string? fieldInputTypeName = null;
-            if (
-                field.ContextData.TryGetValue(InputContextData.Input, out object? contextObj) &&
+            if (field.ContextData.TryGetValue(InputContextData.Input, out var contextObj) &&
                 contextObj is InputContextData context)
             {
                 fieldInputName = context.ArgumentName;
@@ -57,7 +52,7 @@ public override void OnBeforeRegisterDependencies(
                 if (argumentInputName is not null)
                 {
                     arguments ??= new Dictionary<string, ArgumentReference>();
-                    if (!arguments.TryGetValue(argumentInputName, out var reference))
+                    if (!arguments.TryGetValue(argumentInputName, out ArgumentReference? reference))
                     {
                         reference = new ArgumentReference(
                             fieldInputTypeName,
@@ -90,7 +85,7 @@ public override void OnBeforeRegisterDependencies(
                 continue;
             }
 
-            foreach (var argument in arguments)
+            foreach (KeyValuePair<string, ArgumentReference> argument in arguments)
             {
                 if (field.Type is null)
                 {
@@ -111,7 +106,8 @@ TypeSystemObjectBase CreateType(IDescriptorContext _) =>
                     new InputObjectType(x =>
                     {
                         x.Name(typeName);
-                        foreach (var argumentDefinition in argument.Value.ArgumentDefinitions)
+                        foreach (ArgumentDefinition argumentDefinition in
+                            argument.Value.ArgumentDefinitions)
                         {
                             MergeFieldWithArgument(
                                 x.Field(argumentDefinition.Name),
@@ -133,7 +129,7 @@ private static void MergeFieldWithArgument(
         definition.DefaultValue = argumentDefinition.DefaultValue;
         definition.Ignore = argumentDefinition.Ignore;
         definition.RuntimeDefaultValue = argumentDefinition.RuntimeDefaultValue;
-        definition.RuntimeType = argumentDefinition.Parameter.ParameterType;
+        definition.RuntimeType = argumentDefinition.Parameter?.ParameterType;
         definition.ContextData.AddRange(argumentDefinition.ContextData);
         definition.Formatters.AddRange(argumentDefinition.Formatters);
 

src/HotChocolate/Core/src/Types.Mutations/Input/InputParameterExpressionBuilder.cs

@@ -1,10 +1,5 @@
-using System;
-using System.Collections.Generic;
 using System.Linq.Expressions;
-using System.Reflection;
-using HotChocolate.Internal;
-using HotChocolate.Resolvers;
-using HotChocolate.Utilities;
+using HotChocolate.Types.Properties;
 using static System.Linq.Expressions.Expression;
 
 #nullable enable
@@ -18,7 +13,8 @@ internal class InputParameterExpressionBuilder : IParameterExpressionBuilder
                 x => x.ArgumentValue<Dictionary<string, object>>(default));
 
         private static readonly MethodInfo _containsKey =
-            ReflectionUtils.ExtractMethod<Dictionary<string, object>>(x => x.ContainsKey(default!));
+            ReflectionUtils.ExtractMethod<Dictionary<string, object>>(
+                x => x.ContainsKey(default!));
 
         private static readonly PropertyInfo _getValue =
             typeof(Dictionary<string, object>).GetProperty("Item")!;
@@ -29,12 +25,10 @@ internal class InputParameterExpressionBuilder : IParameterExpressionBuilder
 
         public bool IsPure => true;
 
-        public bool CanHandle(ParameterInfo parameter)
-        {
-            InputAttribute? attribute = parameter.GetCustomAttribute<InputAttribute>() ??
-                parameter.Member.GetCustomAttribute<InputAttribute>();
-            return attribute is not null;
-        }
+        public virtual bool IsDefaultHandler => false;
+
+        public virtual bool CanHandle(ParameterInfo parameter)
+            => parameter.IsDefined(typeof(InputAttribute));
 
         public Expression Build(ParameterInfo parameter, Expression context)
         {
@@ -43,7 +37,9 @@ public Expression Build(ParameterInfo parameter, Expression context)
 
             if (attribute is null)
             {
-                throw new ArgumentException("Could not find the InputAttribute", nameof(parameter));
+                throw new ArgumentException(
+                    MutationResources.InputParameterExpressionBuilder_Build_NoAttribute,
+                    nameof(parameter));
             }
 
             ParameterExpression variable =

src/HotChocolate/Core/src/Types.Mutations/Properties/MutationResources.resx

@@ -32,4 +32,7 @@
     <value>Could not find a unique type name for input type of the argument {0} on field {1}. The type name {2} collides with {3}.
 Check the attribute `[Input(TypeName= "{2}")]` or the method `.Input(typeName: "{2}")` on type {4} for naming collisions.</value>
   </data>
+  <data name="InputParameterExpressionBuilder_Build_NoAttribute" xml:space="preserve">
+    <value>Could not find the InputAttribute</value>
+  </data>
 </root>

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

@@ -18,6 +18,8 @@ public abstract class CustomParameterExpressionBuilder : IParameterExpressionBui
 
     bool IParameterExpressionBuilder.IsPure => false;
 
+    bool IParameterExpressionBuilder.IsDefaultHandler => false;
+
     /// <summary>
     /// Checks if this expression builder can handle the following parameter.
     /// </summary>

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

@@ -26,6 +26,8 @@ public CustomServiceParameterExpressionBuilder(ServiceKind kind = ServiceKind.De
     ArgumentKind IParameterExpressionBuilder.Kind
         => ArgumentKind.Service;
 
+    bool IParameterExpressionBuilder.IsDefaultHandler => false;
+
     bool IParameterExpressionBuilder.IsPure
         => _kind is ServiceKind.Default;
 

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

@@ -21,6 +21,11 @@ public interface IParameterExpressionBuilder : IParameterHandler
     /// </summary>
     bool IsPure { get; }
 
+    /// <summary>
+    /// Specifies that this handler is run after all non-default handlers.
+    /// </summary>
+    bool IsDefaultHandler { get; }
+
     /// <summary>
     /// Builds an expression that resolves a resolver parameter.
     /// </summary>

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

@@ -41,6 +41,10 @@ internal sealed class DefaultResolverCompiler : IResolverCompiler
     public DefaultResolverCompiler(
         IEnumerable<IParameterExpressionBuilder>? customParameterExpressionBuilders)
     {
+        var custom = customParameterExpressionBuilders is not null
+            ? new List<IParameterExpressionBuilder>(customParameterExpressionBuilders)
+            : new List<IParameterExpressionBuilder>();
+
         // explicit internal expression builders will be added first.
         var parameterExpressionBuilders = new List<IParameterExpressionBuilder>
         {
@@ -59,9 +63,12 @@ public DefaultResolverCompiler(
         {
             // then we will add custom parameter expression builder and
             // give the user a chance to override our implicit expression builder.
-            foreach (IParameterExpressionBuilder builder in customParameterExpressionBuilders)
+            foreach (IParameterExpressionBuilder builder in custom)
             {
-                parameterExpressionBuilders.Add(builder);
+                if (!builder.IsDefaultHandler)
+                {
+                    parameterExpressionBuilders.Add(builder);
+                }
             }
         }
 
@@ -79,6 +86,19 @@ public DefaultResolverCompiler(
         parameterExpressionBuilders.Add(new ClaimsPrincipalParameterExpressionBuilder());
         parameterExpressionBuilders.Add(new PathParameterExpressionBuilder());
 
+        if (customParameterExpressionBuilders is not null)
+        {
+            // last we will add all custom default handlers. This will give these handlers a chance
+            // to apply logic only on arguments.
+            foreach (IParameterExpressionBuilder builder in custom)
+            {
+                if (builder.IsDefaultHandler)
+                {
+                    parameterExpressionBuilders.Add(builder);
+                }
+            }
+        }
+
         var parameterFieldConfigurations = new List<IParameterFieldConfiguration>();
 
         foreach (IParameterExpressionBuilder builder in parameterExpressionBuilders)

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/ArgumentParameterExpressionBuilder.cs

@@ -49,6 +49,8 @@ static bool IsArgumentOptionalMethod(MethodInfo method)
 
     public bool IsPure => true;
 
+    public bool IsDefaultHandler => true;
+
     public virtual bool CanHandle(ParameterInfo parameter)
         => parameter.IsDefined(typeof(ArgumentAttribute));
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/CancellationTokenParameterExpressionBuilder.cs

@@ -23,6 +23,8 @@ static CancellationTokenParameterExpressionBuilder()
 
     public bool IsPure => false;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => typeof(CancellationToken) == parameter.ParameterType;
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/ClaimsPrincipalParameterExpressionBuilder.cs

@@ -17,6 +17,8 @@ internal sealed class ClaimsPrincipalParameterExpressionBuilder : IParameterExpr
 
     public bool IsPure => true;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => parameter.ParameterType == typeof(ClaimsPrincipal);
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/DocumentParameterExpressionBuilder.cs

@@ -23,6 +23,8 @@ static DocumentParameterExpressionBuilder()
 
     public bool IsPure => false;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => typeof(DocumentNode) == parameter.ParameterType;
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/GlobalStateParameterExpressionBuilder.cs

@@ -31,6 +31,8 @@ internal sealed class GlobalStateParameterExpressionBuilder : IParameterExpressi
 
     public bool IsPure => true;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => parameter.IsDefined(typeof(GlobalStateAttribute));
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/LambdaParameterExpressionBuilder.cs

@@ -26,6 +26,8 @@ protected LambdaParameterExpressionBuilder(Expression<Func<TContext, TValue>> ex
 
     public bool IsPure { get; }
 
+    public bool IsDefaultHandler => false;
+
     public abstract bool CanHandle(ParameterInfo parameter);
 
     public virtual Expression Build(ParameterInfo parameter, Expression context)

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/LegacyScopedServiceParameterExpressionBuilder.cs

@@ -10,6 +10,8 @@ internal class LegacyScopedServiceParameterExpressionBuilder : IParameterExpress
 
     public bool IsPure => false;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => parameter.IsDefined(typeof(ScopedServiceAttribute));
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/ParentParameterExpressionBuilder.cs

@@ -34,6 +34,8 @@ static bool IsParentMethod(MethodInfo method)
 
     public bool IsPure => true;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => parameter.IsDefined(typeof(ParentAttribute));
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/PureResolverContextParameterExpressionBuilder.cs

@@ -14,6 +14,8 @@ internal sealed class PureResolverContextParameterExpressionBuilder
 
     public bool IsPure => true;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => typeof(IPureResolverContext) == parameter.ParameterType;
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/ResolverContextParameterExpressionBuilder.cs

@@ -13,6 +13,8 @@ internal sealed class ResolverContextParameterExpressionBuilder : IParameterExpr
 
     public bool IsPure => false;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => typeof(IResolverContext) == parameter.ParameterType;
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/SchemaParameterExpressionBuilder.cs

@@ -23,6 +23,8 @@ static SchemaParameterExpressionBuilder()
 
     public bool IsPure => true;
 
+    public bool IsDefaultHandler => false;
+
     public bool CanHandle(ParameterInfo parameter)
         => typeof(ISchema) == parameter.ParameterType ||
            typeof(Schema) == parameter.ParameterType;