Merge branch 'master' of https://github.com/landmarkhw/Dapper.GraphQL

Author: dougrday

Dapper.GraphQL.Test/GraphQL/GraphQlQuery.cs

@@ -0,0 +1,12 @@
+using Newtonsoft.Json.Linq;
+
+namespace Dapper.GraphQL.Test.GraphQL
+{
+    public class GraphQlQuery
+    {
+        public string OperationName { get; set; }
+        public string NamedQuery { get; set; }
+        public string Query { get; set; }
+        public JObject Variables { get; set; }
+    }
+}

Dapper.GraphQL.Test/GraphQL/PersonInputType.cs

@@ -0,0 +1,14 @@
+using GraphQL.Types;
+
+namespace Dapper.GraphQL.Test.GraphQL
+{
+    public class PersonInputType : InputObjectGraphType
+    {
+        public PersonInputType()
+        {
+            Name = "PersonInput";
+            Field<StringGraphType>("firstName");
+            Field<StringGraphType>("lastName");
+        }
+    }
+}

Dapper.GraphQL.Test/GraphQL/PersonMutation.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Data;
+using System.Linq;
+using Dapper.GraphQL.Test.EntityMappers;
+using Dapper.GraphQL.Test.Models;
+using GraphQL.Types;
+using Microsoft.Extensions.DependencyInjection;
+
+
+namespace Dapper.GraphQL.Test.GraphQL
+{
+    public class PersonMutation : ObjectGraphType
+    {
+        public PersonMutation(IQueryBuilder<Person> personQueryBuilder, IServiceProvider serviceProvider)
+        {
+            Field<PersonType>(
+                "addPerson",
+                description: "Adds new person.",
+                arguments: new QueryArguments(
+                    new QueryArgument<PersonInputType> { Name = "person" }
+                ),
+                resolve: context =>
+                {
+                    var person = context.GetArgument<Person>("person");
+
+                    using (var connection = serviceProvider.GetRequiredService<IDbConnection>())
+                    {
+                        person.Id = person.MergedToPersonId = PostgreSql.NextIdentity(connection, (Person p) => p.Id);
+
+                        bool success = SqlBuilder
+                           .Insert(person)
+                           .Execute(connection) > 0;
+
+                        if (success)
+                        {
+                            var personMapper = new PersonEntityMapper();
+
+                            var query = SqlBuilder
+                                            .From<Person>("Person")
+                                            .Select("FirstName, LastName")
+                                            .Where("ID = @personId", new { personId = person.Id });
+
+                            var results = query
+                                   .Execute(connection, context.FieldAst, personMapper)
+                                   .Distinct();
+                            return results.FirstOrDefault();
+                        }
+
+                        return null;
+                    }
+                }
+            );
+        }
+    }
+}

Dapper.GraphQL.Test/GraphQL/PersonSchema.cs

@@ -1,24 +1,14 @@
-using Dapper.GraphQL.Test.EntityMappers;
-using Dapper.GraphQL.Test.Models;
-using Dapper.GraphQL.Test.QueryBuilders;
-using GraphQL.Types;
-using Microsoft.Extensions.DependencyInjection;
-using System;
-using System.Collections.Generic;
-using System.Text;
+using GraphQL;
 
 namespace Dapper.GraphQL.Test.GraphQL
 {
     public class PersonSchema :
         global::GraphQL.Types.Schema
     {
-        public PersonSchema(
-            IServiceProvider serviceProvider,
-            PersonQuery personQuery)
+        public PersonSchema(IDependencyResolver resolver) : base(resolver)
         {
-            //Mutation = mutation;
-            ResolveType = type => serviceProvider.GetRequiredService(type) as GraphType;
-            Query = personQuery;
+            Query = resolver.Resolve<PersonQuery>();
+            Mutation = resolver.Resolve<PersonMutation>();
         }
     }
 }

Dapper.GraphQL.Test/GraphQLTests.cs

@@ -1,5 +1,8 @@
 using System.Threading.Tasks;
 using Xunit;
+using Dapper.GraphQL.Test.GraphQL;
+using Newtonsoft.Json.Linq;
+using Dapper.GraphQL.Test.Models;
 
 namespace Dapper.GraphQL.Test
 {
@@ -333,5 +336,35 @@ public async Task SimplePersonQuery()
 
             Assert.True(fixture.JsonEquals(expectedJson, json));
         }
+
+        [Fact(DisplayName = "Simple person insert should succeed")]
+        public async Task SimplePersonInsert()
+        {
+            GraphQlQuery graphQuery = new GraphQlQuery();
+            graphQuery.OperationName = "addPerson";
+            graphQuery.Variables = JObject.Parse(@"{""person"":{""firstName"":""Joe"",""lastName"":""Doe""}}");
+
+            graphQuery.Query = @"
+mutation ($person: PersonInput!) {
+  addPerson(person: $person) {
+    firstName
+    lastName
+  }
+}";
+
+            var json = await fixture.QueryGraphQLAsync(graphQuery);
+
+            var expectedJson = @"
+            {
+                data: {
+                    addPerson: {
+                        firstName: 'Joe',
+                        lastName: 'Doe'
+                    }
+                }
+            }";
+
+            Assert.True(fixture.JsonEquals(expectedJson, json));
+        }
     }
 }

Dapper.GraphQL.Test/TestFixture.cs

@@ -10,6 +10,7 @@
 using Newtonsoft.Json.Linq;
 using Npgsql;
 using System;
+using System.Collections.Generic;
 using System.Data;
 using System.Linq;
 using System.Reflection;
@@ -96,6 +97,21 @@ public async Task<string> QueryGraphQLAsync(string query)
             return json;
         }
 
+        public async Task<string> QueryGraphQLAsync(GraphQlQuery query)
+        {
+            var result = await DocumentExecuter
+                .ExecuteAsync(options =>
+                {
+                    options.Schema = Schema;
+                    options.Query = query.Query;
+                    options.Inputs = query.Variables != null ? new Inputs(StringExtensions.GetValue(query.Variables) as Dictionary<string, object>) : null;
+                })
+                .ConfigureAwait(false);
+
+            var json = new DocumentWriter(indent: true).Write(result);
+            return json;
+        }
+
         public void SetupDatabaseConnection()
         {
             // Generate a random db name
@@ -148,6 +164,8 @@ FROM pg_stat_activity
 
         private void SetupDapperGraphQL(IServiceCollection serviceCollection)
         {
+            serviceCollection.AddSingleton<IDependencyResolver>(s => new FuncDependencyResolver(s.GetRequiredService));
+
             serviceCollection.AddDapperGraphQL(options =>
             {
                 // Add GraphQL types
@@ -156,6 +174,8 @@ private void SetupDapperGraphQL(IServiceCollection serviceCollection)
                 options.AddType<PersonType>();
                 options.AddType<GraphQL.PhoneType>();
                 options.AddType<PersonQuery>();
+                options.AddType<PersonMutation>();
+                options.AddType<PersonInputType>();
 
                 // Add the GraphQL schema
                 options.AddSchema<PersonSchema>();

Dapper.GraphQL/Dapper.GraphQL.csproj

@@ -22,9 +22,9 @@
   <ItemGroup>
     <PackageReference Include="Dapper" Version="1.50.4" />    
     <PackageReference Include="Dapper.SqlBuilder" Version="1.50.4" />
-    <PackageReference Include="GraphQL" Version="0.17.3" />
+    <PackageReference Include="GraphQL" Version="2.3.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="1.1.1" />
-    <PackageReference Include="System.ValueTuple" Version="4.4.0" />
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
   </ItemGroup>
 
 </Project>