private InterfaceType Interface(__Type type)
{
if (_builder.TryGetType <InterfaceType>(type.Name, out var owner))
{
return(owner);
}
_builder.Interface(type.Name, out owner, type.Description, null);
if (type.Fields != null && type.Fields.Any())
{
_delayedActions.Enqueue(() =>
{
_builder.Connections(connect =>
{
foreach (var field in type.Fields)
{
(string Name, IType Type, object DefaultValue, string Description)[] args = field.Args
.Select(arg => (
arg.Name,
InputType(arg.Type),
(object)arg.DefaultValue,
arg.Description))
.ToArray();
connect.Field(
owner,
field.Name,
OutputType(field.Type),
field.Description,
args: args);
}
});
private InputObjectType InputObject(__Type type)
{
if (_builder.TryGetType <InputObjectType>(type.Name, out var owner))
{
return(owner);
}
_builder.InputObject(type.Name, out owner, type.Description);
if (type.InputFields != null && type.InputFields.Any())
{
_builder.Connections(connect =>
{
foreach (var field in type.InputFields)
{
connect.InputField(
owner,
field.Name,
InputType(field.Type),
field.DefaultValue,
field.Description);
}
});
}
return(owner);
}
private EnumType Enum(__Type type)
{
if (_builder.TryGetType <EnumType>(type.Name, out var enumType))
{
return(enumType);
}
var values =
type.EnumValues
.Select(v => (
v.Name,
v.Description,
default(IEnumerable <DirectiveInstance>),
v.DeprecationReason))
.ToArray();
_builder.Enum(
type.Name,
out enumType,
type.Description,
null,
values);
return(enumType);
}
protected IType OutputType(__Type typeReference)
{
if (typeReference.Kind == __TypeKind.NON_NULL)
{
var innerType = OutputType(typeReference.OfType);
return(innerType != null ? new NonNull(innerType) : null);
}
if (typeReference.Kind == __TypeKind.LIST)
{
var innerType = OutputType(typeReference.OfType);
return(innerType != null ? new List(innerType) : null);
}
var typeName = typeReference.Name;
// is type already known by the builder?
if (_builder.TryGetType <INamedType>(typeName, out var knownType))
{
return(knownType);
}
// get the actual type
var typeDefinition = _schema.Types.Single(t => t.Name == typeReference.Name);
// type is not known so we need to build it
switch (typeDefinition.Kind)
{
case __TypeKind.SCALAR:
return(Scalar(typeDefinition));
case __TypeKind.ENUM:
return(Enum(typeDefinition));
case __TypeKind.OBJECT:
return(Object(typeDefinition));
case __TypeKind.INTERFACE:
return(Interface(typeDefinition));
case __TypeKind.UNION:
return(Union(typeDefinition));
}
return(null);
}
private UnionType Union(__Type type)
{
if (_builder.TryGetType <UnionType>(type.Name, out var unionType))
{
return(unionType);
}
var possibleTypes = type.PossibleTypes?
.Select(possibleType => (ObjectType)OutputType(possibleType))
.ToArray();
_builder.Union(
type.Name,
out unionType,
type.Description,
possibleTypes: possibleTypes);
return(unionType);
}
private EnumType Enum(__Type type)
{
if (_builder.TryGetType <EnumType>(type.Name, out var enumType))
{
return(enumType);
}
_builder.Enum(
type.Name,
out enumType,
type.Description,
values => type.EnumValues
.ForEach(v => values.Value(
v.Name,
v.Description,
Enumerable.Empty <DirectiveInstance>(),
v.DeprecationReason))
);
return(enumType);
}
private InterfaceType Interface(__Type type)
{
if (_builder.TryGetType <InterfaceType>(type.Name, out var owner))
{
return(owner);
}
_builder.Interface(type.Name, out owner, type.Description);
if (type.Fields != null && type.Fields.Any())
{
_delayedActions.Enqueue(() =>
{
_builder.Connections(connect =>
{
foreach (var field in type.Fields)
{
connect.Field(
owner,
field.Name,
OutputType(field.Type),
field.Description,
args: args => field.Args
.ForEach(a => args.Arg(
a.Name,
InputType(a.Type),
a.DefaultValue,
a.Description
)
)
);
}
});
});
}
return(owner);
}
private ObjectType Object(__Type type,
bool isQueryType = false,
bool isMutationType = false,
bool isSubscriptionType = false)
{
if (_builder.TryGetType <ObjectType>(type.Name, out var owner))
{
return(owner);
}
var interfaces = type.Interfaces?.Select(Interface)
.ToList();
if (isQueryType)
{
_builder.Query(
out owner,
type.Description,
interfaces);
}
else if (isMutationType)
{
_builder.Mutation(
out owner,
type.Description,
interfaces);
}
else if (isSubscriptionType)
{
_builder.Subscription(
out owner,
type.Description,
interfaces);
}
else
{
_builder.Object(
type.Name,
out owner,
type.Description,
interfaces);
}
if (type.Fields != null && type.Fields.Any())
{
_delayedActions.Enqueue(() =>
{
_builder.Connections(connect =>
{
foreach (var field in type.Fields)
{
connect.Field(
owner,
field.Name,
OutputType(field.Type),
field.Description,
args: args => field.Args
.ForEach(a => args.Arg(
a.Name,
InputType(a.Type),
a.DefaultValue,
a.Description
)
));
}
});
});
}
return(owner);
}
private IType Scalar(__Type type)
{
_builder.TryGetType <ScalarType>(type.Name, out var scalar);
return(scalar);
}
private IType Scalar(__Type type)
{
// throws if scalar not found
_builder.GetScalar(type.Name, out var scalar);
return(scalar);
}
