public async ValueTask InvokeAsync(IRequestContext context)
{
IReadOnlyQueryRequest request = context.Request;
bool addToCache = true;
if (context.Document is null)
{
if (request.QueryId is { } queryId&&
_documentCache.TryGetDocument(queryId, out DocumentNode document))
{
context.DocumentId = queryId;
context.Document = document;
context.ValidationResult = DocumentValidatorResult.Ok;
context.IsCachedDocument = true;
addToCache = false;
_diagnosticEvents.RetrievedDocumentFromCache(context);
}
else if (request.QueryHash is { } queryHash&&
_documentCache.TryGetDocument(queryHash, out document))
{
context.DocumentId = queryHash;
context.Document = document;
context.ValidationResult = DocumentValidatorResult.Ok;
context.IsCachedDocument = true;
addToCache = false;
_diagnosticEvents.RetrievedDocumentFromCache(context);
}
public async ValueTask InvokeAsync(IRequestContext context)
{
IQueryRequest request = context.Request;
var addToCache = true;
if (context.Document is null)
{
if (request.QueryId != null &&
_documentCache.TryGetDocument(request.QueryId, out DocumentNode document))
{
context.DocumentId = request.QueryId;
context.Document = document;
context.ValidationResult = DocumentValidatorResult.Ok;
context.IsCachedDocument = true;
addToCache = false;
_diagnosticEvents.RetrievedDocumentFromCache(context);
}
else if (request.QueryHash != null &&
_documentCache.TryGetDocument(request.QueryHash, out document))
{
context.DocumentId = request.QueryHash;
context.Document = document;
context.ValidationResult = DocumentValidatorResult.Ok;
context.IsCachedDocument = true;
addToCache = false;
_diagnosticEvents.RetrievedDocumentFromCache(context);
}
else if (request.QueryHash is null && request.Query != null)
{
context.DocumentHash =
_documentHashProvider.ComputeHash(request.Query.AsSpan());
if (_documentCache.TryGetDocument(context.DocumentHash, out document))
{
context.DocumentId = context.DocumentHash;
context.Document = document;
context.ValidationResult = DocumentValidatorResult.Ok;
context.IsCachedDocument = true;
addToCache = false;
_diagnosticEvents.RetrievedDocumentFromCache(context);
}
}
}
await _next(context).ConfigureAwait(false);
if (addToCache &&
context.DocumentId != null &&
context.Document != null &&
context.IsValidDocument)
{
_documentCache.TryAddDocument(context.DocumentId, context.Document);
_diagnosticEvents.AddedDocumentToCache(context);
}
}
private GraphQLRequest ParseRequest()
{
var request = new Request();
_reader.Expect(TokenKind.LeftBrace);
while (_reader.Kind != TokenKind.RightBrace)
{
ParseRequestProperty(ref request);
}
if (request.IsQueryNull &&
request.NamedQuery == null)
{
// TODO : resources
throw new SyntaxException(
_reader,
"Either the query `property` or the `namedQuery` " +
"property have to have a value.");
}
DocumentNode document;
if (_useCache)
{
if (request.NamedQuery is null)
{
request.NamedQuery =
_hashProvider.ComputeHash(request.Query);
}
if (!_cache.TryGetDocument(request.NamedQuery, out document))
{
document = ParseQuery(in request);
}
}
else
{
document = ParseQuery(in request);
}
return(new GraphQLRequest
(
document,
request.NamedQuery,
request.OperationName,
request.Variables,
request.Extensions
));
}
public async Task AutoMerge_HotReload_ClearOperationCaches()
{
// arrange
using var cts = new CancellationTokenSource(20_000);
NameString configurationName = "C" + Guid.NewGuid().ToString("N");
var schemaDefinitionV2 = FileResource.Open("AccountSchemaDefinition.json");
IHttpClientFactory httpClientFactory = CreateDefaultRemoteSchemas(configurationName);
DocumentNode document = Utf8GraphQLParser.Parse("{ foo }");
var queryHash = "abc";
IDatabase database = _connection.GetDatabase();
while (!cts.IsCancellationRequested)
{
if (await database.SetLengthAsync(configurationName.Value) == 4)
{
break;
}
await Task.Delay(150, cts.Token);
}
ServiceProvider serviceProvider =
new ServiceCollection()
.AddSingleton(httpClientFactory)
.AddGraphQL()
.AddQueryType(d => d.Name("Query").Field("foo").Resolve("foo"))
.AddRemoteSchemasFromRedis(configurationName, _ => _connection)
.Services
.BuildServiceProvider();
IRequestExecutorResolver executorResolver =
serviceProvider.GetRequiredService <IRequestExecutorResolver>();
IDocumentCache documentCache =
serviceProvider.GetRequiredService <IDocumentCache>();
IPreparedOperationCache preparedOperationCache =
serviceProvider.GetRequiredService <IPreparedOperationCache>();
await executorResolver.GetRequestExecutorAsync(cancellationToken : cts.Token);
var raised = false;
executorResolver.RequestExecutorEvicted += (_, args) =>
{
if (args.Name.Equals(Schema.DefaultName))
{
raised = true;
}
};
Assert.False(documentCache.TryGetDocument(queryHash, out _));
Assert.False(preparedOperationCache.TryGetOperation(queryHash, out _));
IRequestExecutor requestExecutor =
await executorResolver.GetRequestExecutorAsync(cancellationToken : cts.Token);
await requestExecutor
.ExecuteAsync(QueryRequestBuilder
.New()
.SetQuery(document)
.SetQueryHash(queryHash)
.Create(),
cts.Token);
Assert.True(preparedOperationCache.TryGetOperation("_Default-1-abc", out _));
// act
await database.StringSetAsync($"{configurationName}.{_accounts}", schemaDefinitionV2);
await _connection.GetSubscriber().PublishAsync(configurationName.Value, _accounts);
while (!cts.IsCancellationRequested)
{
if (raised)
{
break;
}
await Task.Delay(150, cts.Token);
}
// assert
Assert.True(documentCache.TryGetDocument(queryHash, out _));
Assert.False(preparedOperationCache.TryGetOperation(queryHash, out _));
}
