public void AddDataLoader() { var instance = new DataLoaderDocumentListener(new DataLoaderContextAccessor()); var mockBuilder = new Mock <IGraphQLBuilder>(MockBehavior.Strict); var builder = mockBuilder.Object; mockBuilder.Setup(x => x.Register(typeof(IDataLoaderContextAccessor), typeof(DataLoaderContextAccessor), ServiceLifetime.Singleton)).Returns(builder).Verifiable(); mockBuilder.Setup(x => x.Register(typeof(IDocumentExecutionListener), typeof(DataLoaderDocumentListener), ServiceLifetime.Singleton)).Returns(builder).Verifiable(); mockBuilder.Setup(x => x.Register(typeof(DataLoaderDocumentListener), typeof(DataLoaderDocumentListener), ServiceLifetime.Singleton)).Returns(builder).Verifiable(); var mockServiceProvider = new Mock <IServiceProvider>(MockBehavior.Strict); mockServiceProvider.Setup(x => x.GetService(typeof(DataLoaderDocumentListener))).Returns(instance).Verifiable(); mockBuilder.Setup(x => x.Register(typeof(IConfigureExecution), It.IsAny <object>())) .Returns <Type, IConfigureExecution>((_, action) => { var options = new ExecutionOptions() { RequestServices = mockServiceProvider.Object }; action.Configure(options); options.Listeners.ShouldContain(instance); return(builder); }).Verifiable(); builder.AddDataLoader(); mockServiceProvider.Verify(); mockBuilder.Verify(); }
public async Task <IActionResult> Post( [FromBody] GraphQLQuery query, [FromServices] ISchema schema, [FromServices] IDocumentExecuter executer, [FromServices] DataLoaderDocumentListener dataLoaderListener, [FromServices] IConfiguration configuration, [FromServices] IEnumerable <IValidationRule> rules) { if (query == null) { throw new ArgumentNullException(nameof(query)); } var result = await executer.ExecuteAsync(x => { x.Schema = schema; x.Query = query.Query; x.Inputs = query.Variables.ToInputs(); x.Listeners.Add(dataLoaderListener); x.UserContext = new DepanneurUserContext { User = User }; x.ValidationRules = rules; x.ExposeExceptions = configuration.GetValue <bool>("GraphQL:ExposeExceptions"); }); if (result.Errors?.Count > 0) { return(BadRequest(result)); } return(Ok(result)); }
public GraphQLController(IDocumentExecuter documentExecuter, ISchema schema, DataLoaderDocumentListener listner, IServiceProvider services) { _documentExecuter = documentExecuter; _schema = schema; // _listener = listner; _services = services; }
public void resolve_reference_is_not_trying_to_await_for_each_field_individialy_and_plays_well_with_dataloader_issue_1565() { var definitions = @" extend type Query { user(id: ID!): User } type User @key(fields: ""id"") { id: ID! username: String! } "; var users = new List <User> { new User { Id = "1", Username = "******" }, new User { Id = "2", Username = "******" }, }; var accessor = new DataLoaderContextAccessor { Context = new DataLoaderContext() }; var listener = new DataLoaderDocumentListener(accessor); Builder.Types.For("User").ResolveReferenceAsync(ctx => { var id = ctx.Arguments["id"].ToString(); // return Task.FromResult(users.FirstOrDefault(user => user.Id == id)); var loader = accessor.Context.GetOrAddBatchLoader <string, User>("GetAccountByIdAsync", ids => { var results = users.Where(user => ids.Contains(user.Id)); return(Task.FromResult((IDictionary <string, User>)results.ToDictionary(c => c.Id))); }); return(Task.FromResult(loader.LoadAsync(id))); }); var query = @" { _entities(representations: [{__typename: ""User"", id: ""1"" }, {__typename: ""User"", id: ""2"" }]) { ... on User { id username } } }"; var expected = @"{ ""_entities"": [{ ""__typename"": ""User"", ""id"" : ""1"", ""username"": ""One"" }, { ""__typename"": ""User"", ""id"" : ""2"", ""username"": ""Two"" }] }"; AssertQuery(_ => { _.Definitions = definitions; _.Query = query; _.ExpectedResult = expected; _.Listeners.Add(listener); }); }
public GraphQLController(ISchema schema, IDocumentExecuter documentExecuter, ILogger <GraphQLController> logger, DataLoaderDocumentListener dataLoaderDocumentListener) { _schema = schema; _documentExecuter = documentExecuter; _logger = logger; _dataLoaderDocumentListener = dataLoaderDocumentListener; }
public SpiSchema(IDependencyResolver resolver) : base(resolver) { Query = resolver.Resolve <SpiQuery>(); _dataLoaderDocumentListener = resolver.Resolve <DataLoaderDocumentListener>(); _logger = resolver.Resolve <ILoggerWrapper>(); }
private async Task ExecuteAsync(HttpContext context, ISchema schema) { GraphQlQuery request = Deserialize <GraphQlQuery>(context.Request.Body); DataLoaderDocumentListener listener = _serviceProvider.GetRequiredService <DataLoaderDocumentListener>(); ExecutionResult result = await _documentExecutor.ExecuteAsync(_ => { _.Schema = schema; _.Query = request?.Query; _.OperationName = request?.OperationName; _.Inputs = request?.Variables; _.UserContext = _settings.BuildUserContext?.Invoke(context); _.ValidationRules = DocumentValidator.CoreRules; _.ExposeExceptions = true; _.ThrowOnUnhandledException = true; _.Listeners.Add(listener); // Temporarily removed as GraphiQL runs a schema query that is quite deep. // _.ComplexityConfiguration = new ComplexityConfiguration { MaxDepth = 4 }; _.EnableMetrics = _settings.EnableMetrics; if (_settings.EnableMetrics) { _.FieldMiddleware.Use <InstrumentFieldsMiddleware>(); } }).ConfigureAwait(false); await WriteResponseAsync(context, result).ConfigureAwait(false); }
public GraphQLController() { _executer = new DocumentExecuter(); _writer = new DocumentWriter(); _schema = new TestSchema(); _dataLoaderListener = new DataLoaderDocumentListener(new DataLoaderContextAccessor()); }
public GraphQLController(IDocumentExecuter executer, IDocumentWriter writer, TestSchema schema, DataLoaderDocumentListener dataLoaderListener) { _executer = executer; _writer = writer; _schema = schema; _dataLoaderListener = dataLoaderListener; }
public GraphqlController(ISchema schema, IDocumentExecuter documentExecuter, IServiceProvider serviceProvider, DataLoaderDocumentListener listener) { _schema = schema; _documentExecuter = documentExecuter; _serviceProvider = serviceProvider; _listener = listener; }
public GraphQLController(IDependencyResolver resolver, IDocumentExecuter documentExecuter, DataLoaderDocumentListener documentListener) { _resolver = resolver; _documentExecuter = documentExecuter; _documentListener = documentListener; }
public GraphController(ISchema schema, IDocumentExecuter executer, ITokenManager tokenManager, DataLoaderDocumentListener documentListener) { Schema = schema; Executer = executer; TokenManager = tokenManager; DocumentListener = documentListener; }
public GraphQLController(IDocumentExecuter documentExecutor, ISchema schema, DataLoaderDocumentListener listener, IHostingEnvironment env) { this.documentExecutor = documentExecutor; this.schema = schema; this.listener = listener; showExceptions = env.IsDevelopment(); }
public GraphQLExecutionContext(IAssetQueryService assetQuery, IContentQueryService contentQuery, IDataLoaderContextAccessor dataLoaderContextAccessor, DataLoaderDocumentListener dataLoaderDocumentListener, ICommandBus commandBus, IUrlGenerator urlGenerator, ISemanticLog log) : base(assetQuery, contentQuery) { this.commandBus = commandBus; this.dataLoaderContextAccessor = dataLoaderContextAccessor; this.dataLoaderDocumentListener = dataLoaderDocumentListener; this.urlGenerator = urlGenerator; this.log = log; }
public GraphQLController( AppSchema schema, IDataLoaderContextAccessor accessor ) { this.Schema = schema; //init a new DataLoader context on each request accessor.Context = new DataLoaderContext(); DataLoaderDocumentListener = new DataLoaderDocumentListener(accessor); }
public GraphQLController( IDocumentExecuter executer, ISchema schema, DataLoaderDocumentListener dataLoaderListener, IDependencyResolver dependencyResolver) { _documentExecuter = executer; _schema = schema; _dataLoaderListener = dataLoaderListener; _dependencyResolver = dependencyResolver; }
/// <summary> /// Injection constructor. /// </summary> /// <param name="documentWriter">Instance injected by DI.</param> /// <param name="listener">Instance injected by DI.</param> /// <param name="schema">Instance injected by DI.</param> /// <param name="cosmos">Injected instance of the gateway for setting up the database</param> /// <param name="stores">Injected instance of the repository for setting up the database</param> /// <param name="tools">Injected instance of the repository for setting up the database</param> public QueryService(IDocumentWriter documentWriter, DataLoaderDocumentListener listener, StoreSchema schema, CosmosGateway cosmos, StoreRepository stores, ToolRepository tools) { _documentWriter = documentWriter; _listener = listener; _schema = schema; _cosmos = cosmos; _stores = stores; _tools = tools; }
public GraphQLController( IDocumentExecuter documentExecuter, IEnumerable <IValidationRule> validationRules, ISchema schema, IServiceProvider serviceProvider ) { _documentExecuter = documentExecuter; _listener = serviceProvider.GetRequiredService <DataLoaderDocumentListener>(); _schema = schema; _validationRules = validationRules; }
public GraphQLMiddleware( RequestDelegate next, GraphQLSettings settings, IDocumentExecuter executer, IDocumentWriter writer, DataLoaderDocumentListener listener) { this.next = next; this.settings = settings; this.executer = executer; this.writer = writer; this.listener = listener; }
public GraphQLMiddleware( RequestDelegate next, GraphQLSettings settings, IDocumentExecuter executer, IDocumentWriter writer, DataLoaderDocumentListener dataLoaderDocumentListener) { _next = next; _settings = settings; _executer = executer; _writer = writer; _dataLoaderDocumentListener = dataLoaderDocumentListener; }
private CachingGraphQLService CreateSut() { var cache = new BackgroundCache(new MemoryCache(Options.Create(new MemoryCacheOptions()))); var appProvider = A.Fake <IAppProvider>(); A.CallTo(() => appProvider.GetSchemasAsync(appId.Id)) .Returns(new List <ISchemaEntity> { schema, schemaRef1, schemaRef2, schemaInvalidName }); var dataLoaderContext = (IDataLoaderContextAccessor) new DataLoaderContextAccessor(); var dataLoaderListener = new DataLoaderDocumentListener(dataLoaderContext); var services = new ServiceCollection() .AddMemoryCache() .AddTransient <GraphQLExecutionContext>() .AddSingleton(A.Fake <ISemanticLog>()) .AddSingleton(appProvider) .AddSingleton(assetQuery) .AddSingleton(commandBus) .AddSingleton(contentQuery) .AddSingleton(dataLoaderContext) .AddSingleton(dataLoaderListener) .AddSingleton(userResolver) .AddSingleton <InstantGraphType>() .AddSingleton <JsonGraphType>() .AddSingleton <JsonNoopGraphType>() .AddSingleton <SharedTypes>() .AddSingleton <IUrlGenerator, FakeUrlGenerator>() .BuildServiceProvider(); var schemasHash = A.Fake <ISchemasHash>(); return(new CachingGraphQLService(cache, schemasHash, services, Options.Create(new GraphQLOptions()))); }
public async Task <IActionResult> Post( [FromBody] GraphQLRequest request, [FromServices] ISchema schema, [FromServices] DataLoaderDocumentListener dataLoaderDocumentListener) { var result = await _executer.ExecuteAsync(_ => { _.Schema = schema; _.OperationName = request.OperationName; _.Query = request.Query; _.Inputs = request.Variables.ToInputs(); _.ExposeExceptions = true; _.Listeners.Add(dataLoaderDocumentListener); }); var json = await _writer.WriteToStringAsync(result); var httpResult = result.Errors?.Count > 0 ? HttpStatusCode.BadRequest : HttpStatusCode.OK; return(Content(json, "application/json")); }
public GraphQLController(IDocumentExecuter documentExecuter, ISchema schema, DataLoaderDocumentListener dataLoaderListener) { _dataLoaderListener = dataLoaderListener; _documentExecuter = documentExecuter; _schema = schema; }
public GraphQLController(IDocumentExecuter executer, ISchema schema, DataLoaderDocumentListener dataLoaderDocumentListener = null) { this.executer = executer; this.schema = schema; this.dataLoaderDocumentListener = dataLoaderDocumentListener; }