Mutation Conventions

src/HotChocolate/Core/src/Abstractions/AttributeExtensions.cs

@@ -22,7 +22,7 @@ public static string GetGraphQLName(this Type type)
         }
 
         TypeInfo typeInfo = type.GetTypeInfo();
-        string name = typeInfo.IsDefined(typeof(GraphQLNameAttribute), false)
+        var name = typeInfo.IsDefined(typeof(GraphQLNameAttribute), false)
             ? typeInfo.GetCustomAttribute<GraphQLNameAttribute>()!.Name
             : GetFromType(typeInfo);
 
@@ -36,7 +36,7 @@ public static string GetGraphQLName(this PropertyInfo property)
             throw new ArgumentNullException(nameof(property));
         }
 
-        string name = property.IsDefined(
+        var name = property.IsDefined(
             typeof(GraphQLNameAttribute), false)
             ? property.GetCustomAttribute<GraphQLNameAttribute>()!.Name
             : NormalizeName(property.Name);
@@ -51,7 +51,7 @@ public static string GetGraphQLName(this MethodInfo method)
             throw new ArgumentNullException(nameof(method));
         }
 
-        string name = method.IsDefined(
+        var name = method.IsDefined(
             typeof(GraphQLNameAttribute), false)
             ? method.GetCustomAttribute<GraphQLNameAttribute>()!.Name
             : NormalizeMethodName(method);
@@ -66,7 +66,7 @@ public static string GetGraphQLName(this ParameterInfo parameter)
             throw new ArgumentNullException(nameof(parameter));
         }
 
