feat(MultipleOperations) possibility to send multiple operations with…

…in query a select which to execute
mkmarek · Jul 24, 2016 · 81a459a · 81a459a
1 parent fa02d19
commit 81a459a
Show file tree

Hide file tree

Showing 7 changed files with 105 additions and 16 deletions.
diff --git a/examples/GraphQLCore.GraphiQLExample/Controllers/GraphQLController.cs b/examples/GraphQLCore.GraphiQLExample/Controllers/GraphQLController.cs
@@ -27,7 +27,7 @@ public JsonResult Post([FromBody] GraphiQLInput input)
                 return this.Json(
                     new
                     {
-                        data = this.schema.Execute(input.Query, GetVariables(input))
+                        data = this.schema.Execute(input.Query, GetVariables(input), input.OperationName)
                     }
                 );
             }

diff --git a/examples/GraphQLCore.GraphiQLExample/Models/GraphiQLInput.cs b/examples/GraphQLCore.GraphiQLExample/Models/GraphiQLInput.cs
@@ -2,6 +2,7 @@
 {
     public class GraphiQLInput
     {
+        public string OperationName { get; set; }
         public string Query { get; set; }
         public string Variables { get; set; }
     }

diff --git a/examples/GraphQLCore.GraphiQLExample/project.json b/examples/GraphQLCore.GraphiQLExample/project.json
@@ -14,7 +14,7 @@
     "Microsoft.Extensions.Logging.Console": "1.0.0",
     "Microsoft.Extensions.Logging.Debug": "1.0.0",
     "Microsoft.AspNetCore.StaticFiles": "1.0.0",
-    "GraphQLCore": "1.0.0-alpha"
+    "GraphQLCore": "1.0.0-alpha-*"
   },
 
   "tools": {

diff --git a/src/GraphQLCore/Execution/ExecutionContext.cs b/src/GraphQLCore/Execution/ExecutionContext.cs
@@ -41,13 +41,20 @@ public void Dispose()
         }
 
         public dynamic Execute()
+        {
+            return this.Execute(null);
+        }
+
+        public dynamic Execute(string operationToExecute)
         {
             this.ValidateAstAndThrowErrorWhenFaulty();
 
             foreach (var definition in this.ast.Definitions)
-                this.ResolveDefinition(definition);
+                this.ResolveDefinition(definition, operationToExecute);
 
-            if (this.operation == null)
+            if (this.operation == null && !string.IsNullOrWhiteSpace(operationToExecute))
+                throw new GraphQLException($"Unknown operation named \"{operationToExecute}\".");
+            if (this.operation == null && string.IsNullOrWhiteSpace(operationToExecute))
                 throw new GraphQLException("Must provide an operation.");
 
             return this.ComposeResultForType(this.GetOperationRootType(), this.operation.SelectionSet);
@@ -160,12 +167,12 @@ private GraphQLObjectType GetOperationRootType()
             return null;
         }
 
-        private void ResolveDefinition(ASTNode definition)
+        private void ResolveDefinition(ASTNode definition, string operationToExecute)
         {
             switch (definition.Kind)
             {
                 case ASTNodeKind.OperationDefinition:
-                    this.ResolveOperationDefinition(definition as GraphQLOperationDefinition); break;
+                    this.ResolveOperationDefinition(definition as GraphQLOperationDefinition, operationToExecute); break;
                 case ASTNodeKind.FragmentDefinition:
                     this.ResolveFragmentDefinition(definition as GraphQLFragmentDefinition); break;
                 default: throw new Exception($"GraphQL cannot execute a request containing a {definition.Kind}.");
@@ -177,12 +184,14 @@ private void ResolveFragmentDefinition(GraphQLFragmentDefinition graphQLFragment
             this.fragments.Add(graphQLFragmentDefinition.Name.Value, graphQLFragmentDefinition);
         }
 
-        private void ResolveOperationDefinition(GraphQLOperationDefinition graphQLOperationDefinition)
+        private void ResolveOperationDefinition(GraphQLOperationDefinition graphQLOperationDefinition, string operationToExecute)
         {
-            if (this.operation != null)
-                throw new Exception("Must provide operation name if query contains multiple operations.");
+            if (this.operation != null && string.IsNullOrWhiteSpace(operationToExecute))
+                throw new GraphQLException("Must provide operation name if query contains multiple operations.");
 
-            if (this.operation == null)
+            if (!string.IsNullOrWhiteSpace(operationToExecute) && graphQLOperationDefinition.Name.Value == operationToExecute)
+                this.operation = graphQLOperationDefinition;
+            else if (string.IsNullOrWhiteSpace(operationToExecute) && this.operation == null)
                 this.operation = graphQLOperationDefinition;
         }
     }

diff --git a/src/GraphQLCore/Type/GraphQLSchema.cs b/src/GraphQLCore/Type/GraphQLSchema.cs
@@ -6,6 +6,8 @@
     using Language.AST;
     using System.Linq;
     using Translation;
+    using System;
+    using System.Dynamic;
 
     public class GraphQLSchema : IGraphQLSchema
     {
@@ -21,6 +23,7 @@ public GraphQLSchema()
 
         public IntrospectedSchemaType IntrospectedSchema { get; private set; }
         public GraphQLObjectType MutationType { get; private set; }
+
         public GraphQLObjectType QueryType { get; private set; }
 
         public void AddKnownType(GraphQLBaseType type)
@@ -44,11 +47,24 @@ public dynamic Execute(string expression, dynamic variables)
             }
         }
 
