Fixed Scoped Service Handling (#1066)

Author: michaelstaib

.circleci/config.yml

@@ -3,15 +3,19 @@ jobs:
   pull-request:
     working_directory: /work
     docker:
-      - image: chillicream/dotnet-build:3.0
+      - image: chillicream/dotnet-build:4.0
     steps:
       - checkout
       - run:
           name: Check that Templates Compile
-          command: dotnet cake -target=TemplatesCompile
+          command: |
+            export PATH="$PATH:/root/.dotnet/tools"
+            dotnet cake -target=TemplatesCompile
       - run:
           name: Pull Request Build
-          command: dotnet cake -target=CoreTests
+          command: |
+            export PATH="$PATH:/root/.dotnet/tools"
+            dotnet cake -target=CoreTests
       - store_test_results:
           path: /work/testoutput
       - store_artifacts:

global.json

@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "2.2.103"
+    "version": "2.2.402"
   }
 }

src/Core/Core/Execution/QueryExecutionBuilder.cs

@@ -88,7 +88,6 @@ public void Populate(IServiceCollection services, bool lazyExecutor)
                         () => new QueryExecutor
                         (
                             sp.GetRequiredService<ISchema>(),
-                            sp,
                             Compile(_middlewareComponents),
                             Compile(_fieldMiddlewareComponents)
                         )
@@ -99,7 +98,6 @@ public void Populate(IServiceCollection services, bool lazyExecutor)
                     return new QueryExecutor
                     (
                         sp.GetRequiredService<ISchema>(),
-                        sp,
                         Compile(_middlewareComponents),
                         Compile(_fieldMiddlewareComponents)
                     );

src/Core/Core/Execution/QueryExecutor.cs

@@ -21,11 +21,19 @@ public QueryExecutor(
             IServiceProvider applicationServices,
             QueryDelegate queryDelegate,
             FieldMiddleware fieldMiddleware)
+            : this(schema, queryDelegate, fieldMiddleware)
         {
-            Schema = schema
-                ?? throw new ArgumentNullException(nameof(schema));
             _applicationServices = applicationServices
                 ?? throw new ArgumentNullException(nameof(applicationServices));
+        }
+
+        public QueryExecutor(
+            ISchema schema,
+            QueryDelegate queryDelegate,
+            FieldMiddleware fieldMiddleware)
+        {
+            Schema = schema
+                ?? throw new ArgumentNullException(nameof(schema));
             _queryDelegate = queryDelegate
                 ?? throw new ArgumentNullException(nameof(queryDelegate));
 
@@ -92,20 +100,33 @@ private async Task<IExecutionResult> ExecuteMiddlewareAsync(
         private IRequestServiceScope CreateServiceScope(
             IServiceProvider requestServices)
         {
-            IServiceScope serviceScope = _applicationServices.CreateScope();
-            IServiceProvider services = requestServices ?? Schema.Services;
-
-            if (services == null)
+            if (_applicationServices is null)
             {
                 return new RequestServiceScope(
-                    serviceScope.ServiceProvider,
-                    serviceScope);
+                    CreateRequestServices(requestServices),
+                    Disposable.Instance);
             }
+            else
+            {
+                IServiceScope serviceScope = _applicationServices.CreateScope();
+                IServiceProvider services = requestServices ?? Schema.Services;
+
+                if (services == null)
+                {
+                    return new RequestServiceScope(
+                        serviceScope.ServiceProvider,
+                        serviceScope);
+                }
 
-            services = serviceScope.ServiceProvider.Include(services);
-            return new RequestServiceScope(services, serviceScope);
+                services = serviceScope.ServiceProvider.Include(services);
+                return new RequestServiceScope(services, serviceScope);
+            }
         }
 
+        private IServiceProvider CreateRequestServices(
+            IServiceProvider requestServices) =>
+            requestServices ?? Schema.Services;
+
         public void Dispose()
         {
             Dispose(true);
@@ -116,12 +137,24 @@ protected virtual void Dispose(bool disposing)
         {
             if (!_disposed)
             {
-                if (disposing && _applicationServices is IDisposable d)
+                if (disposing
+                    && _applicationServices != null
+                    && _applicationServices is IDisposable d)
                 {
                     d.Dispose();
                 }
                 _disposed = true;
             }
         }
+
+        private class Disposable
+            : IDisposable
+        {
+            public void Dispose()
+            {
+            }
+
+            public static Disposable Instance { get; } = new Disposable();
+        }
     }
 }

