public void Trivial2Test()
{
var api = new ApiDescription
{
ApiName = "TestApi1",
TypeName = "TestApi1",
Version = new Version("0.0.0.1"),
};
var provider = new MoqProvider {
Description = api
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
}
public async Task SchemaPrint()
{
var graphQlService = new EfGraphQLService <MappingContext>(sqlInstance.Model, userContext => null !);
var printer = new SchemaPrinter(new MappingSchema(graphQlService));
var print = printer.Print();
await Verifier.Verify(print);
}
static async Task Main(string[] args)
{
var dataAdapter = new OrderDbDataAdapter(false, false, "test");
IEdmModel edmModel = dataAdapter.BuildEdmModel();
await InitializeAsync(dataAdapter, edmModel);
var schemaBuilder = new OeSchemaBuilder(dataAdapter, edmModel, new ModelBuilder.OeEdmModelMetadataProvider());
var schema = schemaBuilder.Build();
var printer = new SchemaPrinter(schema);
var jsonSchema = printer.Print();
Object dataContext = dataAdapter.CreateDataContext();
var result = await new DocumentExecuter().ExecuteAsync(options =>
{
options.UserContext = dataContext;
options.Schema = schema;
//options.Query = "query { orders { name customer (address: \"RU\") { name } } }";
options.Query = "query { orders (id: 1) { items (orderId: 1) { product } } }";
}).ConfigureAwait(false);
dataAdapter.CloseDataContext(dataContext);
var json = new DocumentWriter(indent: true).Write(result);
}
private static Command ConfigureServerCommand()
{
var serverCommand =
new Command("server")
{
new Option <bool>("--print-graphql-schema", () => false, "Print the GraphQL schema and exit")
};
serverCommand.Handler = CommandHandler.Create <bool>(printGraphQlSchema =>
{
using var webApp = Server.Server.ConfigureWebApplication(builder =>
{
Bootstrap.ConfigureFeature(builder.Services);
Bootstrap.ConfigureFileService(builder.Services);
Bootstrap.ConfigureLogging(builder.Logging);
});
if (printGraphQlSchema)
{
var schema = webApp.Services.GetRequiredService <ISchema>();
var printer = new SchemaPrinter(schema);
Console.WriteLine(printer.Print());
return;
}
webApp.Run();
});
return(serverCommand);
}
public async Task SchemaPrint()
{
await using var database = await sqlInstance.Build();
var dbContext = database.Context;
var services = new ServiceCollection();
services.AddSingleton <Query>();
services.AddSingleton <Mutation>();
services.AddSingleton(database.Context);
foreach (var type in GetGraphQlTypes())
{
services.AddSingleton(type);
}
EfGraphQLConventions.RegisterInContainer(services, _ => dbContext, dbContext.Model);
EfGraphQLConventions.RegisterConnectionTypesInContainer(services);
await using var provider = services.BuildServiceProvider();
using var schema = new Schema(provider);
var printer = new SchemaPrinter(schema);
var print = printer.Print();
await Verify(print);
}
public string Describe(Func <ISchema, SchemaPrinter> ctor = null)
{
BuildSchema(); // Ensure that the schema has been constructed
if (ctor != null)
{
_schemaPrinter = ctor(_schema);
}
return(_schemaPrinter.Print());
}
public void TrivialTest()
{
var schema = SchemaGenerator.Generate(new List <ApiProvider>());
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine(description);
Assert.False(string.IsNullOrEmpty(description));
}
}
public void Should_Print_Default_Values_Of_Arguments()
{
CultureTestHelper.UseCultures(() =>
{
var printer = new SchemaPrinter(new Bug2194Schema(), new SchemaPrinterOptions {
IncludeDeprecationReasons = false, IncludeDescriptions = false
});
var printed = printer.Print();
printed.ShouldBe("Bug2194".ReadSDL());
});
}
public async Task Invoke(HttpContext context, ISchema schema)
{
using (var printer = new SchemaPrinter(schema))
{
context.Response.ContentType = "application/text";
context.Response.StatusCode = (int)HttpStatusCode.OK;
await context.Response.WriteAsync(printer.Print());
return;
}
}
public async Task EnumApiTest()
{
var enumType = new ApiEnumType("EnumType", new[] { "item1", "item2" });
var api = new ApiDescription(
"TestApi1",
"0.0.0.1",
new ApiType[] { enumType },
new[] { ApiField.Object("enumField", enumType.TypeName) });
var provider = new MoqProvider {
Description = api, Data = "{\"enumField\": \"item2\"}"
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = "query { api { enumField } } ";
}).ConfigureAwait(true);
this.output.WriteLine("-------- Response -----------");
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = @"{
""data"": {
""api"": {
""enumField"": ""item2""
}
}
}";
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
public async Task Print()
{
var services = new ServiceCollection();
services.AddSingleton <ILoggerFactory>(_ => NullLoggerFactory.Instance);
new Startup().ConfigureServices(services);
await using var provider = services.BuildServiceProvider();
var schema = ServiceProviderServiceExtensions.GetRequiredService <ISchema>(provider);
var printer = new SchemaPrinter(schema);
var print = printer.Print();
var settings = new VerifySettings();
await Verifier.Verify(print, settings);
}
public async Task Print()
{
var services = new ServiceCollection();
services.AddSingleton <ILoggerFactory>(x => NullLoggerFactory.Instance);
new Startup().ConfigureServices(services);
await using var provider = services.BuildServiceProvider();
var schema = new Schema(new FuncDependencyResolver(provider.GetRequiredService));
var printer = new SchemaPrinter(schema);
var print = printer.Print();
var settings = new VerifySettings();
await Verifier.Verify(print, settings);
}
public async Task SchemaPrint()
{
var graphQlService = new EfGraphQLService <MappingContext>(sqlInstance.Model, _ => null !);
ServiceCollection services = new();
EfGraphQLConventions.RegisterInContainer <MappingContext>(services);
services.AddSingleton(new MappingChildGraph(graphQlService));
services.AddSingleton(new MappingParentGraph(graphQlService));
await using var provider = services.BuildServiceProvider();
var mappingSchema = new MappingSchema(graphQlService, provider);
var printer = new SchemaPrinter(mappingSchema);
var print = printer.Print();
await Verifier.Verify(print);
}
public async Task SchemaPrint()
{
var services = new ServiceCollection();
EfGraphQLConventions.RegisterInContainer <MappingContext>(services, model: sqlInstance.Model);
services.AddSingleton <MappingChildGraph>();
services.AddSingleton <MappingParentGraph>();
services.AddSingleton <MappingSchema>();
await using var provider = services.BuildServiceProvider();
var mappingSchema = provider.GetRequiredService <MappingSchema>();
var printer = new SchemaPrinter(mappingSchema);
var print = printer.Print();
await Verify(print);
}
public void ApiGenerationTest()
{
var system = ActorSystem.Create("test");
var api = new ApiProvider(system, new TestRepository());
foreach (var error in api.GenerationErrors)
{
this.output.WriteLine($"Error: {error}");
}
Assert.Equal(0, api.GenerationErrors.Count);
var webApiProvider = new DirectProvider(api, this.output.WriteLine)
{
UseJsonRepack = true
};
var schema = SchemaGenerator.Generate(new List <Web.GraphQL.Publisher.ApiProvider> {
webApiProvider
});
var hasSchemaErrors = false;
foreach (var error in SchemaGenerator.CheckSchema(schema))
{
hasSchemaErrors = true;
this.output.WriteLine($"Schema error: {error}");
}
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.False(hasSchemaErrors);
hasSchemaErrors = false;
foreach (var error in SchemaGenerator.CheckSchemaIntrospection(schema))
{
hasSchemaErrors = true;
this.output.WriteLine($"Schema introspection error: {error}");
}
Assert.False(hasSchemaErrors);
}
// 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)
{
services.AddMvc();
var deserializer = new YamlDeserializer();
var settings = deserializer.DeserializeConfiguration <Settings>();
settings.DynamicObjects.AddDefaultFields();
var objectGenerator = new ObjectGenerator();
objectGenerator.CreateObjects(settings.DynamicObjects);
services.AddAllServices(settings);
var entityTypes = CustomTypeBuilder.GetAllCustomTypes();
var schemaTypes = new List <Type>();
foreach (var type in entityTypes)
{
IServiceProvider serviceProvider = services.BuildServiceProvider();
var service = serviceProvider.GetRequiredService <DynamicObjectService>();
var schemaType = Activator.CreateInstance(typeof(DynamicObjectType <>).MakeGenericType(type), new object[] { service }).GetType();
schemaTypes.Add(schemaType);
services.AddSingleton(schemaType);
}
IServiceProvider schemaServiceProvider = services.BuildServiceProvider();
var schemaGenerator = new SchemaGenerator(schemaServiceProvider);
var schema = schemaGenerator.CreateSchema(schemaTypes.ToArray());
SchemaPrinter printer = new SchemaPrinter(schema);
string wat = printer.Print();
services.AddSingleton <IDocumentExecuter, DocumentExecuter>();
services.AddSingleton <ISchema>(schema);
}
private string print(ISchema schema, SchemaPrinterOptions options)
{
var printer = new SchemaPrinter(schema, options);
return(Environment.NewLine + printer.Print());
}
public override async Task Invoke(IOwinContext context)
{
try
{
var schema = _applicationContext.ApplicationCache.RuntimeCache.GetCacheItem <UmbracoSchema>(
"Our.Umbraco.GraphQL::Schema",
() =>
new UmbracoSchema(
_applicationContext.Services.ContentTypeService,
_applicationContext.Services.MemberTypeService,
_options
)
);
if (false == context.Request.Path.HasValue)
{
var request = context.Get <GraphQLRequest>("Our.Umbraco.GraphQL::Request");
switch (context.Request.Method)
{
case "POST":
if (request == null)
{
context.Response.StatusCode = 400;
await context.Response.WriteAsync("POST body missing.");
return;
}
break;
default:
context.Response.StatusCode = 405;
await context.Response.WriteAsync("Server supports only POST requests.");
return;
}
IEnumerable <Task <ExecutionResult> > requests = request.Select(requestParams =>
{
try
{
string query = requestParams.Query;
string operationName = requestParams.OperationName;
Inputs variables = requestParams.Variables;
return(new DocumentExecuter()
.ExecuteAsync(x =>
{
x.CancellationToken = context.Request.CallCancelled;
//x.ComplexityConfiguration = new ComplexityConfiguration();
x.ExposeExceptions = _options.Debug;
//x.FieldMiddleware.Use<InstrumentFieldsMiddleware>();
x.FieldNameConverter = new DefaultFieldNameConverter();
x.Inputs = variables;
x.OperationName = operationName;
x.Query = query;
//x.Root =
x.Schema = schema;
x.UserContext = new UmbracoGraphQLContext(
context.Request.Uri,
_applicationContext,
UmbracoContext.Current,
_options
);
}));
}
catch (Exception)
{
throw;
}
});
var responses = await Task.WhenAll(requests);
context.Response.ContentType = "application/json";
var writer = new DocumentWriter();
if (false == request.IsBatched)
{
var response = writer.Write(responses[0]);
await context.Response.WriteAsync(response);
}
else
{
var response = writer.Write(responses);
await context.Response.WriteAsync(response);
}
}
else if (context.Request.Path.ToString() == "/schema")
{
using (var schemaPrinter = new SchemaPrinter(schema))
{
context.Response.ContentType = "text/plain";
await context.Response.WriteAsync(schemaPrinter.Print());
}
}
}
catch (Exception ex)
{
context.Response.ContentType = "text/plain";
context.Response.StatusCode = 500;
if (_options.Debug)
{
await context.Response.WriteAsync(ex.ToString());
}
else
{
await context.Response.WriteAsync("Internal server error");
}
}
}
public string Describe()
{
BuildSchema(); // Ensure that the schema has been constructed
return(_schemaPrinter.Print());
}
public override async Task Invoke(IOwinContext context)
{
try
{
var schema = _applicationContext.ApplicationCache.RuntimeCache.GetCacheItem <UmbracoSchema>(
"Our.Umbraco.GraphQL::Schema",
() =>
new UmbracoSchema(
_applicationContext.Services.ContentTypeService,
_applicationContext.Services.MemberTypeService,
_options
)
);
if (false == context.Request.Path.HasValue)
{
var request = context.Get <GraphQLRequest>("Our.Umbraco.GraphQL::Request");
switch (context.Request.Method)
{
case "POST":
if (request == null)
{
context.Response.StatusCode = 400;
await context.Response.WriteAsync("POST body missing.");
return;
}
break;
default:
context.Response.StatusCode = 405;
await context.Response.WriteAsync("Server supports only POST requests.");
return;
}
IEnumerable <Task <ExecutionResult> > requests = request.Select(async requestParams =>
{
string query = requestParams.Query;
string operationName = requestParams.OperationName;
string accessToken = context.Request.Query["accessToken"];
Inputs variables = requestParams.Variables;
var validationRules = new List <IValidationRule> {
new RequiresAuthValidationRule()
};
var start = DateTime.Now;
MiniProfiler.Start();
var errors = new ExecutionErrors();
var result = await _documentExecutor
.ExecuteAsync(x =>
{
x.CancellationToken = context.Request.CallCancelled;
//x.ComplexityConfiguration = new ComplexityConfiguration();
x.ExposeExceptions = _options.Debug;
if (_options.EnableMetrics)
{
x.EnableMetrics = true;
x.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
x.FieldMiddleware.Use <MiniProfilerFieldsMiddleware>();
}
x.FieldNameConverter = new DefaultFieldNameConverter();
x.Inputs = variables;
x.OperationName = operationName;
x.Query = query;
//x.Root =
x.Schema = schema;
x.UserContext = new UmbracoGraphQLContext(
context.Request.Uri,
_applicationContext,
UmbracoContext.Current,
_options,
accessToken,
out errors
);
x.ValidationRules = validationRules;
});
// Save any of our errors reported by our authentication stuff in UserContext
if (errors.Any())
{
if (result.Errors != null)
{
result.Errors.Concat(errors);
}
else
{
result.Errors = errors;
}
}
if (_options.EnableMetrics && result.Errors == null)
{
result.EnrichWithApolloTracing(start);
if (result.Extensions == null)
{
result.Extensions = new Dictionary <string, object>();
}
result.Extensions["miniProfiler"] = JObject.FromObject(MiniProfiler.Current, new JsonSerializer {
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
}
MiniProfiler.Stop();
return(result);
});
var responses = await Task.WhenAll(requests);
context.Response.ContentType = "application/json";
if (false == request.IsBatched)
{
var response = _documentWriter.Write(responses[0]);
await context.Response.WriteAsync(response);
}
else
{
var response = _documentWriter.Write(responses);
await context.Response.WriteAsync(response);
}
}
else if (context.Request.Path.ToString() == "/schema")
{
using (var schemaPrinter = new SchemaPrinter(schema))
{
context.Response.ContentType = "text/plain";
await context.Response.WriteAsync(schemaPrinter.Print());
}
}
}
catch (Exception ex)
{
context.Response.ContentType = "text/plain";
context.Response.StatusCode = 500;
if (_options.Debug)
{
await context.Response.WriteAsync(ex.ToString());
}
else
{
await context.Response.WriteAsync("Internal server error");
}
}
}
public async Task NonEmptyApiTest()
{
var viewerType = new ApiObjectType(
"viewer",
new[] { ApiField.Scalar("id", EnScalarType.Integer), ApiField.Scalar("name", EnScalarType.String) });
var api = new ApiDescription(
"TestApi1",
"0.0.0.1",
new[] { viewerType },
new[] { viewerType.CreateField("viewer") });
var provider = new MoqProvider
{
Description = api,
Data = "{\"viewer\": {\"__id\": 1, \"name\": \"test name\"}}"
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = @"
query {
api {
viewer {
__id,
name
}
}
}
";
}).ConfigureAwait(true);
this.output.WriteLine("-------- Response -----------");
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = @"{
""data"": {
""api"": {
""viewer"": {
""__id"": 1,
""name"": ""test name""
}
}
}
}";
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
public async Task SchemaDescriptionTest()
{
var checkAttributeArguments = new[]
{
ApiField.Scalar(
"attribute",
EnScalarType.String,
description: "attribute to check")
};
var objectFields = new[]
{
ApiField.Scalar(
"uid",
EnScalarType.Guid,
description: "The object unique identifier"),
ApiField.Scalar("name", EnScalarType.String, description: "The object name"),
ApiField.Scalar(
"attributes",
EnScalarType.String,
EnFieldFlags.IsArray,
description: "The object attributes"),
ApiField.Scalar(
"checkAttribute",
EnScalarType.Boolean,
arguments: checkAttributeArguments,
description: "checks the attribute")
};
var objectType = new ApiObjectType("object", objectFields)
{
Description = "Some abstract object"
};
var apiField = objectType.CreateField(
"new",
description: "The new object data");
var mutations = new[]
{
ApiMutation.CreateFromField(
ApiField.Object(
"objects_create",
"object",
arguments: new[] { apiField },
description: "creates a new object"),
ApiMutation.EnType.ConnectionCreate,
new List <ApiRequest>())
};
var api = new ApiDescription(
"TestApi",
"0.0.0.1",
new[] { objectType },
new[] { objectType.CreateField("objects", EnFieldFlags.IsConnection, "The objects dataset") },
mutations)
{
Description = "The test api"
};
var provider = new MoqProvider {
Description = api
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
var errors = SchemaGenerator.CheckSchema(schema).Select(e => $"Schema type error: {e}")
.Union(SchemaGenerator.CheckSchemaIntrospection(schema))
.Select(e => $"Schema introspection error: {e}");
var hasErrors = false;
foreach (var error in errors)
{
hasErrors = true;
this.output.WriteLine(error);
}
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.False(hasErrors);
var query = BaseInstaller.ReadTextResource(
this.GetType().GetTypeInfo().Assembly,
"KlusterKite.Web.Tests.GraphQL.Resources.IntrospectionQuery.txt");
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = query;
}).ConfigureAwait(true);
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = BaseInstaller.ReadTextResource(
this.GetType().GetTypeInfo().Assembly,
"KlusterKite.Web.Tests.GraphQL.Resources.SchemaDescriptionTestSnapshot.txt");
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
private string print(ISchema schema)
{
var printer = new SchemaPrinter(schema);
return(Environment.NewLine + printer.Print());
}
public async Task ArraysApiTest()
{
var viewerFields = new[]
{
ApiField.Scalar("id", EnScalarType.Guid, EnFieldFlags.Queryable | EnFieldFlags.IsKey),
ApiField.Scalar("name", EnScalarType.String),
ApiField.Scalar("numbers", EnScalarType.Integer, EnFieldFlags.IsArray | EnFieldFlags.Queryable)
};
var viewerType = new ApiObjectType("viewer", viewerFields);
var objectFields = new[]
{
ApiField.Scalar("id", EnScalarType.Integer, EnFieldFlags.IsKey | EnFieldFlags.Queryable),
ApiField.Scalar("name", EnScalarType.String)
};
var objectType = new ApiObjectType("object", objectFields);
var api = new ApiDescription(
"TestApi1",
"0.0.0.1",
new[] { viewerType, objectType },
new[] { viewerType.CreateField("viewer"), objectType.CreateField("object", EnFieldFlags.IsConnection | EnFieldFlags.Queryable) });
var provider = new MoqProvider
{
Description = api,
Data = @"{
""viewer"": {
""__id"": ""FD73BAFB-3698-4FA1-81F5-27C8C83BB4F0"",
""name"": ""test name"",
""numbers"": [1, 2, 3]
},
""object"": {
""count"": 2,
""edges"": [
{""__id"": 10, ""node___id"": 10},
{""__id"": 20, ""node___id"": 20}
]
}
}"
};
var schema = SchemaGenerator.Generate(new List <ApiProvider> {
provider
});
using (var printer = new SchemaPrinter(schema))
{
var description = printer.Print();
this.output.WriteLine("-------- Schema -----------");
this.output.WriteLine(description);
Assert.False(string.IsNullOrWhiteSpace(description));
}
Assert.NotNull(schema.Query);
Assert.Equal(3, schema.Query.Fields.Count());
Assert.True(schema.Query.HasField("api"));
var result = await new DocumentExecuter().ExecuteAsync(
r =>
{
r.Schema = schema;
r.Query = @"
query {
api {
viewer {
__id,
name,
numbers
},
object {
count,
edges {
cursor,
node {
__id
}
}
}
}
}
";
}).ConfigureAwait(true);
this.output.WriteLine("-------- Response -----------");
var response = new DocumentWriter(true).Write(result);
this.output.WriteLine(response);
var expectedResponse = @"{
""data"": {
""api"": {
""viewer"": {
""__id"": ""fd73bafb-3698-4fa1-81f5-27c8c83bb4f0"",
""name"": ""test name"",
""numbers"": [1, 2, 3]
},
""object"": {
""count"": 2,
""edges"": [
{
""cursor"": 10,
""node"": {
""__id"": 10
}
},
{
""cursor"": 20,
""node"": {
""__id"": 20
}
}
]
}
}
}
}";
Assert.Equal(CleanResponse(expectedResponse), CleanResponse(response));
}
public static string GetSchemaDefinition(this ISchema schema)
{
var schemaPrinter = new SchemaPrinter(schema);
return(schemaPrinter.Print());
}