+        public dynamic Execute(string expression, dynamic variables, string operationToExecute)
+        {
+            using (var context = new ExecutionContext(this, this.GetAst(expression), variables))
+            {
+                return context.Execute(operationToExecute);
+            }
+        }
+
         public void Mutation(GraphQLObjectType root)
         {
             this.MutationType = root;
         }
 
+        public object Execute(object multipleOperationQuery)
+        {
+            throw new NotImplementedException();
+        }
+
         public void Query(GraphQLObjectType root)
         {
             this.QueryType = root;

diff --git a/src/GraphQLCore/Type/IGraphQLSchema.cs b/src/GraphQLCore/Type/IGraphQLSchema.cs
@@ -13,6 +13,8 @@ public interface IGraphQLSchema
 
         dynamic Execute(string query, dynamic variables);
 
+        dynamic Execute(string query, dynamic variables, string operationToExecute);
+
         void Query(GraphQLObjectType root);
     }
 }
diff --git a/test/GraphQLCore.Tests/Type/GraphQLSchemaTests.cs b/test/GraphQLCore.Tests/Type/GraphQLSchemaTests.cs
@@ -1,22 +1,81 @@
 namespace GraphQLCore.Tests.Type
 {
+    using Exceptions;
     using GraphQLCore.Type;
     using NUnit.Framework;
     using System;
+    using System.Dynamic;
 
     [TestFixture]
     public class GraphQLSchemaTests
     {
         private GraphQLSchema schema;
+        private string singleOperationQuery;
+        private string multipleOperationQuery;
 
         [Test]
-        public void Execute_MultipleOperationsNoOperationName_ThrowsAnError()
+        public void SingleOperationNoOperationNameProvided_PicksSingleOne()
         {
-            var exception = Assert.Throws<Exception>(new TestDelegate(() =>
-                this.schema.Execute("query Example { hello } query OtherExample { hello }")));
+            var result = this.schema.Execute(this.singleOperationQuery);
 
-            Assert.AreEqual("Must provide operation name if query contains multiple operations.",
-                exception.Message);
+            Assert.IsNotNull(result.a);
+        }
+
+        [Test]
+        public void SingleOperationOperationNameProvided_PicksOperationByOperationName()
+        {
+            var result = this.schema.Execute(this.singleOperationQuery, new ExpandoObject(), "q1");
+
+            Assert.IsNotNull(result.a);
+        }
+
+        [Test]
+        public void NotExistingOperationNameProvided_TrowsException()
+        {
+            var exception = Assert.Throws<GraphQLException>(() =>
+            {
+                var result = this.schema.Execute(this.singleOperationQuery, new ExpandoObject(), "q2");
+            });
+
+            Assert.AreEqual("Unknown operation named \"q2\".", exception.Message);
+        }
+
+        [Test]
+        public void MultipleOperationsNoOperationNameProvided_TrowsException()
+        {
+            var exception = Assert.Throws<GraphQLException>(() =>
+            {
+                var result = this.schema.Execute(this.multipleOperationQuery);
+            });
+
+            Assert.AreEqual("Must provide operation name if query contains multiple operations.", exception.Message);
+        }
+
+        [Test]
+        public void MultipleOperationsSelectingFirstOperation_ReturnsResultFromTheFirstOperation()
+        {
+            var result = this.schema.Execute(this.multipleOperationQuery, new ExpandoObject(), "q1");
+
+            Assert.IsNotNull(result.a);
+        }
+
+        [Test]
+        public void MultipleOperationsSelectingSecondOperation_ReturnsResultFromTheSecondOperation()
+        {
+            var result = this.schema.Execute(this.multipleOperationQuery, new ExpandoObject(), "q2");
+
+            Assert.IsNotNull(result.b);
+        }
+
+        [Test]
+        public void NoOperationProvided_ThrowsError()
+        {
+            var exception = Assert.Throws<GraphQLException>(() =>
+            {
+                var result = this.schema.Execute("");
+            });
+
+            Assert.AreEqual("Must provide an operation.", exception.Message);
         }
 
         [SetUp]
@@ -26,14 +85,16 @@ public void SetUp()
             var rootType = new RootQueryType();
 
             schema.Query(rootType);
+
+            this.singleOperationQuery = "query q1 { a : hello }";
+            this.multipleOperationQuery = "query q1 { a : hello } query q2 { b : hello }";
         }
 
         private class RootQueryType : GraphQLObjectType
         {
             public RootQueryType() : base("RootQueryType", "")
             {
                 this.Field("hello", () => "world");
-                this.Field("test", () => "test");
             }
         }
     }