/// <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);