public ErrorHandler(IErrorBuilder errorBuilder, DateTime firstValidDate = default, DateTime lastValidDate = default)
{
_errorBuilder = errorBuilder;
_firstValidDate = firstValidDate == default ? GetDefaultFirstValidDate() : firstValidDate;
_lastValidDate = lastValidDate == default ? GetDefaultLastValidDate() : lastValidDate;
_jsonSerializerOptions = GetDefaultJsonSerializerOptions();
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IErrorBuilder errorBuilder)
{
if (env.IsDevelopment())
{
//app.UseDeveloperExceptionPage();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpStatusCodeExceptionMiddleware();
//HandleExceptions(app);
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});
app.UseHttpsRedirection();
app.UseMvc();
}
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());
}
}
public IResult <TData> ValidationError <TData>(ValidationResult result, string target = "")
{
if (result == null)
{
throw new VanthException("Cannot create a validation error without the validation result");
}
if (result.IsValid || !result.Errors.Any())
{
return(new Result <TData>());
}
IErrorBuilder error = DefaultError <TData>(CommonErrorCode.ValidationError,
CommonErrorType.ValidationError,
CommonErrorMessage.ValidationError,
target);
foreach (ValidationFailure failure in result.Errors)
{
error.WithDetail(builder => builder.WithErrorCode(failure.ErrorCode)
.WithMessage(failure.ErrorMessage)
.WithTarget($"Property: {failure.PropertyName}")
.Build());
}
return(DefaultResult <TData>(error, null, CommonErrorCode.ValidationError));
}
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()));
}
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 void Default(IErrorBuilder errorBuilder, ErrorMappingContext mappingContext)
{
errorBuilder
.SetCode(Code)
.SetPath(mappingContext.MiddlewareContext.Path)
.SetMessage(mappingContext.ValidationFailure.ErrorMessage);
}
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 static IErrorBuilder SetMessage(
this IErrorBuilder builder,
string format,
params object[] args) =>
builder.SetMessage(string.Format(
CultureInfo.InvariantCulture,
format,
args));
public IResult <TData> IntegrationError <TData>(IErrorDetail detail, string service, string target = "")
{
IErrorBuilder error = DefaultError <TData>(CommonErrorCode.IntegrationError,
CommonErrorType.IntegrationError,
CommonErrorMessage.IntegrationError(service),
target);
return(DefaultResult <TData>(error, detail, CommonErrorCode.IntegrationError));
}
public IResult <TData> DatabaseError <TData>(IErrorDetail detail, string database, string target = "")
{
IErrorBuilder error = DefaultError <TData>(CommonErrorCode.DatabaseError,
CommonErrorType.DatabaseError,
CommonErrorMessage.DatabaseError(database),
target);
return(DefaultResult <TData>(error, detail, CommonErrorCode.DatabaseError));
}
public static void Details(IErrorBuilder errorBuilder, ErrorMappingContext mappingContext)
{
errorBuilder
.SetExtension(ExtensionKeys.ValidatorKey, mappingContext.ValidationFailure.ErrorCode)
.SetExtension(ExtensionKeys.FieldKey, mappingContext.MiddlewareContext.Field.Name)
.SetExtension(ExtensionKeys.ArgumentKey, mappingContext.Argument.Name)
.SetExtension(ExtensionKeys.PropertyKey, mappingContext.ValidationFailure.PropertyName)
.SetExtension(ExtensionKeys.SeverityKey, mappingContext.ValidationFailure.Severity);
}
public static void Extended(IErrorBuilder errorBuilder, ErrorMappingContext mappingContext)
{
errorBuilder
.SetExtension(ExtensionKeys.AttemptedValueKey, mappingContext.ValidationFailure.AttemptedValue)
.SetExtension(ExtensionKeys.CustomStateKey, mappingContext.ValidationFailure.CustomState)
.SetExtension(
ExtensionKeys.FormattedMessagePlaceholderValuesKey,
mappingContext.ValidationFailure.FormattedMessagePlaceholderValues);
}
public IResult <TData> TransportError <TData>(IErrorDetail detail, string target = "")
{
IErrorBuilder error = DefaultError <TData>(CommonErrorCode.TransportError,
CommonErrorType.TransportError,
CommonErrorMessage.TransportError,
target);
return(DefaultResult <TData>(error, detail, CommonErrorCode.ValidationError));
}
public IResult <TData> NullObjectError <TData>(IErrorDetail detail, string operation, string target = "")
{
IErrorBuilder error = DefaultError <TData>(CommonErrorCode.NullObjectError,
CommonErrorType.NullObjectError,
CommonErrorMessage.NullObjectError(operation),
target);
return(DefaultResult <TData>(error, detail, CommonErrorCode.NullObjectError));
}
public static IErrorBuilder SetFragmentName(
this IErrorBuilder errorBuilder,
ISyntaxNode node)
{
if (node.Kind == SyntaxKind.FragmentDefinition)
{
errorBuilder.SetExtension("fragment", ((FragmentDefinitionNode)node).Name.Value);
}
return(errorBuilder);
}
public static IErrorBuilder AddLocation(
this IErrorBuilder builder,
ISyntaxNode?syntaxNode)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (syntaxNode is { Location : not null })
public IErrorBuilder BuildError(
IErrorBuilder builder,
ValidationFailure failure,
IInputField argument,
IMiddlewareContext context)
{
return(builder.SetCode("VALIDATION_ERROR")
.SetMessage(failure.ErrorMessage)
.SetExtension("argument", argument.Name)
.SetPath(context.Path));
}
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 IError ArgumentNotUnique(
this IDocumentValidatorContext context,
ArgumentNode node,
IOutputField?field = null,
DirectiveType?directive = null)
{
IErrorBuilder builder = ErrorBuilder.New()
.SetMessage(Resources.ErrorHelper_ArgumentNotUnique)
.AddLocation(node)
.SetPath(context.CreateErrorPath());
if (field is { })
public ExceptionRuleForErrorProvider(
Func <ISetErrorBuilder <TException>, IProvideErrorBuilder <TException> > errorBuilderProvider,
Func <TException, bool> predicate)
{
if (errorBuilderProvider == null)
{
throw new ArgumentNullException(nameof(errorBuilderProvider));
}
_predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));
_exceptionType = typeof(TException);
TypeFullName = _exceptionType.FullName;
_errorBuilder = errorBuilderProvider(new ErrorBuilderConfiguration <TException>()).GetBuilder();
}
private IErrorBuilder CreateErrorFromException(Exception exception)
{
IErrorBuilder builder = ErrorBuilder.New()
.SetMessage("Unexpected Execution Error");
if (_includeExceptionDetails)
{
builder.SetException(exception)
.SetExtension("message", exception.Message)
.SetExtension("stackTrace", exception.StackTrace);
}
return(builder);
}
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();
}
private IErrorBuilder CreateErrorFromException(Exception exception)
{
IErrorBuilder builder = ErrorBuilder.New()
.SetMessage(CoreResources.ErrorHandler_UnexpectedError)
.SetException(exception);
if (_includeExceptionDetails)
{
builder
.SetExtension(_messageProperty, exception.Message)
.SetExtension(_stackTraceProperty, exception.StackTrace);
}
return(builder);
}
public IResult <TData> Exception <TData>(Exception exception, bool shouldAddStackTrace, string target = "")
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception), "Cannot create exception error from a null exception object");
}
IErrorBuilder error = DefaultError <TData>(CommonErrorCode.ExceptionError,
CommonErrorType.Exception,
CommonErrorMessage.ExceptionError,
target)
.WithDetail(exception.ExtractDetailsFromException(shouldAddStackTrace));
return(DefaultResult <TData>(error, null, CommonErrorCode.ExceptionError));
}
public static IErrorBuilder AddLocation(
this IErrorBuilder builder,
ISyntaxNode syntaxNode)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (syntaxNode == null)
{
throw new ArgumentNullException(nameof(syntaxNode));
}
return(builder.AddLocation(
syntaxNode.Location.StartToken.Line,
syntaxNode.Location.StartToken.Column));
}
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 static IErrorBuilder UseExponentiationOverflow(this IErrorBuilder builder)
{
builder.Services.AddTransient <IErrorExpressionProvider, ExponentFunctionErrorExpressionProvider>();
return(builder);
}
public static IErrorBuilder SpecifiedBy(
this IErrorBuilder errorBuilder,
string section) =>
errorBuilder.SetExtension(
"specifiedBy",
"http://spec.graphql.org/June2018/#" + section);
