public static ISchema InitializeSchema()
{
var events = new SingleValueEventChannel();
var builder = new SchemaBuilder()
.Sdl(Parser.ParseTypeSystemDocument(
@"
type Query {
simple: String
}
type Mutation {
simple: String
}
type Subscription {
simple: String
}
schema {
query: Query
mutation: Mutation
subscription: Subscription
}
"));
var resolvers = new ObjectTypeMap
{
{
"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))
}
}
}
};
var schema = SchemaTools.MakeExecutableSchema(
builder,
resolvers,
resolvers);
return(schema);
}
public ExecutionPathFacts()
{
// schema
var builder = new SchemaBuilder();
builder.Object("Node", out var node)
.Connections(connect => connect
.Field(node, "child", node)
.Field(node, "path", new List(ScalarType.String))
.Field(node, "value", ScalarType.String)
.Field(node, "children", new List(node)));
builder.Query(out var query)
.Connections(connect => connect
.Field(query, "root", node));
builder.Mutation(out var mutation)
.Connections(connect => connect
.Field(mutation, "root", node));
var schema = builder.Build();
var resolvers = new ObjectTypeMap
{
{
"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 = SchemaTools.MakeExecutableSchema(schema, resolvers);
}
public async Task Make_executable_schema()
{
/* Given */
var builder = new SchemaBuilder()
.Sdl(@"
type Query {
field1: Int!
}
schema {
query: Query
}
"
);
var resolvers = new ObjectTypeMap
{
{
"Query", new FieldResolversMap
{
{
"field1", async context =>
{
await Task.Delay(1);
return(Resolve.As(1));
}
}
}
}
};
/* When */
var executableSchema = SchemaTools.MakeExecutableSchema(
builder: builder,
resolvers: resolvers,
subscribers: null,
converters: null,
directives: null);
/* Then */
var result = await Executor.ExecuteAsync(
new ExecutionOptions
{
Document = Parser.ParseDocument(@"{ field1 }"),
Schema = executableSchema
});
result.ShouldMatchJson(
@"{
""data"": {
""field1"": 1
}
}");
}
public NullErrorsFacts()
{
var builder = new SchemaBuilder();
builder.Object("Nest", out var nested)
.Connections(connect => connect
.Field(nested, "nestedNonNull", ScalarType.NonNullString));
builder.Query(out var query)
.Connections(connect => connect
.Field(query, "nonNull", ScalarType.NonNullString)
.Field(query, "nonNullNested", new NonNull(nested))
.Field(query, "nonNullListItem", new List(ScalarType.NonNullString))
.Field(query, "nonNullList", new NonNull(new List(ScalarType.String)))
.Field(query, "nullableNested", nested)
.Field(query, "nullable", ScalarType.String));
var nestedNonNullData = new Dictionary <string, string>
{
["nestedNonNull"] = null
};
IResolverMap resolvers = new ObjectTypeMap
{
["Query"] = new FieldResolversMap
{
{ "nonNull", context => new ValueTask <IResolverResult>(Resolve.As(null)) },
{ "nonNullNested", context => new ValueTask <IResolverResult>(Resolve.As(nestedNonNullData)) },
{ "nonNullListItem", context => new ValueTask <IResolverResult>(Resolve.As(new[] { "str", null, "str" })) },
{ "nonNullList", context => new ValueTask <IResolverResult>(Resolve.As(null)) },
{ "nullableNested", context => new ValueTask <IResolverResult>(Resolve.As(nestedNonNullData)) },
{ "nullable", context => new ValueTask <IResolverResult>(Resolve.As("hello")) }
},
["Nest"] = new FieldResolversMap
{
{ "nestedNonNull", Resolve.PropertyOf <Dictionary <string, string> >(d => d["nestedNonNull"]) }
}
};
_schema = SchemaTools.MakeExecutableSchema(
builder,
resolvers);
}
// 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()
.Sdl(Parser.ParseTypeSystemDocument(sdl));
var resolvers = new ObjectTypeMap
{
{
"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 = SchemaTools.MakeExecutableSchemaWithIntrospection(
builder,
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();
}
public ExecutorFacts(ITestOutputHelper atr)
{
Model = new EventsModel();
Resolvers = new ObjectTypeMap
{
{
"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.GetNamedType <ObjectType>("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.GetNamedType <ObjectType>("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 = SchemaTools.MakeExecutableSchema(
new SchemaBuilder().Sdl(Sdl),
Resolvers,
Resolvers);
}
public async Task Authorize_field_directive()
{
/* Given */
var authorizeType = new DirectiveType(
"authorize",
new[]
{
DirectiveLocation.FIELD_DEFINITION
},
new Args
{
{ "role", ScalarType.NonNullString, "user", "Required role" }
});
var builder = new SchemaBuilder();
builder.Include(authorizeType);
builder.Query(out var query)
.Connections(connect => connect
.Field(query, "requiresAdmin", ScalarType.String,
directives: new[]
{
authorizeType.CreateInstance(new Dictionary <string, object>
{
// this will override the default value of the DirectiveType
["role"] = "admin"
})
})
.Field(query, "requiresUser", ScalarType.String,
directives: new[]
{
// this will use defaultValue from DirectiveType
authorizeType.CreateInstance()
}));
var resolvers = new ObjectTypeMap
{
{
query.Name, new FieldResolversMap
{
{ "requiresAdmin", context => new ValueTask <IResolverResult>(Resolve.As("Hello Admin!")) },
{ "requiresUser", context => new ValueTask <IResolverResult>(Resolve.As("Hello User!")) }
}
}
};
// mock user and user store
var user = new ClaimsPrincipal(new ClaimsIdentity(new []
{
new Claim("role", "user"),
}));
ClaimsPrincipal FetchUser(int id) => user;
/* When */
var schema = SchemaTools.MakeExecutableSchema(
builder,
resolvers,
directives: new Dictionary <string, CreateDirectiveVisitor>
{
// register directive visitor to be used when authorizeType.Name present
[authorizeType.Name] = AuthorizeVisitor(FetchUser)
});
var result = await Executor.ExecuteAsync(new ExecutionOptions
{
Document = Parser.ParseDocument(@"{ requiresAdmin requiresUser }"),
Schema = schema
});
/* Then */
result.ShouldMatchJson(
@"
{
""data"": {
""requiresAdmin"": null,
""requiresUser"": ""Hello User!""
},
""errors"": [
{
""message"": ""requires admin role. "",
""locations"": [
{
""line"": 1,
""column"": 3
}
],
""path"": [
""requiresAdmin""
],
""extensions"": {
""code"": ""EXCEPTION""
}
}
]
}
");
}
public async Task Authorize_field_directive_sdl()
{
/* Given */
var builder = new SchemaBuilder()
.Sdl(Parser.ParseTypeSystemDocument(@"
directive @authorize(
role: String =""user""
) on FIELD_DEFINITION
type Query {
requiresAdmin: String @authorize(role:""admin"")
requiresUser: String @authorize
}
schema {
query: Query
}
"));
var resolvers = new ObjectTypeMap
{
{
"Query", new FieldResolversMap
{
{ "requiresAdmin", context => new ValueTask <IResolverResult>(Resolve.As("Hello Admin!")) },
{ "requiresUser", context => new ValueTask <IResolverResult>(Resolve.As("Hello User!")) }
}
}
};
// mock user and user store
var user = new ClaimsPrincipal(new ClaimsIdentity(new []
{
new Claim("role", "user"),
}));
ClaimsPrincipal FetchUser(int id) => user;
/* When */
var schema = SchemaTools.MakeExecutableSchema(
builder,
resolvers,
directives: new Dictionary <string, CreateDirectiveVisitor>
{
// register directive visitor to be used when authorizeType.Name present
["authorize"] = AuthorizeVisitor(FetchUser)
});
var result = await Executor.ExecuteAsync(new ExecutionOptions
{
Document = Parser.ParseDocument(@"{ requiresAdmin requiresUser }"),
Schema = schema
});
/* Then */
result.ShouldMatchJson(@"
{
""data"": {
""requiresAdmin"": null,
""requiresUser"": ""Hello User!""
},
""errors"": [
{
""message"": ""requires admin role. "",
""locations"": [
{
""line"": 1,
""column"": 3
}
],
""path"": [
""requiresAdmin""
],
""extensions"": {
""code"": ""EXCEPTION""
}
}
]
}
");
}
public SubscriptionsFacts()
{
// schema
var builder = new SchemaBuilder();
builder.Object("Message", out var messageType)
.Connections(connect => connect
.Field(messageType, "content", ScalarType.String));
var messageListType = new List(messageType);
builder.Query(out var query)
.Connections(connect => connect
.Field(query, "messages", messageListType));
builder.Subscription(out var subscription)
.Connections(connect => connect
.Field(subscription, "messageAdded", messageType));
var schema = builder.Build();
// data
var messages = new List <Message>();
_messagesChannel = new EventChannel <Message>();
// resolvers
ValueTask <IResolverResult> GetMessagesAsync(IResolverContext context)
{
return(ResolveSync.As(messages));
}
ValueTask <ISubscriberResult> OnMessageAdded(IResolverContext context, CancellationToken unsubscribe)
{
return(ResolveSync.Subscribe(_messagesChannel, unsubscribe));
}
ValueTask <IResolverResult> ResolveMessage(IResolverContext context)
{
return(ResolveSync.As(context.ObjectValue));
}
var resolvers = new ObjectTypeMap
{
["Query"] = new FieldResolversMap
{
{ "messages", GetMessagesAsync }
},
["Subscription"] = new FieldResolversMap
{
{ "messageAdded", OnMessageAdded, ResolveMessage }
},
["Message"] = new FieldResolversMap
{
{ "content", Resolve.PropertyOf <Message>(r => r.Content) }
}
};
// make executable
_executable = SchemaTools.MakeExecutableSchema(
schema,
resolvers,
resolvers);
}
