Added Schema Error Interceptor

src/HotChocolate/Core/src/Execution/DependencyInjection/SchemaRequestExecutorBuilderExtensions.TypeInterceptor.cs

@@ -2,6 +2,7 @@
 using HotChocolate;
 using HotChocolate.Configuration;
 using HotChocolate.Execution.Configuration;
+using HotChocolate.Types.Descriptors;
 using HotChocolate.Types.Descriptors.Definitions;
 
 namespace Microsoft.Extensions.DependencyInjection
@@ -356,10 +357,30 @@ public static partial class SchemaRequestExecutorBuilderExtensions
                 throw new ArgumentNullException(nameof(onAfterCompleteType));
             }
 
-            return builder.ConfigureSchema(b => b
-                .TryAddTypeInterceptor(new DelegateTypeInitializationInterceptor<T>(
-                    canHandle,
-                    onAfterCompleteType: onAfterCompleteType)));
+            return builder.ConfigureSchema(
+                b => b.TryAddTypeInterceptor(
+                    new DelegateTypeInitializationInterceptor<T>(
+                        canHandle,
+                        onAfterCompleteType: onAfterCompleteType)));
+        }
+
+        public static IRequestExecutorBuilder OnSchemaError(
+            this IRequestExecutorBuilder builder,
+            Action<IDescriptorContext, Exception> onError)
+        {
+            if (builder is null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
+            if (onError is null)
+            {
+                throw new ArgumentNullException(nameof(onError));
+            }
+
+            return builder.ConfigureSchema(
+                b => b.TryAddSchemaInterceptor(
+                    new DelegateSchemaInterceptor(onError: onError)));
         }
     }
 }

src/HotChocolate/Core/src/Types/Configuration/AggregateSchemaInterceptor.cs

@@ -45,5 +45,18 @@ public void OnAfterCreate(IDescriptorContext context, ISchema schema)
                 interceptor.OnAfterCreate(context, schema);
             }
         }
+
+        public void OnError(IDescriptorContext context, Exception exception)
+        {
+            if (_interceptors.Count == 0)
+            {
+                return;
+            }
+
+            foreach (ISchemaInterceptor interceptor in _interceptors)
+            {
+                interceptor.OnError(context, exception);
+            }
+        }
     }
 }

src/HotChocolate/Core/src/Types/Configuration/DelegateSchemaInterceptor.cs

@@ -0,0 +1,39 @@
+using System;
+using HotChocolate.Types.Descriptors;
+
+#nullable enable
+
+namespace HotChocolate.Configuration
+{
+    public class DelegateSchemaInterceptor : SchemaInterceptor
+    {
+        private readonly Action<IDescriptorContext, ISchemaBuilder>? _onBeforeCreate;
+        private readonly Action<IDescriptorContext, ISchema>? _onAfterCreate;
+        private readonly Action<IDescriptorContext, Exception>? _onError;
+
+        public DelegateSchemaInterceptor(
+            Action<IDescriptorContext, ISchemaBuilder>? onBeforeCreate = null,
+            Action<IDescriptorContext, ISchema>? onAfterCreate = null,
+            Action<IDescriptorContext, Exception>? onError = null)
+        {
+            _onAfterCreate = onAfterCreate;
+            _onBeforeCreate = onBeforeCreate;
+            _onError = onError;
+        }
+
+        public override void OnBeforeCreate(
+            IDescriptorContext context,
+            ISchemaBuilder schemaBuilder) =>
+            _onBeforeCreate?.Invoke(context, schemaBuilder);
+
+        public override void OnAfterCreate(
+            IDescriptorContext context,
+            ISchema schema) =>
+            _onAfterCreate?.Invoke(context, schema);
+
+        public override void OnError(
+            IDescriptorContext context,
+            Exception exception) =>
+            _onError?.Invoke(context, exception);
+    }
+}

src/HotChocolate/Core/src/Types/Configuration/ISchemaInterceptor.cs

@@ -1,3 +1,4 @@
+using System;
 using HotChocolate.Types.Descriptors;
 
 namespace HotChocolate.Configuration
@@ -7,5 +8,7 @@ public interface ISchemaInterceptor
         void OnBeforeCreate(IDescriptorContext context, ISchemaBuilder schemaBuilder);
 
         void OnAfterCreate(IDescriptorContext context, ISchema schema);
+
+        void OnError(IDescriptorContext context, Exception exception);
     }
 }

src/HotChocolate/Core/src/Types/Configuration/SchemaInterceptor.cs

@@ -1,5 +1,8 @@
+using System;
 using HotChocolate.Types.Descriptors;
 
+#nullable  enable
+
 namespace HotChocolate.Configuration
 {
     public class SchemaInterceptor : ISchemaInterceptor
@@ -19,5 +22,11 @@ protected SchemaInterceptor()
             ISchema schema)
         {
         }
