private void ParseInternal(
JsonDocument document,
IOperationResultBuilder resultBuilder)
{
if (document.RootElement.TryGetProperty(
_data, out JsonElement data))
{
resultBuilder.SetData(ParseData(data));
}
if (document.RootElement.TryGetProperty(
_errors, out JsonElement errors))
{
resultBuilder.AddErrors(ParseErrors(errors));
}
if (TryParseExtensions(
document.RootElement,
out IReadOnlyDictionary <string, object?>?extensions))
{
resultBuilder.AddExtensions(extensions !);
}
if (!resultBuilder.IsDataOrErrorModified)
{
resultBuilder.AddError(ErrorBuilder.New()
.SetMessage(
"The specified document is not a valid " +
"GraphQL response document. Ensure that either " +
"`data` or `errors` os provided. The document " +
"parses property names case-sensitive.")
.SetCode(ErrorCodes.InvalidResponse)
.Build());
}
}
protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand, IOperand valueOperand) :
base(operationResultBuilder)
{
this.fieldRefOperand = fieldRefOperand;
this.valueOperand = valueOperand;
}
protected CompositeOperationBase(IOperationResultBuilder operationResultBuilder,
IOperation leftOperation, IOperation rightOperation) :
base(operationResultBuilder)
{
this.leftOperation = leftOperation;
this.rightOperation = rightOperation;
}
private async Task ExecuteAsync(
IObserver <IOperationResult <TResult> > observer,
ObserverSession session)
{
try
{
CancellationToken token = session.RequestSession.Token;
IOperationResultBuilder <TData, TResult> resultBuilder = _resultBuilder();
await foreach (var response in
_connection.ExecuteAsync(_request, token).ConfigureAwait(false))
{
if (token.IsCancellationRequested)
{
return;
}
observer.OnNext(resultBuilder.Build(response));
}
}
catch (Exception ex)
{
observer.OnError(ex);
}
finally
{
// after all the transport logic is finished we will dispose
// the request session.
session.RequestSession.Dispose();
}
}
protected CompositeOperationBase(IOperationResultBuilder operationResultBuilder,
IOperation leftOperation, IOperation rightOperation)
: base(operationResultBuilder)
{
this.leftOperation = leftOperation;
this.rightOperation = rightOperation;
}
private async Task ExecuteOperationAsync(
IOperation operation,
IOperationResultBuilder resultBuilder,
CancellationToken cancellationToken)
{
var context = new HttpOperationContext(
operation,
_operationFormatter,
resultBuilder,
_resultParserResolver.Get(operation.ResultType),
_clientFactory(),
cancellationToken);
try
{
await _executeOperation(context).ConfigureAwait(false);
}
finally
{
if (context.HttpResponse != null)
{
context.HttpResponse.Dispose();
}
if (context.HttpRequest != null)
{
context.HttpRequest.Dispose();
}
}
}
protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
IOperand columnOperand, IOperand valueOperand)
: base(operationResultBuilder)
{
this.ColumnOperand = columnOperand;
this.ValueOperand = valueOperand;
}
protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand, IOperand valueOperand)
: base(operationResultBuilder)
{
this.fieldRefOperand = fieldRefOperand;
this.valueOperand = valueOperand;
}
public Task ParseAsync(
Stream stream,
IOperationResultBuilder resultBuilder,
CancellationToken cancellationToken)
{
return Task.CompletedTask;
}
protected BinaryOperationBase(IOperationResultBuilder operationResultBuilder,
IOperand columnOperand, IOperand valueOperand) :
base(operationResultBuilder)
{
this.ColumnOperand = columnOperand;
this.ValueOperand = valueOperand;
}
private async Task ExecuteAsync(RequestSession session)
{
try
{
IOperationResultBuilder <TData, TResult> resultBuilder = _resultBuilder();
await foreach (var response in
_connection.ExecuteAsync(_request, session.Token).ConfigureAwait(false))
{
if (session.Token.IsCancellationRequested)
{
return;
}
_operationStore.Set(_request, resultBuilder.Build(response));
if (_request.Document.Kind == OperationKind.Subscription)
{
_operationStore.ClearResult <TResult>(_request);
}
}
}
finally
{
session.Dispose();
}
}
/// <inheritdocs />
public async Task <IOperationResult <TResult> > ExecuteAsync(
OperationRequest request,
CancellationToken cancellationToken = default)
{
if (request is null)
{
throw new ArgumentNullException(nameof(request));
}
IOperationResult <TResult>?result = null;
IOperationResultBuilder <TData, TResult> resultBuilder = _resultBuilder();
await foreach (var response in _connection.ExecuteAsync(request, cancellationToken))
{
result = resultBuilder.Build(response);
_operationStore.Set(request, result);
}
if (result is null)
{
throw new InvalidOperationException(HttpOperationExecutor_ExecuteAsync_NoResult);
}
return(result);
}
public DateRangesOverlapOperation(IOperationResultBuilder operationResultBuilder,
IOperand startFieldRefOperand, IOperand stopFieldRefOperand, IOperand recurrenceFieldRefOperand, IOperand dateTimeOperand) :
base(operationResultBuilder)
{
this.startFieldRefOperand = startFieldRefOperand;
this.stopFieldRefOperand = stopFieldRefOperand;
this.recurrenceFieldRefOperand = recurrenceFieldRefOperand;
this.dateTimeOperand = dateTimeOperand;
}
public DateRangesOverlapOperation(IOperationResultBuilder operationResultBuilder,
IOperand startFieldRefOperand, IOperand stopFieldRefOperand, IOperand recurrenceFieldRefOperand, IOperand dateTimeOperand)
: base(operationResultBuilder)
{
this.startFieldRefOperand = startFieldRefOperand;
this.stopFieldRefOperand = stopFieldRefOperand;
this.recurrenceFieldRefOperand = recurrenceFieldRefOperand;
this.dateTimeOperand = dateTimeOperand;
}
private async Task ParseInternalAsync(
Stream stream,
IOperationResultBuilder resultBuilder,
CancellationToken cancellationToken)
{
using JsonDocument document = await JsonDocument.ParseAsync(
stream, _options, cancellationToken)
.ConfigureAwait(false);
ParseInternal(document, resultBuilder);
}
private async Task ExecuteAsync(
IObserver <IOperationResult <TResult> > observer,
ObserverSession session)
{
try
{
CancellationToken token = session.RequestSession.Token;
IOperationResultBuilder <TData, TResult> resultBuilder = _resultBuilder();
await foreach (var response in
_connection.ExecuteAsync(_request, token).ConfigureAwait(false))
{
if (token.IsCancellationRequested)
{
return;
}
IOperationResult <TResult> result = resultBuilder.Build(response);
_operationStore.Set(_request, result);
if (!session.HasStoreSession)
{
observer.OnNext(result);
IDisposable storeSession =
_operationStore
.Watch <TResult>(_request)
.Subscribe(observer);
try
{
session.SetStoreSession(storeSession);
}
catch (ObjectDisposedException)
{
storeSession.Dispose();
throw;
}
}
}
}
catch (Exception ex)
{
observer.OnError(ex);
}
finally
{
// after all the transport logic is finished we will dispose
// the request session.
session.RequestSession.Dispose();
}
}
public HttpOperationContext(
IOperation operation,
HttpClient client,
IServiceProvider services,
IOperationResultBuilder result,
CancellationToken requestAborted)
{
Operation = operation ?? throw new ArgumentNullException(nameof(operation));
Client = client ?? throw new ArgumentNullException(nameof(client));
Services = services ?? throw new ArgumentNullException(nameof(services));
Result = result;
RequestAborted = requestAborted;
}
public static IOperationResultBuilder <Void> OnSuccessAsync(
[NotNull] this IOperationResultBuilder <Void> operationBuilder,
[NotNull] Func <CancellationToken, Task> handler)
{
if (operationBuilder == null)
{
throw new ArgumentNullException(nameof(operationBuilder));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
return(operationBuilder.OnSuccessAsync((_, cancellationToken) => handler(cancellationToken)));
}
public static IOperationResultBuilder <Void> OnSuccess(
[NotNull] this IOperationResultBuilder <Void> operationBuilder,
[NotNull] Action handler)
{
if (operationBuilder == null)
{
throw new ArgumentNullException(nameof(operationBuilder));
}
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
return(operationBuilder.OnSuccess(_ => handler()));
}
public Task ParseAsync(
Stream stream,
IOperationResultBuilder resultBuilder,
CancellationToken cancellationToken)
{
if (stream is null)
{
throw new ArgumentNullException(nameof(stream));
}
if (resultBuilder is null)
{
throw new ArgumentNullException(nameof(resultBuilder));
}
return(ParseInternalAsync(stream, resultBuilder, cancellationToken));
}
public void Parse(ReadOnlySpan <byte> result, IOperationResultBuilder resultBuilder)
{
if (resultBuilder is null)
{
throw new ArgumentNullException(nameof(resultBuilder));
}
byte[] rented = ArrayPool <byte> .Shared.Rent(result.Length);
result.CopyTo(rented);
var memory = new ReadOnlyMemory <byte>(rented);
memory = memory.Slice(0, result.Length);
using JsonDocument document = JsonDocument.Parse(memory, _options);
ParseInternal(document, resultBuilder);
ArrayPool <byte> .Shared.Return(rented);
}
public HttpOperationContext(
IOperation operation,
IOperationFormatter operationFormatter,
IOperationResultBuilder result,
IResultParser resultParser,
HttpClient client,
CancellationToken requestAborted)
{
Operation = operation
?? throw new ArgumentNullException(nameof(operation));
OperationFormatter = operationFormatter
?? throw new ArgumentNullException(nameof(operationFormatter));
Result = result
?? throw new ArgumentNullException(nameof(result));
ResultParser = resultParser
?? throw new ArgumentNullException(nameof(resultParser));
Client = client
?? throw new ArgumentNullException(nameof(client));
RequestAborted = requestAborted;
RequestWriter = new MessageWriter();
}
private async Task ParseInternalAsync(
Stream stream,
IOperationResultBuilder resultBuilder,
CancellationToken cancellationToken)
{
using (JsonDocument document = await JsonDocument.ParseAsync(stream)
.ConfigureAwait(false))
{
if (document.RootElement.TryGetProperty(
_data, out JsonElement data))
{
resultBuilder.SetData(ParserData(data));
}
if (document.RootElement.TryGetProperty(
_errors, out JsonElement errors))
{
resultBuilder.AddErrors(ParseErrors(errors));
}
if (TryParseExtensions(
document.RootElement,
out IReadOnlyDictionary <string, object?>?extensions))
{
resultBuilder.AddExtensions(extensions !);
}
if (!resultBuilder.IsDataOrErrorModified)
{
resultBuilder.AddError(ErrorBuilder.New()
.SetMessage(
"The specified document is not a valid " +
"GraphQL response document. Ensure that either " +
"`data` or `errors` os provided. The document " +
"parses property names case-sensitive.")
.SetCode(ErrorCodes.InvalidResponse)
.Build());
}
}
}
public OrElseAnalyzer(IOperationResultBuilder operationResultBuilder, IAnalyzerFactory analyzerFactory)
: base(operationResultBuilder, analyzerFactory)
{
}
public AnalyzerFactory(IOperandBuilder operandBuilder, IOperationResultBuilder operationResultBuilder)
{
this.operandBuilder = operandBuilder;
this.operationResultBuilder = operationResultBuilder;
}
protected UnaryOperationBase(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand)
: base(operationResultBuilder)
{
this.fieldRefOperand = fieldRefOperand;
}
public OrElseOperation(IOperationResultBuilder operationResultBuilder,
IOperation leftOperation, IOperation rightOperation)
: base(operationResultBuilder, leftOperation, rightOperation)
{
}
public IsNotNullAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
public GeqAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
protected CompositeExpressionBaseAnalyzer(IOperationResultBuilder operationResultBuilder,
IAnalyzerFactory analyzerFactory)
: base(operationResultBuilder)
{
this.analyzerFactory = analyzerFactory;
}
public IsNotNullOperation(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand)
: base(operationResultBuilder, fieldRefOperand)
{
}
public DateRangesOverlapAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
public ContainsAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
protected OperationBase(IOperationResultBuilder operationResultBuilder)
{
this.operationResultBuilder = operationResultBuilder;
}
public ArrayOperation(IOperationResultBuilder operationResultBuilder,
params IOperand[] fieldRefOperands)
: base(operationResultBuilder)
{
this.fieldRefOperands = fieldRefOperands;
}
public IncludesOperation(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand, IOperand valueOperand)
: base(operationResultBuilder, fieldRefOperand, valueOperand)
{
}
public IsNullOperation(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand)
: base(operationResultBuilder, fieldRefOperand)
{
}
protected NullabilityBaseAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
protected BaseAnalyzer(IOperationResultBuilder operationResultBuilder)
{
this.OperationResultBuilder = operationResultBuilder;
}
public ArrayAnalyzer(IOperationResultBuilder operationResultBuilder,
IOperandBuilder operandBuilder) :
base(operationResultBuilder)
{
this.operandBuilder = operandBuilder;
}
public ArrayOperation(IOperationResultBuilder operationResultBuilder,
params IOperand[] columnOperands) :
base(operationResultBuilder)
{
this._columnOperands = columnOperands;
}
protected BinaryExpressionBaseAnalyzer(IOperationResultBuilder operationResultBuilder,
IOperandBuilder operandBuilder) :
base(operationResultBuilder)
{
this.operandBuilder = operandBuilder;
}
public BeginsWithAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
public AndAlsoAnalyzer(IOperationResultBuilder operationResultBuilder,
IAnalyzerFactory analyzerFactory)
: base(operationResultBuilder, analyzerFactory)
{
}
public OrElseAnalyzer(IOperationResultBuilder operationResultBuilder, IAnalyzerFactory analyzerFactory) :
base(operationResultBuilder, analyzerFactory)
{
}
public BeginsWithOperation(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand, IOperand valueOperand)
: base(operationResultBuilder, fieldRefOperand, valueOperand)
{
}
public IsNotNullAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
public GeqOperation(IOperationResultBuilder operationResultBuilder,
IOperand fieldRefOperand, IOperand valueOperand)
: base(operationResultBuilder, fieldRefOperand, valueOperand)
{
}
protected OperationBase(IOperationResultBuilder operationResultBuilder)
{
this.operationResultBuilder = operationResultBuilder;
}
public BeginsWithAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
protected UnaryOperationBase(IOperationResultBuilder operationResultBuilder,
IOperand columnOperand)
: base(operationResultBuilder)
{
this.ColumnOperand = columnOperand;
}
public ArrayAnalyzer(IOperationResultBuilder operationResultBuilder,
IOperandBuilder operandBuilder)
: base(operationResultBuilder)
{
this.operandBuilder = operandBuilder;
}
protected UnaryExpressionBaseAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder)
{
this.OperandBuilder = operandBuilder;
}
public LtAnalyzer(IOperationResultBuilder operationResultBuilder, IOperandBuilder operandBuilder)
: base(operationResultBuilder, operandBuilder)
{
}
public AndAlsoOperation(IOperationResultBuilder operationResultBuilder,
IOperation leftOperation, IOperation rightOperation)
: base(operationResultBuilder, leftOperation, rightOperation)
{
}
