public override void OnTypeRegistered(ITypeDiscoveryContext discoveryContext)
{
foreach (ITypeRegistryInterceptor interceptor in _registryInterceptors)
{
interceptor.OnTypeRegistered(discoveryContext);
}
}
public override void OnBeforeRegisterDependencies(
ITypeDiscoveryContext discoveryContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if (definition is FilterInputTypeDefinition def)
{
IFilterConvention convention = GetConvention(
discoveryContext.DescriptorContext,
def.Scope);
SchemaTypeReference typeReference = TypeReference.Create(
discoveryContext.Type,
def.Scope);
var descriptor = FilterInputTypeDescriptor.New(
discoveryContext.DescriptorContext,
def.EntityType,
def.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
FilterInputTypeDefinition extensionDefinition = descriptor.CreateDefinition();
discoveryContext.RegisterDependencies(extensionDefinition);
}
}
protected override ObjectTypeDefinition CreateDefinition(ITypeDiscoveryContext context)
{
SyntaxTypeReference stringType = Create(ScalarNames.String);
SyntaxTypeReference nonNullStringType = Parse($"{ScalarNames.String}!");
SyntaxTypeReference nonNullBooleanType = Parse($"{ScalarNames.Boolean}!");
SyntaxTypeReference argumentListType = Parse($"[{nameof(__InputValue)}!]!");
SyntaxTypeReference locationListType = Parse($"[{nameof(__DirectiveLocation)}!]!");
return(new ObjectTypeDefinition(
Names.__Directive,
TypeResources.Directive_Description,
typeof(DirectiveType))
{
Fields =
{
new(Names.Name, type: nonNullStringType, pureResolver: Resolvers.Name),
new(Names.Description, type: stringType, pureResolver: Resolvers.Description),
new(Names.Locations, type: locationListType, pureResolver: Resolvers.Locations),
new(Names.Args, type: argumentListType, pureResolver: Resolvers.Arguments),
new(Names.IsRepeatable,
type: nonNullBooleanType,
pureResolver: Resolvers.IsRepeatable),
new(Names.OnOperation,
type: nonNullBooleanType,
pureResolver: Resolvers.OnOperation)
{
DeprecationReason = TypeResources.Directive_UseLocation
},
public void OnAfterInitialize(ITypeDiscoveryContext discoveryContext, DefinitionBase?definition, IDictionary <string, object?> contextData)
{
if (definition is T casted)
{
_onAfterInitialize?.Invoke(discoveryContext, casted, contextData);
}
}
public bool CanHandle(
ITypeDiscoveryContext context,
IFilterInputTypeDefinition typeDefinition,
IFilterFieldDefinition fieldDefinition)
{
throw new NotImplementedException();
}
public override bool CanHandle(
ITypeDiscoveryContext context,
EnumTypeDefinition typeDefinition,
SortEnumValueDefinition valueDefinition)
{
return(valueDefinition.Operation == _operation);
}
public override void OnTypeRegistered(ITypeDiscoveryContext discoveryContext)
{
if (ReferenceEquals(_watch, discoveryContext.Type))
{
Count++;
}
}
public override void OnBeforeRegisterDependencies(
ITypeDiscoveryContext discoveryContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
switch (definition)
{
case ObjectTypeDefinition od:
ValidateObjectType(discoveryContext, od);
return;
case InputObjectTypeDefinition ind:
ValidateInputObjectType(discoveryContext, ind);
return;
case InterfaceTypeDefinition id:
ValidateInterfaceType(discoveryContext, id);
return;
case UnionTypeDefinition ud:
ValidateUnionType(discoveryContext, ud);
return;
case DirectiveTypeDefinition ud:
ValidateDirectiveType(discoveryContext, ud);
return;
}
}
public TypeInfo(
ITypeDiscoveryContext context,
IComplexOutputTypeDefinition definition)
{
Context = context;
Definition = definition;
}
public static void RegisterDependencies(
this ITypeDiscoveryContext context,
InputObjectTypeDefinition 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);
foreach (InputFieldDefinition field in definition.Fields)
{
RegisterAdditionalDependencies(context, field);
if (field.Type is not null)
{
context.RegisterDependency(field.Type,
TypeDependencyKind.Default);
}
context.RegisterDependencyRange(
field.GetDirectives().Select(t => t.TypeReference),
TypeDependencyKind.Completed);
}
}
public virtual bool TryCreateScope(
ITypeDiscoveryContext discoveryContext,
[NotNullWhen(true)] out IReadOnlyList <TypeDependency>?typeDependencies)
{
typeDependencies = null;
return(false);
}
public override void OnBeforeRegisterDependencies(
ITypeDiscoveryContext discoveryContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
EnsurePagingSettingsAreLoaded(discoveryContext.DescriptorContext);
EnsureCostSettingsAreLoaded(discoveryContext.DescriptorContext);
if (!_costSettings.Enable)
{
return;
}
// if the cost settings are set to apply default cost we need to ensure that
// object types that we apply defaults to have type dependencies to the
// cost directive.
if (_costSettings.ApplyDefaults &&
!discoveryContext.IsIntrospectionType &&
definition is ObjectTypeDefinition objectDef &&
objectDef.Fields.Any(CanApplyDefaultCost))
{
IExtendedType directive =
discoveryContext.TypeInspector.GetType(typeof(CostDirectiveType));
discoveryContext.Dependencies.Add(new(
TypeReference.Create(directive),
TypeDependencyKind.Completed));
}
}
private static void RegisterAdditionalDependencies(
this ITypeDiscoveryContext context,
DefinitionBase definition)
{
context.RegisterDependencyRange(
definition.Dependencies);
}
internal sealed override void Initialize(ITypeDiscoveryContext context)
{
AssertUninitialized();
OnBeforeInitialize(context);
Scope = context.Scope;
_definition = CreateDefinition(context);
if (_definition is null)
{
throw new InvalidOperationException(
TypeResources.TypeSystemObjectBase_DefinitionIsNull);
}
// if we at this point already know the name we will just commit it.
if (_definition.Name.HasValue)
{
Name = _definition.Name;
}
RegisterConfigurationDependencies(context, _definition);
OnAfterInitialize(context, _definition, _definition.ContextData);
MarkInitialized();
}
protected override void OnRegisterDependencies(
ITypeDiscoveryContext context,
InputObjectTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
SetTypeIdentity(typeof(FilterInputType <>));
}
public override bool CanHandle(
ITypeDiscoveryContext context,
FilterInputTypeDefinition typeDefinition,
FilterFieldDefinition fieldDefinition)
{
return(true);
}
protected override void OnRegisterDependencies(
ITypeDiscoveryContext context,
ObjectTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
context.Dependencies.Add(new(context.TypeInspector.GetTypeRef(typeof(T))));
}
protected override void OnRegisterDependencies(
ITypeDiscoveryContext context,
EnumTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
context.RegisterDependencies(definition);
}
protected override ObjectTypeDefinition CreateDefinition(ITypeDiscoveryContext context)
{
SyntaxTypeReference stringType = Create(ScalarNames.String);
SyntaxTypeReference nonNullStringType = Parse($"{ScalarNames.String}!");
SyntaxTypeReference nonNullTypeType = Parse($"{nameof(__Type)}!");
SyntaxTypeReference appDirectiveListType = Parse($"[{nameof(__AppliedDirective)}!]!");
var def = new ObjectTypeDefinition(
Names.__InputValue,
InputValue_Description,
typeof(IInputField))
{
Fields =
{
new(Names.Name, type: nonNullStringType, pureResolver: Resolvers.Name),
new(Names.Description, type: stringType, pureResolver: Resolvers.Description),
new(Names.Type, type: nonNullTypeType, pureResolver: Resolvers.Type),
new(Names.DefaultValue,
InputValue_DefaultValue,
stringType,
pureResolver: Resolvers.DefaultValue),
}
};
if (context.DescriptorContext.Options.EnableDirectiveIntrospection)
{
def.Fields.Add(new(
Names.AppliedDirectives,
type: appDirectiveListType,
pureResolver: Resolvers.AppliedDirectives));
}
return(def);
}
public static void RegisterDependencies(
this ITypeDiscoveryContext context,
ObjectTypeDefinition definition)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
context.RegisterDependencyRange(
definition.Interfaces,
TypeDependencyKind.Default);
RegisterAdditionalDependencies(context, definition);
RegisterDirectiveDependencies(context, definition);
RegisterFieldDependencies(context, definition.Fields);
foreach (ObjectFieldDefinition field in definition.Fields)
{
if (field.Resolver is null)
{
if (field.ResolverMember is { })
public override bool CanHandle(
ITypeDiscoveryContext context,
FilterInputTypeDefinition typeDefinition,
FilterFieldDefinition fieldDefinition)
{
return(fieldDefinition is FilterOperationFieldDefinition def &&
def.Id == DefaultOperations.Data);
}
protected override void OnRegisterDependencies(
ITypeDiscoveryContext context,
InterfaceTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
context.RegisterDependencies(definition);
SetTypeIdentity(typeof(InterfaceType <>));
}
public override bool CanHandle(
ITypeDiscoveryContext context,
FilterInputTypeDefinition typeDefinition,
FilterFieldDefinition fieldDefinition)
{
return(fieldDefinition is FilterOperationFieldDefinition {
Id : 155
});
private void RegisterDependencies(
ITypeDiscoveryContext context,
DirectiveTypeDefinition definition)
{
context.RegisterDependencyRange(
definition.Arguments.Select(t => t.Type),
TypeDependencyKind.Completed);
}
protected virtual void OnAfterRegisterDependencies(
ITypeDiscoveryContext context,
DefinitionBase definition,
IDictionary <string, object?> contextData)
{
context.TypeInterceptor.OnAfterRegisterDependencies(
context, definition, contextData);
}
protected virtual void OnAfterInitialize(
ITypeDiscoveryContext context,
DefinitionBase definition,
IDictionary <string, object?> contextData)
{
context.TypeInterceptor.OnAfterInitialize(
context, definition, contextData);
}
public override bool CanHandle(
ITypeDiscoveryContext context,
IFilterInputTypeDefinition typeDefinition,
IFilterFieldDefinition fieldDefinition)
{
return(context.Type is IListFilterInput &&
fieldDefinition is FilterOperationFieldDefinition operationField &&
operationField.Id == DefaultOperations.Any);
}
private static void RegisterDirectiveDependencies <T>(
this ITypeDiscoveryContext context,
TypeDefinitionBase <T> definition)
where T : class, ISyntaxNode
{
context.RegisterDependencyRange(
definition.GetDirectives().Select(t => t.TypeReference),
TypeDependencyKind.Completed);
}
protected override EnumTypeDefinition CreateDefinition(
ITypeDiscoveryContext context)
{
var descriptor = EnumTypeDescriptor.New(
context.DescriptorContext);
_configure(descriptor);
return(descriptor.CreateDefinition());
}
public override bool CanHandle(
ITypeDiscoveryContext context,
FilterInputTypeDefinition typeDefinition,
FilterFieldDefinition fieldDefinition)
{
return(context.Type is IEnumOperationInput &&
fieldDefinition is FilterOperationFieldDefinition operationField &&
operationField.Id == Operation);
}
