Required keyed services to be registered instead of returning null (#7602)

Co-authored-by: Michael Staib <michael@chillicream.com>

Author: glen-84

src/HotChocolate/ApolloFederation/test/ApolloFederation.Tests/EntitiesResolverTests.cs

@@ -4,6 +4,7 @@
 using HotChocolate.Execution;
 using HotChocolate.Language;
 using Microsoft.Extensions.DependencyInjection;
+using Moq;
 using static HotChocolate.ApolloFederation.TestHelper;
 
 namespace HotChocolate.ApolloFederation;
@@ -108,12 +109,13 @@ public async Task TestResolveViaEntityResolver_WithDataLoader()
         var batchScheduler = new ManualBatchScheduler();
         var dataLoader = new FederatedTypeDataLoader(batchScheduler, new DataLoaderOptions());
 
-        var context = CreateResolverContext(schema,
+        var serviceProviderMock = new Mock<IServiceProvider>();
+        serviceProviderMock.Setup(c => c.GetService(typeof(FederatedTypeDataLoader))).Returns(dataLoader);
+
+        var context = CreateResolverContext(
+            schema,
             null,
-            mock =>
-            {
-                mock.Setup(c => c.Service<FederatedTypeDataLoader>()).Returns(dataLoader);
-            });
+            mock => mock.Setup(c => c.Services).Returns(serviceProviderMock.Object));
 
         var representations = RepresentationsOf(
             nameof(FederatedType),

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

@@ -170,7 +170,7 @@ public T Resolver<T>()
 
     public T Service<T>() where T : notnull => Services.GetRequiredService<T>();
 
-    public T? Service<T>(object key) where T : notnull => Services.GetKeyedService<T>(key);
+    public T Service<T>(object key) where T : notnull => Services.GetRequiredKeyedService<T>(key);
 
     public object Service(Type service)
     {

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

@@ -212,7 +212,7 @@ public object Service(Type service)
 
         public T Service<T>() where T : notnull => parentContext.Service<T>();
 
-        public T? Service<T>(object key) where T : notnull => parentContext.Service<T>(key);
+        public T Service<T>(object key) where T : notnull => parentContext.Service<T>(key);
 
         public T Resolver<T>() => parentContext.Resolver<T>();
 

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/ServiceExpressionHelper.cs

@@ -10,19 +10,18 @@ namespace HotChocolate.Resolvers.Expressions.Parameters;
 /// </summary>
 internal static class ServiceExpressionHelper
 {
-    private const string _service = nameof(IResolverContext.Service);
+    private const string _serviceResolver = nameof(GetService);
+    private const string _keyedServiceResolver = nameof(GetKeyedService);
+    private static readonly Expression _true = Expression.Constant(true);
+    private static readonly Expression _false = Expression.Constant(false);
 
     private static readonly MethodInfo _getServiceMethod =
-        ParameterExpressionBuilderHelpers.ContextType.GetMethods().First(
-            method => method.Name.Equals(_service, StringComparison.Ordinal) &&
-                method.IsGenericMethod &&
-                method.GetParameters().Length == 0);
+        typeof(ServiceExpressionHelper).GetMethods().First(
+            method => method.Name.Equals(_serviceResolver, StringComparison.Ordinal));
 
     private static readonly MethodInfo _getKeyedServiceMethod =
-        ParameterExpressionBuilderHelpers.ContextType.GetMethods().First(
-            method => method.Name.Equals(_service, StringComparison.Ordinal) &&
-                method.IsGenericMethod &&
-                method.GetParameters().Length == 1);
+        typeof(ServiceExpressionHelper).GetMethods().First(
+            method => method.Name.Equals(_keyedServiceResolver, StringComparison.Ordinal));
 
     /// <summary>
     /// Builds the service expression.
@@ -45,14 +44,41 @@ private static Expression BuildDefaultService(ParameterInfo parameter, Expressio
     {
         var parameterType = parameter.ParameterType;
         var argumentMethod = _getServiceMethod.MakeGenericMethod(parameterType);
-        return Expression.Call(context, argumentMethod);
+        var nullabilityContext = new NullabilityInfoContext();
+        var nullabilityInfo = nullabilityContext.Create(parameter);
+        var isRequired = nullabilityInfo.ReadState == NullabilityState.NotNull;
+        return Expression.Call(argumentMethod, context, isRequired ? _true : _false);
     }
 
     private static Expression BuildDefaultService(ParameterInfo parameter, Expression context, string key)
     {
         var parameterType = parameter.ParameterType;
-        var argumentMethod =  _getKeyedServiceMethod.MakeGenericMethod(parameterType);
+        var argumentMethod = _getKeyedServiceMethod.MakeGenericMethod(parameterType);
         var keyExpression = Expression.Constant(key, typeof(object));
-        return Expression.Call(context, argumentMethod, keyExpression);
+        var nullabilityContext = new NullabilityInfoContext();
+        var nullabilityInfo = nullabilityContext.Create(parameter);
+        var isRequired = nullabilityInfo.ReadState == NullabilityState.NotNull;
+        return Expression.Call(argumentMethod, context, keyExpression, isRequired ? _true : _false);
+    }
+
+    public static TService? GetService<TService>(
+        IResolverContext context,
+        bool required)
+        where TService : notnull
+    {
+        return required
+            ? context.Services.GetRequiredService<TService>()
+            : context.Services.GetService<TService>();
+    }
+
+    public static TService? GetKeyedService<TService>(
+        IResolverContext context,
+        object? key,
+        bool required)
+        where TService : notnull
+    {
+        return required
+            ? context.Services.GetRequiredKeyedService<TService>(key)
+            : context.Services.GetKeyedService<TService>(key);
     }
 }

src/HotChocolate/Core/src/Types/Resolvers/Expressions/Parameters/ServiceParameterExpressionBuilder.cs

@@ -45,10 +45,16 @@ public ServiceParameterBinding(ParameterInfo parameter)
         {
             var attribute = parameter.GetCustomAttribute<ServiceAttribute>();
             Key = attribute?.Key;
+
+            var context = new NullabilityInfoContext();
+            var nullabilityInfo = context.Create(parameter);
+            IsRequired = nullabilityInfo.ReadState == NullabilityState.NotNull;
         }
 
         public string? Key { get; }
 
+        public bool IsRequired { get; }
+
         public ArgumentKind Kind => ArgumentKind.Service;
 
         public bool IsPure => true;
@@ -57,10 +63,14 @@ public T Execute<T>(IResolverContext context) where T : notnull
         {
             if (Key is not null)
             {
-                return context.Service<T>(Key)!;
+                return IsRequired
+                    ? context.Services.GetRequiredKeyedService<T>(Key)
+                    : context.Services.GetKeyedService<T>(Key)!;
             }
 
-            return context.Service<T>();
+            return IsRequired
+                ? context.Services.GetRequiredService<T>()
+                : context.Services.GetService<T>()!;
         }
     }
 }

src/HotChocolate/Core/src/Types/Resolvers/IResolverContext.cs

@@ -129,7 +129,7 @@ public interface IResolverContext : IHasContextData
     /// <returns>
     /// Returns the specified service.
     /// </returns>
-    T? Service<T>(object key) where T : notnull;
+    T Service<T>(object key) where T : notnull;
 
     /// <summary>
     /// Gets a resolver object containing one or more resolvers.

src/HotChocolate/Core/test/Types.CursorPagination.Tests/QueryableCursorPagingProviderTests.cs

@@ -697,7 +697,7 @@ public T Service<T>() where T : notnull
             throw new NotImplementedException();
         }
 
-        public T? Service<T>(object key) where T : notnull
+        public T Service<T>(object key) where T : notnull
         {
             throw new NotImplementedException();
         }

src/HotChocolate/Core/test/Types.Tests/Resolvers/ResolverCompilerTests.cs

@@ -695,9 +695,11 @@ public async Task Compile_Arguments_Service()
         var resolver = compiler.CompileResolve(member, type).Resolver!;
 
         // assert
+        var serviceProvider = new Mock<IServiceProvider>();
+        serviceProvider.Setup(t => t.GetService(typeof(MyService))).Returns(new MyService());
         var context = new Mock<IResolverContext>();
         context.Setup(t => t.Parent<Resolvers>()).Returns(new Resolvers());
-        context.Setup(t => t.Service<MyService>()).Returns(new MyService());
+        context.Setup(t => t.Services).Returns(serviceProvider.Object);
         var result = (bool)(await resolver(context.Object))!;
         Assert.True(result);
     }

