read cosmos db schema and resolver from file (#35)

This PR only has changes for the Cosmos DB service:

- read cosmos db config (schema and resolvers) from file
- removed rest apis for setting (schema and resolver)

Author: moderakh

Cosmos.GraphQL.Service/Cosmos.GraphQL.Service.Tests/MetadataStoreProviderForTest.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using Cosmos.GraphQL.Service.Models;
+using Cosmos.GraphQL.Services;
+
+namespace Cosmos.GraphQL.Service.Tests
+{
+    public class MetadataStoreProviderForTest : IMetadataStoreProvider
+    {
+        private string _graphQLSchema;
+        private IDictionary<string, MutationResolver> _mutationResolvers = new Dictionary<string, MutationResolver>();
+        private IDictionary<string, GraphQLQueryResolver> _queryResolvers = new Dictionary<string, GraphQLQueryResolver>();
+
+        public void StoreGraphQLSchema(string schema)
+        {
+            _graphQLSchema = schema;
+        }
+
+        public string GetGraphQLSchema()
+        {
+            return _graphQLSchema;
+        }
+
+        public MutationResolver GetMutationResolver(string name)
+        {
+            MutationResolver result;
+            _mutationResolvers.TryGetValue(name, out result);
+            return result;
+        }
+
+        public GraphQLQueryResolver GetQueryResolver(string name)
+        {
+            GraphQLQueryResolver result;
+            _queryResolvers.TryGetValue(name, out result);
+            return result;
+        }
+
+        public void StoreMutationResolver(MutationResolver mutationResolver)
+        {
+            _mutationResolvers.Add(mutationResolver.id, mutationResolver);
+        }
+
+        public void StoreQueryResolver(GraphQLQueryResolver queryResolver)
+        {
+            _queryResolvers.Add(queryResolver.id, queryResolver);
+        }
+    }
+}

Cosmos.GraphQL.Service/Cosmos.GraphQL.Service.Tests/MutationTests.cs

@@ -7,29 +7,18 @@ namespace Cosmos.GraphQL.Service.Tests
     [TestClass, TestCategory(TestCategory.Cosmos)]
     public class MutationTests : TestBase
     {
-
-
         [TestMethod]
         public async Task TestMutationRun()
         {
-
             // Add mutation resolver
-            this.controller.addMutationResolver(TestHelper.SampleMutationResolver());
+            _metadataStoreProvider.StoreMutationResolver(TestHelper.SampleMutationResolver());
 
             // Run mutation;
-            controller.ControllerContext.HttpContext = GetHttpContextWithBody(TestHelper.SampleMutation);
-            JsonDocument response = await controller.Post();
+            _controller.ControllerContext.HttpContext = GetHttpContextWithBody(TestHelper.SampleMutation);
+            JsonDocument response = await _controller.PostAsync();
 
             // Validate results
             Assert.IsFalse(response.ToString().Contains("Error"));
         }
-
-        /* [ClassInitialize]
-         public void Init()
-         {
-
-         }
-        */
-
     }
 }

Cosmos.GraphQL.Service/Cosmos.GraphQL.Service.Tests/QueryTests.cs

@@ -7,30 +7,18 @@ namespace Cosmos.GraphQL.Service.Tests
     [TestClass, TestCategory(TestCategory.Cosmos)]
     public class QueryTests : TestBase
     {
-
-
         [TestMethod]
         public async Task TestSimpleQuery()
         {
-
             // Add query resolver
-            this.controller.addResolver(TestHelper.SampleQueryResolver());
+            _metadataStoreProvider.StoreQueryResolver(TestHelper.SampleQueryResolver());
 
             // Run query
-            controller.ControllerContext.HttpContext = GetHttpContextWithBody(TestHelper.SampleQuery);
-            JsonDocument response = await controller.Post();
+            _controller.ControllerContext.HttpContext = GetHttpContextWithBody(TestHelper.SampleQuery);
+            JsonDocument response = await _controller.PostAsync();
 
             // Validate results
             Assert.IsFalse(response.ToString().Contains("Error"));
         }
-
-
-        /* [ClassInitialize]
-         public void Init()
-         {
-
-         }
-        */
-
     }
 }

Cosmos.GraphQL.Service/Cosmos.GraphQL.Service.Tests/SchemaTests.cs