-        string name = parameter.IsDefined(
+        var name = parameter.IsDefined(
             typeof(GraphQLNameAttribute), false)
             ? parameter.GetCustomAttribute<GraphQLNameAttribute>()!.Name
             : NormalizeName(parameter.Name!);
@@ -97,7 +97,7 @@ public static string GetGraphQLName(this MemberInfo member)
 
     private static string NormalizeMethodName(MethodInfo method)
     {
-        string name = method.Name;
+        var name = method.Name;
 
         if (name.StartsWith(_get, StringComparison.Ordinal)
             && name.Length > _get.Length)
@@ -140,7 +140,7 @@ private static bool IsAsyncMethod(Type returnType)
             typeof(GraphQLDescriptionAttribute),
             false))
         {
-            GraphQLDescriptionAttribute attribute =
+            var attribute =
                 (GraphQLDescriptionAttribute)
                     attributeProvider.GetCustomAttributes(
                         typeof(GraphQLDescriptionAttribute),
@@ -181,7 +181,7 @@ private static string GetFromType(Type type)
     {
         if (type.GetTypeInfo().IsGenericType)
         {
-            string name = type.GetTypeInfo()
+            var name = type.GetTypeInfo()
                 .GetGenericTypeDefinition()
                 .Name;
 

src/HotChocolate/Core/src/Abstractions/WellKnownMiddleware.cs

@@ -64,4 +64,9 @@ public static class WellKnownMiddleware
     /// This key identifies a resolver service middleware.
     /// </summary>
     public const string ResolverService = "HotChocolate.Resolvers.ResolverService";
+
+    /// <summary>
+    /// This key identifies the mutation convention middleware.
+    /// </summary>
+    public const string MutationConvention = "HotChocolate.Types.Mutations.Conventions";
 }

src/HotChocolate/Core/src/Execution/HotChocolate.Execution.csproj

@@ -11,6 +11,10 @@
     <RootNamespace>HotChocolate.Execution</RootNamespace>
   </PropertyGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="HotChocolate.Types.Mutations" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Abstractions\HotChocolate.Abstractions.csproj" />
     <ProjectReference Include="..\Fetching\HotChocolate.Fetching.csproj" />

src/HotChocolate/Core/src/Execution/Processing/ArgumentCoercionHelper.cs

@@ -43,18 +43,18 @@ public static bool TryCoerceArguments(
         {
             if (argument.IsFinal)
             {
-                args.Add(argument.Argument.Name, argument);
+                args.Add(argument.Name, argument);
             }
             else
             {
                 IValueNode literal = VariableRewriter.Rewrite(
                     argument.ValueLiteral!,
                     argument.Type,
-                    argument.Argument.DefaultValue,
+                    argument.DefaultValue,
                     resolverContext.Variables);
 
-                args.Add(argument.Argument.Name, new ArgumentValue(
-                    argument.Argument,
+                args.Add(argument.Name, new ArgumentValue(
+                    argument,
                     literal.TryGetValueKind(out ValueKind kind)
                         ? kind
                         : ValueKind.Unknown,

src/HotChocolate/Core/src/Execution/Processing/ArgumentValue.cs

@@ -4,17 +4,19 @@
 
 namespace HotChocolate.Execution.Processing;
 
-public sealed class ArgumentValue
+public sealed class ArgumentValue : IInputFieldInfo
 {
+    private readonly IInputFieldInfo _argument;
+
     public ArgumentValue(
-        IInputField argument,
+        IInputFieldInfo argument,
         ValueKind kind,
         bool isFinal,
         bool isImplicit,
         object? value,
         IValueNode valueLiteral)
     {
-        Argument = argument ?? throw new ArgumentNullException(nameof(argument));
+        _argument = argument ?? throw new ArgumentNullException(nameof(argument));
         Kind = kind;
         IsFinal = isFinal;
         IsImplicit = isImplicit;
@@ -24,9 +26,9 @@ public ArgumentValue(
         ValueLiteral = valueLiteral ?? throw new ArgumentNullException(nameof(valueLiteral));
     }
 
-    public ArgumentValue(IInputField argument, IError error)
+    public ArgumentValue(IInputFieldInfo argument, IError error)
     {
-        Argument = argument ?? throw new ArgumentNullException(nameof(argument));
+        _argument = argument ?? throw new ArgumentNullException(nameof(argument));
         Error = error ?? throw new ArgumentNullException(nameof(error));
         HasError = true;
         IsFinal = true;
@@ -35,23 +37,64 @@ public ArgumentValue(IInputField argument, IError error)
         ValueLiteral = null;
     }
 
-    public IInputField Argument { get; }
+    /// <summary>
+    /// Gets the argument name.
+    /// </summary>
+    public NameString Name => _argument.Name;
+
+    /// <summary>
+    /// Gets the argument field coordinate.
+    /// </summary>
+    public FieldCoordinate Coordinate => _argument.Coordinate;
+
+    /// <summary>
+    /// Gets the argument type.
+    /// </summary>
+    public IInputType Type => _argument.Type;
 
-    public IInputType Type => Argument.Type;
+    /// <summary>
+    /// Gets the argument runtime type.
+    /// </summary>
+    public Type RuntimeType => _argument.RuntimeType;
 
-    public IInputValueFormatter? Formatter => Argument.Formatter;
+    /// <summary>
+    /// Gets the argument default value.
+    /// </summary>
+    public IValueNode? DefaultValue => _argument.DefaultValue;
+
+    /// <summary>
+    /// Return an optional input value formatter.
+    /// </summary>
+    public IInputValueFormatter? Formatter => _argument.Formatter;
 
     public ValueKind? Kind { get; }
 
+    /// <summary>
+    /// Defines if this argument value is fully coerced and
+    /// need no post processing.
+    /// </summary>
     public bool IsFinal { get; }
 
+    /// <summary>
+    /// Defines if this argument value has errors.
+    /// </summary>
     public bool HasError { get; }
 
     public bool IsImplicit { get; }
 
+    /// <summary>
+    /// Gets the runtime value representation of this argument.
+    /// </summary>
     public object? Value { get; }
 
+    /// <summary>
+    /// Gets the value literal of this argument value.
+    /// </summary>
     public IValueNode? ValueLiteral { get; }
 
+    /// <summary>
+    /// If this argument has error this represents the argument error.
+    /// </summary>
     public IError? Error { get; }
+
 }

src/HotChocolate/Core/src/Execution/Processing/MiddlewareContext.Arguments.cs

@@ -90,7 +90,7 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
         // runtime version we can skip over parsing it.
         if (!argument.IsFinal)
         {
-            value = _parser.ParseLiteral(argument.ValueLiteral!, argument.Argument, typeof(T));
+            value = _parser.ParseLiteral(argument.ValueLiteral!, argument, typeof(T));
         }
 
         if (value is null)
@@ -111,15 +111,15 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
             throw ResolverContext_LiteralsNotSupported(
                 _selection.SyntaxNode,
                 Path,
-                argument.Argument.Name,
+                argument.Name,
                 typeof(T));
         }
 
         // we are unable to convert the argument to the request type.
         throw ResolverContext_CannotConvertArgument(
             _selection.SyntaxNode,
             Path,
-            argument.Argument.Name,
+            argument.Name,
             typeof(T));
     }
 }

src/HotChocolate/Core/src/Execution/Processing/MiddlewareContext.Pure.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using HotChocolate.Language;
 using HotChocolate.Resolvers;
@@ -155,7 +154,7 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
             {
                 value = _parentContext._parser.ParseLiteral(
                     argument.ValueLiteral!,
-                    argument.Argument,
+                    argument,
                     typeof(T));
             }
 
@@ -177,7 +176,7 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
             if (typeof(IValueNode).IsAssignableFrom(typeof(T)))
             {
                 throw ResolverContext_LiteralsNotSupported(
-                    _selection.SyntaxNode, _path, argument.Argument.Name, typeof(T));
+                    _selection.SyntaxNode, _path, argument.Name, typeof(T));
             }
 
             // If the object is internally held as a dictionary structure we will try to
@@ -204,7 +203,7 @@ private T CoerceArgumentValue<T>(ArgumentValue argument)
 
             // we are unable to convert the argument to the request type.
             throw ResolverContext_CannotConvertArgument(
-                _selection.SyntaxNode, _path, argument.Argument.Name, typeof(T));
+                _selection.SyntaxNode, _path, argument.Name, typeof(T));
         }
     }
 }

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

@@ -10,27 +10,53 @@ public static class MutationRequestExecutorBuilderExtensions
     /// <param name="builder">
     /// The request executor builder
     /// </param>
+    /// <param name="applyToAllMutations">
+    /// Defines if the mutation convention defaults shall be applied to all mutations.
+    /// </param>
     /// <returns>
     /// The request executor builder
     /// </returns>
     /// <exception cref="ArgumentNullException">
     /// The <paramref name="builder"/> is null.
     /// </exception>
-    public static IRequestExecutorBuilder EnableMutationConventions(
-        this IRequestExecutorBuilder builder)
+    public static IRequestExecutorBuilder AddMutationConventions(
+        this IRequestExecutorBuilder builder,
+        bool applyToAllMutations = false)
+        => AddMutationConventions(
+            builder,
+            new MutationConventionOptions
+            {
+                ApplyToAllMutations = applyToAllMutations
+            });
+
+    /// <summary>
+    /// Enables mutation conventions which will simplify creating GraphQL mutations.
+    /// </summary>
+    /// <param name="builder">
+    /// The request executor builder
+    /// </param>
+    /// <param name="options">
+    /// The mutation convention options.
+    /// </param>
+    /// <returns>
+    /// The request executor builder
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// The <paramref name="builder"/> is null.
+    /// </exception>
+    public static IRequestExecutorBuilder AddMutationConventions(
+        this IRequestExecutorBuilder builder,
+        MutationConventionOptions options)
     {
         if (builder is null)
         {
             throw new ArgumentNullException(nameof(builder));
         }
 
         builder
+            .ConfigureSchema(c => c.ContextData[MutationContextDataKeys.Options] = options)
             .TryAddTypeInterceptor<ErrorTypeInterceptor>()
-            .TryAddTypeInterceptor<InputArgumentTypeInterceptor>()
-            .TryAddTypeInterceptor<PayloadTypeInterceptor>()
-            .Services
-            .AddSingleton<IParameterExpressionBuilder, InputParameterExpressionBuilder>()
-            .AddSingleton<IParameterExpressionBuilder, InputArgumentParameterExpressionBuilder>();
+            .TryAddTypeInterceptor<MutationConventionTypeInterceptor>();
 
         return builder;
     }

src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorContextDataExtensions.cs

@@ -1,4 +1,4 @@
-using static HotChocolate.Types.ErrorContextData;
+using static HotChocolate.Types.ErrorContextDataKeys;
 
 namespace HotChocolate.Types;
 

src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorContextData.cs → src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorContextDataKeys.cs

@@ -1,6 +1,6 @@
 namespace HotChocolate.Types;
 
-internal static class ErrorContextData
+internal static class ErrorContextDataKeys
 {
     /// <summary>
     /// Stores the definition of the errors on the context data

src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorMiddleware.cs

@@ -48,7 +48,7 @@ public async ValueTask InvokeAsync(IMiddlewareContext context)
                 throw;
             }
 
-            context.SetScopedValue(ErrorContextData.Errors, errors);
+            context.SetScopedValue(ErrorContextDataKeys.Errors, errors);
             context.Result = ErrorObject;
         }
         catch (Exception ex)
@@ -69,7 +69,7 @@ public async ValueTask InvokeAsync(IMiddlewareContext context)
                 throw;
             }
 
-            context.SetScopedValue(ErrorContextData.Errors,
+            context.SetScopedValue(ErrorContextDataKeys.Errors,
                 new[]
                 {
                     error

src/HotChocolate/Core/src/Types.Mutations/Errors/ErrorObjectType.cs

@@ -18,7 +18,7 @@ private void RewriteMessageFieldToNonNullableStringType(
     {
         // if a user provides his/her own error interface we will not rewrite the message type
         // and the user is responsible for ensuring that type and interface align.
-        if (context.ContextData.ContainsKey(ErrorContextData.ErrorType))
+        if (context.ContextData.ContainsKey(ErrorContextDataKeys.ErrorType))
         {
             return;
         }