public Type GetSerializationType(IType type)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
INamedType namedType = type.NamedType();
if (!namedType.IsLeafType())
{
throw new ArgumentException("Only leaf types are allowed.", nameof(type));
}
if (namedType.IsEnumType())
{
return(typeof(string));
}
if (!_leafTypes.TryGetValue(namedType.Name, out LeafTypeInfo? typeInfo))
{
throw new NotSupportedException(
$"Leaf type `{namedType.Name}` is not supported.");
}
return(typeInfo.SerializationType);
}
private static void AddInputTypeProperties(
Dictionary <NameString, InputTypeDescriptorModel> typeDescriptors,
Dictionary <NameString, INamedTypeDescriptor> leafTypeDescriptors)
{
foreach (InputTypeDescriptorModel typeDescriptorModel in typeDescriptors.Values)
{
var properties = new List <PropertyDescriptor>();
foreach (var field in typeDescriptorModel.Model.Fields)
{
INamedTypeDescriptor?fieldType;
INamedType namedType = field.Type.NamedType();
if (namedType.IsScalarType() || namedType.IsEnumType())
{
fieldType = leafTypeDescriptors[namedType.Name];
}
else
{
fieldType = GetInputTypeDescriptor(
field.Type.NamedType(),
typeDescriptors);
}
properties.Add(
new PropertyDescriptor(
field.Name,
BuildFieldType(
field.Type,
fieldType)));
}
typeDescriptorModel.Descriptor.CompleteProperties(properties);
}
}
public ITypeInfo GetTypeInfo(IType fieldType, bool readOnly)
{
INamedType namedType = fieldType.NamedType();
if (namedType.IsEnumType())
{
var typeInfo = new TypeInfo
(
BuildType(namedType.Name, fieldType, readOnly, true),
namedType.Name,
typeof(string),
fieldType
);
BuildTypeInfo(true, fieldType, true, readOnly, typeInfo);
return(typeInfo);
}
if (namedType.IsScalarType())
{
if (!_leafTypes.TryGetValue(namedType.Name, out LeafTypeInfo? type))
{
throw new NotSupportedException(
$"Leaf type `{namedType.Name}` is not supported.");
}
var typeInfo = new TypeInfo
(
BuildType(type.ClrType, fieldType, readOnly),
namedType.Name,
type.SerializationType,
fieldType
);
BuildTypeInfo(type.ClrType, fieldType, readOnly, typeInfo);
return(typeInfo);
}
throw new NotSupportedException(
"Type infos are only supported for leaf types.");
}
protected override void VisitField(FieldNode node, object?context)
{
IType currentType = _typeContext.Peek();
if (currentType is IComplexOutputType complexType &&
complexType.Fields.TryGetField(
node.Name.Value, out IOutputField field))
{
INamedType fieldType = field.Type.NamedType();
if (fieldType.IsEnumType())
{
_enumTypes.Add(fieldType);
}
_typeContext.Push(fieldType);
_fieldContext.Push(field);
base.VisitField(node, context);
_fieldContext.Pop();
_typeContext.Pop();
}
}
private static void AddProperties(
ClientModel model,
IMapperContext context,
Dictionary <NameString, TypeDescriptorModel> typeDescriptors,
Dictionary <NameString, NamedTypeDescriptor> scalarTypeDescriptors)
{
foreach (TypeDescriptorModel typeDescriptorModel in typeDescriptors.Values.ToList())
{
var properties = new List <PropertyDescriptor>();
foreach (var field in typeDescriptorModel.TypeModel.Fields)
{
NamedTypeDescriptor?fieldType;
INamedType namedType = field.Type.NamedType();
if (namedType.IsScalarType())
{
var scalarType = (ScalarType)namedType;
if (!scalarTypeDescriptors.TryGetValue(
scalarType.Name,
out fieldType))
{
string[] runtimeTypeName = scalarType.GetRuntimeType().Split('.');
fieldType = new NamedTypeDescriptor(
runtimeTypeName.Last(),
string.Join(
".",
runtimeTypeName.Take(runtimeTypeName.Length - 1)),
false,
graphQLTypeName: scalarType.Name,
kind: TypeKind.LeafType);
scalarTypeDescriptors.Add(
scalarType.Name,
fieldType);
}
}
else if (namedType.IsEnumType())
{
var enumTypeModel = model.LeafTypes
.OfType <EnumTypeModel>()
.First(t => t.Type == namedType);
if (!scalarTypeDescriptors.TryGetValue(
namedType.Name,
out fieldType))
{
fieldType = new NamedTypeDescriptor(
enumTypeModel.Name,
context.Namespace,
false,
graphQLTypeName: namedType.Name,
serializationType: enumTypeModel.Type.GetSerializationType(),
kind: TypeKind.LeafType,
isEnum: true);
scalarTypeDescriptors.Add(
enumTypeModel.Name,
fieldType);
}
}
else
{
fieldType = GetFieldTypeDescriptor(
model,
field.SyntaxNode,
field.Type.NamedType(),
typeDescriptors);
}
properties.Add(
new PropertyDescriptor(
field.Name,
BuildFieldType(
field.Type,
fieldType)));
}
typeDescriptorModel.NamedTypeDescriptor.Complete(properties);
}
}