public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
var page = context.Argument <int?>("page") ?? 1;
if (page <= 0)
{
page = 1;
}
var pageSize = context.Argument <int?>("pageSize") ?? 10;
var source = context.Result switch
{
IQueryable <TValueType> q => q,
IEnumerable <TValueType> e => e.AsQueryable(),
_ => null
};
if (source != null)
{
context.Result = new OffsetPaging <TValueType>
{
TotalCount = source.LongCount(),
Edges = source
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToList()
};
}
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
IValueNode sortArgument = context.Argument <IValueNode>(_contextData.ArgumentName);
if (sortArgument is null || sortArgument is NullValueNode)
{
return;
}
IQueryable <T>?source = null;
if (context.Result is IQueryable <T> q)
{
source = q;
}
else if (context.Result is IEnumerable <T> e)
{
source = e.AsQueryable();
}
if (source is not null &&
context.Field.Arguments[_contextData.ArgumentName].Type is InputObjectType iot &&
iot is ISortInputType fit &&
fit.EntityType is { })
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
IValueNode filter = context.Argument <IValueNode>(_contextData.ArgumentName);
if (filter is null || filter is NullValueNode)
{
return;
}
IQueryable <T>?source = null;
if (context.Result is IQueryable <T> q)
{
source = q;
}
else if (context.Result is IEnumerable <T> e)
{
source = e.AsQueryable();
}
if (source is not null &&
context.Field.Arguments[_contextData.ArgumentName].Type is InputObjectType iot &&
iot is IFilterInputType fit)
{
var visitorContext = new QueryableFilterVisitorContext(
iot, fit.EntityType, _converter, source is EnumerableQuery);
QueryableFilterVisitor.Default.Visit(filter, visitorContext);
source = source.Where(visitorContext.CreateFilter <T>());
context.Result = source;
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
IQueryable <TData> source = context.Result switch
{
IQueryable <TData> result => result,
IEnumerable <TData> enumerable => enumerable.AsQueryable(),
_ => throw new NotSupportedException($"Unsupported result type: {context.Result.GetType()}")
};
CancellationToken requestAborted = context.RequestAborted;
var settings = new PageSettings(context.Argument <int>("pageNumber"), context.Argument <int>("pageSize"));
context.Result = new SearchResult <TData>(
await source.WithPaging(settings).ToArrayAsync(requestAborted),
await source.LongCountAsync(requestAborted));
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
var filter = context.Argument <IValueNode>("where");
if (filter is null || filter is NullValueNode)
{
return;
}
IQueryable <T> source = null;
if (context.Result is PageableData <T> p)
{
source = p.Source;
}
else
{
p = null;
}
if (context.Result is IQueryable <T> q)
{
source = q;
}
else if (context.Result is IEnumerable <T> e)
{
source = e.AsQueryable();
}
if (source != null &&
context.Field.Arguments["where"].Type is InputObjectType iot &&
iot is IFilterInputType fit)
{
var visitor = new QueryableFilterVisitor(
iot,
fit.EntityType,
_converter);
filter.Accept(visitor);
if (source is EnumerableQuery)
{
source = source.Where(visitor.CreateFilterInMemory <T>());
}
else
{
source = source.Where(visitor.CreateFilter <T>());
}
context.Result = p is null
? (object)source
: new PageableData <T>(source, p.Properties);
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
IValueNode sortArgument = context.Argument <IValueNode>(_contextData.ArgumentName);
if (sortArgument is null || sortArgument is NullValueNode)
{
return;
}
IQueryable <T> source = null;
if (context.Result is IQueryable <T> q)
{
source = q;
}
else if (context.Result is IEnumerable <T> e)
{
source = e.AsQueryable();
}
if (context.Result is PageableData <T> p)
{
source = p.Source;
}
else
{
p = null;
}
if (source != null &&
context.Field.Arguments[_contextData.ArgumentName].Type is InputObjectType iot &&
iot is ISortInputType fit)
{
QueryableSortVisitor visitor;
if (source is EnumerableQuery)
{
visitor = new QueryableSortVisitorInMemory(iot, fit.EntityType);
}
else
{
visitor = new QueryableSortVisitor(iot, fit.EntityType);
}
sortArgument.Accept(visitor);
source = visitor.Sort(source);
context.Result = p is null
? (object)source
: new PageableData <T>(source, p.Properties);
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
var pagingDetails = new PagingDetails
{
First = context.Argument <int?>("first"),
After = context.Argument <string>("after"),
Last = context.Argument <int?>("last"),
Before = context.Argument <string>("before"),
};
IQueryable <T> source = null;
if (context.Result is PageableData <T> p)
{
source = p.Source;
pagingDetails.Properties = p.Properties;
}
if (context.Result is IQueryable <T> q)
{
source = q;
}
if (context.Result is IEnumerable <T> e)
{
source = e.AsQueryable();
}
if (source != null)
{
IConnectionResolver connectionResolver = _createConnectionResolver(
source, pagingDetails);
context.Result = await connectionResolver
.ResolveAsync(context.RequestAborted)
.ConfigureAwait(false);
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
var pagingDetails = new PaginationDetails
{
Limit = context.Argument <int?>("limit"),
PageNumber = context.Argument <int?>("pageNumber"),
};
IQueryable <T> source = null;
if (context.Result is PageableData <T> p)
{
source = p.Source;
pagingDetails.Properties = p.Properties;
}
if (context.Result is IQueryable <T> q)
{
source = q;
}
else if (context.Result is IEnumerable <T> e)
{
source = e.AsQueryable();
}
if (source != null)
{
IConnectionResolver connectionResolver = _createConnectionResolver(
source, pagingDetails);
context.Result = await connectionResolver
.ResolveAsync(context, source)
.ConfigureAwait(false);
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
var arguments = context.Field.Arguments;
var validationResults = new List <ValidationResult>();
foreach (var argument in arguments)
{
if (argument == null ||
!_options.ShouldValidate(context, argument))
{
continue;
}
var resolvedValidators = _validatorProvider.GetValidators(context, argument);
try
{
var value = context.Argument <object>(argument.Name);
foreach (var resolvedValidator in resolvedValidators)
{
var validationResult = await resolvedValidator.Validator.ValidateAsync(value, context.RequestAborted);
if (validationResult != null)
{
validationResults.Add(validationResult);
_validationResultHandler.Handle(context, validationResult);
}
}
}
finally
{
foreach (var resolvedValidator in resolvedValidators)
{
resolvedValidator.Scope?.Dispose();
}
}
}
var invalidValidationResults = validationResults.Where(r => !r.IsValid);
if (invalidValidationResults.Any())
{
OnInvalid(context, invalidValidationResults);
}
await _next(context);
}
public async Task Invoke(IMiddlewareContext context)
{
if (context.FieldSelection.Arguments.Count == 0)
{
await _next(context);
return;
}
var errors = context.FieldSelection.Arguments
.Select(a => context.Argument <object>(a.Name.Value))
.SelectMany(ValidateObject);
if (errors.Any())
{
foreach (var error in errors)
{
context.ReportError(ErrorBuilder.New()
.SetCode("error.validation")
.SetMessage(error.ErrorMessage)
.SetExtension("memberNames", error.MemberNames)
.AddLocation(context.FieldSelection.Location.Line, context.FieldSelection.Location.Column)
.SetPath(context.Path)
.Build());
}
context.Result = null;
}
else
{
await _next(context);
}
IEnumerable <ValidationResult> ValidateObject(object argument)
{
var results = new List <ValidationResult>();
Validator.TryValidateObject(argument, new ValidationContext(argument), results, validateAllProperties: true);
return(results);
}
}
public async Task InvokeAsync(IMiddlewareContext context)
{
await _next(context).ConfigureAwait(false);
IValueNode sortArgument = context.Argument <IValueNode>(
SortObjectFieldDescriptorExtensions.OrderByArgumentName);
if (sortArgument is null || sortArgument is NullValueNode)
{
return;
}
IQueryable <T> source = null;
if (context.Result is IQueryable <T> q)
{
source = q;
}
else if (context.Result is IEnumerable <T> e)
{
source = e.AsQueryable();
}
if (source != null &&
context.Field
.Arguments[SortObjectFieldDescriptorExtensions.OrderByArgumentName]
.Type is InputObjectType iot &&
iot is ISortInputType fit)
{
var visitor = new QueryableSortVisitor(
iot,
fit.EntityType);
sortArgument.Accept(visitor);
source = visitor.Sort(source);
context.Result = source;
}
}
public Task Run(IMiddlewareContext context, FieldDelegate next)
{
var rootCtx = new FieldValidationContext(context.Field.Name);
foreach (var inputField in context.Field.Arguments)
{
var directives = GetValidationDirectives(inputField.Directives);
var value = context.Argument <object>(inputField.Name);
var ctx = new FieldValidationContext(inputField.Name);
HandleInput(value, inputField.Type, directives, ctx);
rootCtx.AddErrored(ctx);
}
if (rootCtx.HasErrors())
{
var errorsProperty = new ErrorProperty("FieldValidationError", rootCtx);
var error = new QueryError("Invalid input data", errorsProperty);
throw new QueryException(error);
}
return(next.Invoke(context));
}
public async Task Invoke(IMiddlewareContext context)
{
if (context.FieldSelection.Arguments.Count == 0)
{
await _next(context);
return;
}
var errors = context.FieldSelection.Arguments
.Select(a => context.Argument <object>(a.Name.Value))
.SelectMany(ValidateObject);
if (errors.Any())
{
foreach (var error in errors)
{
context.ReportError(ErrorBuilder.New()
.SetCode(error.ErrorCode)
.SetMessage(error.ErrorMessage)
.SetExtension("memberNames", error.PropertyName)
.AddLocation(context.FieldSelection.Location.Line, context.FieldSelection.Location.Column)
.SetPath(context.Path)
.Build());
}
context.Result = null;
}
else
{
await _next(context);
}
IEnumerable <ValidationFailure> ValidateObject(object argument)
{
try
{
var actualObjectType = argument.GetType();
var validatorGenericType = typeof(IValidator <>);
var validatorType = validatorGenericType.MakeGenericType(actualObjectType);
object validator = null;
try
{
validator = context.Service(validatorType);
}
catch (InvalidOperationException)
{
// No service found
return(Enumerable.Empty <ValidationFailure>());
}
if (validator == null)
{
return(Enumerable.Empty <ValidationFailure>());
}
var validateMethodInfo = validatorType.GetMethod(nameof(IValidator.Validate), new[] { actualObjectType });
var results = validateMethodInfo.Invoke(validator, new[] { argument }) as ValidationResult;
return(results.Errors.AsEnumerable());
}
catch (Exception ex)
{
throw new Exception($"Failed to validate with error '{ex.Message}'.");
}
}
}