Fix #6605 mutation error type Int32 scalar resolution (#9252)

Author: michaelstaib

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

@@ -307,6 +307,10 @@ private void TryApplyPayloadConvention(
                 _typeRegistry.TryRegister(
                     _context.TypeInspector.GetOutputTypeRef(errorDef.RuntimeType),
                     errorTypeRef);
+                if (!typeof(Exception).IsAssignableFrom(errorDef.RuntimeType))
+                {
+                    EnsureMemberTypesRegistered(errorDef.RuntimeType);
+                }
                 ((ObjectType)obj.Type).Configuration!.Interfaces.Add(errorInterfaceTypeRef);
             }
 
@@ -623,6 +627,19 @@ private static Options CreateErrorOptions(
         _typeInitializer.CompleteTypeName(registeredType);
         _typeInitializer.CompileResolvers(registeredType);
 
+        // Late-registered types bypass the normal discovery pipeline; add a direct runtime
+        // binding so output field references (e.g. Int32! on error objects) can normalize.
+        _typeRegistry.TryRegister(
+            _context.TypeInspector.GetOutputTypeRef(type),
+            registeredType.TypeReference);
+
+        if (registeredType.RuntimeType != typeof(object))
+        {
+            _typeRegistry.TryRegister(
+                _context.TypeInspector.GetOutputTypeRef(registeredType.RuntimeType),
+                registeredType.TypeReference);
+        }
+
         if (registeredType.Type is ObjectType errorObject
             && errorObject.RuntimeType != typeof(object))
         {
@@ -665,6 +682,81 @@ private static Options CreateErrorOptions(
         return registeredType;
     }
 
+    private void EnsureMemberTypesRegistered(Type runtimeType)
+    {
+        HashSet<Type> processed = [];
+        EnsureMemberTypesRegistered(runtimeType, processed);
+    }
+
+    private void EnsureMemberTypesRegistered(
+        Type runtimeType,
+        HashSet<Type> processed)
+    {
+        if (!processed.Add(runtimeType))
+        {
+            return;
+        }
+
+        foreach (var member in _context.TypeInspector.GetMembers(runtimeType))
+        {
+            var memberTypeReference = _context.TypeInspector.GetReturnTypeRef(member, TypeContext.Output);
+            EnsureTypeReferenceRegistered(memberTypeReference, processed);
+        }
+    }
+
+    private void EnsureTypeReferenceRegistered(
+        TypeReference typeReference,
+        HashSet<Type> processed)
+    {
+        if (typeReference is not ExtendedTypeReference runtimeTypeReference)
+        {
+            return;
+        }
+
+        if (_typeRegistry.TryGetTypeRef(runtimeTypeReference, out var existingTypeReference)
+            && _typeRegistry.IsRegistered(existingTypeReference))
+        {
+            return;
+        }
+
+        if (!_context.TryInferSchemaType(typeReference, out var schemaTypeReferences))
+        {
+            return;
+        }
+
+        foreach (var schemaTypeReference in schemaTypeReferences)
+        {
+            _typeRegistry.TryRegister(
+                runtimeTypeReference.WithContext(schemaTypeReference.Context),
+                schemaTypeReference);
+
+            var schemaClrType = schemaTypeReference switch
+            {
+                SchemaTypeReference { Type: TypeSystemObject schemaType } => schemaType.GetType(),
+                ExtendedTypeReference { Type: { IsSchemaType: true } schemaType } => schemaType.Type,
+                _ => null
+            };
+
+            if (schemaClrType is null)
+            {
+                continue;
+            }
+
+            var dependencyType = TryRegisterType(schemaClrType);
+            if (dependencyType is not { RuntimeType: { } dependencyRuntimeType })
+            {
+                continue;
+            }
+
+            if (dependencyRuntimeType != typeof(object)
+                && dependencyRuntimeType != typeof(string)
+                && !dependencyRuntimeType.IsPrimitive)
+            {
+                EnsureMemberTypesRegistered(dependencyRuntimeType, processed);
+            }
+        }
+    }
+
     private void RegisterType(TypeSystemObject type)
     {
         var registeredType = _typeInitializer.InitializeType(type);

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

@@ -0,0 +1,61 @@
+using HotChocolate.Execution;
+using HotChocolate.Tests;
+using HotChocolate.Types.Descriptors;
+using HotChocolate.Types.Descriptors.Configurations;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace HotChocolate.Types;
+
+public class Issue6605ReproTests
+{
+    [Fact]
+    public async Task Mutation_Error_Type_With_Int_Field_Should_Not_Fail_Schema_Build()
+    {
+        var exception = await Record.ExceptionAsync(async () =>
+            await new ServiceCollection()
+                .AddGraphQL()
+                .AddQueryType<Query>()
+                .AddMutationType<Mutation>()
+                .AddMutationConventions()
+                .AddMutationErrorConfiguration<CustomErrorConfig>()
+                .BuildSchemaAsync());
+
+        Assert.Null(exception);
+    }
+
+    public class CustomErrorConfig : MutationErrorConfiguration
+    {
+        public override void OnConfigure(
+            IDescriptorContext context,
+            ObjectFieldConfiguration mutationField)
+        {
+            mutationField.AddErrorType(context, typeof(CustomError));
+            mutationField.MiddlewareConfigurations.Add(
+                new(next => async ctx =>
+                {
+                    try
+                    {
+                        await next(ctx);
+                    }
+                    catch (Exception ex)
+                    {
+                        ctx.Result = new FieldError(new CustomError(1, ex.Message));
+                    }
+                }));
+        }
+    }
+
+    public record CustomError(int ErrorCode, string Message);
+
+    public class Query
+    {
+        public Foo GetFoo() => new("Baz");
+    }
+
+    public class Mutation
+    {
+        public Foo AddFoo() => throw new Exception("foo");
+    }
+
+    public record Foo(string Bar);
+}