public ExecutionPathFacts()
{
// schema
var builder = new SchemaBuilder();
builder.Add((TypeSystemDocument) @"
type Node {
child: Node
path: [String]
value: String
children: [Node]
}
type Query {
root: Node
}
type Mutation {
root: Node
}
");
var resolvers = new ResolversMap
{
{
"Query", new FieldResolversMap
{
{ "root", context => new ValueTask <IResolverResult>(Resolve.As(new { })) }
}
},
{
"Mutation", new FieldResolversMap
{
{ "root", context => new ValueTask <IResolverResult>(Resolve.As(new { })) }
}
},
{
"Node", new FieldResolversMap
{
{ "child", context => new ValueTask <IResolverResult>(Resolve.As(new { })) },
{
"children", context => new ValueTask <IResolverResult>(Resolve.As(new[]
{
new { id = 0 },
new { id = 1 }
}))
},
{ "value", context => new ValueTask <IResolverResult>(Resolve.As("value")) },
{ "path", context => new ValueTask <IResolverResult>(Resolve.As(context.Path.Segments)) }
}
}
};
_schema = builder.Build(resolvers).Result;
}
public ResolversMap Clone()
{
var result = new ResolversMap();
foreach (var objectMap in this)
{
result.Add(objectMap.Key, objectMap.Value.Clone());
}
return(result);
}
public static Task <ISchema> InitializeSchema()
{
var events = new SingleValueEventChannel();
var builder = new SchemaBuilder()
.Add(
@"
type Query {
simple: String
}
type Mutation {
simple: String
}
type Subscription {
simple: String
}
schema {
query: Query
mutation: Mutation
subscription: Subscription
}
");
var resolvers = new ResolversMap
{
{
"Query", new FieldResolversMap
{
{ "simple", context => new ValueTask <IResolverResult>(Resolve.As("value")) }
}
},
{
"Mutation", new FieldResolversMap
{
{ "simple", context => new ValueTask <IResolverResult>(Resolve.As("value")) }
}
},
{
"Subscription", new FieldResolversMap
{
{
"simple",
(context, unsubscribe) => ResolveSync.Subscribe(events, unsubscribe),
context => new ValueTask <IResolverResult>(Resolve.As(context.ObjectValue))
}
}
}
};
return(builder.Build(resolvers, resolvers));
}
//todo: use ResolversBuilder.AddLinkedTypes()
/// <summary>
/// Create resolvers for ObjectTypes and ObjectType extensions in <see cref="TypeSystemDocument"/> which
/// resolve the values using the given <paramref name="link"/>
/// </summary>
/// <param name="remoteTypes"></param>
/// <param name="link"></param>
/// <param name="createResolver"></param>
/// <param name="createSubscriber"></param>
/// <returns></returns>
public static ResolversMap CreateLinkResolvers(
TypeSystemDocument remoteTypes,
ExecutionResultLink link,
Func <ExecutionResultLink, Resolver> createResolver = null,
Func <ExecutionResultLink, Subscriber> createSubscriber = null)
{
if (createResolver == null)
{
createResolver = DefaultCreateRemoteResolver;
}
if (createSubscriber == null)
{
createSubscriber = DefaultCreateRemoteSubscriber;
}
var objectDefinitionsAndExtensions = GetObjectDefinitions(remoteTypes);
var rootTypes = objectDefinitionsAndExtensions.Where(type => RootTypes.Contains(type.Name.Value))
.OfType <ObjectDefinition>();
ResolversMap resolvers = new ResolversMap();
foreach (var rootType in rootTypes)
{
foreach (var field in rootType.Fields)
{
if (rootType.Name != "Subscription")
{
resolvers.Add(rootType.Name.Value, field.Name.Value, createResolver(link));
}
else
{
resolvers.Add(rootType.Name.Value, field.Name.Value, createSubscriber(link));
}
}
}
var resolver = DefaultDictionaryResolver();
foreach (var objectType in objectDefinitionsAndExtensions.Where(type => !RootTypes.Contains(type.Name.Value))
.OfType <ObjectDefinition>())
{
foreach (var field in objectType.Fields)
{
resolvers.Add(objectType.Name.Value, field.Name.Value, resolver);
}
}
return(resolvers);
}
public ExecutorFacts(ITestOutputHelper atr)
{
Model = new EventsModel();
Resolvers = new ResolversMap
{
{
"Success", new FieldResolversMap
{
{ "id", Resolve.PropertyOf <EventsModel.Success>(m => m.Id) },
{ "event", Resolve.PropertyOf <EventsModel.Success>(m => m.Event) }
}
},
{
"Failure", new FieldResolversMap
{
{ "message", Resolve.PropertyOf <EventsModel.Failure>(m => m.Message) }
}
},
{
"Event", new FieldResolversMap
{
{ "id", Resolve.PropertyOf <EventsModel.Event>(ev => ev.Id) },
{ "type", Resolve.PropertyOf <EventsModel.Event>(ev => ev.Type) },
{ "payload", Resolve.PropertyOf <EventsModel.Event>(ev => ev.Payload) }
}
},
{
"NewEvent", new FieldResolversMap
{
{ "type", Resolve.PropertyOf <EventsModel.NewEvent>(type => type.Type) },
{ "payload", Resolve.PropertyOf <EventsModel.NewEvent>(type => type.Payload) }
}
},
{
"Query", new FieldResolversMap
{
{ "events", context => new ValueTask <IResolverResult>(Resolve.As(Model.Events)) }
}
},
{
"Mutation", new FieldResolversMap
{
{
"create", async context =>
{
var newEvent = context.GetObjectArgument <EventsModel.NewEvent>("event");
if (newEvent.Payload == null)
{
return(Resolve.As(
context.ExecutionContext.Schema.GetRequiredNamedType <ObjectDefinition>("Failure"),
new EventsModel.Failure("Payload should be given")));
}
var id = await Model.AddAsync(newEvent);
var ev = Model.Events.Single(e => e.Id == id);
return(Resolve.As(
context.ExecutionContext.Schema.GetRequiredNamedType <ObjectDefinition>("Success"),
new EventsModel.Success(id, ev)));
}
}
}
},
{
"Subscription", new FieldResolversMap
{
{
"events", async(context, unsubscribe) =>
{
await Task.Delay(0);
var source = Model.Subscribe(unsubscribe);
return(source);
},
context => new ValueTask <IResolverResult>(Resolve.As(context.ObjectValue))
}
}
}
};
Schema = new SchemaBuilder()
.Add((TypeSystemDocument)Sdl)
.Build(Resolvers, Resolvers).Result;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
var eventManager = new EventManager();
var sdl = @"
input InputEvent {
type: String!
message: String!
}
type Event {
type: String!
message: String!
}
type Query {
hello: String!
}
type Mutation {
add(event: InputEvent!): Event
}
type Subscription {
events: Event!
}
schema {
query: Query
mutation: Mutation
}
";
var builder = new SchemaBuilder()
.Add(sdl);
var resolvers = new ResolversMap
{
{
"Event", new FieldResolversMap
{
{ "type", Resolve.PropertyOf <Event>(ev => ev.Type) },
{ "message", Resolve.PropertyOf <Event>(ev => ev.Message) }
}
},
{
"Query", new FieldResolversMap
{
{ "hello", context => new ValueTask <IResolverResult>(Resolve.As("world")) }
}
},
{
"Mutation", new FieldResolversMap
{
{
"add", async context =>
{
var input = context.GetObjectArgument <InputEvent>("event");
var ev = await eventManager.Add(input.Type, input.Message);
return(Resolve.As(ev));
}
}
}
},
{
"Subscription", new FieldResolversMap
{
{
"events", (context, ct) =>
{
var events = eventManager.Subscribe(ct);
return(new ValueTask <ISubscriberResult>(events));
},
context => new ValueTask <IResolverResult>(Resolve.As(context.ObjectValue))
}
}
}
};
var executable = builder.Build(resolvers, resolvers);
services.AddSingleton(provider => eventManager);
// configure common options and add web socket services
services.AddTankaGraphQL()
.ConfigureSchema(() => new ValueTask <ISchema>(executable))
.ConfigureWebSockets();
// add SignalR services and Tanka SignalR hub services
services.AddSignalR()
.AddTankaGraphQL();
}
