/// <inheritdoc/>
public override bool CanHandle(
ITypeCompletionContext context,
EnumTypeDefinition typeDefinition,
SortEnumValueDefinition valueDefinition)
{
return(valueDefinition.Operation == _operation);
}
public void AddDirectiveWithArgument()
{
// arrange
var descriptor = EnumTypeDescriptor.New(Context);
// act
IEnumTypeDescriptor desc = descriptor;
desc.Directive("Bar",
new ArgumentNode("a", new StringValueNode("b")));
// assert
EnumTypeDefinition description = descriptor.CreateDefinition();
Assert.Collection(description.Directives,
t =>
{
Assert.Equal("Bar", t.ParsedDirective.Name.Value);
Assert.Collection(t.ParsedDirective.Arguments,
x =>
{
Assert.Equal("a", x.Name.Value);
Assert.IsType <StringValueNode>(x.Value);
Assert.Equal("b", ((StringValueNode)x.Value).Value);
});
});
}
public void SpecifyOneValueInferTheOthers()
{
// arrange
var descriptor = EnumTypeDescriptor.New(Context, typeof(FooEnum));
// act
IEnumTypeDescriptor desc = descriptor;
desc.Item(FooEnum.Bar1).Name("FOOBAR");
// assert
EnumTypeDefinition description = descriptor.CreateDefinition();
Assert.Collection(description.Values,
t =>
{
Assert.Equal("FOOBAR", t.Name);
Assert.Equal(FooEnum.Bar1, t.Value);
},
t =>
{
Assert.Equal("BAR2", t.Name);
Assert.Equal(FooEnum.Bar2, t.Value);
});
}
protected override void OnCompleteType(
ITypeCompletionContext context,
EnumTypeDefinition definition)
{
base.OnCompleteType(context, definition);
_naming = context.DescriptorContext.Naming;
SyntaxNode = definition.SyntaxNode;
foreach (EnumValueDefinition enumValueDefinition in definition.Values)
{
if (TryCreateEnumValue(context, enumValueDefinition, out IEnumValue? enumValue))
{
_enumValues[enumValue.Name] = enumValue;
_valueLookup[enumValue.Value] = enumValue;
}
}
if (!Values.Any())
{
context.ReportError(
SchemaErrorBuilder.New()
.SetMessage(TypeResources.EnumType_NoValues, Name)
.SetCode(ErrorCodes.Schema.NoEnumValues)
.SetTypeSystemObject(this)
.AddSyntaxNode(SyntaxNode)
.Build());
}
}
private static void DeclareValues(
EnumTypeDefinition parent,
IReadOnlyCollection <EnumValueDefinitionNode> values,
bool preserveSyntaxNodes)
{
foreach (EnumValueDefinitionNode value in values)
{
var valueDefinition = new EnumValueDefinition(
value.Name.Value,
value.Description?.Value,
value.Name.Value);
valueDefinition.BindTo = value.GetBindingValue();
if (preserveSyntaxNodes)
{
valueDefinition.SyntaxNode = value;
}
SdlToTypeSystemHelper.AddDirectives(valueDefinition, value);
if (value.DeprecationReason() is { Length: > 0 } reason)
{
valueDefinition.DeprecationReason = reason;
}
parent.Values.Add(valueDefinition);
}
}
protected override void OnRegisterDependencies(
ITypeDiscoveryContext context,
EnumTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
context.RegisterDependencies(definition);
SetTypeIdentity(typeof(EnumType <>));
}
public static SchemaException SortInterceptor_NoOperationHandlerFoundForValue(
EnumTypeDefinition type,
SortEnumValueDefinition value) =>
new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
DataResources.SortInterceptor_NoOperationHandlerFoundForValue,
value.Name,
type.Name)
.Build());
public IEnumerable <ITypeDeclaration> GetTypeDeclarations()
{
return(document.Children.Concat(options.ScalarTypes).Select(def => def switch
{
ObjectTypeDefinition objectTypeDefinition => new ObjectTypeContext(objectTypeDefinition, options, document) as ITypeDeclaration,
InputObjectTypeDefinition inputObjectTypeDefinition => new InputObjectTypeContext(inputObjectTypeDefinition, options, document) as ITypeDeclaration,
InterfaceTypeDefinition interfaceTypeDefinition => new InterfaceTypeContext(interfaceTypeDefinition, options, document) as ITypeDeclaration,
EnumTypeDefinition enumTypeDefinition => new EnumTypeContext(enumTypeDefinition, options, document) as ITypeDeclaration,
UnionTypeDefinition unionTypeDefinition => new UnionTypeContext(unionTypeDefinition, options) as ITypeDeclaration,
ScalarTypeDefinition scalarTypeDefinition => new ScalarTypeContext(scalarTypeDefinition, options) as ITypeDeclaration,
SchemaDefinition _ => null,
_ => throw new InvalidOperationException("Unhandled definition type " + def.Kind.ToString("g"))
})
public EnumTypeExtension Create(IDescriptorContext context, EnumTypeExtensionNode node)
{
var preserveSyntaxNodes = context.Options.PreserveSyntaxNodes;
var typeDefinition = new EnumTypeDefinition(node.Name.Value);
typeDefinition.BindTo = node.GetBindingValue();
SdlToTypeSystemHelper.AddDirectives(typeDefinition, node);
DeclareValues(typeDefinition, node.Values, preserveSyntaxNodes);
return(EnumTypeExtension.CreateUnsafe(typeDefinition));
}
protected override EnumTypeDefinition CreateDefinition(ITypeDiscoveryContext context)
{
EnumTypeDefinition definition = base.CreateDefinition(context);
ISortingNamingConvention convention =
context.DescriptorContext.GetSortingNamingConvention();
definition.Name = convention.GetSortingOperationKindTypeName(
context.DescriptorContext, definition.RuntimeType);
foreach (EnumValueDefinition value in definition.Values)
{
ConfigureEnumValue(value, convention);
}
return(definition);
}
public void AddDirective()
{
// arrange
var descriptor = new EnumTypeDescriptor(Context, "Foo");
// act
IEnumTypeDescriptor desc = descriptor;
desc.Directive(new NameString("Bar"));
// assert
EnumTypeDefinition description = descriptor.CreateDefinition();
Assert.Collection(description.Directives,
t => Assert.Equal("Bar", t.ParsedDirective.Name.Value));
}
public static void RegisterDependencies(
this ITypeDiscoveryContext context,
EnumTypeDefinition definition)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (definition is null)
{
throw new ArgumentNullException(nameof(definition));
}
CollectDependencies(definition, context.Dependencies);
}
public void AddDirectiveWithDirectiveNode()
{
// arrange
var descriptor = EnumTypeDescriptor.New(Context);
// act
IEnumTypeDescriptor desc = descriptor;
desc.Directive(new DirectiveNode("Bar"));
// assert
EnumTypeDefinition description = descriptor.CreateDefinition();
Assert.Collection(description.Directives,
t => Assert.Equal("Bar", t.ParsedDirective.Name.Value));
}
public static void RegisterDependencies(
this IInitializationContext context,
EnumTypeDefinition definition)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
RegisterDirectiveDependencies(context, definition);
}
public bool TryGetOperationHandler(
ITypeCompletionContext context,
EnumTypeDefinition typeDefinition,
SortEnumValueDefinition fieldDefinition,
[NotNullWhen(true)] out ISortOperationHandler?handler)
{
foreach (ISortOperationHandler sortFieldHandler in _provider.OperationHandlers)
{
if (sortFieldHandler.CanHandle(context, typeDefinition, fieldDefinition))
{
handler = sortFieldHandler;
return(true);
}
}
handler = null;
return(false);
}
public static void RegisterDependencies(
this ITypeDiscoveryContext context,
EnumTypeDefinition definition)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (definition is null)
{
throw new ArgumentNullException(nameof(definition));
}
RegisterAdditionalDependencies(context, definition);
RegisterDirectiveDependencies(context, definition);
RegisterEnumValueDependencies(context, definition.Values);
}
public void InferValuesFromType()
{
// act
var descriptor = EnumTypeDescriptor.New(Context, typeof(FooEnum));
// assert
EnumTypeDefinition description = descriptor.CreateDefinition();
Assert.Collection(description.Values,
t =>
{
Assert.Equal("BAR1", t.Name);
Assert.Equal(FooEnum.Bar1, t.Value);
},
t =>
{
Assert.Equal("BAR2", t.Name);
Assert.Equal(FooEnum.Bar2, t.Value);
});
}
public void ExplicitValueBinding()
{
// arrange
var descriptor = EnumTypeDescriptor.New(Context, typeof(FooEnum));
// act
IEnumTypeDescriptor desc = descriptor;
desc.Item(FooEnum.Bar1).Name("FOOBAR");
desc.BindItems(BindingBehavior.Explicit);
// assert
EnumTypeDefinition description = descriptor.CreateDefinition();
Assert.Collection(description.Values,
t =>
{
Assert.Equal("FOOBAR", t.Name);
Assert.Equal(FooEnum.Bar1, t.Value);
});
}
public static void CollectDependencies(
EnumTypeDefinition definition,
ICollection <TypeDependency> dependencies)
{
if (definition is null)
{
throw new ArgumentNullException(nameof(definition));
}
if (dependencies is null)
{
throw new ArgumentNullException(nameof(dependencies));
}
if (definition.HasDependencies)
{
foreach (TypeDependency dependency in definition.Dependencies)
{
dependencies.Add(dependency);
}
}
foreach (EnumValueDefinition value in definition.Values)
{
if (value.HasDependencies)
{
foreach (TypeDependency dependency in value.Dependencies)
{
dependencies.Add(dependency);
}
}
CollectDirectiveDependencies(value, dependencies);
}
CollectDirectiveDependencies(definition, dependencies);
}
public override bool CanHandle(
ITypeCompletionContext context,
EnumTypeDefinition typeDefinition,
SortEnumValueDefinition valueDefinition) => true;
/// <inheritdoc />
public abstract bool CanHandle(
ITypeCompletionContext context,
EnumTypeDefinition typeDefinition,
SortEnumValueDefinition valueDefinition);
protected internal EnumTypeDescriptor(
IDescriptorContext context,
EnumTypeDefinition definition)
: base(context, definition)
{
}
public EnumTypeContext(EnumTypeDefinition enumTypeDefinition, GraphQLGenerationOptions options, Document document)
{
this.enumTypeDefinition = enumTypeDefinition;
this.options = options;
this.document = document;
}
/// <inheritdoc />
public abstract bool CanHandle(
ITypeDiscoveryContext context,
EnumTypeDefinition typeDefinition,
SortEnumValueDefinition valueDefinition);
public static EnumTypeDescriptor ToDescriptor(
this EnumTypeDefinition definition,
IDescriptorContext context)
=> EnumTypeDescriptor.From(context, definition);
