public ExecutionResult AssertQuery <TSchema>(Action <ExecutionOptions> options, ExecutionResult expectedExecutionResult)
where TSchema : ISchema
{
var schema = Services.GetRequiredService <TSchema>();
// Run the executer within an async context to make sure there are no deadlock issues
var runResult = AsyncContext.Run(() => executer.ExecuteAsync((opts) =>
{
options(opts);
opts.Schema = schema;
opts.ExposeExceptions = true;
}));
var writtenResult = writer.Write(runResult);
var expectedResult = writer.Write(expectedExecutionResult);
string additionalInfo = null;
if (runResult.Errors?.Any() == true)
{
additionalInfo = string.Join(Environment.NewLine, runResult.Errors
.Where(x => x.InnerException is GraphQLSyntaxErrorException)
.Select(x => x.InnerException.Message));
}
writtenResult.ShouldBe(expectedResult, additionalInfo);
return(runResult);
}
public async Task <HttpResponseMessage> Get(HttpRequestMessage request, GraphQLQuery query)
{
if (request.Method == HttpMethod.Get)
{
Request.RequestUri.TryReadQueryAs(out query);
}
var httpResult = HttpStatusCode.OK;
var json = string.Empty;
if (query != null)
{
var input = query.Variables?.ToString().ToInputs();
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = query.Query;
_.OperationName = query.OperationName;
_.Inputs = input;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 250
};
_.FieldMiddleware.Use <ErrorLogFieldsMiddleware>();
_.Listeners.Add(_dataLoaderListener);
}).ConfigureAwait(false);
if (result != null && result.Errors != null && result.Errors.Any())
{
httpResult = HttpStatusCode.BadRequest;
foreach (var error in result.Errors)
{
//_log.Exception("GraphQL: " + JsonConvert.SerializeObject(error));
}
json = _writer.Write(result.Errors.First());
var errorResponse = request.CreateResponse(httpResult);
errorResponse.Content = new StringContent(json, Encoding.UTF8, "application/json");
return(errorResponse);
}
else
{
httpResult = HttpStatusCode.OK;
}
json = _writer.Write(result);
}
var response = request.CreateResponse(httpResult);
response.Content = new StringContent(json, Encoding.UTF8, "application/json");
return(response);
}
public async Task <string> ExecuteAsync(string query, string variables, string operationName, CancellationToken cancellationToken)
{
var inputs = variables.ToInputs();
var result = await _executer.ExecuteAsync(_ =>
{
_.UserContext = _ctx;
_.Schema = _schema;
_.Query = query;
_.OperationName = operationName;
_.Inputs = inputs;
_.CancellationToken = cancellationToken;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
}; // Set limit to the nesting
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
_.ValidationRules = new[] { new RequiresAuthValidationRule() }; // Will be executed for every field before it gets resolved
});
if (result.Errors?.Any() ?? false)
{
var sb = new StringBuilder();
foreach (var error in result.Errors)
{
sb.AppendLine(error.Message);
}
return(JObject.FromObject(new { Error = sb.ToString() }).ToString());
}
return(_writer.Write(result));
}
/// <summary>
/// Parse the given log file.
/// </summary>
/// <returns>Count of documents that were successfully parsed.</returns>
public long Parse(LogFileContext logFile)
{
long processedDocumentCount = 0;
using (var reader = new StreamReader(new FileStream(logFile.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
while (!parser.FinishedParsing)
{
// Parse a document.
JObject document = parser.ParseLogDocument(reader);
if (document != null)
{
DocumentWriteResult result = writer.Write(document);
if (!result.IsSuccessful)
{
Log.WarnFormat("Failed to write document parsed from file '{0}': {1}", logFile, result.ErrorMessage);
}
else
{
processedDocumentCount++;
}
}
}
}
writer.Shutdown();
return(processedDocumentCount);
}
public async Task InvokeAsync(HttpContext httpContext, ISchema schema, IServiceProvider serviceProvider)
{
if (httpContext.Request.Path.StartsWithSegments("/api/graphql") && string.Equals(httpContext.Request.Method, "POST", StringComparison.OrdinalIgnoreCase))
{
string body;
using (var streamReader = new StreamReader(httpContext.Request.Body))
{
body = await streamReader.ReadToEndAsync();
var request = JsonConvert.DeserializeObject <GraphQLRequest>(body);
var result = await _executor.ExecuteAsync(doc =>
{
doc.Schema = schema;
doc.Query = request.Query;
doc.Inputs = request.Variables.ToInputs();
doc.Listeners.Add(serviceProvider.GetRequiredService <DataLoaderDocumentListener>());
}).ConfigureAwait(false);
var json = _writer.Write(result);
await httpContext.Response.WriteAsync(json);
}
}
else
{
await _next(httpContext);
}
}
public async Task <TOutput> InvokeAsync <TInput, TOutput>(TInput input)
where TInput : class
where TOutput : class
{
var start = DateTime.UtcNow;
var req = input as HttpRequest;
var request = req.Body.Deserialize <GraphQLRequest>();
var result = await documentExecuter.ExecuteAsync(_ =>
{
_.Schema = schema;
_.Query = request.Query;
_.OperationName = request.OperationName;
_.Inputs = request.Variables.ToInputs();
_.ExposeExceptions = true;
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
//_.UserContext = _settings.BuildUserContext?.Invoke(context);
});
result.EnrichWithApolloTracing(start);
var json = documentWriter.Write(result);
return(result.Errors?.Any() == true
? new BadRequestObjectResult(json) as TOutput
: new OkObjectResult(json) as TOutput);
}
public async Task <HttpResponseMessage> PostAsync(HttpRequestMessage request, GraphQLQuery query)
{
var inputs = query.Variables.ToInputs();
var queryToExecute = query.Query;
if (!string.IsNullOrWhiteSpace(query.NamedQuery))
{
queryToExecute = _namedQueries[query.NamedQuery];
}
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
}).ConfigureAwait(false);
var httpResult = result.Errors?.Count > 0
? HttpStatusCode.BadRequest
: HttpStatusCode.OK;
var json = _writer.Write(result);
var response = request.CreateResponse(httpResult);
response.Content = new StringContent(json, Encoding.UTF8, "application/json");
return(response);
}
public async Task <ActionResult> PostAsync([FromBody] GraphQLQuery query)
{
var queryToExecute = query.Query;
var inputs = JsonConvert.SerializeObject(query.Variables).ToInputs();
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
}).ConfigureAwait(false);
var httpResult = result.Errors?.Count > 0
? HttpStatusCode.BadRequest
: HttpStatusCode.OK;
var json = _writer.Write(result);
return(new ContentResult()
{
StatusCode = (int)httpResult,
Content = json,
ContentType = "application/json"
});
}
public async Task <string> ProcessAsync(GraphQLParameter query)
{
Inputs inputs = null;
if (query.Variables != null)
{
var variables = query.Variables as JObject;
var values = GetValue(variables) as Dictionary <string, object>;
inputs = new Inputs(values);
}
var queryToExecute = query.Query;
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
});
return(_writer.Write(result));
}
public async Task <string> Post(GraphQLQuery query)
{
var inputs = query.Variables.ToInputs();
var queryToExecute = query.Query;
if (!string.IsNullOrWhiteSpace(query.NamedQuery))
{
queryToExecute = _namedQueries[query.NamedQuery];
}
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
////_.UserContext = userInfo;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
////_.UserContext = userInfo;
////_.Root = new
////{
//// nSession = NHibernateSessionManager.GetInstance().GetSession()
////};
}).ConfigureAwait(false);
var json = _writer.Write(result);
return(json);
}
/// <summary>
/// Parse the given log file.
/// </summary>
/// <returns>Count of documents that were successfully parsed.</returns>
public long Parse(LogFileContext logFile)
{
long processedDocumentCount = 0;
using (var reader = new StreamReader(new FileStream(logFile.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
while (!parser.FinishedParsing)
{
// Parse a document.
JObject document = parser.ParseLogDocument(reader);
if (document != null)
{
DocumentWriteResult result = writer.Write(document);
switch (result.Result)
{
case DocumentWriteResultType.Failure:
Log.WarnFormat("Failed to write document parsed from file '{0}': {1}", logFile, result.ErrorMessage);
break;
case DocumentWriteResultType.SuccessWithWarning:
Log.WarnFormat($"Document from file '{logFile}' processed with warning: {result.ErrorMessage}");
break;
}
processedDocumentCount++;
}
}
}
writer.Shutdown();
return(processedDocumentCount);
}
public async Task InvokeAsync(HttpContext httpContext)
{
if (httpContext.Request.Path.StartsWithSegments("/api/graphql") && string.Equals(httpContext.Request.Method, "POST", StringComparison.OrdinalIgnoreCase))
{
string body;
using (var streamReader = new StreamReader(httpContext.Request.Body))
{
body = await streamReader.ReadToEndAsync();
var request = JsonConvert.DeserializeObject <GraphQLRequest>(body);
var result = await _executor.ExecuteAsync(doc =>
{
doc.Schema = _schema;
doc.Query = request.Query;
}).ConfigureAwait(false);
var json = _writer.Write(result);
await httpContext.Response.WriteAsync(json);
}
}
else
{
await _next(httpContext);
}
}
private async Task InternalExecute()
{
Console.WriteLine($"{GetType().Name} executing");
var value = await _bookmark.Read();
await _documentWriter.Write(value);
}
private async Task WriteResult(HttpContext httpContext, ExecutionResult result)
{
var json = _writer.Write(result);
httpContext.Response.ContentType = "application/json";
httpContext.Response.StatusCode = result.Errors?.Any() == true ? (int)HttpStatusCode.BadRequest : (int)HttpStatusCode.OK;
await httpContext.Response.WriteAsync(json);
}
public static Task WriteResponseAsync(this HttpContext context, IDocumentWriter writer, ExecutionResult result)
{
var json = writer.Write(result);
context.Response.ContentType = "application/json";
context.Response.StatusCode = 200; // OK
return(context.Response.WriteAsync(json));
}
public Task OnNext(object value)
{
var json = _documentWriter.Write(value);
return(_messageWriter.WriteMessageAsync(new OperationMessage
{
Id = Op.Id,
Type = MessageTypes.GQL_DATA,
Payload = JObject.Parse(json)
}));
}
private static async Task WriteResponseJson(Stream responseBody, ExecutionResult result, IDocumentWriter documentWriter)
{
var json = documentWriter.Write(result);
using (var streamWriter = new StreamWriter(responseBody, System.Text.Encoding.UTF8, 4069, true))
{
await streamWriter.WriteAsync(json);
await streamWriter.FlushAsync();
}
}
public ExecutionResult AssertQuery(Action <ExecutionOptions> options, ExecutionResult expectedExecutionResult)
{
var runResult = Executer.ExecuteAsync(options).Result;
var writtenResult = Writer.Write(runResult);
var expectedResult = Writer.Write(expectedExecutionResult);
string additionalInfo = null;
if (runResult.Errors?.Any() == true)
{
additionalInfo = string.Join(Environment.NewLine, runResult.Errors
.Where(x => x.InnerException is GraphQLSyntaxErrorException)
.Select(x => x.InnerException.Message));
}
writtenResult.ShouldBe(expectedResult, additionalInfo);
return(runResult);
}
public ExecutionResult AssertQuery(
ISchema schema,
string query,
ExecutionResult expectedExecutionResult,
Inputs inputs,
object root,
object userContext = null,
CancellationToken cancellationToken = default(CancellationToken),
IEnumerable <IValidationRule> rules = null)
{
var runResult = Executer.ExecuteAsync(
schema,
root,
query,
null,
inputs,
userContext,
cancellationToken,
rules
).Result;
var writtenResult = Writer.Write(runResult);
var expectedResult = Writer.Write(expectedExecutionResult);
//#if DEBUG
// Console.WriteLine(writtenResult);
//#endif
string additionalInfo = null;
if (runResult.Errors?.Any() == true)
{
additionalInfo = string.Join(Environment.NewLine, runResult.Errors
.Where(x => x.InnerException is GraphQLSyntaxErrorException)
.Select(x => x.InnerException.Message));
}
writtenResult.ShouldBe(expectedResult, additionalInfo);
return(runResult);
}
public async Task <HttpResponseMessage> Handle(HttpRequestMessage request)
{
string content = "";
HttpStatusCode statusCode = HttpStatusCode.OK;
RelayRequest queries = await Deserializer.Deserialize(request.Content);
var options = executionOptions(queries);
if (options.RootContext != null && options.RootContext is RelayRootContext)
{
RelayRootContext ctx = options.RootContext as RelayRootContext;
if (ctx.Files == null)
{
ctx.Files = queries.Files;
}
}
var result = await Task.WhenAll(
queries.Select(q => executor.ExecuteAsync(
options.Schema,
options.RootContext,
query: q.Query,
inputs: q.Variables,
userContext: options.UserContext,
operationName: q.OperationName
))
);
if (Enumerable.Any(result, r => r.Errors?.Count > 0))
{
statusCode = HttpStatusCode.BadRequest;
}
try {
content = writer.Write(queries.IsBatched
? (object)result
: result[0]
);
}
catch (Exception err)
{
statusCode = HttpStatusCode.InternalServerError;
content = $"{{ \"errors\": [\"{err.Message}\"] }}";
}
return(new HttpResponseMessage
{
StatusCode = statusCode,
RequestMessage = request,
Content = new StringContent(content, Encoding.UTF8, "application/json")
});
}
private async Task WriteResponseAsync(HttpContext context, ExecutionResult result)
{
var json = _writer.Write(result);
context.Response.ContentType = "application/json";
if (result.Errors != null && result.Errors.Any() && !result.Errors.All(x => x is DefinedException))
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
}
await context.Response.WriteAsync(json);
}
public async Task <string> Generate()
{
ExecutionResult result = await executor.ExecuteAsync(
_schema,
null,
introspectionQuery,
null
);
if (result.Errors?.Any() ?? false)
{
throw result.Errors.First();
}
return(writer.Write(result));
}
private static void bulkTransfer(IDocumentReader reader, IDocumentWriter writer)
{
using (reader)
{
using (writer)
{
writer.Schema = reader.Schema;
while (reader.Read())
{
var doc = reader.Current;
writer.Write(doc);
}
}
}
}
public async Task <HttpResponseMessage> Post(HttpRequestMessage request, GraphQLQuery query)
{
var inputs = query.Variables.ToInputs();
var result = await Execute(_schema, null, query.Query, query.OperationName, inputs);
var httpResult = result.Errors?.Count > 0
? HttpStatusCode.BadRequest
: HttpStatusCode.OK;
var json = _writer.Write(result);
var response = request.CreateResponse(httpResult);
response.Content = new StringContent(json, Encoding.UTF8, "application/json");
return(response);
}
public static Task WriteBadRequestResponseAsync(this HttpContext context, IDocumentWriter writer, string errorMessage)
{
var result = new ExecutionResult()
{
Errors = new ExecutionErrors()
{
new ExecutionError(errorMessage)
}
};
var json = writer.Write(result);
context.Response.ContentType = "application/json";
context.Response.StatusCode = 400; // Bad Request
return(context.Response.WriteAsync(json));
}
public async Task <string> ProcessAsync(GraphQLQuery query)
{
var inputs = query.Variables.ToInputs();
var queryToExecute = query.Query;
var result = await _executer.ExecuteAsync(x =>
{
x.Schema = _schema;
x.Query = queryToExecute;
x.OperationName = query.OperationName;
x.Inputs = inputs;
x.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
x.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
});
return(_writer.Write(result));
}
public async Task <IActionResult> Post([FromBody] GraphQLQuery query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var inputs = query.Variables.ToInputs();
var queryToExecute = query.Query;
try
{
var result = await _documentExecuter.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
}).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
var json = _writer.Write(result);
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <IActionResult> PostAsync(HttpRequestMessage request, [FromBody] GraphQLQuery query)
{
var inputs = query.Variables.ToInputs();
var queryToExecute = query.Query;
if (!string.IsNullOrWhiteSpace(query.NamedQuery))
{
queryToExecute = _namedQueries[query.NamedQuery];
}
var context = GetContext();
var resultRaw = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
_.UserContext = context;
}).ConfigureAwait(false);
var result = new ExecutionResultProxy(resultRaw);
var httpResult = result.Errors?.Count > 0
? HttpStatusCode.BadRequest
: HttpStatusCode.OK;
var json = _writer.Write(result);
return(new ContentResult
{
Content = json,
StatusCode = (int)httpResult
});
}
public async Task <dynamic> PostAsync(GraphQLQuery query)
{
var inputs = query.Variables.ToInputs();
var queryToExecute = query.Query;
if (!string.IsNullOrWhiteSpace(query.NamedQuery))
{
queryToExecute = _namedQueries[query.NamedQuery];
}
var result = await _executer.ExecuteAsync(_ =>
{
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
_.ValidationRules = _validationRules.Concat(DocumentValidator.CoreRules());
}).ConfigureAwait(false);
var httpResult = result.Errors?.Count > 0
? HttpStatusCode.BadRequest
: HttpStatusCode.OK;
if (httpResult != HttpStatusCode.OK)
{
throw new Exception(result.Errors.First().Message);
}
var json = _writer.Write(result);
dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(json);
return(obj);
}
public void IdentifiesR2AsTheHero(IDocumentBuilder builder, IDocumentWriter writer)
{
// Assign
var query = @"
query HeroNameQuery {
hero {
name
}
}
";
var expected =
@"{
hero: {
name: 'R2-D2'
}
}";
// Act
var doc = builder.Build(query);
var result = writer.Write(doc);
// Assert
result.ShouldEqual(expected);
}
public void IdentifiesR2AsTheHero(IDocumentBuilder builder, IDocumentWriter writer)
{
// Assign
var query = @"
query HeroNameQuery {
hero {
name
}
}
";
var expected =
@"{
hero: {
name: 'R2-D2'
}
}";
// Act
var doc = builder.Build(query);
var result = writer.Write(doc);
// Assert
result.ShouldEqual(expected);
}
public async Task InvokeAsync()
{
string body;
using (var streamReader = new StreamReader(_httpContextAccessor.HttpContext.Request.Body))
{
body = await streamReader.ReadToEndAsync().ConfigureAwait(true);
}
var query = JsonConvert.DeserializeObject <GraphQLQuery>(body);
var inputs = query.Variables.ToInputs();
var queryToExecute = query.Query;
var result = await _executer.ExecuteAsync(_ =>
{
_.UserContext = new GraphQLUserContext(_httpContextAccessor);
_.Schema = _schema;
_.Query = queryToExecute;
_.OperationName = query.OperationName;
_.Inputs = inputs;
_.ComplexityConfiguration = new ComplexityConfiguration {
MaxDepth = 15
};
_.FieldMiddleware.Use <InstrumentFieldsMiddleware>();
_.ValidationRules = _pluginValidationRules.Concat(DocumentValidator.CoreRules());
}).ConfigureAwait(false);
var httpResult = result.Errors?.Count > 0
? HttpStatusCode.BadRequest
: HttpStatusCode.OK;
var json = _writer.Write(result);
dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject <dynamic>(json);
// var rr = new ObjectResult(obj) { StatusCode = (int)httpResult };
_httpContextAccessor.HttpResponseMessage.Content = new JsonContent(obj);
}
