public async Task <Response> ProcessRequest(Request request, IUserContext userContext)
{
var result = await _engine
.NewExecutor()
.WithQueryString(request.QueryString)
.WithInputs(request.Variables)
.WithOperationName(request.OperationName)
.WithDependencyInjector(_dependencyInjector)
.WithUserContext(userContext)
.WithComplexityConfiguration(_complexityConfiguration)
.EnableValidation(_useValidation)
.EnableProfiling(_useProfiling)
.Execute()
.ConfigureAwait(false);
var response = new Response(request, result);
var errors = result?.Errors?.Where(e => !string.IsNullOrWhiteSpace(e?.Message));
foreach (var error in errors ?? new List <ExecutionError>())
{
if (_exceptionsTreatedAsWarnings.Contains(error.InnerException.GetType()))
{
response.Warnings.Add(error);
}
else
{
response.Errors.Add(error);
}
}
result.Errors = new ExecutionErrors();
result.Errors.AddRange(response.Errors);
response.Body = _engine.SerializeResult(result);
return(response);
}
public async Task <IActionResult> Post()
{
var requestBody = await ReadRequestBody();
ExecutionResult result = await _engine
.NewExecutor()
.WithValidationRules(_validationRules)
.WithUserContext(_userContext)
.WithDependencyInjector(_injector)
.WithRequest(requestBody)
.Execute();
var responseBody = _engine.SerializeResult(result);
HttpStatusCode statusCode = HttpStatusCode.OK;
if (result.Errors?.Any() ?? false)
{
statusCode = HttpStatusCode.InternalServerError;
if (result.Errors.Any(x => x.Code == "VALIDATION_ERROR"))
{
statusCode = HttpStatusCode.BadRequest;
}
else if (result.Errors.Any(x => x.Code == "UNAUTHORIZED_ACCESS"))
{
statusCode = HttpStatusCode.Forbidden;
}
var eventId = $"{Guid.NewGuid():N}";
foreach (ExecutionError error in result.Errors)
{
error.Data.Add("__eventid", eventId);
Exception exception = error.InnerException?.InnerException
?? error.InnerException
?? error;
_logger.LogError(exception, "[{eventId}] Graph API execution failed. Body = {body}", eventId, requestBody);
}
}
else if (result.Perf?.Any() ?? false)
{
_logger.LogInformation($"Graph API with '{result.Perf[0].Category} {result.Perf[0].Subject}' finished in {result.Perf[0].Duration} ms");
}
else if (result.Operation != null)
{
_logger.LogInformation($"Graph API with '{result.Operation.Name}'");
}
return(new ContentResult
{
Content = responseBody,
ContentType = "application/json; charset=utf-8",
StatusCode = (int)statusCode
});
}
public async Task Executor_Should_Use_UserContext_Injector()
{
var engine = new GraphQLEngine(documentExecuter: new ScopedDocumentExecuter())
.WithQuery <Query>()
.BuildSchema();
var executor1 = engine
.NewExecutor()
.WithQueryString("{ field }")
.WithDependencyInjector(new DependencyInjector("Injector"));
var result1 = await executor1.Execute();
result1.ShouldHaveNoErrors();
result1.Data.ShouldHaveFieldWithValue("field", "Injector->ChildScope");
}
private async Task <ExecutionResult> ExecuteQuery(bool useMultiple, string query)
{
var engine = new GraphQLEngine();
if (useMultiple)
{
engine.BuildSchema(typeof(SchemaDefinition <Query1>), typeof(SchemaDefinition <Query2>));
}
else
{
engine.BuildSchema(typeof(SchemaDefinition <Query1>));
}
var result = await engine
.NewExecutor()
.WithQueryString(query)
.Execute();
return(result);
}
public async Task <IActionResult> Post()
{
string requestBody;
using (var reader = new StreamReader(Request.Body))
requestBody = await reader.ReadToEndAsync();
var result = await engine
.NewExecutor()
.WithDependencyInjector(injector)
.WithUserContext(userContext)
.WithRequest(requestBody)
.Execute();
return(new ContentResult {
Content = engine.SerializeResult(result),
ContentType = "application/json",
StatusCode = 200
});
}
public async Task <IActionResult> Post()
{
string requestBody;
using (var reader = new StreamReader(Request.Body))
requestBody = await reader.ReadToEndAsync();
ExecutionResult result = await _engine
.NewExecutor()
.WithUserContext(_userContext)
.WithDependencyInjector(_injector)
.WithRequest(requestBody)
.Execute();
var responseBody = _engine.SerializeResult(result);
HttpStatusCode statusCode = HttpStatusCode.OK;
if (result.Errors?.Any() ?? false)
{
statusCode = HttpStatusCode.InternalServerError;
if (result.Errors.Any(x => x.Code == "VALIDATION_ERROR"))
{
statusCode = HttpStatusCode.BadRequest;
}
else if (result.Errors.Any(x => x.Code == "UNAUTHORIZED_ACCESS"))
{
statusCode = HttpStatusCode.Forbidden;
}
}
return(new ContentResult
{
Content = responseBody,
ContentType = "application/json; charset=utf-8",
StatusCode = (int)statusCode
});
}
public async Task <IActionResult> Post()
{
string requestBody;
using (var reader = new StreamReader(Request.Body))
{
requestBody = await reader.ReadToEndAsync();
}
Logger.InfoFormat("Post: {Body}", requestBody);
try
{
ExecutionResult result = await _engine
.NewExecutor()
.WithUserContext(_userContext)
.WithDependencyInjector(_injector)
.WithRequest(requestBody)
.Execute();
var responseBody = _engine.SerializeResult(result);
HttpStatusCode statusCode = HttpStatusCode.OK;
if (result.Errors?.Any() ?? false)
{
Exception ex = result.Errors.First();
Logger.ErrorException("Ocorreu um erro durante execução do GraphQL.", ex);
while (ex.InnerException != null)
{
ex = ex.InnerException;
Logger.ErrorException("Ocorreu um erro durante execução do GraphQL.", ex);
}
statusCode = HttpStatusCode.InternalServerError;
if (result.Errors.Any(x => x.Code == "VALIDATION_ERROR"))
{
statusCode = HttpStatusCode.BadRequest;
}
else if (result.Errors.Any(x => x.Code == "UNAUTHORIZED_ACCESS"))
{
statusCode = HttpStatusCode.Forbidden;
}
}
return(new ContentResult
{
Content = responseBody,
ContentType = "application/json; charset=utf-8",
StatusCode = (int)statusCode
});
}
catch (Exception e)
{
Logger.ErrorException("Ocorreu um erro durante execução do GraphQL.", e);
return(new ContentResult
{
Content = e.Message,
ContentType = "application/json; charset=utf-8",
StatusCode = (int)HttpStatusCode.InternalServerError
});
}
}