@@ -12,12 +12,12 @@ namespace Cosmos.GraphQL.Service.Tests
 {
     public class TestBase
     {
-        internal GraphQLService graphQLService;
-        internal CosmosClientProvider clientProvider;
-        internal IMetadataStoreProvider metadataStoreProvider;
-        internal CosmosQueryEngine queryEngine;
-        internal CosmosMutationEngine mutationEngine;
-        internal GraphQLController controller;
+        protected GraphQLService _graphQLService;
+        protected CosmosClientProvider _clientProvider;
+        protected IMetadataStoreProvider _metadataStoreProvider;
+        protected CosmosQueryEngine _queryEngine;
+        protected CosmosMutationEngine _mutationEngine;
+        protected GraphQLController _controller;
 
         public TestBase()
         {
@@ -28,17 +28,17 @@ public TestBase()
         private void Init()
         {
             TestHelper.LoadConfig();
-            clientProvider = new CosmosClientProvider();
+            _clientProvider = new CosmosClientProvider();
             string uid = Guid.NewGuid().ToString();
             dynamic sourceItem = TestHelper.GetItem(uid);
-            clientProvider.GetClient().GetContainer(TestHelper.DB_NAME, TestHelper.COL_NAME).CreateItemAsync(sourceItem, new PartitionKey(uid));
-            metadataStoreProvider = new CachedMetadataStoreProvider(new DocumentMetadataStoreProvider(clientProvider));
 
-            queryEngine = new CosmosQueryEngine(clientProvider, metadataStoreProvider);
-            mutationEngine = new CosmosMutationEngine(clientProvider, metadataStoreProvider);
-            graphQLService = new GraphQLService(queryEngine, mutationEngine, metadataStoreProvider);
-            graphQLService.parseAsync(TestHelper.GraphQLTestSchema);
-            controller = new GraphQLController(null, queryEngine, mutationEngine, graphQLService);
+            _clientProvider.GetClient().GetContainer(TestHelper.DB_NAME, TestHelper.COL_NAME).CreateItemAsync(sourceItem, new PartitionKey(uid));
+            _metadataStoreProvider = new MetadataStoreProviderForTest();
+            _queryEngine = new CosmosQueryEngine(_clientProvider, _metadataStoreProvider);
+            _mutationEngine = new CosmosMutationEngine(_clientProvider, _metadataStoreProvider);
+            _graphQLService = new GraphQLService(_queryEngine, _mutationEngine, _metadataStoreProvider);
+            _graphQLService.parseAsync(TestHelper.GraphQLTestSchema);
+            _controller = new GraphQLController(null, _queryEngine, _mutationEngine, _graphQLService);
         }
 
         internal static DefaultHttpContext GetHttpContextWithBody(string data)
@@ -53,7 +53,5 @@ internal static DefaultHttpContext GetHttpContextWithBody(string data)
             };
             return httpContext;
         }
-
-
     }
 }

Cosmos.GraphQL.Service/Cosmos.GraphQL.Service.Tests/TestBase.cs

@@ -1,8 +1,6 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
-using System;
 using System.Threading.Tasks;
-using Cosmos.GraphQL.Service.Models;
 using System.IO;
 using System.Text.Json;
 using Cosmos.GraphQL.Services;
@@ -25,48 +23,15 @@ public class GraphQLController : ControllerBase
         private readonly GraphQLService _schemaManager;
 
         public GraphQLController(ILogger<GraphQLController> logger, IQueryEngine queryEngine, IMutationEngine mutationEngine, GraphQLService schemaManager)
-
         {
             _logger = logger;
             _queryEngine = queryEngine;
             _mutationEngine = mutationEngine;
             _schemaManager = schemaManager;
         }
 
-        [Route("addResolver")]
-        [HttpPost]
-        public void addResolver(GraphQLQueryResolver resolver)
-        {
-            _queryEngine.RegisterResolver(resolver);
-        }
-
-        [Route("addMutationResolver")]
-        [HttpPost]
-        public void addMutationResolver(MutationResolver resolver)
-        {
-            _mutationEngine.RegisterResolver(resolver);
-        }
-
-        [Route("schema")]
-        [HttpPost]
-        public async void Schema()
-        {
-            string data;
-            using (StreamReader reader = new StreamReader(this.HttpContext.Request.Body))
-            {
-                data = await reader.ReadToEndAsync();
-            }
-            if (!String.IsNullOrEmpty(data))
-            {
-                this._schemaManager.parseAsync(data);
-                return;
-            }
-
-            throw new InvalidDataException();
-        }
-
         [HttpPost]
-        public async Task<JsonDocument> Post()
+        public async Task<JsonDocument> PostAsync()
         {
             string requestBody;
             using (StreamReader reader = new StreamReader(this.HttpContext.Request.Body))

Cosmos.GraphQL.Service/Cosmos.GraphQL.Service/Controllers/GraphQLController.cs

@@ -28,11 +28,10 @@ public CosmosMutationEngine(CosmosClientProvider clientProvider, IMetadataStoreP
         /// <param name="resolver">The given mutation resolver.</param>
         public void RegisterResolver(MutationResolver resolver)
         {
-            // TODO: add into system container/rp
-            this._metadataStoreProvider.StoreMutationResolver(resolver);
+            // TODO no op for now. remove me
         }
 
-        private async Task<JObject> executeAsync(IDictionary<string, object> inputDict, MutationResolver resolver)
+        private async Task<JObject> ExecuteAsync(IDictionary<string, object> inputDict, MutationResolver resolver)
         {
             // TODO: add support for all mutation types
             // we only support CreateOrUpdate (Upsert) for now
@@ -73,7 +72,7 @@ public async Task<JsonDocument> ExecuteAsync(string graphQLMutationName,
 
             // TODO: we are doing multiple round of serialization/deserialization
             // fixme
-            JObject jObject = await executeAsync(parameters, resolver);
+            JObject jObject = await ExecuteAsync(parameters, resolver);
             return JsonDocument.Parse(jObject.ToString());
         }
     }

Cosmos.GraphQL.Service/Cosmos.GraphQL.Service/Resolvers/CosmosMutationEngine.cs

@@ -13,7 +13,7 @@ namespace Cosmos.GraphQL.Service.Resolvers
     //</summary>
     public class SqlQueryEngine : IQueryEngine
     {
-        private IMetadataStoreProvider _metadataStoreProvider;
+        private readonly IMetadataStoreProvider _metadataStoreProvider;
         private readonly IQueryExecutor _queryExecutor;
         private readonly IQueryBuilder _queryBuilder;