private IResult <TData> DefaultResult <TData>(IErrorBuilder builder, IErrorDetail detail, string errorCode)
{
var statusCode = Convert.ToInt32(errorCode);
if (detail is null)
{
return(new Result <TData>().AddError(builder.Build()).AddStatusCode(statusCode));
}
builder.WithDetail(detail);
return(new Result <TData>().AddError(builder.Build()).AddStatusCode(statusCode));
}
public static GraphQLException VariableValueInvalidType(
VariableDefinitionNode variableDefinition,
Exception?exception = null)
{
var underlyingError = exception is SerializationException serializationException
? serializationException.Message
: null;
IErrorBuilder errorBuilder = ErrorBuilder.New()
.SetMessage(
ThrowHelper_VariableValueInvalidType_Message,
variableDefinition.Variable.Name.Value)
.SetCode(ErrorCodes.Execution.InvalidType)
.SetExtension("variable", variableDefinition.Variable.Name.Value)
.AddLocation(variableDefinition);
if (exception is not null)
{
errorBuilder.SetException(exception);
}
if (underlyingError is not null)
{
errorBuilder.SetExtension(nameof(underlyingError), underlyingError);
}
return(new GraphQLException(errorBuilder.Build()));
}
public IError Handle(
Exception exception,
Action <IErrorBuilder> configure)
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
IErrorBuilder builder = CreateErrorFromException(exception);
configure(builder);
IError current = builder.Build();
foreach (IErrorFilter filter in _filters)
{
current = filter.OnError(current);
if (current == null)
{
throw new InvalidOperationException(
"IErrorFilter.OnError mustn't return null.");
}
}
return(current);
}
public static GraphQLException VariableValueInvalidType(
VariableDefinitionNode variableDefinition,
Exception?exception = null)
{
IErrorBuilder errorBuilder = ErrorBuilder.New()
.SetMessage(
"Variable `{0}` got an invalid value.",
variableDefinition.Variable.Name.Value)
.SetCode(ErrorCodes.Execution.InvalidType)
.SetExtension("variable", variableDefinition.Variable.Name.Value)
.AddLocation(variableDefinition);
switch (exception)
{
case ScalarSerializationException ex:
errorBuilder.SetExtension("scalarError", ex.Message);
break;
case InputObjectSerializationException ex:
errorBuilder.SetExtension("inputObjectError", ex.Message);
break;
default:
errorBuilder.SetException(exception);
break;
}
return(new GraphQLException(errorBuilder.Build()));
}
private static void ReportErrors(
NameString schemaName,
IResolverContext context,
IEnumerable <IError> errors)
{
foreach (IError error in errors)
{
IErrorBuilder builder = ErrorBuilder.FromError(error)
.SetExtension(_remoteErrorField, error.RemoveException())
.SetExtension(_schemaNameErrorField, schemaName.Value);
if (error.Path != null)
{
Path path = RewriteErrorPath(error, context.Path);
builder.SetPath(path)
.ClearLocations()
.AddLocation(context.FieldSelection);
}
else if (IsHttpError(error))
{
builder.SetPath(context.Path)
.ClearLocations()
.AddLocation(context.FieldSelection);
}
context.ReportError(builder.Build());
}
}
private void CreateError(IMiddlewareContext context, Exception ex = default)
{
IErrorBuilder errorBuilder = ErrorBuilder.New()
.SetMessage("NotAuthorized")
.SetPath(context.Path)
.AddLocation(context.FieldSelection);
if (ex != default)
{
errorBuilder.SetException(ex);
}
context.Result = errorBuilder.Build();
}
public Error GetError <TExceptionToBuildErrorFor>(TExceptionToBuildErrorFor exception,
IEnumerable <Error> internalErrors,
bool includeSystemLevelExceptions)
where TExceptionToBuildErrorFor : Exception
{
if (CanHandle(exception) == false)
{
throw new ArgumentException(
$"'{exception.GetType().FullName}' can't be handled by this exception rule. Rules supports " +
$"'{typeof(TException).FullName}' and its derived types only!",
nameof(exception));
}
var exceptionForBuilder = exception as TException;
return(_errorBuilder.Build(exceptionForBuilder, internalErrors, includeSystemLevelExceptions));
}
public static GraphQLException VariableValueInvalidType(
VariableDefinitionNode variableDefinition,
Exception?exception = null)
{
IErrorBuilder errorBuilder = ErrorBuilder.New()
.SetMessage(
"Variable `{0}` got an invalid value.",
variableDefinition.Variable.Name.Value)
.SetCode(ErrorCodes.Execution.InvalidType)
.SetExtension("variable", variableDefinition.Variable.Name.Value)
.AddLocation(variableDefinition);
if (exception is not null)
{
errorBuilder.SetException(exception);
}
return(new GraphQLException(errorBuilder.Build()));
}
private static void ReportErrors(
IResolverContext context,
IEnumerable <IError> errors)
{
foreach (IError error in errors)
{
IErrorBuilder builder = ErrorBuilder.FromError(error)
.SetExtension("remote", error);
if (error.Path != null)
{
Path path = RewriteErrorPath(error, context.Path);
builder.SetPath(path)
.ClearLocations()
.AddLocation(context.FieldSelection);
}
context.ReportError(builder.Build());
}
}
public async void ProcessServerError(HttpContext context, Exception exception, int statusCode = 500)
{
_errorBuilder.Clean();
_errorBuilder.WithMessage(statusCode, exception.Message, context.Request.Path, exception.Source);
var errorNode = _errorBuilder.Build();
context.Response.Clear();
context.Response.StatusCode = statusCode;
var headerAccept = context.Request.Headers["Accept"].ToString().ToLower();
if (headerAccept == "application/xml")
{
context.Response.ContentType = "application/problem+xml";
var xmlResult = SerializeXMLResponse(errorNode);
await context.Response.WriteAsync(xmlResult, System.Text.Encoding.UTF8);
}
else
{
context.Response.ContentType = "application/problem+json";
var jsonResult = JsonConvert.SerializeObject(errorNode);
await context.Response.WriteAsync(jsonResult, System.Text.Encoding.UTF8);
}
}
protected override async Task HandleAsync(
ISocketConnection connection,
DataStartMessage message,
CancellationToken cancellationToken)
{
var session = new CancellationTokenSource();
var combined = CancellationTokenSource.CreateLinkedTokenSource(
session.Token, cancellationToken);
var sessionIsHandled = false;
IExecutionResult result = await ExecuteAsync(combined.Token);
try
{
switch (result)
{
case SubscriptionResult subscriptionResult:
// first we add the cts to the result so that they are disposed when the
// subscription is disposed.
subscriptionResult.RegisterDisposable(combined);
// while a subscription result must be disposed we are not handling it here
// and leave this responsibility to the subscription session.
ISubscription subscription = GetSubscription(result);
var subscriptionSession = new SubscriptionSession(
session,
_socketSessionInterceptor,
connection,
subscriptionResult,
subscription,
_diagnosticEvents,
message.Id);
connection.Subscriptions.Register(subscriptionSession);
sessionIsHandled = true;
break;
case IResponseStream streamResult:
// stream results represent deferred execution streams that use execution
// resources. We need to ensure that these are disposed when we are
// finished.
await using (streamResult)
{
await HandleStreamResultAsync(
connection,
message,
streamResult,
cancellationToken);
}
break;
case IQueryResult queryResult:
// query results use pooled memory an need to be disposed after we have
// used them.
using (queryResult)
{
await HandleQueryResultAsync(
connection,
message,
queryResult,
cancellationToken);
}
break;
default:
throw DataStartMessageHandler_RequestTypeNotSupported();
}
}
finally
{
if (!sessionIsHandled)
{
session.Dispose();
combined.Dispose();
}
}
async ValueTask <IExecutionResult> ExecuteAsync(CancellationToken cancellationToken)
{
try
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.From(message.Payload)
.SetServices(connection.RequestServices);
await _socketSessionInterceptor.OnRequestAsync(
connection, requestBuilder, cancellationToken);
return(await _requestExecutor.ExecuteAsync(
requestBuilder.Create(), cancellationToken));
}
catch (Exception ex)
{
IErrorBuilder error = _errorHandler.CreateUnexpectedError(ex);
return(QueryResultBuilder.CreateError(error.Build()));
}
}
}
public async Task <IExecutionResult> ExecuteAsync(
IRequestContext requestContext,
QueryPlan queryPlan,
Func <object?> resolveQueryValue)
{
if (requestContext is null)
{
throw new ArgumentNullException(nameof(requestContext));
}
if (queryPlan is null)
{
throw new ArgumentNullException(nameof(queryPlan));
}
if (requestContext.Operation is null || requestContext.Variables is null)
{
throw SubscriptionExecutor_ContextInvalidState();
}
ISelectionSet selectionSet = requestContext.Operation.GetRootSelectionSet();
if (selectionSet.Selections.Count != 1)
{
throw SubscriptionExecutor_SubscriptionsMustHaveOneField();
}
if (selectionSet.Selections[0].Field.SubscribeResolver is null)
{
throw SubscriptionExecutor_NoSubscribeResolver();
}
Subscription?subscription = null;
try
{
subscription = await Subscription.SubscribeAsync(
_operationContextPool,
_queryExecutor,
requestContext,
queryPlan,
requestContext.Operation.RootType,
selectionSet,
resolveQueryValue,
_diagnosticEvents)
.ConfigureAwait(false);
return(new SubscriptionResult(
subscription.ExecuteAsync,
null,
session: subscription,
contextData: new SingleValueExtensionData(
WellKnownContextData.Subscription,
subscription)));
}
catch (GraphQLException ex)
{
if (subscription is not null)
{
await subscription.DisposeAsync().ConfigureAwait(false);
}
return(new SubscriptionResult(null, ex.Errors));
}
catch (Exception ex)
{
requestContext.Exception = ex;
IErrorBuilder errorBuilder = requestContext.ErrorHandler.CreateUnexpectedError(ex);
IError error = requestContext.ErrorHandler.Handle(errorBuilder.Build());
if (subscription is not null)
{
await subscription.DisposeAsync().ConfigureAwait(false);
}
return(new SubscriptionResult(null, Unwrap(error)));
}
IReadOnlyList <IError> Unwrap(IError error)
{
if (error is AggregateError aggregateError)
{
return(aggregateError.Errors);
}
return(new[] { error });
}
}
public async Task <IExecutionResult> ExecuteAsync(
IRequestContext requestContext)
{
if (requestContext is null)
{
throw new ArgumentNullException(nameof(requestContext));
}
if (requestContext.Operation is null || requestContext.Variables is null)
{
throw SubscriptionExecutor_ContextInvalidState();
}
ISelectionSet selectionSet = requestContext.Operation.GetRootSelectionSet();
if (selectionSet.Selections.Count != 1)
{
throw SubscriptionExecutor_SubscriptionsMustHaveOneField();
}
if (selectionSet.Selections[0].Field.SubscribeResolver is null)
{
throw SubscriptionExecutor_NoSubscribeResolver();
}
Subscription?subscription = null;
try
{
subscription = await Subscription.SubscribeAsync(
_operationContextPool,
_queryExecutor,
requestContext,
requestContext.Operation.RootType,
selectionSet,
_diagnosticEvents)
.ConfigureAwait(false);
return(new SubscriptionResult(
subscription.ExecuteAsync,
null,
session: subscription));
}
catch (GraphQLException ex)
{
if (subscription is not null)
{
await subscription.DisposeAsync().ConfigureAwait(false);
}
return(new SubscriptionResult(null, ex.Errors));
}
catch (Exception ex)
{
requestContext.Exception = ex;
IErrorBuilder errorBuilder = requestContext.ErrorHandler.CreateUnexpectedError(ex);
IError error = requestContext.ErrorHandler.Handle(errorBuilder.Build());
if (subscription is not null)
{
await subscription.DisposeAsync().ConfigureAwait(false);
}
return(new SubscriptionResult(null, new[] { error }));
}
}
