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