Added full support for ?SDL download of the Schema (?SDL) and functioning Playground when configured correctly in the AzureFunction HttpTrigger and route bindings + Options!

cajuncoding · cajuncoding · commit cf63ae3c95b8 · 2021-02-02T01:28:38.000-06:00
diff --git a/GraphQL.AzureFunctionsProxy.Tests/AzureFunctionGraphQLTestBase.cs b/GraphQL.AzureFunctionsProxy.Tests/AzureFunctionGraphQLTestBase.cs
@@ -20,8 +20,7 @@ public HttpRequest CreateGraphQLQueryRequest(AzureFunctionTestContext functionTe
 
             return httpRequest;
         }
-
-
+        
         public void WriteLine(string text)
         {
             TestContext?.WriteLine(text);
diff --git a/GraphQL.AzureFunctionsProxy.Tests/AzureFunctions/HelloWorldFunctionsStartup.cs b/GraphQL.AzureFunctionsProxy.Tests/AzureFunctions/HelloWorldFunctionsStartup.cs
@@ -31,7 +31,10 @@ public override void Configure(IFunctionsHostBuilder builder)
             //Finally Initialize AzureFunctions Executor Proxy here...
             //You man Provide a specific SchemaName for multiple Functions (e.g. endpoints).
             //TODO: Test multiple SchemaNames...
-            services.AddAzureFunctionsGraphQL();
+            services.AddAzureFunctionsGraphQL((options) =>
+            {
+                options.AzureFunctionsGraphQLRoutePath = "/api/graphql";
+            });
         }
     }
 }
diff --git a/GraphQL.AzureFunctionsProxy.Tests/GraphQLSdlAndPlaygroundTests.cs b/GraphQL.AzureFunctionsProxy.Tests/GraphQLSdlAndPlaygroundTests.cs
@@ -0,0 +1,73 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using GraphQL.AzureFunctionsProxy.Tests.AzureFunctionsTestFramework;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json.Linq;
+using StarWars.AzureFunctions;
+
+namespace GraphQL.AzureFunctionsProxy.Tests
+{
+    [TestClass]
+    public class GraphQLSdlAndPlaygroundTests : AzureFunctionGraphQLTestBase
+    {
+        [TestMethod]
+        public async Task TestSDLRetrieval()
+        {   //arrange
+            using var functionTestCtx = AzureFunctionTestFactory.CreateFunctionTestContext<HelloWorldFunction>(new HelloWorldFunctionsStartup());
+
+            var queryStringValues = new List<KeyValuePair<string, string>>()
+            {
+                new KeyValuePair<string, string>("SDL", "")
+            };
+
+            var httpRequest = functionTestCtx.CreateHttpGetRequest("", "", queryStringValues);
+
+            var helloWorldFunction = functionTestCtx.ResolveFunctionWithDependencies<HelloWorldFunction>();
+
+            //act
+            var functionResult = await helloWorldFunction
+                .Run(httpRequest, functionTestCtx.Logger, CancellationToken.None)
+                .ConfigureAwait(false);
+            
+            var sdlResult = functionTestCtx.ReadResponseContentAsString();
+
+            //assert
+            Assert.AreEqual(functionTestCtx.HttpContext.Response.StatusCode, 200);
+            Assert.IsNotNull(functionResult);
+            Assert.IsNotNull(sdlResult, "Query Execution Failed");
+            Assert.IsFalse(string.IsNullOrWhiteSpace(sdlResult));
+
+            Assert.IsTrue(sdlResult.Contains("﻿schema {\r\n  query: Query\r\n}"));
+            Assert.IsTrue(sdlResult.Contains("type HelloWorldTranslation {\r\n  language: String\r\n  translation: String\r\n}"));
+        }
+
+        [TestMethod]
+        public async Task TestStaticFileRetrievalForManifestJson()
+        {   //arrange
+            using var functionTestCtx = AzureFunctionTestFactory.CreateFunctionTestContext<HelloWorldFunction>(new HelloWorldFunctionsStartup());
+
+            var httpRequest = functionTestCtx.CreateHttpGetRequest("/api/graphql/manifest.json", "application/json");
+
+            var helloWorldFunction = functionTestCtx.ResolveFunctionWithDependencies<HelloWorldFunction>();
+
+            //act
+            var functionResult = await helloWorldFunction
+                .Run(httpRequest, functionTestCtx.Logger, CancellationToken.None)
+                .ConfigureAwait(false);
+
+            var responseBody = functionTestCtx.ReadResponseContentAsString();
+
+            //assert
+            Assert.AreEqual(200, functionTestCtx.HttpContext.Response.StatusCode);
+            Assert.IsNotNull(functionResult);
+            Assert.IsNotNull(responseBody, "Query Execution Failed");
+            Assert.IsFalse(string.IsNullOrWhiteSpace(responseBody));
+
+            Assert.IsTrue(responseBody.Contains("\"short_name\": \"Banana Cake Pop\""));
+            Assert.IsTrue(responseBody.Contains("\"name\": \"Banana Cake Pop\""));
+        }
+    }
+}
diff --git a/GraphQL.AzureFunctionsProxy.Tests/_TestFrameworks/AzureFunctionsTestFramework/AzureFunctionTestContext.cs b/GraphQL.AzureFunctionsProxy.Tests/_TestFrameworks/AzureFunctionsTestFramework/AzureFunctionTestContext.cs
@@ -35,18 +35,30 @@ public TFunction ResolveFunctionWithDependencies<TFunction>()
             return function;
         }
 
