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