public async ValueTask InvokeAsync(IRequestContext context)
{
if (context.Document is null)
{
context.Result = StateInvalidForDocumentValidation();
}
else
{
if (context.ValidationResult is null)
{
using (_diagnosticEvents.ValidateDocument(context))
{
context.ValidationResult = _documentValidator.Validate(
context.Schema,
context.Document,
context.ContextData);
}
}
if (context.ValidationResult is { HasErrors : true } validationResult)
{
context.Result = QueryResultBuilder.CreateError(
validationResult.Errors,
new Dictionary <string, object?>
{
{ WellKnownContextData.ValidationErrors, true }
});
_diagnosticEvents.ValidationErrors(context, validationResult.Errors);
}
private IReadOnlyList <HCError> ValidateQueryDocuments(ISchema schema)
{
var errors = new List <HCError>();
try
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddValidation();
IDocumentValidator validator = serviceCollection.BuildServiceProvider()
.GetService <IDocumentValidatorFactory>().CreateValidator();
foreach (DocumentInfo documentInfo in _queries.Values)
{
DocumentValidatorResult validationResult =
validator.Validate(schema, documentInfo.Document);
if (validationResult.HasErrors)
{
foreach (HCError error in validationResult.Errors)
{
errors.Add(HCErrorBuilder.FromError(error)
.SetExtension("fileName", documentInfo.FileName)
.SetExtension("document", documentInfo.Document)
.Build());
}
}
}
}
catch (GeneratorException ex)
{
errors.AddRange(ex.Errors);
}
return(errors);
}
public async ValueTask InvokeAsync(IRequestContext context)
{
if (context.Document is null)
{
// TODO : ErrorHelper
context.Result = QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage("Cannot Validate")
.Build());
}
else
{
if (context.ValidationResult is null)
{
using (_diagnosticEvents.ValidateDocument(context))
{
context.ValidationResult =
_documentValidator.Validate(context.Schema, context.Document !);
}
}
if (context.ValidationResult is { HasErrors : true } validationResult)
{
context.Result = QueryResultBuilder.CreateError(validationResult.Errors);
_diagnosticEvents.ValidationErrors(context, validationResult.Errors);
}
public virtual CaptureResponse Capture(XDocument xmlDocument)
{
var startDate = SystemContext.Clock.Now;
_documentValidator.Validate(xmlDocument);
var events = _documentParser.Parse(xmlDocument.Root);
var currentUser = _userProvider.GetCurrentUser();
var request = new EpcisRequest
{
RecordTime = SystemContext.Clock.Now,
DocumentTime = DateTime.Parse(xmlDocument.Root.Attribute("creationDate").Value),
User = currentUser
};
foreach (var @event in events)
{
request.AddEvent(@event);
}
_requestPersister.Persist(request);
return(new CaptureResponse
{
EventCount = request.Events.Count,
CaptureStartDateUtc = startDate,
CaptureEndDateUtc = SystemContext.Clock.Now,
EventIds = request.Events.Select(e => e.Id.ToString()).ToArray()
});
}
public async Task <ExecutionResult> ExecuteAsync(
ISchema schema,
object root,
string query,
string operationName,
Inputs inputs = null,
object userContext = null,
CancellationToken cancellationToken = default(CancellationToken),
IEnumerable <IValidationRule> rules = null)
{
var result = new ExecutionResult();
try
{
var document = _documentBuilder.Build(query);
var validationResult = _documentValidator.Validate(query, schema, document, rules);
if (validationResult.IsValid)
{
var context = BuildExecutionContext(schema, root, document, operationName, inputs, userContext, cancellationToken);
if (context.Errors.Any())
{
result.Errors = context.Errors;
return(result);
}
result.Data = await ExecuteOperationAsync(context).ConfigureAwait(false);
if (context.Errors.Any())
{
result.Errors = context.Errors;
}
}
else
{
result.Data = null;
result.Errors = validationResult.Errors;
}
return(result);
}
catch (Exception exc)
{
if (result.Errors == null)
{
result.Errors = new ExecutionErrors();
}
result.Data = null;
result.Errors.Add(new ExecutionError(exc.Message, exc));
return(result);
}
}
private void ValidateDocument(string document)
{
if (string.IsNullOrWhiteSpace(document))
{
throw new EstablishmentValidatorException(Properties.Resources.EstablishmentDocumentError);
}
if (!_documentValidator.Validate(document))
{
throw new EstablishmentValidatorException(Properties.Resources.EstablishmentDocumentInvalidErro);
}
}
public void DocumentIsNull()
{
// arrange
Schema schema = ValidationUtils.CreateSchema();
IDocumentValidator queryValidator = CreateValidator();
// act
Action a = () => queryValidator.Validate(schema, null !);
// assert
Assert.Throws <ArgumentNullException>(a);
}
private void ValidateDocument(OwnerPet entity)
{
if (string.IsNullOrWhiteSpace(entity.Document))
{
throw new OwnerPetValidatorException(Properties.Resources.OwnerPetDocumentError);
}
if (!_documentValidator.Validate(entity.Document))
{
throw new OwnerPetValidatorException(Properties.Resources.OwnerPetDocumentInvalidError);
}
}
private void ExpectValid(ISchema schema, IDocumentValidator validator, string sourceText)
{
// arrange
schema ??= ValidationUtils.CreateSchema();
validator ??= CreateValidator();
DocumentNode query = Utf8GraphQLParser.Parse(sourceText);
// act
DocumentValidatorResult result = validator.Validate(schema, query);
// assert
Assert.Empty(result.Errors);
}
public void SchemaIsNull()
{
// arrange
Schema schema = ValidationUtils.CreateSchema();
IDocumentValidator queryValidator = CreateValidator();
// act
// act
Action a = () => queryValidator.Validate(null,
new DocumentNode(null, new List <IDefinitionNode>()));
// assert
Assert.Throws <ArgumentNullException>(a);
}
public virtual IEnumerable <string> Capture(XDocument document)
{
_validator.Validate(document);
var masterdataList = _masterdataParser.Parse(document.Root);
var currentUser = _userProvider.GetCurrentUser();
foreach (var masterdata in masterdataList)
{
_masterdataRepository.Store(masterdata);
}
return(masterdataList.Select(x => x.Id));
}
private static bool TryValidateRequest(
ISchema schema,
IReadOnlyList <GraphQLFile> executableFiles,
Dictionary <ISyntaxNode, string> fileLookup,
List <IError> errors)
{
IDocumentValidator validator = CreateDocumentValidator();
DocumentNode document = MergeDocuments(executableFiles);
DocumentValidatorResult validationResult = validator.Validate(schema, document);
if (validationResult.HasErrors)
{
errors.AddRange(
validationResult.Errors.Select(
error => error.WithFileReference(fileLookup)));
return(false);
}
return(true);
}
public void DuplicatesWillBeIgnoredOnFieldMerging()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddStarWarsTypes()
.Create();
DocumentNode document = Utf8GraphQLParser.Parse(
FileResource.Open("InvalidIntrospectionQuery.graphql"));
var originalOperation = ((OperationDefinitionNode)document.Definitions[0]);
OperationDefinitionNode operationWithDuplicates = originalOperation.WithSelectionSet(
originalOperation.SelectionSet.WithSelections(
new List <ISelectionNode>
{
originalOperation.SelectionSet.Selections[0],
originalOperation.SelectionSet.Selections[0]
}));
document = document.WithDefinitions(
new List <IDefinitionNode>(document.Definitions.Skip(1))
{
operationWithDuplicates
});
ServiceProvider services = new ServiceCollection()
.AddValidation()
.Services
.BuildServiceProvider();
IDocumentValidatorFactory factory = services.GetRequiredService <IDocumentValidatorFactory>();
IDocumentValidator validator = factory.CreateValidator();
// act
DocumentValidatorResult result = validator.Validate(schema, document);
// assert
Assert.False(result.HasErrors);
}
private void ExpectErrors(
ISchema schema,
IDocumentValidator validator,
string sourceText,
params Action <IError>[] elementInspectors)
{
// arrange
schema ??= ValidationUtils.CreateSchema();
validator ??= CreateValidator();
DocumentNode query = Utf8GraphQLParser.Parse(sourceText);
// act
DocumentValidatorResult result = validator.Validate(schema, query);
// assert
Assert.NotEmpty(result.Errors);
if (elementInspectors.Length > 0)
{
Assert.Collection(result.Errors, elementInspectors);
}
result.Errors.MatchSnapshot();
}
public async ValueTask InvokeAsync(IRequestContext context)
{
if (context.Document is null)
{
context.Result = StateInvalidForDocumentValidation();
}
else
{
using (_diagnosticEvents.ValidateDocument(context))
{
context.ValidationResult = _documentValidator.Validate(
context.Schema,
context.Document,
context.ContextData,
context.ValidationResult is not null);
}
if (context.IsValidDocument)
{
await _next(context).ConfigureAwait(false);
}
else
{
DocumentValidatorResult validationResult = context.ValidationResult;
context.Result = QueryResultBuilder.CreateError(
validationResult.Errors,
new Dictionary <string, object?>
{
{ WellKnownContextData.ValidationErrors, true }
});
_diagnosticEvents.ValidationErrors(context, validationResult.Errors);
}
}
}
public virtual IEnumerable <string> Capture(XDocument xmlDocument)
{
_documentValidator.Validate(xmlDocument);
var events = _documentParser.Parse(xmlDocument.Root);
var currentUser = _userProvider.GetCurrentUser();
var request = new EpcisRequest
{
RecordTime = SystemContext.Clock.Now,
DocumentTime = DateTime.Parse(xmlDocument.Root.Attribute("creationDate").Value),
SubscriptionId = TryExtractSubscriptionId(xmlDocument),
User = currentUser
};
foreach (var @event in events)
{
request.AddEvent(@event);
}
_requestPersister.Persist(request);
return(request.Events.Select(e => e.Id.ToString()));
}
public async Task <ExecutionResult> ExecuteAsync(ExecutionOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var metrics = new Metrics(options.EnableMetrics);
metrics.Start(options.OperationName);
options.Schema.FieldNameConverter = options.FieldNameConverter;
ExecutionResult result = null;
try
{
ValidateOptions(options);
if (!options.Schema.Initialized)
{
using (metrics.Subject("schema", "Initializing schema"))
{
if (options.SetFieldMiddleware)
{
options.FieldMiddleware.ApplyTo(options.Schema);
}
options.Schema.Initialize();
}
}
var document = options.Document;
using (metrics.Subject("document", "Building document"))
{
if (document == null)
{
document = _documentBuilder.Build(options.Query);
}
}
var operation = GetOperation(options.OperationName, document);
metrics.SetOperationName(operation?.Name);
if (operation == null)
{
throw new ExecutionError("Unable to determine operation from query.");
}
IValidationResult validationResult;
using (metrics.Subject("document", "Validating document"))
{
validationResult = _documentValidator.Validate(
options.Query,
options.Schema,
document,
options.ValidationRules,
options.UserContext,
options.Inputs);
}
if (options.ComplexityConfiguration != null && validationResult.IsValid)
{
using (metrics.Subject("document", "Analyzing complexity"))
_complexityAnalyzer.Validate(document, options.ComplexityConfiguration);
}
foreach (var listener in options.Listeners)
{
await listener.AfterValidationAsync(
options.UserContext,
validationResult,
options.CancellationToken)
.ConfigureAwait(false);
}
if (!validationResult.IsValid)
{
return(new ExecutionResult()
{
Errors = validationResult.Errors
});
}
var context = BuildExecutionContext(
options.Schema,
options.Root,
document,
operation,
options.Inputs,
options.UserContext,
options.CancellationToken,
metrics,
options.Listeners);
if (context.Errors.Any())
{
return(new ExecutionResult()
{
Errors = context.Errors
});
}
using (metrics.Subject("execution", "Executing operation"))
{
foreach (var listener in context.Listeners)
{
await listener.BeforeExecutionAsync(context.UserContext, context.CancellationToken)
.ConfigureAwait(false);
}
IExecutionStrategy executionStrategy = SelectExecutionStrategy(context);
if (executionStrategy == null)
{
throw new InvalidOperationException("Invalid ExecutionStrategy!");
}
var task = executionStrategy.ExecuteAsync(context)
.ConfigureAwait(false);
foreach (var listener in context.Listeners)
{
await listener.BeforeExecutionAwaitedAsync(context.UserContext, context.CancellationToken)
.ConfigureAwait(false);
}
result = await task;
foreach (var listener in context.Listeners)
{
await listener.AfterExecutionAsync(context.UserContext, context.CancellationToken)
.ConfigureAwait(false);
}
}
if (context.Errors.Any())
{
result.Errors = context.Errors;
}
}
catch (Exception ex)
{
result = new ExecutionResult
{
Errors = new ExecutionErrors()
{
new ExecutionError(ex.Message, ex)
}
};
}
finally
{
result = result ?? new ExecutionResult();
result.ExposeExceptions = options.ExposeExceptions;
result.Perf = metrics.Finish()?.ToArray();
}
return(result);
}
private DocumentValidatorResult Validate(ISchema schema, DocumentNode document)
{
return(_validator.Validate(schema, document));
}
public void Setup()
{
_validator.Validate(_schema, _introspectionQuery);
}
public async Task <ExecutionResult> ExecuteAsync(ExecutionOptions config)
{
var metrics = new Metrics();
metrics.Start(config.OperationName);
config.Schema.FieldNameConverter = config.FieldNameConverter;
var result = InitializeResult(config);
try
{
ValidateOptions(config);
if (!config.Schema.Initialized)
{
using (metrics.Subject("schema", "Initializing schema"))
{
config.FieldMiddleware.ApplyTo(config.Schema);
config.Schema.Initialize();
}
}
var document = config.Document;
using (metrics.Subject("document", "Building document"))
{
if (document == null)
{
document = _documentBuilder.Build(config.Query);
}
}
result.Document = document;
var operation = GetOperation(config.OperationName, document);
result.Operation = operation;
metrics.SetOperationName(operation?.Name);
if (operation == null)
{
throw new ExecutionError("Unable to determine operation from query.");
}
if (config.ComplexityConfiguration != null)
{
using (metrics.Subject("document", "Analyzing complexity"))
_complexityAnalyzer.Validate(document, config.ComplexityConfiguration);
}
IValidationResult validationResult;
using (metrics.Subject("document", "Validating document"))
{
validationResult = _documentValidator.Validate(
config.Query,
config.Schema,
document,
config.ValidationRules,
config.UserContext);
}
foreach (var listener in config.Listeners)
{
await listener.AfterValidationAsync(
config.UserContext,
validationResult,
config.CancellationToken)
.ConfigureAwait(false);
}
if (validationResult.IsValid)
{
var context = BuildExecutionContext(
config.Schema,
config.Root,
document,
operation,
config.Inputs,
config.UserContext,
config.CancellationToken,
metrics);
if (context.Errors.Any())
{
result.Errors = context.Errors;
return(result);
}
using (metrics.Subject("execution", "Executing operation"))
{
foreach (var listener in config.Listeners)
{
await listener.BeforeExecutionAsync(config.UserContext, config.CancellationToken).ConfigureAwait(false);
}
await OnExecution(config, context, result);
foreach (var listener in config.Listeners)
{
await listener.AfterExecutionAsync(config.UserContext, config.CancellationToken).ConfigureAwait(false);
}
}
if (context.Errors.Any())
{
result.Errors = context.Errors;
}
}
else
{
OnValidationError(validationResult, result);
}
return(result);
}
catch (Exception exc)
{
OnError(exc, result);
return(result);
}
finally
{
result.Perf = metrics.Finish().ToArray();
}
}
