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