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(); }