Fix #93

src/graphql/type/ConnectionBuilder.cs

@@ -140,7 +140,7 @@ public ConnectionBuilder IncludeInputFields(InputObjectType owner,
 
             foreach (var field in fields)
             {
-                if (!_fields.ContainsKey(owner.Name))
+                if (!_inputFields.ContainsKey(owner.Name))
                     _inputFields[owner.Name] = new Dictionary<string, InputObjectField>();
 
                 _inputFields[owner.Name].Add(field.Key, field.Value);

tests/graphql.server.tests.host/Startup.cs

@@ -10,6 +10,7 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.DependencyInjection;
+using tanka.graphql.sdl;
 
 namespace graphql.server.tests.host
 {
@@ -20,28 +21,70 @@ public class Startup
         public void ConfigureServices(IServiceCollection services)
         {
             var eventManager = new EventManager();
-            var builder = new SchemaBuilder();
+            var sdl = @"
+                input InputEvent {
+                    type: String!
+                    message: String!
+                }
+
+                type Event {
+                    type: String!
+                    message: String!
+                }
+
+                type Query {
+                    hello: String!
+                }
 
-            builder.Query(out var query);
-            builder.Subscription(out var subscription);
+                type Mutation {
+                    add(event: InputEvent!): Event
+                }
 
-            builder.Connections(connect => connect
-                .Field(query, "hello", ScalarType.String)
-                .Field(subscription, "helloEvents", ScalarType.String));
+                type Subscription {
+                    events: Event!
+                }
+
+                schema {
+                    query: Query
+                    mutation: Mutation
+                }
+                ";
+
+            var schema = Sdl.Schema(Parser.ParseDocument(sdl));
 
             var resolvers = new ResolverMap
             {
                 {
-                    query.Name, new FieldResolverMap
+                    "Event", new FieldResolverMap()
+                    {
+                        {"type", Resolve.PropertyOf<Event>(ev => ev.Type)},
+                        {"message", Resolve.PropertyOf<Event>(ev => ev.Message)}
+                    }
+                },
+                {
+                    schema.Query.Name, new FieldResolverMap
                     {
                         {"hello", context => new ValueTask<IResolveResult>(Resolve.As("world"))}
                     }
                 },
                 {
-                    subscription.Name, new FieldResolverMap
+                    schema.Mutation.Name, new FieldResolverMap()
+                    {
+                        {"add", async context =>
+                            {
+                                var input = context.GetArgument<InputEvent>("event");
+                                var ev = await eventManager.Add(input.Type, input.Message);
+
+                                return Resolve.As(ev);
+                            }
+                        }
+                    }
+                },
+                {
+                    schema.Subscription.Name, new FieldResolverMap
                     {
                         {
-                            "helloEvents", (context,ct) =>
+                            "events", (context,ct) =>
                             {
                                 var events = eventManager.Subscribe(ct);
                                 return new ValueTask<ISubscribeResult>(Resolve.Stream(events));
@@ -52,8 +95,7 @@ public void ConfigureServices(IServiceCollection services)
                 }
             };
 
-            var executable = SchemaTools
-                .MakeExecutableSchemaWithIntrospection(builder.Build(), resolvers, resolvers).Result;
+            var executable = SchemaTools.MakeExecutableSchemaWithIntrospection(schema, resolvers, resolvers).Result;
             services.AddSingleton(provider => executable);
             services.AddSingleton(provider => eventManager);
 
@@ -73,23 +115,41 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
         }
     }
 
+    public class Event
+    {
+        public string Type { get; set; }
+        public string Message { get; set; }
+    }
+
+    public class InputEvent
+    {
+        public string Type { get; set; }
+        public string Message { get; set; }
+    }
+
     public class EventManager
     {
-        private readonly BufferBlock<string> _buffer;
+        private readonly BufferBlock<Event> _buffer;
 
         public EventManager()
         {
-            _buffer = new BufferBlock<string>();
+            _buffer = new BufferBlock<Event>();
         }
 
-        public Task Hello(string message)
+        public async Task<Event> Add(string type, string message)
         {
-            return _buffer.SendAsync(message);
+            var ev = new Event()
+            {
+                Type = type,
+                Message = message
+            };
+            await _buffer.SendAsync(ev);
+            return ev;
         }
 
-        public ISourceBlock<string> Subscribe(CancellationToken cancellationToken)
+        public ISourceBlock<Event> Subscribe(CancellationToken cancellationToken)
         {
-            var targetBlock = new BufferBlock<string>();
+            var targetBlock = new BufferBlock<Event>();
 
             var sub = _buffer.LinkTo(targetBlock);
             cancellationToken.Register(() =>

tests/graphql.server.tests/ServerFacts.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -7,6 +8,7 @@
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
+using tanka.graphql.tests.data;
 using Xunit;
 
 namespace tanka.graphql.server.tests
@@ -104,6 +106,48 @@ public async Task Multiple_Queries()
             await hubConnection.StopAsync();
         }
 
+        [Fact]
+        public async Task Mutation()
+        {
+            /* Given */
+            var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
+            var hubConnection = Connect();
+            await hubConnection.StartAsync();
+
+            /* When */
+            var reader = await hubConnection.StreamAsChannelAsync<ExecutionResult>("Query", new QueryRequest
+            {
+                Query = @"
+                        mutation Add($event: InputEvent!) { 
+                            add(event: $event) {
+                                    type
+                                    message
+                                }
+                        }",
+                Variables = new Dictionary<string, object>()
+                {
+                    {"event", new Dictionary<string, object>()
+                    {
+                        {"type", "hello"},
+                        {"message", "world"}
+                    }}
+                }
+            }, cancellationToken: cts.Token);
+
+
+            /* Then */
+            var result = await reader.ReadAsync(cts.Token);
+
+            Assert.Contains(result.Data, kv =>
+            {
+                var (key, value) = kv;
+                return key == "add";
+            });
+
+            cts.Cancel();
+            await hubConnection.StopAsync();
+        }
+
         [Fact]
         public async Task Subscribe()
         {
@@ -116,20 +160,23 @@ public async Task Subscribe()
             var reader = await hubConnection.StreamAsChannelAsync<ExecutionResult>("Query", new QueryRequest
             {
                     Query = @"
-subscription { 
-    helloEvents 
-}"
+                        subscription { 
+                            events {
+                                 type
+                                 message
+                            }
+                        }"
             }, cancellationToken: cts.Token);
 
-            await _eventManager.Hello("world");
+            await _eventManager.Add("hello", "world");
 
             /* Then */
             var result = await reader.ReadAsync(cts.Token);
 
             Assert.Contains(result.Data, kv =>
             {
                 var (key, value) = kv;
-                return key == "helloEvents" && value.ToString() == "world";
+                return key == "events";
             });
 
             cts.Cancel();
@@ -148,20 +195,23 @@ public async Task Subscribe_with_unsubscribe()
             var reader = await hubConnection.StreamAsChannelAsync<ExecutionResult>("Query", new QueryRequest
             {
                 Query = @"
-subscription { 
-    helloEvents 
-}"
+                    subscription { 
+                        events {
+                             type
+                             message
+                        }
+                    }"
             }, cancellationToken: cts.Token);
 
-            await _eventManager.Hello("world");
+            await _eventManager.Add("hello", "world");
 
             /* Then */
             var result = await reader.ReadAsync(cts.Token);
 
             Assert.Contains(result.Data, kv =>
             {
                 var (key, value) = kv;
-                return key == "helloEvents" && value.ToString() == "world";
+                return key == "events";
             });
 
             cts.Cancel();

tests/graphql.server.tests/graphql.server.tests.csproj

@@ -29,6 +29,7 @@
     <ProjectReference Include="..\..\src\graphql.server\graphql.server.csproj" />
     <ProjectReference Include="..\..\src\graphql\graphql.csproj" />
     <ProjectReference Include="..\graphql.server.tests.host\graphql.server.tests.host.csproj" />
+    <ProjectReference Include="..\graphql.tests.data\graphql.tests.data.csproj" />
   </ItemGroup>
 
 </Project>