internal static Directive FromDescription(
DirectiveType directiveType,
DirectiveDescription description,
object source)
{
if (directiveType == null)
{
throw new ArgumentNullException(nameof(directiveType));
}
if (description == null)
{
throw new ArgumentNullException(nameof(description));
}
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (description.CustomDirective is null)
{
return(new Directive(directiveType,
description.ParsedDirective,
source));
}
else
{
return(new Directive(directiveType,
description.CustomDirective,
source));
}
}
private void CompleteDirective(
ITypeInitializationContext context,
DirectiveDescription description,
HashSet <string> processed)
{
DirectiveReference reference =
DirectiveReference.FromDescription(description);
DirectiveType directiveType = context.GetDirectiveType(reference);
if (directiveType != null)
{
if (!processed.Add(directiveType.Name) &&
!directiveType.IsRepeatable)
{
context.ReportError(new SchemaError(
$"The specified directive `@{directiveType.Name}` " +
"is unique and cannot be added twice.",
context.Type as INamedType));
}
else if (directiveType.Locations.Contains(_location))
{
_directives.Add(Directive.FromDescription(
directiveType, description, _source));
}
else
{
context.ReportError(new SchemaError(
$"The specified directive `@{directiveType.Name}` " +
"is not allowed on the current location " +
$"`{_location}`.",
context.Type as INamedType));
}
}
}
public void DeclareArgument()
{
// arrange
var descriptor = new DirectiveDescriptor();
// act
IDirectiveDescriptor desc = descriptor;
desc.Name("Foo");
desc.Argument("arg").Type <BooleanType>();;
// assert
DirectiveDescription description = descriptor.CreateDescription();
Assert.Equal("arg", description.Arguments.Single().Name);
}
internal static DirectiveReference FromDescription(
DirectiveDescription description)
{
if (description == null)
{
throw new ArgumentNullException(nameof(description));
}
if (description.ParsedDirective != null)
{
return(new DirectiveReference(
description.ParsedDirective.Name.Value));
}
return(new DirectiveReference(
description.CustomDirective.GetType()));
}
public void DeclareLocation()
{
// arrange
var descriptor = new DirectiveDescriptor();
// act
IDirectiveDescriptor desc = descriptor;
desc.Name("Foo");
desc.Location(DirectiveLocation.Enum);
desc.Location(DirectiveLocation.Enum);
desc.Location(DirectiveLocation.EnumValue);
// assert
DirectiveDescription description = descriptor.CreateDescription();
Assert.Collection(description.Locations,
t => Assert.Equal(DirectiveLocation.Enum, t),
t => Assert.Equal(DirectiveLocation.EnumValue, t));
}
private void Initialize(Action <IDirectiveDescriptor> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
DirectiveDescriptor descriptor = CreateDescriptor();
configure(descriptor);
DirectiveDescription description = descriptor.CreateDescription();
SyntaxNode = description.SyntaxNode;
Name = description.Name;
Description = description.Description;
Locations = description.Locations.ToImmutableList();
Arguments = new FieldCollection <InputField>(
description.Arguments.Select(t => new InputField(t)));
}
private void CompleteDirecive(
ITypeInitializationContext context,
DirectiveDescription description)
{
DirectiveReference reference =
DirectiveReference.FromDescription(description);
DirectiveType type = context.GetDirectiveType(reference);
if (type != null)
{
if (type.Locations.Contains(_location))
{
_directives.Add(
Directive.FromDescription(type, description, _source));
}
else
{
context.ReportError(new SchemaError(
$"The specified directive `{type.Name}` is not " +
$"allowed on the current location `{_location}`.",
context.Type));
}
}
}