src/Server/AspNetCore.HttpPost/HttpPostMiddleware.cs

@@ -228,11 +228,10 @@ await _streamSerializer.SerializeAsync(
                 .ConfigureAwait(false);
         }
 
-        private async Task<IReadOnlyList<IReadOnlyQueryRequest>>
-            BuildBatchRequestAsync(
-                HttpContext context,
-                IServiceProvider services,
-                IReadOnlyList<GraphQLRequest> batch)
+        private async Task<IReadOnlyList<IReadOnlyQueryRequest>> BuildBatchRequestAsync(
+            HttpContext context,
+            IServiceProvider services,
+            IReadOnlyList<GraphQLRequest> batch)
         {
             var queryBatch = new IReadOnlyQueryRequest[batch.Count];
 
@@ -248,12 +247,11 @@ private async Task<IReadOnlyList<IReadOnlyQueryRequest>>
             return queryBatch;
         }
 
-        private async Task<IReadOnlyList<IReadOnlyQueryRequest>>
-            BuildBatchRequestAsync(
-                HttpContext context,
-                IServiceProvider services,
-                GraphQLRequest request,
-                IReadOnlyList<string> operationNames)
+        private async Task<IReadOnlyList<IReadOnlyQueryRequest>> BuildBatchRequestAsync(
+            HttpContext context,
+            IServiceProvider services,
+            GraphQLRequest request,
+            IReadOnlyList<string> operationNames)
         {
             var queryBatch = new IReadOnlyQueryRequest[operationNames.Count];
 

src/Server/AspNetCore.Tests/PostMiddlewareTests.cs

@@ -2,9 +2,13 @@
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using HotChocolate;
+using HotChocolate.Types;
 using HotChocolate.AspNetCore.Tests.Utilities;
 using HotChocolate.Language;
-using Microsoft.AspNetCore.TestHost;
 using Snapshooter;
 using Snapshooter.Xunit;
 using Xunit;
@@ -802,5 +806,60 @@ await server.SendPostRequestAsync(
             byte[] json = await message.Content.ReadAsByteArrayAsync();
             Utf8GraphQLRequestParser.ParseJson(json).MatchSnapshot();
         }
+
+        [Fact]
+        public async Task HttpPost_Ensure_Scoped_Services_Work()
+        {
+            // arrange
+            TestServer server = ServerFactory.Create(
+                services =>
+                {
+                    services.AddScoped<ScopedService>();
+                    services.AddGraphQL(SchemaBuilder.New()
+                        .AddQueryType(c => c
+                            .Name("Query")
+                            .Field("foo")
+                            .Resolver(ctx =>
+                            {
+                                ScopedService service = ctx.Service<ScopedService>();
+                                service.Increase();
+                                return service.Count;
+                            })));
+                },
+                app => app
+                    .Use(next => ctx =>
+                    {
+                        ScopedService service = ctx.RequestServices.GetService<ScopedService>();
+                        service.Increase();
+                        return next(ctx);
+                    })
+                    .UseGraphQL());
+
+            var request =
+                @"
+                    {
+                        foo
+                    }
+                ";
+            var contentType = "application/graphql";
+
+            // act
+            HttpResponseMessage message =
+                await server.SendPostRequestAsync(request, contentType, null);
+
+            // assert
+            ClientQueryResult result = await DeserializeAsync(message);
+            result.MatchSnapshot();
+        }
+
+        public class ScopedService
+        {
+            public int Count { get; private set; }
+
+            public void Increase()
+            {
+                Count += 1;
+            }
+        }
     }
 }

src/Server/AspNetCore.Tests/__snapshots__/PostMiddlewareTests.HttpPost_Ensure_Scoped_Services_Work.snap

@@ -0,0 +1,7 @@
+{
+  "Data": {
+    "foo": 2
+  },
+  "Errors": null,
+  "Extensions": null
+}