Scope the projection selection properly when using the mutation conventions.

src/HotChocolate/Core/src/Abstractions/WellKnownContextData.cs

@@ -230,6 +230,11 @@ public static class WellKnownContextData
     /// </summary>
     public const string MutationQueryField = "HotChocolate.Relay.Mutations.QueryField";
 
+    /// <summary>
+    /// The key to the name of the data field when using the mutation convention.
+    /// </summary>
+    public const string MutationConventionDataField = "HotChocolate.Types.Mutations.Conventions.DataField";
+
     /// <summary>
     /// The key to get the Cache-Control header value from the context data.
     /// </summary>

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

@@ -418,6 +418,7 @@ private static ObjectType CreatePayloadType(
 
                 return parent;
             });
+        objectDef.ContextData.Add(MutationConventionDataField, dataFieldDef.Name);
         objectDef.Fields.Add(dataFieldDef);
 
         // if the mutation has domain errors we will add the errors

src/HotChocolate/Data/src/Data/Projections/Extensions/ProjectionObjectFieldDescriptorExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using System.Reflection;
 using System.Security.AccessControl;
 using System.Threading;
@@ -205,10 +206,27 @@ value is ObjectType objectType &&
                 context = new MiddlewareContextProxy(context, selection, objectType);
             }
 
+            if (context.Operation.Definition.Operation == OperationType.Mutation
+                && context.Selection.Field.Type.NullableType() is ObjectType mutationPayloadType
+                && mutationPayloadType.ContextData.GetValueOrDefault(MutationConventionDataField, null) is string dataFieldName)
+            {
+                var dataField = mutationPayloadType.Fields[dataFieldName];
+                var selection = UnwrapMutationPayloadSelect(context, dataField);
+                context = new MiddlewareContextProxy(context, selection, dataField.DeclaringType);
+            }
             return executor.Invoke(next).Invoke(context);
         };
     }
 
+    private static ISelection UnwrapMutationPayloadSelect(IMiddlewareContext context, IObjectField field)
+    {
+        var selectionVariant =
+            context.Operation.SelectionVariants.First(sv => sv.GetPossibleTypes().Contains(field.DeclaringType));
+        var unwrap = selectionVariant.GetSelectionSet(field.DeclaringType).Selections
+            .First(s => s.Field.Name == field.Name);
+        return unwrap;
+    }
+
     private sealed class MiddlewareContextProxy : IMiddlewareContext
     {
         private readonly IMiddlewareContext _context;
@@ -329,7 +347,7 @@ public ArgumentValue ReplaceArgument(string argumentName, ArgumentValue newArgum
         IResolverContext IResolverContext.Clone() => _context.Clone();
     }
 
-    private static Selection CreateProxySelection(ISelection selection, NodeFieldProxy field)
+    private static Selection CreateProxySelection(ISelection selection, IObjectField field)
     {
         var includeConditionsSource = ((Selection)selection).IncludeConditions;
         var includeConditions = new long[includeConditionsSource.Length];

src/HotChocolate/Data/test/Data.Projections.Tests/IntegrationTests.cs

@@ -280,6 +280,56 @@ ... on Bar { fieldOfBar }
 
         result.MatchSnapshot();
     }
+
+    [Fact]
+    public async Task Mutation_Convention_Select()
+    {
+        var executor = await new ServiceCollection()
+            .AddGraphQL()
+            .AddQueryType<Query>() //error thrown without query, it's not needed for the test though
+            .AddMutationType<Mutation>()
+            .AddProjections()
+            .AddMutationConventions()
+            .BuildRequestExecutorAsync();
+
+        var result = await executor.ExecuteAsync(
+             """
+              mutation {
+                  modify {
+                      foo {
+                          bar
+                      }
+                  }
+              }
+              """);
+
+        result.MatchSnapshot();
+    }
+
+    [Fact]
+    public async Task Mutation_Convention_Select_With_SingleOrDefault()
+    {
+        var executor = await new ServiceCollection()
+            .AddGraphQL()
+            .AddQueryType<Query>() //error thrown without query, it's not needed for the test though
+            .AddMutationType<Mutation>()
+            .AddProjections()
+            .AddMutationConventions()
+            .BuildRequestExecutorAsync();
+
+        var result = await executor.ExecuteAsync(
+             """
+              mutation {
+                  modifySingleOrDefault {
+                      foo {
+                          bar
+                      }
+                  }
+              }
+              """);
+
+        result.MatchSnapshot();
+    }
 }
 
 public class Query
@@ -289,6 +339,24 @@ public IQueryable<Foo> Foos
         => new Foo[] { new() { Bar = "A" }, new() { Bar = "B" } }.AsQueryable();
 }
 
+public class Mutation
+{
+    [UseMutationConvention]
+    [UseProjection]
+    public IQueryable<Foo> Modify()
+    {
+        return new Foo[] { new() { Bar = "A" }, new() { Bar = "B" } }.AsQueryable();
+    }
+
+    [UseMutationConvention]
+    [UseSingleOrDefault]
+    [UseProjection]
+    public IQueryable<Foo> ModifySingleOrDefault()
+    {
+        return new Foo[] { new() { Bar = "A" } }.AsQueryable();
+    }
+}
+
 [ExtendObjectType(typeof(Foo))]
 public class FooExtensions
 {

src/HotChocolate/Data/test/Data.Projections.Tests/__snapshots__/IntegrationTests.Mutation_Convention_Select.snap

@@ -0,0 +1,14 @@
+{
+  "data": {
+    "modify": {
+      "foo": [
+        {
+          "bar": "A"
+        },
+        {
+          "bar": "B"
+        }
+      ]
+    }
+  }
+}

src/HotChocolate/Data/test/Data.Projections.Tests/__snapshots__/IntegrationTests.Mutation_Convention_Select_With_SingleOrDefault.snap

@@ -0,0 +1,9 @@
+{
+  "data": {
+    "modifySingleOrDefault": {
+      "foo": {
+        "bar": "A"
+      }
+    }
+  }
+}