+
+        public virtual void OnError(
+            IDescriptorContext context,
+            Exception exception)
+        {
+        }
     }
 }

src/HotChocolate/Core/src/Types/SchemaBuilder.Setup.cs

@@ -24,15 +24,25 @@ public static Schema Create(SchemaBuilder builder)
             {
                 var lazySchema = new LazySchema();
                 DescriptorContext context = CreateContext(builder, lazySchema);
-                IBindingLookup bindingLookup = builder._bindingCompiler.Compile(context);
 
-                IReadOnlyList<ITypeReference> typeReferences =
-                    CreateTypeReferences(builder, context, bindingLookup);
+                try
+                {
+                    IBindingLookup bindingLookup = builder._bindingCompiler.Compile(context);
+
+                    IReadOnlyList<ITypeReference> typeReferences =
+                        CreateTypeReferences(builder, context, bindingLookup);
 
-                TypeRegistry typeRegistry =
-                    InitializeTypes(builder, context, bindingLookup, typeReferences, lazySchema);
+                    TypeRegistry typeRegistry =
+                        InitializeTypes(builder, context, bindingLookup, typeReferences,
+                            lazySchema);
 
-                return CompleteSchema(builder, context, lazySchema, typeRegistry);
+                    return CompleteSchema(builder, context, lazySchema, typeRegistry);
+                }
+                catch (Exception ex)
+                {
+                    context.SchemaInterceptor.OnError(context, ex);
+                    throw;
+                }
             }
 
             private static DescriptorContext CreateContext(

src/HotChocolate/Core/test/Execution.Tests/DependencyInjection/SchemaRequestExecutorBuilderExtensions.TypeInterceptor.Tests.cs

@@ -1,7 +1,10 @@
+using System;
 using System.Threading.Tasks;
+using HotChocolate.Execution.Configuration;
 using HotChocolate.Types;
 using HotChocolate.Types.Descriptors.Definitions;
 using Microsoft.Extensions.DependencyInjection;
+using Moq;
 using Snapshooter.Xunit;
 using Xunit;
 using static HotChocolate.Tests.TestHelper;
@@ -669,5 +672,50 @@ public async Task OnAfterCompleteType_Generic_CanHandle()
             Assert.True(found);
             Assert.True(canHandleInvoked);
         }
+
+        [Fact]
+        public async Task OnSchemaError()
+        {
+            // arrange
+            Snapshot.FullName();
+            Exception ex = null;
+
+            // act
+            try
+            {
+                await new ServiceCollection()
+                    .AddGraphQL()
+                    .OnSchemaError((_, exception) => ex = exception)
+                    .BuildSchemaAsync();
+            }
+            catch
+            {
+                // ignored
+            }
+
+            // assert
+            Assert.IsType<SchemaException>(ex);
+        }
+
+        [Fact]
+        public void OnSchemaError_Builder_IsNull()
+        {
+            void Action() =>
+                SchemaRequestExecutorBuilderExtensions
+                    .OnSchemaError(null!, (context, exception) => { });
+
+            Assert.Throws<ArgumentNullException>(Action);
+        }
+
+        [Fact]
+        public void OnSchemaError_OnError_IsNull()
+        {
+            var builder = new Mock<IRequestExecutorBuilder>();
+
+            void Action() =>
+                builder.Object.OnSchemaError(null!);
+
+            Assert.Throws<ArgumentNullException>(Action);
+        }
     }
 }

src/HotChocolate/Core/test/Types.Tests/SchemaErrorTests.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
+using HotChocolate.Configuration;
 using HotChocolate.Language;
 using HotChocolate.Types;
+using HotChocolate.Types.Descriptors;
 using Xunit;
 
 namespace HotChocolate
@@ -129,5 +132,33 @@ public void CreateSchemaError_AddSyntaxNode()
             Assert.Null(schemaError.Path);
             Assert.Null(schemaError.Code);
         }
+
+        [Fact]
+        public void Intercept_Schema_Error()
+        {
+            // arrange
+            var errorInterceptor = new ErrorInterceptor();
+
+            // act
+            void Action() => SchemaBuilder.New()
+                .TryAddSchemaInterceptor(errorInterceptor)
+                .Create();
+
+            // assert
+            Assert.Throws<SchemaException>(Action);
+            Assert.Collection(
+                errorInterceptor.Exceptions,
+                ex => Assert.IsType<SchemaException>(ex));
+        }
+
+        private class ErrorInterceptor : SchemaInterceptor
+        {
+            public List<Exception> Exceptions { get; } = new List<Exception>();
+
+            public override void OnError(IDescriptorContext context, Exception exception)
+            {
+                Exceptions.Add(exception);
+            }
+        }
     }
 }