+        public HttpRequest CreateHttpGetRequest(string path, string contentType, List<KeyValuePair<string, string>> queryStringValues = null)
+        {
+            var httpRequest = CreateHttpRequest(
+                HttpMethod.Get, 
+                requestPath: path, 
+                requestContentType: contentType, 
+                queryStringValues: queryStringValues
+            );
+            return httpRequest;
+        }
+
         public HttpRequest CreateHttpJsonPostRequest<TRequestPayload>(
             TRequestPayload requestPayload
         )
         {
             var requestBody = JsonConvert.SerializeObject(requestPayload);
-            var httpRequest = CreateHttpRequest(HttpMethod.Post, requestBody, "application/json");
+            var httpRequest = CreateHttpRequest(HttpMethod.Post, requestBody: requestBody, requestContentType: "application/json");
             return httpRequest;
         }
 
         public HttpRequest CreateHttpRequest(
             HttpMethod httpMethod = null,
             string requestBody = null,
+            string requestPath = "",
             string requestContentType = "application/json",
             List<KeyValuePair<string, string>> queryStringValues = null
         )
@@ -60,6 +72,7 @@ public HttpRequest CreateHttpRequest(
             //Initialize the Http Request
             //NOTE: Default Body is a NullStream...which ignores all Reads/Writes.
             var httpRequest = this.HttpContext.Request;
+            httpRequest.Path = new PathString(requestPath);
             httpRequest.Method = httpMethod?.Method ?? HttpMethod.Get.Method;
             httpRequest.Query = CreateQueryCollection(queryStringValues);
 
diff --git a/GraphQL.AzureFunctionsProxy.sln.DotSettings b/GraphQL.AzureFunctionsProxy.sln.DotSettings
@@ -1,2 +1,4 @@
 ﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=QL/@EntryIndexedValue">QL</s:String></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=QL/@EntryIndexedValue">QL</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=GRAPHQL/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Serverless/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
diff --git a/GraphQL.AzureFunctionsProxy/GraphQL.AzureFunctionsProxy.csproj b/GraphQL.AzureFunctionsProxy/GraphQL.AzureFunctionsProxy.csproj
@@ -2,18 +2,21 @@
 
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
-    <Version>11.0.4.1</Version>
+    <Version>11.0.4.2</Version>
     <Authors>BBernard / CajunCoding</Authors>
     <Company>CajunCoding</Company>
     <Description>This is a extension package for HotChocolate GraphQL framework to enable execution within AzureFunctions using the new v11 API. Provides very easy integration with Azure Functions with maximum support for out-of-the-box HotChocolate functionality.</Description>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://github.com/cajuncoding/HotChocolate.AzureFunctionsProxy</PackageProjectUrl>
     <RepositoryUrl>https://github.com/cajuncoding/HotChocolate.AzureFunctionsProxy</RepositoryUrl>
     <PackageTags>graphql, graph-ql, hotchocolate, azure, functions, serverless</PackageTags>
-    <PackageReleaseNotes>- Added ConfigureAwait(false) to all awaits for performance.
-- Bumped to HC v11.0.4
+    <PackageReleaseNotes>- Added support for download of the Schema (?SDL)
+- Added support for functioning Playground (when configured correctly iin the AzureFunction HttpTrigger)
+- Maintained current version compatibility with HC v11.0.4
 
 Prior Releases Notes:
+- Added ConfigureAwait(false) to all awaits for performance.
+- Bumped to HC v11.0.4
 - Bump to HotChocolate v11.0.1 which now resolves a bug that we helped identify with interfaces in the initial release of v11.0.0.
 - Updated to support namespace changes in HotChocolate v11 rc.03 with synced version here as v11.0.0.3. Bumped HotChocolate version to v11-rc.03. 
 - Prior release Changed Repo &amp; Package names to eliminate conflict risks with the core HotChocolate packages. 
diff --git a/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsConfigOptions.cs b/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsConfigOptions.cs
@@ -0,0 +1,14 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace HotChocolate.AzureFunctionsProxy
+{
+    public class GraphQLAzureFunctionsConfigOptions
+    {
+        public string AzureFunctionsGraphQLRoutePath { get; set; } = "/api/graphql";
+        public bool EnableSchemaDefinitionMiddleware { get; set; } = true;
+        public bool EnablePlayground { get; set; } = true;
+        public bool EnableGetRequestMiddleware { get; set; } = true;
+    }
+}
diff --git a/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsExecutorProxyV11.cs b/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsExecutorProxyV11.cs
@@ -23,17 +23,19 @@ public class GraphQLAzureFunctionsExecutorProxyV11 : IGraphQLAzureFunctionsExecu
         protected GraphQLAzureFunctionsMiddlewareProxy AzureFunctionsMiddlewareProxy { get; }
 
         public GraphQLAzureFunctionsExecutorProxyV11(
-            IRequestExecutorResolver graphqlExecutorResolver,
-            IHttpResultSerializer graphqlResultSerializer,
-            IHttpRequestParser graphqlRequestParser,
-            NameString schemaName = default
+            IRequestExecutorResolver graphQLExecutorResolver,
+            IHttpResultSerializer graphQLResultSerializer,
+            IHttpRequestParser graphQLRequestParser,
+            NameString schemaName = default,
+            GraphQLAzureFunctionsConfigOptions options = null
         )
         {
             this.AzureFunctionsMiddlewareProxy = new GraphQLAzureFunctionsMiddlewareProxy(
-                graphqlExecutorResolver,
-                graphqlResultSerializer,
-                graphqlRequestParser,
-                schemaName
+                graphQLExecutorResolver,
+                graphQLResultSerializer,
+                graphQLRequestParser,
+                schemaName,
+                options
             );
         }
 
diff --git a/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsMiddlewareExtensions.cs b/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsMiddlewareExtensions.cs
@@ -1,4 +1,6 @@
-﻿using HotChocolate.AspNetCore.Serialization;
+﻿using System;
+using HotChocolate.AspNetCore;
+using HotChocolate.AspNetCore.Serialization;
 using HotChocolate.AzureFunctionsProxy;
 using HotChocolate.Execution;
 using Microsoft.Extensions.DependencyInjection;
@@ -7,26 +9,55 @@ namespace HotChocolate.AzureFunctionsProxy
 {
     public static class AzureFunctionsMiddlewareExtensions
     {
+        /// <summary>
+        /// Initialize an AzureFunctionsGraphQL Middleware for the optionally specified SchemaName.
+        /// Default Schema name will be used if not specified.
+        /// </summary>
+        /// <param name="serviceCollection"></param>
+        /// <param name="configureOptions"></param>
+        /// <returns></returns>
+        public static IServiceCollection AddAzureFunctionsGraphQL(this IServiceCollection serviceCollection,
+            Action<GraphQLAzureFunctionsConfigOptions> configureOptions
+        )
+        {
+            return serviceCollection.AddAzureFunctionsGraphQL(default, configureOptions: configureOptions);
+        }
+
         /// <summary>
         /// Initialize an AzureFunctionsGraphQL Middleware for the optionally specified SchemaName.
         /// Default Schema name will be used if not specified.
         /// </summary>
         /// <param name="serviceCollection"></param>
         /// <param name="schemaName"></param>
+        /// <param name="configureOptions"></param>
         /// <returns></returns>
-        public static IServiceCollection AddAzureFunctionsGraphQL(this IServiceCollection serviceCollection, NameString schemaName = default)
+        public static IServiceCollection AddAzureFunctionsGraphQL(this IServiceCollection serviceCollection, 
+            NameString schemaName = default,
+            Action<GraphQLAzureFunctionsConfigOptions> configureOptions = null
+        )
         {
             //serviceCollection.AddAzureFunctionsGraphQL(new AzureFunctionsMiddlewareOptions());
             serviceCollection.AddSingleton<IGraphQLAzureFunctionsExecutorProxy, GraphQLAzureFunctionsExecutorProxyV11>(
                 provider => new GraphQLAzureFunctionsExecutorProxyV11(
                     provider.GetService<IRequestExecutorResolver>(),
                     provider.GetService<IHttpResultSerializer>(),
                     provider.GetService<IHttpRequestParser>(),
-                    schemaName
+                    schemaName,
+                    GetConfiguredOptions(configureOptions)
                 )
             );
 
             return serviceCollection;
         }
+
+        private static GraphQLAzureFunctionsConfigOptions GetConfiguredOptions(Action<GraphQLAzureFunctionsConfigOptions> optionsAction)
+        {
+            if (optionsAction == null)
+                return null;
+
+            var options = new GraphQLAzureFunctionsConfigOptions();
+            optionsAction?.Invoke(options);
+            return options;
+        }
     }
 }
diff --git a/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsMiddlewarePipelineShim.cs b/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsMiddlewarePipelineShim.cs
@@ -0,0 +1,33 @@
+﻿//using System;
+//using System.Collections.Generic;
+//using System.Text;
+//using HotChocolate.AspNetCore;
+
+//namespace GraphQL.AzureFunctionsProxy
+//{
+//    public class GraphQLAzureFunctionsMiddlewarePipelineShim
+//    {
+//        public void RegisterMiddleware(MiddlewareBase middleware)
+//        {
+
+//        }
+
+//    }
+
+//    public class MiddlewareShim
+//    {
+//        public MiddlewareBase Next { get; set; }
+
+//        protected HttpMiddleware(HttpMiddleware next)
+//        {
+//            this.Next = next;
+//        }
+
+//        protected HttpMiddleware()
+//        {
+
+//        }
+
+//        public abstract Task InvokeAsync(IHttpFunctionContext context);
+//    }
+//}
diff --git a/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsMiddlewareProxy.cs b/GraphQL.AzureFunctionsProxy/GraphQLAzureFunctionsMiddlewareProxy.cs
diff --git a/GraphQL.AzureFunctionsProxy/GraphQLInitHelpers.cs b/GraphQL.AzureFunctionsProxy/GraphQLInitHelpers.cs
diff --git a/PureCodeFirst-AzureFunctions-v11/StarWarsFunctionEndpoint.cs b/PureCodeFirst-AzureFunctions-v11/StarWarsFunctionEndpoint.cs
diff --git a/PureCodeFirst-AzureFunctions-v11/Startup.cs b/PureCodeFirst-AzureFunctions-v11/Startup.cs

Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,7 @@ public HttpRequest CreateGraphQLQueryRequest(AzureFunctionTestContext functionTe`
`20`	`20`
`21`	`21`	`return httpRequest;`
`22`	`22`	`}`
`23`		`-`
`24`		`-`
	`23`	`+`
`25`	`24`	`public void WriteLine(string text)`
`26`	`25`	`{`
`27`	`26`	`TestContext?.WriteLine(text);`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,10 @@ public override void Configure(IFunctionsHostBuilder builder)`
`31`	`31`	`//Finally Initialize AzureFunctions Executor Proxy here...`
`32`	`32`	`//You man Provide a specific SchemaName for multiple Functions (e.g. endpoints).`
`33`	`33`	`//TODO: Test multiple SchemaNames...`
`34`		`- services.AddAzureFunctionsGraphQL();`
	`34`	`+ services.AddAzureFunctionsGraphQL((options) =>`
	`35`	`+ {`
	`36`	`+ options.AzureFunctionsGraphQLRoutePath = "/api/graphql";`
	`37`	`+ });`
`35`	`38`	`}`
`36`	`39`	`}`
`37`	`40`	`}`