private async Task ExecuteResolverSeriallyAsync(
IExecutionContext executionContext,
ResolverTask resolverTask,
List <ResolverTask> nextBatch,
CancellationToken cancellationToken)
{
resolverTask.ResolverResult = ExecuteResolver(
resolverTask, executionContext.Options.DeveloperMode,
cancellationToken);
await CompleteDataLoadersAsync(
executionContext.DataLoaders,
cancellationToken);
// await async results
resolverTask.ResolverResult = await FinalizeResolverResultAsync(
resolverTask.FieldSelection.Node,
resolverTask.ResolverResult,
executionContext.Options.DeveloperMode);
// serialize and integrate result into final query result
var completionContext = new FieldValueCompletionContext(
executionContext, resolverTask.ResolverContext,
resolverTask, t => nextBatch.Add(t));
CompleteValue(completionContext);
}
private async Task ExecuteResolverSeriallyAsync(
IExecutionContext executionContext,
ResolverTask resolverTask,
Action <ResolverTask> enqueueTask,
BatchOperationHandler batchOperationHandler,
CancellationToken cancellationToken)
{
resolverTask.Task = ExecuteResolverAsync(
resolverTask,
executionContext.ErrorHandler,
cancellationToken);
await CompleteBatchOperationsAsync(
new[] { resolverTask.Task },
batchOperationHandler,
cancellationToken)
.ConfigureAwait(false);
resolverTask.ResolverResult = await resolverTask.Task
.ConfigureAwait(false);
// serialize and integrate result into final query result
var completionContext = new CompleteValueContext(
executionContext.Services.GetTypeConversion(),
executionContext.FieldHelper, enqueueTask);
completionContext.CompleteValue(resolverTask);
}
private async Task ExecuteResolverSeriallyAsync(
IExecutionContext executionContext,
ResolverTask resolverTask,
Action <ResolverTask> enqueueTask,
CancellationToken cancellationToken)
{
resolverTask.Task = ExecuteResolverAsync(
resolverTask,
cancellationToken);
await CompleteDataLoadersAsync(
executionContext.DataLoaders,
cancellationToken);
if (resolverTask.Task.IsCompleted)
{
resolverTask.ResolverResult = resolverTask.Task.Result;
}
else
{
resolverTask.ResolverResult = await resolverTask.Task;
}
// serialize and integrate result into final query result
var completionContext = new FieldValueCompletionContext(
executionContext, resolverTask.ResolverContext,
resolverTask, enqueueTask);
CompleteValue(completionContext);
}
public FieldValueCompletionContext(
IExecutionContext executionContext,
IResolverContext resolverContext,
ResolverTask resolverTask,
Action <ResolverTask> enqueueTask)
{
if (resolverTask == null)
{
throw new ArgumentNullException(nameof(resolverTask));
}
_integrateResult = resolverTask.IntegrateResult;
_enqueueResolverTask = enqueueTask
?? throw new ArgumentNullException(nameof(enqueueTask));
ExecutionContext = executionContext
?? throw new ArgumentNullException(nameof(executionContext));
ResolverContext = resolverContext
?? throw new ArgumentNullException(nameof(resolverContext));
Source = resolverContext.Source;
Selection = resolverTask.FieldSelection;
SelectionSet = resolverTask.FieldSelection.Selection.SelectionSet;
Type = resolverContext.Field.Type;
Path = resolverContext.Path;
Value = resolverTask.ResolverResult;
IsNullable = true;
}
private static async Task <object> ExecuteMiddlewareAsync(
ResolverTask resolverTask,
IErrorHandler errorHandler)
{
object result = null;
try
{
result = await ExecuteFieldMiddlewareAsync(resolverTask)
.ConfigureAwait(false);
if (result is IError error)
{
return(errorHandler.Handle(error));
}
else if (result is IEnumerable <IError> errors)
{
return(errorHandler.Handle(errors));
}
else
{
return(result);
}
}
catch (QueryException ex)
{
return(errorHandler.Handle(ex.Errors));
}
catch (Exception ex)
{
return(errorHandler.Handle(ex, builder => builder
.SetPath(resolverTask.Path)
.AddLocation(resolverTask.FieldSelection.Selection)));
}
}
protected static async Task <object> ExecuteResolverAsync(
ResolverTask resolverTask,
IErrorHandler errorHandler,
CancellationToken cancellationToken)
{
Activity activity = resolverTask.Diagnostics.BeginResolveField(
resolverTask.ResolverContext);
object result = await ExecuteMiddlewareAsync(
resolverTask, errorHandler)
.ConfigureAwait(false);
if (result is IEnumerable <IError> errors)
{
resolverTask.Diagnostics.ResolverError(
resolverTask.ResolverContext, errors);
}
else if (result is IError error)
{
resolverTask.Diagnostics.ResolverError(
resolverTask.ResolverContext, error);
}
resolverTask.Diagnostics.EndResolveField(
activity,
resolverTask.ResolverContext,
result);
return(result);
}
public static void CompleteValue(
this CompleteValueContext context,
ResolverTask resolverTask)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
context.ResolverTask = resolverTask;
ValueCompletion.CompleteValue(
context,
resolverTask.FieldType,
resolverTask.ResolverResult);
if (context.IsViolatingNonNullType)
{
resolverTask.PropagateNonNullViolation();
}
else
{
resolverTask.SetResult(context.Value);
}
}
private ResolverTask(
ResolverTask parent,
FieldSelection fieldSelection,
Path path,
IImmutableStack <object> source,
IDictionary <string, object> result,
Action propagateNonNullViolation)
{
_parent = parent;
_executionContext = parent._executionContext;
Source = source;
ObjectType = fieldSelection.Field.DeclaringType;
FieldSelection = fieldSelection;
FieldType = fieldSelection.Field.Type;
Path = path;
_result = result;
ScopedContextData = parent.ScopedContextData;
_propagateNonNullViolation = propagateNonNullViolation;
ResolverContext = new ResolverContext(
parent._executionContext, this,
parent._executionContext.RequestAborted);
FieldDelegate = parent._executionContext.FieldHelper
.CreateMiddleware(fieldSelection);
}
public static object CompleteResolverResult(
this ResolverTask resolverTask,
object resolverResult)
{
return(CompleteResolverResult(
resolverTask.ResolverContext,
resolverResult));
}
public static bool IsMaxExecutionDepthReached(
this ResolverTask resolverTask)
{
bool isLeafField =
resolverTask.FieldSelection.Field.Type.IsLeafType();
int maxExecutionDepth = isLeafField
? resolverTask.Options.MaxExecutionDepth - 1
: resolverTask.Options.MaxExecutionDepth;
return(resolverTask.Path.Depth > maxExecutionDepth);
}
private static async Task <object> ExecuteDirectiveMiddlewareAsync(
ResolverTask resolverTask)
{
return(await resolverTask.ExecuteMiddleware.Invoke(
resolverTask.ResolverContext, ExecuteResolver));
Task <object> ExecuteResolver()
{
return(ExecuteFieldMiddlewareAsync(
resolverTask));
}
}
private static async Task <object> ExecuteFieldMiddlewareAsync(
ResolverTask resolverTask)
{
if (resolverTask.FieldSelection.Field.Resolver == null)
{
return(null);
}
object result = await resolverTask.FieldSelection.Field.Resolver(
resolverTask.ResolverContext);
return(resolverTask.CompleteResolverResult(result));
}
public static IQueryError CreateError(
this ResolverTask resolverTask,
Exception exception)
{
if (resolverTask.Options.DeveloperMode)
{
return(resolverTask.CreateError(
$"{exception.Message}\r\n\r\n{exception.StackTrace}"));
}
else
{
return(resolverTask.CreateError("Unexpected execution error."));
}
}
private static async Task <object> ExecuteMiddlewareAsync(
ResolverTask resolverTask,
IErrorHandler errorHandler)
{
object result = null;
try
{
if (!resolverTask.FieldSelection.Field.IsIntrospectionField &&
resolverTask.HasMiddleware)
{
result = await ExecuteDirectiveMiddlewareAsync(
resolverTask).ConfigureAwait(false);
}
else
{
result = await ExecuteFieldMiddlewareAsync(
resolverTask).ConfigureAwait(false);
}
if (result is IError error)
{
return(errorHandler.Handle(error));
}
else if (result is IEnumerable <IError> errors)
{
return(errorHandler.Handle(errors));
}
else
{
return(result);
}
}
catch (QueryException ex)
{
return(errorHandler.Handle(ex.Errors));
}
catch (Exception ex)
{
ResolverDiagnosticEvents.ResolverError(
resolverTask.ResolverContext,
ex);
return(errorHandler.Handle(ex, error => error
.WithPath(resolverTask.Path)
.WithSyntaxNodes(resolverTask.FieldSelection.Selection)));
}
}
private static async Task <object> ExecuteFieldMiddlewareAsync(
ResolverTask resolverTask)
{
var middlewareContext = new MiddlewareContext
(
resolverTask.ResolverContext,
() => resolverTask.FieldSelection.Field
.Resolver?.Invoke(resolverTask.ResolverContext)
?? Task.FromResult <object>(null),
result => resolverTask.CompleteResolverResult(result)
);
await resolverTask.FieldDelegate.Invoke(middlewareContext)
.ConfigureAwait(false);
return(middlewareContext.Result);
}
public ResolverContext(
IExecutionContext executionContext,
ResolverTask resolverTask)
{
if (executionContext == null)
{
throw new ArgumentNullException(nameof(executionContext));
}
if (resolverTask == null)
{
throw new ArgumentNullException(nameof(resolverTask));
}
_executionContext = executionContext;
_resolverTask = resolverTask;
_arguments = _argumentResolver.CoerceArgumentValues(
resolverTask.ObjectType, resolverTask.FieldSelection,
executionContext.Variables);
}
private FieldValueCompletionContext(
FieldValueCompletionContext completionContext,
IType type, bool isNullable)
{
_integrateResult = completionContext._integrateResult;
_enqueueResolverTask = completionContext._enqueueResolverTask;
_resolverTask = completionContext._resolverTask;
ExecutionContext = completionContext.ExecutionContext;
ResolverContext = completionContext.ResolverContext;
Source = completionContext.Source;
Selection = completionContext.Selection;
SelectionSet = completionContext.SelectionSet;
Path = completionContext.Path;
Value = completionContext.Value;
Converter = completionContext.Converter;
Type = type;
IsNullable = isNullable;
}
protected static object ExecuteResolver(
ResolverTask resolverTask,
bool isDeveloperMode,
CancellationToken cancellationToken)
{
try
{
return(resolverTask.FieldSelection.Field.Resolver(
resolverTask.ResolverContext,
cancellationToken));
}
catch (QueryException ex)
{
return(ex.Errors);
}
catch (Exception ex)
{
return(CreateErrorFromException(ex,
resolverTask.FieldSelection.Node,
isDeveloperMode));
}
}
public ResolverContext(
IExecutionContext executionContext,
ResolverTask resolverTask,
CancellationToken requestAborted)
{
if (executionContext == null)
{
throw new ArgumentNullException(nameof(executionContext));
}
if (resolverTask == null)
{
throw new ArgumentNullException(nameof(resolverTask));
}
_executionContext = executionContext;
_resolverTask = resolverTask;
RequestAborted = requestAborted;
_arguments = _argumentResolver.CoerceArgumentValues(
resolverTask.FieldSelection, executionContext.Variables);
}
protected static async Task <object> ExecuteResolverAsync(
ResolverTask resolverTask,
CancellationToken cancellationToken)
{
Activity activity = ResolverDiagnosticEvents.BeginResolveField(
resolverTask.ResolverContext);
object result = await ExecuteMiddlewareAsync(
resolverTask,
cancellationToken);
if (result is IQueryError error)
{
activity?.AddTag("error", "true");
}
ResolverDiagnosticEvents.EndResolveField(
activity,
resolverTask.ResolverContext,
result);
return(result);
}
public ResolverContext(
IExecutionContext executionContext,
ResolverTask resolverTask,
CancellationToken requestAborted)
{
if (executionContext == null)
{
throw new ArgumentNullException(nameof(executionContext));
}
if (resolverTask == null)
{
throw new ArgumentNullException(nameof(resolverTask));
}
_executionContext = executionContext;
_resolverTask = resolverTask;
RequestAborted = requestAborted;
_converter = _executionContext.Services.GetTypeConversion();
_arguments = resolverTask.FieldSelection.CoerceArgumentValues(
executionContext.Variables, resolverTask.Path);
}
protected static async Task <object> ExecuteResolverAsync(
ResolverTask resolverTask,
IErrorHandler errorHandler,
CancellationToken cancellationToken)
{
Activity activity = ResolverDiagnosticEvents.BeginResolveField(
resolverTask.ResolverContext);
object result = await ExecuteMiddlewareAsync(
resolverTask, errorHandler).ConfigureAwait(false);
if (result is IError || result is IEnumerable <IError> )
{
activity?.AddTag("error", "true");
}
ResolverDiagnosticEvents.EndResolveField(
activity,
resolverTask.ResolverContext,
result);
return(result);
}
private static async Task <object> ExecuteMiddlewareAsync(
ResolverTask resolverTask,
CancellationToken cancellationToken)
{
object result = null;
try
{
if (!resolverTask.FieldSelection.Field.IsIntrospectionField &&
resolverTask.HasMiddleware)
{
result = await ExecuteDirectiveMiddlewareAsync(
resolverTask,
cancellationToken);
}
else
{
result = await ExecuteFieldMiddlewareAsync(
resolverTask,
cancellationToken);
}
}
catch (QueryException ex)
{
result = ex.Errors;
}
catch (Exception ex)
{
ResolverDiagnosticEvents.ResolverError(
resolverTask.ResolverContext,
ex);
result = resolverTask.CreateError(ex);
}
return(result);
}