src/HotChocolate/Core/test/Types.Tests/Resolvers/ResolverServiceTests.cs

@@ -1,3 +1,5 @@
+#nullable enable
+
 using CookieCrumble;
 using HotChocolate.Execution;
 using HotChocolate.Types;
@@ -315,6 +317,38 @@ public async Task Resolver_KeyedService()
         result.MatchMarkdownSnapshot();
     }
 
+    [Fact]
+    public async Task Resolver_Optional_KeyedService_Does_Not_Exist()
+    {
+        var executor =
+            await new ServiceCollection()
+                .AddGraphQL()
+                .AddQueryType<QueryOptional>()
+                .ModifyRequestOptions(o => o.IncludeExceptionDetails = true)
+                .BuildRequestExecutorAsync();
+
+        var result = await executor.ExecuteAsync("{ foo }");
+
+        result.MatchMarkdownSnapshot();
+    }
+
+    [Fact]
+    public async Task Resolver_Optional_KeyedService_Exists()
+    {
+        var executor =
+            await new ServiceCollection()
+                .AddKeyedSingleton("abc", (_, _) => new KeyedService("abc"))
+                .AddKeyedSingleton("def", (_, _) => new KeyedService("def"))
+                .AddGraphQL()
+                .AddQueryType<QueryOptional>()
+                .ModifyRequestOptions(o => o.IncludeExceptionDetails = true)
+                .BuildRequestExecutorAsync();
+
+        var result = await executor.ExecuteAsync("{ foo }");
+
+        result.MatchMarkdownSnapshot();
+    }
+
     public sealed class SayHelloService
     {
         public string Scope = "Resolver";
@@ -372,6 +406,12 @@ public string Foo([AbcService] KeyedService service)
             => service.Key;
     }
 
+    public class QueryOptional
+    {
+        public string Foo([AbcService] KeyedService? service)
+            => service?.Key ?? "No Service";
+    }
+
     public class KeyedService(string key)
     {
         public string Key => key;

src/HotChocolate/Core/test/Types.Tests/Resolvers/__snapshots__/ResolverServiceTests.Resolver_Optional_KeyedService_Does_Not_Exist.md

@@ -0,0 +1,9 @@
+# Resolver_Optional_KeyedService_Does_Not_Exist
+
+```json
+{
+  "data": {
+    "foo": "No Service"
+  }
+}
+```