private void CompleteAbstractTypeResolver(
ICompletionContext context,
ResolveAbstractType resolveAbstractType)
{
if (resolveAbstractType == null)
{
Func <ISchema> schemaResolver = context.GetSchemaResolver();
// if there is no custom type resolver we will use this default
// abstract type resolver.
IReadOnlyCollection <ObjectType> types = null;
_resolveAbstractType = (c, r) =>
{
if (types == null)
{
ISchema schema = schemaResolver.Invoke();
types = schema.GetPossibleTypes(this);
}
foreach (ObjectType type in types)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null);
};
}
else
{
_resolveAbstractType = resolveAbstractType;
}
}
void INeedsInitialization.CompleteType(
ISchemaContext schemaContext, Action <SchemaError> reportError)
{
foreach (Field field in _fieldMap.Values)
{
field.CompleteField(schemaContext, reportError, this);
}
if (_resolveAbstractType == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
List <ObjectType> types = null;
_resolveAbstractType = (c, r) =>
{
if (types == null)
{
types = schemaContext.Types.GetTypes()
.OfType <ObjectType>()
.Where(t => t.Interfaces.ContainsKey(Name))
.ToList();
}
foreach (ObjectType type in types)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
private void CompleteAbstractTypeResolver(
ITypeInitializationContext context)
{
if (_resolveAbstractType == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
IReadOnlyCollection <ObjectType> types = null;
_resolveAbstractType = (c, r) =>
{
if (types == null)
{
types = context.GetPossibleTypes(this);
}
foreach (ObjectType type in types)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
public IUnionTypeDescriptor ResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
Definition.ResolveAbstractType = resolveAbstractType
?? throw new ArgumentNullException(nameof(resolveAbstractType));
return(this);
}
public UnionType()
{
UnionTypeDescriptor descriptor = new UnionTypeDescriptor(GetType());
Configure(descriptor);
if (string.IsNullOrEmpty(descriptor.Name))
{
throw new ArgumentException(
"A union type name must not be null or empty.");
}
if (descriptor.Types == null)
{
throw new ArgumentException(
"A union type must have a set of types.");
}
_typesFactory = r => descriptor.Types
.Select(t => t.TypeFactory(r))
.Cast <ObjectType>();
_typeInfos = descriptor.Types;
_typeResolver = descriptor.ResolveAbstractType;
Name = descriptor.Name;
Description = descriptor.Description;
}
internal UnionType(UnionTypeConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (string.IsNullOrEmpty(config.Name))
{
throw new ArgumentException(
"A union type name must not be null or empty.",
nameof(config));
}
if (config.Types == null)
{
throw new ArgumentException(
"A union type must have a set of types.",
nameof(config));
}
_typesFactory = config.Types;
_typeResolver = config.ResolveAbstractType;
SyntaxNode = config.SyntaxNode;
Name = config.Name;
Description = config.Description;
}
public IInterfaceTypeDescriptor ResolveAbstractType(
ResolveAbstractType typeResolver)
{
Definition.ResolveAbstractType = typeResolver
?? throw new ArgumentNullException(nameof(typeResolver));
return(this);
}
void INeedsInitialization.CompleteType(ISchemaContext schemaContext, Action <SchemaError> reportError)
{
if (_typesFactory == null)
{
reportError(new SchemaError(
"A Union type must define one or more unique member types.",
this));
}
else
{
foreach (ObjectType memberType in _typesFactory(schemaContext.Types))
{
_typeMap[memberType.Name] = memberType;
}
}
if (_typeResolver == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
_typeResolver = (c, r) =>
{
foreach (ObjectType type in _typeMap.Values)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
private void CompleteAbstractTypeResolver(
ITypeRegistry typeRegistry)
{
if (_resolveAbstractType == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
List <ObjectType> types = null;
_resolveAbstractType = (c, r) =>
{
if (types == null)
{
types = typeRegistry.GetTypes()
.OfType <ObjectType>()
.Where(t => t.Interfaces.ContainsKey(Name))
.ToList();
}
foreach (ObjectType type in types)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
private void Initialize(Action <IInterfaceTypeDescriptor> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
InterfaceTypeDescriptor descriptor = CreateDescriptor();
configure(descriptor);
InterfaceTypeDescription description =
descriptor.CreateDescription();
_resolveAbstractType = description.ResolveAbstractType;
SyntaxNode = description.SyntaxNode;
Fields = new FieldCollection <InterfaceField>(
description.Fields.Select(t => new InterfaceField(t)));
Initialize(description.Name, description.Description,
new DirectiveCollection(this,
DirectiveLocation.Interface,
description.Directives));
}
public InterfaceType()
{
InterfaceTypeDescriptor descriptor = new InterfaceTypeDescriptor(GetType());
Configure(descriptor);
if (string.IsNullOrEmpty(descriptor.Name))
{
throw new ArgumentException(
"The type name must not be null or empty.");
}
if (descriptor.Fields.Count == 0)
{
throw new ArgumentException(
$"The interface type `{Name}` has no fields.");
}
foreach (Field field in descriptor.Fields.Select(t => t.CreateField()))
{
_fieldMap[field.Name] = field;
}
_resolveAbstractType = descriptor.ResolveAbstractType;
Name = descriptor.Name;
Description = descriptor.Description;
}
IUnionTypeDescriptor IUnionTypeDescriptor.ResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
if (resolveAbstractType == null)
{
throw new ArgumentNullException(nameof(resolveAbstractType));
}
ResolveAbstractType = resolveAbstractType;
return(this);
}
private void Initialize(Action <IUnionTypeDescriptor> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var descriptor = new UnionTypeDescriptor(GetType());
configure(descriptor);
UnionTypeDescription description = descriptor.CreateDescription();
_types = description.Types;
_resolveAbstractType = description.ResolveAbstractType;
Name = description.Name;
Description = description.Description;
}
internal InterfaceType(InterfaceTypeConfig config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (string.IsNullOrEmpty(config.Name))
{
throw new ArgumentException(
"An interface type name must not be null or empty.",
nameof(config));
}
Field[] fields = config.Fields?.ToArray()
?? Array.Empty <Field>();
if (fields.Length == 0)
{
throw new ArgumentException(
$"The interface type `{Name}` has no fields.",
nameof(config));
}
foreach (Field field in fields)
{
if (_fieldMap.ContainsKey(field.Name))
{
throw new ArgumentException(
$"The field name `{field.Name}` " +
$"is not unique within `{Name}`.",
nameof(config));
}
else
{
_fieldMap.Add(field.Name, field);
}
}
_resolveAbstractType = config.ResolveAbstractType;
SyntaxNode = config.SyntaxNode;
Name = config.Name;
Description = config.Description;
}
private void Initialize(UnionTypeDescriptor descriptor)
{
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
if (string.IsNullOrEmpty(descriptor.Name))
{
throw new ArgumentException(
"A union type name must not be null or empty.");
}
_types = descriptor.Types;
_resolveAbstractType = descriptor.ResolveAbstractType;
Name = descriptor.Name;
Description = descriptor.Description;
}
private void CompleteResolveAbstractType()
{
if (_resolveAbstractType == null)
{
// if there is now custom type resolver we will use this default
// abstract type resolver.
_resolveAbstractType = (c, r) =>
{
foreach (ObjectType type in _typeMap.Values)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null); // todo: should we throw instead?
};
}
}
private void Initialize(InterfaceTypeDescriptor descriptor)
{
if (string.IsNullOrEmpty(descriptor.Name))
{
throw new ArgumentException(
"The type name must not be null or empty.");
}
foreach (Field field in descriptor.Fields
.Select(t => new Field(t)))
{
_fieldMap[field.Name] = field;
}
_resolveAbstractType = descriptor.ResolveAbstractType;
SyntaxNode = descriptor.SyntaxNode;
Name = descriptor.Name;
Description = descriptor.Description;
}
private void Initialize(Action <IUnionTypeDescriptor> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
var descriptor = new UnionTypeDescriptor(GetType());
configure(descriptor);
UnionTypeDescription description = descriptor.CreateDescription();
_types = description.Types;
_resolveAbstractType = description.ResolveAbstractType;
Initialize(description.Name, description.Description,
new DirectiveCollection(this,
DirectiveLocation.Union,
description.Directives));
}
private void CompleteResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
if (resolveAbstractType == null)
{
// if there is no custom type resolver we will use this default
// abstract type resolver.
_resolveAbstractType = (c, r) =>
{
foreach (ObjectType type in _typeMap.Values)
{
if (type.IsOfType(c, r))
{
return(type);
}
}
return(null);
};
}
else
{
_resolveAbstractType = resolveAbstractType;
}
}
public new IInterfaceTypeDescriptor <T> ResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
base.ResolveAbstractType(resolveAbstractType);
return(this);
}
public new IInterfaceTypeDescriptor <T> ResolveAbstractType(
ResolveAbstractType typeResolver)
{
base.ResolveAbstractType(typeResolver);
return(this);
}
protected void ResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
InterfaceDescription.ResolveAbstractType = resolveAbstractType
?? throw new ArgumentNullException(nameof(resolveAbstractType));
}
IInterfaceTypeDescriptor IInterfaceTypeDescriptor.ResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
ResolveAbstractType(resolveAbstractType);
return(this);
}
public void ResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
UnionDescription.ResolveAbstractType = resolveAbstractType
?? throw new ArgumentNullException(nameof(resolveAbstractType));
}
IUnionTypeDescriptor IUnionTypeDescriptor.ResolveAbstractType(
ResolveAbstractType resolveAbstractType)
{
ResolveAbstractType(resolveAbstractType);
return(this);
}