Throw schema exception for mutation fields that do not return a value (#8662)

Author: glen-84

src/HotChocolate/Core/src/Types.Mutations/Properties/MutationResources.Designer.cs

@@ -47,4 +47,7 @@ Check the attribute `[Input(TypeName= "{2}")]` or the method `.Input(typeName: "
   <data name="ThrowHelper_UnknownDirectiveArgument" xml:space="preserve">
     <value>`{0}` is not a valid argument of the directive `@mutation`.</value>
   </data>
+  <data name="ThrowHelper_MutationMustReturnValue" xml:space="preserve">
+    <value>The mutation field '{0}' must return a value.</value>
+  </data>
 </root>

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

@@ -47,4 +47,10 @@ public static SchemaException UnknownDirectiveArgument(
             .SetMessage(ThrowHelper_UnknownDirectiveArgument, argumentName)
             .SetCode(ErrorCodes.Schema.UnknownDirectiveArgument)
             .Build());
+
+    public static SchemaException MutationMustReturnValue(string memberName)
+        => new(SchemaErrorBuilder.New()
+            .SetMessage(ThrowHelper_MutationMustReturnValue, memberName)
+            .SetCode(ErrorCodes.Schema.MutationMustReturnValue)
+            .Build());
 }

src/HotChocolate/Core/src/Types.Mutations/ThrowHelper.cs

@@ -92,6 +92,13 @@ protected override void OnConfigure(
         IObjectFieldDescriptor descriptor,
         MemberInfo member)
     {
+        var returnType = member.GetReturnType();
+
+        if (returnType == typeof(void) || returnType == typeof(Task) || returnType == typeof(ValueTask))
+        {
+            throw ThrowHelper.MutationMustReturnValue(member.Name);
+        }
+
         descriptor.Extend().OnBeforeNaming(
             (c, d) => c.GetMutationFields().Add(
                 new MutationContextData(d,

src/HotChocolate/Core/src/Types.Mutations/UseMutationConventionAttribute.cs

@@ -1322,6 +1322,28 @@ async Task Act() =>
             exception?.Errors[0].Message);
     }
 
+    [Theory]
+    [InlineData(typeof(MutationWithVoidResult))]
+    [InlineData(typeof(MutationWithTaskResult))]
+    [InlineData(typeof(MutationWithValueTaskResult))]
+    public async Task Mutation_NotReturningValue_ThrowsSchemaException(Type mutationType)
+    {
+        // arrange
+        async Task Act() =>
+            await new ServiceCollection()
+                .AddGraphQL()
+                .AddMutationType(mutationType)
+                .BuildSchemaAsync();
+
+        // act & assert
+        var exception =
+            (SchemaException?)(await Assert.ThrowsAsync<SchemaException>(Act)).Errors[0].Exception;
+
+        Assert.Equal(
+            "The mutation field 'DoSomething' must return a value.",
+            exception?.Errors[0].Message);
+    }
+
     public class ExplicitMutation
     {
         public FieldResult<int, ExplicitCustomError> DoSomething(int status)
@@ -1852,6 +1874,26 @@ public interface IErrorInterface
         public string Message { get; }
     }
 
+    public class MutationWithVoidResult
+    {
+        [UseMutationConvention]
+        public void DoSomething()
+        {
+        }
+    }
+
+    public class MutationWithTaskResult
+    {
+        [UseMutationConvention]
+        public Task DoSomething() => Task.CompletedTask;
+    }
+
+    public class MutationWithValueTaskResult
+    {
+        [UseMutationConvention]
+        public ValueTask DoSomething() => ValueTask.CompletedTask;
+    }
+
     public class CustomNamingConvention : DefaultNamingConventions
     {
         public override string GetArgumentName(ParameterInfo parameter)

src/HotChocolate/Core/test/Types.Mutations.Tests/AnnotationBasedMutations.cs

@@ -253,6 +253,11 @@ public static class Schema
         /// The specified directive argument does not exist.
         /// </summary>
         public const string UnknownDirectiveArgument = "HC0072";
+
+        /// <summary>
+        /// A mutation field must return a value.
+        /// </summary>
+        public const string MutationMustReturnValue = "HC0089";
     }
 
     public static class Scalars