private static void AddConstructor(
ClassBuilder classBuilder,
IReadOnlyList <OperationArgumentDescriptor> arguments)
{
if (arguments.Count == 0)
{
return;
}
ConstructorBuilder constructorBuilder =
ConstructorBuilder.New()
.SetAccessModifier(AccessModifier.Public);
foreach (OperationArgumentDescriptor argument in arguments.OrderBy(t => t.IsOptional))
{
constructorBuilder.AddParameter(
ParameterBuilder.New()
.SetType(argument.Type)
.SetName(argument.ParameterName)
.SetDefault(condition: argument.IsOptional));
}
constructorBuilder.AddCode(CreateConstructorBody(arguments));
classBuilder.AddConstructor(constructorBuilder);
}
public static ConstructorBuilder AddConstructor(this ClassBuilder builder)
{
var constructorBuilder = ConstructorBuilder.New();
builder.AddConstructor(constructorBuilder);
return(constructorBuilder);
}
protected override void Generate(
CodeWriter writer,
OperationDescriptor descriptor,
out string fileName)
{
var documentName = CreateDocumentTypeName(descriptor.Name);
fileName = documentName;
string operationKind = descriptor switch
{
MutationOperationDescriptor => "Mutation",
QueryOperationDescriptor => "Query",
SubscriptionOperationDescriptor => "Subscription",
_ => throw new ArgumentOutOfRangeException(nameof(descriptor))
};
ClassBuilder classBuilder = ClassBuilder
.New()
.AddImplements(TypeNames.IDocument)
.SetName(fileName);
classBuilder
.AddConstructor()
.SetPrivate();
classBuilder
.AddProperty("Instance")
.SetStatic()
.SetType(documentName)
.SetValue($"new {documentName}()");
classBuilder
.AddProperty("Kind")
.SetType(TypeNames.OperationKind)
.AsLambda($"{TypeNames.OperationKind}.{operationKind}");
classBuilder
.AddProperty("Body")
.SetType(TypeNames.IReadOnlySpan.WithGeneric(TypeNames.Byte))
.AsLambda(GetByteArray(descriptor.BodyString));
classBuilder
.AddMethod("ToString")
.SetPublic()
.SetOverride()
.SetReturnType(TypeNames.String)
.AddCode(MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(TypeNames.EncodingUtf8, nameof(Encoding.UTF8.GetString))
.AddArgument("Body"));
CodeFileBuilder
.New()
.SetNamespace(descriptor.Namespace)
.AddType(classBuilder)
.Build(writer);
}
protected override void Generate(
CodeWriter writer,
NamedTypeDescriptor namedTypeDescriptor,
out string fileName)
{
fileName = namedTypeDescriptor.Name;
ClassBuilder classBuilder = ClassBuilder.New()
.SetName(fileName);
ConstructorBuilder constructorBuilder = ConstructorBuilder.New()
.SetTypeName(fileName)
.SetAccessModifier(AccessModifier.Public);
foreach (var prop in namedTypeDescriptor.Properties)
{
var propTypeBuilder = prop.Type.ToBuilder();
// Add Property to class
var propBuilder = PropertyBuilder
.New()
.SetName(prop.Name)
.SetType(propTypeBuilder)
.SetAccessModifier(AccessModifier.Public);
if (prop.Type.IsNullableType())
{
propBuilder.SetValue("default!");
}
classBuilder.AddProperty(propBuilder);
// Add initialization of property to the constructor
var paramName = prop.Name.WithLowerFirstChar();
ParameterBuilder parameterBuilder = ParameterBuilder.New()
.SetName(paramName)
.SetType(propTypeBuilder);
constructorBuilder.AddParameter(parameterBuilder);
constructorBuilder.AddCode(prop.Name + " = " + paramName + ";");
}
foreach (var implement in namedTypeDescriptor.Implements)
{
classBuilder.AddImplements(implement);
}
classBuilder.AddConstructor(constructorBuilder);
CodeFileBuilder
.New()
.SetNamespace(namedTypeDescriptor.Namespace)
.AddType(classBuilder)
.Build(writer);
}
protected override Task WriteAsync(
CodeWriter writer,
OutputModelDescriptor descriptor)
{
if (writer is null)
{
throw new ArgumentNullException(nameof(writer));
}
if (descriptor is null)
{
throw new ArgumentNullException(nameof(descriptor));
}
ClassBuilder classBuilder =
ClassBuilder.New()
.SetAccessModifier(AccessModifier.Public)
.SetName(descriptor.Name);
ConstructorBuilder constructorBuilder =
ConstructorBuilder.New()
.AddCode(CreateConstructorBody(descriptor));
classBuilder.AddConstructor(constructorBuilder);
foreach (var typeName in descriptor.Implements)
{
classBuilder.AddImplements(typeName);
}
foreach (OutputFieldDescriptor field in descriptor.Fields)
{
classBuilder.AddProperty(
PropertyBuilder.New()
.SetAccessModifier(AccessModifier.Public)
.SetName(field.Name)
.SetType(field.Type));
constructorBuilder.AddParameter(
ParameterBuilder.New()
.SetName(field.ParameterName)
.SetType(field.Type));
}
return(CodeFileBuilder.New()
.SetNamespace(descriptor.Namespace)
.AddType(classBuilder)
.BuildAsync(writer));
}
protected override void Generate(
CodeWriter writer,
ObjectTypeDescriptor namedTypeDescriptor,
out string fileName)
{
fileName = namedTypeDescriptor.RuntimeType.Name;
ClassBuilder classBuilder = ClassBuilder.New()
.SetName(fileName);
ConstructorBuilder constructorBuilder = ConstructorBuilder.New()
.SetTypeName(fileName)
.SetAccessModifier(AccessModifier.Public);
foreach (var prop in namedTypeDescriptor.Properties)
{
var propTypeBuilder = prop.Type.ToBuilder();
// Add Property to class
classBuilder.AddProperty(
prop.Name,
x => x
.SetName(prop.Name)
.SetType(propTypeBuilder)
.SetAccessModifier(AccessModifier.Public)
.SetValue(prop.Type.IsNullableType() ? "default!" : null));
// Add initialization of property to the constructor
var paramName = GetParameterName(prop.Name);
constructorBuilder.AddParameter(paramName, x => x.SetType(propTypeBuilder));
constructorBuilder.AddCode(prop.Name + " = " + paramName + ";");
}
foreach (NameString implement in namedTypeDescriptor.Implements)
{
classBuilder.AddImplements(implement);
}
classBuilder.AddConstructor(constructorBuilder);
CodeFileBuilder
.New()
.SetNamespace(namedTypeDescriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(classBuilder)
.Build(writer);
}
protected override void Generate(
CodeWriter writer,
ObjectTypeDescriptor descriptor,
out string fileName)
{
fileName = descriptor.RuntimeType.Name;
ClassBuilder classBuilder = ClassBuilder
.New()
.SetName(fileName);
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(fileName);
foreach (var prop in descriptor.Properties)
{
TypeReferenceBuilder propTypeBuilder = prop.Type.ToBuilder();
// Add Property to class
classBuilder
.AddProperty(prop.Name)
.SetName(prop.Name)
.SetType(propTypeBuilder)
.SetPublic()
.SetValue(prop.Type.IsNullableType() ? "default!" : null);
// Add initialization of property to the constructor
var paramName = GetParameterName(prop.Name);
constructorBuilder
.AddParameter(paramName, x => x.SetType(propTypeBuilder))
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(prop.Name)
.SetRighthandSide(paramName));
}
classBuilder.AddImplementsRange(descriptor.Implements.Select(x => x.Value));
CodeFileBuilder
.New()
.SetNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(classBuilder)
.Build(writer);
}
protected override void Generate(
CodeWriter writer,
OperationDescriptor operationDescriptor,
out string fileName)
{
fileName = operationDescriptor.Name;
ClassBuilder classBuilder = ClassBuilder
.New()
.SetName(fileName);
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(fileName);
var runtimeTypeName =
operationDescriptor.ResultTypeReference.GetRuntimeType().Name;
AddConstructorAssignedField(
TypeNames.IOperationExecutor.WithGeneric(runtimeTypeName),
_operationExecutor,
classBuilder,
constructorBuilder);
AddInjectedSerializers(operationDescriptor, constructorBuilder, classBuilder);
if (operationDescriptor is not SubscriptionOperationDescriptor)
{
classBuilder.AddMethod(CreateExecuteMethod(operationDescriptor, runtimeTypeName));
}
classBuilder.AddMethod(CreateWatchMethod(operationDescriptor, runtimeTypeName));
classBuilder.AddMethod(CreateRequestMethod(operationDescriptor));
AddFormatMethods(operationDescriptor, classBuilder);
CodeFileBuilder
.New()
.SetNamespace(operationDescriptor.Namespace)
.AddType(classBuilder)
.Build(writer);
}
private void AddConstructor(
ClassBuilder classBuilder,
IReadOnlyList <ValueSerializerDescriptor> serializers,
string indent)
{
foreach (ValueSerializerDescriptor serializer in serializers)
{
classBuilder.AddField(
FieldBuilder.New()
.SetType(Types.IValueSerializer)
.SetName(serializer.FieldName));
}
classBuilder.AddConstructor(
ConstructorBuilder.New()
.SetAccessModifier(AccessModifier.Public)
.AddParameter(ParameterBuilder.New()
.SetType(Types.IValueSerializerCollection)
.SetName("serializerResolver"))
.AddCode(CreateConstructorBody(serializers, indent)));
}
protected override void Generate(
CodeWriter writer,
ClientDescriptor descriptor,
out string fileName)
{
fileName = descriptor.Name;
ClassBuilder classBuilder = ClassBuilder
.New()
.SetName(fileName);
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(fileName);
foreach (OperationDescriptor operation in descriptor.Operations)
{
AddConstructorAssignedField(
operation.Name,
GetFieldName(operation.Name),
classBuilder,
constructorBuilder);
classBuilder
.AddProperty(operation.Name)
.SetPublic()
.SetType(operation.Name)
.AsLambda(GetFieldName(operation.Name));
}
CodeFileBuilder
.New()
.SetNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(classBuilder)
.Build(writer);
}
protected override void Generate(
CodeWriter writer,
DataTypeDescriptor descriptor,
out string fileName)
{
fileName = descriptor.RuntimeType.Name;
AbstractTypeBuilder typeBuilder;
ConstructorBuilder? constructorBuilder = null;
if (descriptor.IsInterface)
{
typeBuilder = InterfaceBuilder
.New()
.SetName(fileName);
typeBuilder
.AddProperty(__typename)
.SetType(TypeNames.String);
}
else
{
ClassBuilder classBuilder = ClassBuilder
.New()
.SetName(fileName);
typeBuilder = classBuilder;
classBuilder
.AddProperty(__typename)
.SetPublic()
.SetType(TypeNames.String);
constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(fileName);
constructorBuilder
.AddParameter(_typename)
.SetType(TypeNames.String)
.SetName(_typename);
constructorBuilder
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide(__typename)
.SetRighthandSide(_typename)
.AssertNonNull());
}
// Add Properties to class
foreach (PropertyDescriptor property in descriptor.Properties)
{
TypeReferenceBuilder propertyType = property.Type.Kind switch
{
TypeKind.LeafType => property.Type.ToBuilder(),
TypeKind.DataType => property.Type.ToBuilder(property.Type.Name),
TypeKind.EntityType => property.Type.ToEntityIdBuilder(),
_ => throw new ArgumentOutOfRangeException()
};
typeBuilder
.AddProperty(property.Name)
.SetType(propertyType)
.SetPublic();
var parameterName = GetParameterName(property.Name);
constructorBuilder?
.AddParameter(parameterName)
.SetType(propertyType)
.SetDefault("null");
constructorBuilder?
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(property.Name)
.SetRighthandSide(parameterName));
}
// implement interfaces
typeBuilder.AddImplementsRange(descriptor.Implements.Select(CreateDataTypeName));
CodeFileBuilder
.New()
.SetNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(typeBuilder)
.Build(writer);
}
}
protected override void Generate(
CodeWriter writer,
ITypeDescriptor typeDescriptor,
out string fileName)
{
ComplexTypeDescriptor complexTypeDescriptor =
typeDescriptor as ComplexTypeDescriptor ??
throw new InvalidOperationException(
"A result entity mapper can only be generated for complex types");
var className = CreateResultInfoName(complexTypeDescriptor.RuntimeType.Name);
fileName = className;
ClassBuilder classBuilder = ClassBuilder
.New()
.AddImplements(TypeNames.IOperationResultDataInfo)
.SetName(fileName);
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(complexTypeDescriptor.RuntimeType.Name);
foreach (var prop in complexTypeDescriptor.Properties)
{
TypeReferenceBuilder propTypeBuilder = prop.Type.ToEntityIdBuilder();
// Add Property to class
classBuilder
.AddProperty(prop.Name)
.SetType(propTypeBuilder)
.SetPublic();
// Add initialization of property to the constructor
var paramName = GetParameterName(prop.Name);
constructorBuilder.AddParameter(paramName).SetType(propTypeBuilder);
constructorBuilder.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide(prop.Name)
.SetRighthandSide(paramName));
}
classBuilder
.AddProperty("EntityIds")
.SetType(TypeNames.IReadOnlyCollection.WithGeneric(TypeNames.EntityId))
.AsLambda(_entityIds);
classBuilder
.AddProperty("Version")
.SetType(TypeNames.UInt64)
.AsLambda(_version);
AddConstructorAssignedField(
TypeNames.IReadOnlyCollection.WithGeneric(TypeNames.EntityId),
_entityIds,
classBuilder,
constructorBuilder);
AddConstructorAssignedField(
TypeNames.UInt64,
_version,
classBuilder,
constructorBuilder,
true);
// WithVersion
const string version = nameof(version);
classBuilder
.AddMethod("WithVersion")
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(TypeNames.IOperationResultDataInfo)
.AddParameter(version, x => x.SetType(TypeNames.UInt64))
.AddCode(MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(className)
.AddArgumentRange(
complexTypeDescriptor.Properties.Select(x => x.Name.Value))
.AddArgument(_entityIds)
.AddArgument(version));
CodeFileBuilder
.New()
.SetNamespace(complexTypeDescriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(classBuilder)
.Build(writer);
}
protected override void Generate(
CodeWriter writer,
ResultBuilderDescriptor resultBuilderDescriptor,
out string fileName)
{
InterfaceTypeDescriptor resultTypeDescriptor =
resultBuilderDescriptor.ResultNamedType as InterfaceTypeDescriptor
?? throw new InvalidOperationException(
"A result type can only be generated for complex types");
fileName = resultBuilderDescriptor.RuntimeType.Name;
ClassBuilder classBuilder = ClassBuilder
.New()
.SetName(fileName);
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(fileName);
classBuilder
.AddImplements(
TypeNames.IOperationResultBuilder.WithGeneric(
TypeNames.JsonDocument,
resultTypeDescriptor.RuntimeType.Name));
AddConstructorAssignedField(
TypeNames.IEntityStore,
_entityStore,
classBuilder,
constructorBuilder);
AddConstructorAssignedField(
TypeNames.Func.WithGeneric(TypeNames.JsonElement, TypeNames.EntityId),
_extractId,
classBuilder,
constructorBuilder);
AddConstructorAssignedField(
TypeNames.IOperationResultDataFactory
.WithGeneric(resultTypeDescriptor.RuntimeType.Name),
_resultDataFactory,
classBuilder,
constructorBuilder);
constructorBuilder
.AddParameter(_serializerResolver)
.SetType(TypeNames.ISerializerResolver);
IEnumerable <ValueParserDescriptor> valueParsers = resultBuilderDescriptor
.ValueParsers
.GroupBy(t => t.Name)
.Select(t => t.First());
foreach (ValueParserDescriptor valueParser in valueParsers)
{
var parserFieldName = $"{GetFieldName(valueParser.Name)}Parser";
classBuilder
.AddField(parserFieldName)
.SetReadOnly()
.SetType(
TypeNames.ILeafValueParser
.WithGeneric(valueParser.SerializedType, valueParser.RuntimeType));
MethodCallBuilder getLeaveValueParser = MethodCallBuilder
.Inline()
.SetMethodName(
_serializerResolver,
nameof(ISerializerResolver.GetLeafValueParser))
.AddGeneric(valueParser.SerializedType.ToString())
.AddGeneric(valueParser.RuntimeType.ToString())
.AddArgument(valueParser.Name.AsStringToken());
constructorBuilder.AddCode(
AssignmentBuilder
.New()
.SetAssertNonNull()
.SetAssertException(
ExceptionBuilder
.Inline(TypeNames.ArgumentException)
.AddArgument(
$"\"No serializer for type `{valueParser.Name}` found.\""))
.SetLefthandSide(parserFieldName)
.SetRighthandSide(getLeaveValueParser));
}
AddBuildMethod(resultTypeDescriptor, classBuilder);
AddBuildDataMethod(resultTypeDescriptor, classBuilder);
var processed = new HashSet <string>();
AddRequiredDeserializeMethods(resultTypeDescriptor, classBuilder, processed);
CodeFileBuilder
.New()
.SetNamespace(resultTypeDescriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(classBuilder)
.Build(writer);
}
protected override void Generate(
CodeWriter writer,
ITypeDescriptor typeDescriptor,
out string fileName)
{
ComplexTypeDescriptor descriptor =
typeDescriptor as ComplexTypeDescriptor ??
throw new InvalidOperationException(
"A result data factory can only be generated for complex types");
fileName = CreateResultFactoryName(descriptor.RuntimeType.Name);
ClassBuilder classBuilder =
ClassBuilder
.New()
.SetName(fileName)
.AddImplements(
TypeNames.IOperationResultDataFactory
.WithGeneric(descriptor.RuntimeType.Name));
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(descriptor.Name);
AddConstructorAssignedField(
TypeNames.IEntityStore,
_entityStore,
classBuilder,
constructorBuilder);
MethodCallBuilder returnStatement = MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(descriptor.RuntimeType.Name);
foreach (PropertyDescriptor property in descriptor.Properties)
{
returnStatement
.AddArgument(BuildMapMethodCall(_info, property));
}
IfBuilder ifHasCorrectType = IfBuilder
.New()
.SetCondition(
$"{_dataInfo} is {CreateResultInfoName(descriptor.RuntimeType.Name)} {_info}")
.AddCode(returnStatement);
classBuilder
.AddMethod("Create")
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(descriptor.RuntimeType.Name)
.AddParameter(_dataInfo, b => b.SetType(TypeNames.IOperationResultDataInfo))
.AddCode(ifHasCorrectType)
.AddEmptyLine()
.AddCode(
ExceptionBuilder
.New(TypeNames.ArgumentException)
.AddArgument(
$"\"{CreateResultInfoName(descriptor.RuntimeType.Name)} expected.\""));
var processed = new HashSet <string>();
AddRequiredMapMethods(
_info,
descriptor,
classBuilder,
constructorBuilder,
processed,
true);
CodeFileBuilder
.New()
.SetNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(classBuilder)
.Build(writer);
}
protected override void Generate(
CodeWriter writer,
ITypeDescriptor typeDescriptor,
out string fileName)
{
// Setup class
ComplexTypeDescriptor descriptor =
typeDescriptor as ComplexTypeDescriptor ??
throw new InvalidOperationException(
"A result entity mapper can only be generated for complex types");
fileName = descriptor.ExtractMapperName();
ClassBuilder classBuilder = ClassBuilder
.New()
.AddImplements(
TypeNames.IEntityMapper
.WithGeneric(descriptor.ExtractTypeName(), descriptor.RuntimeType.Name))
.SetName(fileName);
ConstructorBuilder constructorBuilder = ConstructorBuilder
.New()
.SetTypeName(descriptor.Name);
if (descriptor.ContainsEntity())
{
AddConstructorAssignedField(
TypeNames.IEntityStore,
StoreFieldName,
classBuilder,
constructorBuilder);
}
// Define map method
MethodBuilder mapMethod = MethodBuilder
.New()
.SetName(_map)
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(descriptor.RuntimeType.Name)
.AddParameter(
ParameterBuilder
.New()
.SetType(
descriptor.Kind == TypeKind.EntityType
? CreateEntityTypeName(descriptor.Name)
: descriptor.Name)
.SetName(_entity));
MethodCallBuilder constructorCall =
MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(descriptor.RuntimeType.Name);
if (typeDescriptor is ComplexTypeDescriptor complexTypeDescriptor)
{
foreach (PropertyDescriptor property in complexTypeDescriptor.Properties)
{
constructorCall.AddArgument(BuildMapMethodCall(_entity, property));
}
}
mapMethod.AddCode(constructorCall);
if (constructorBuilder.HasParameters())
{
classBuilder.AddConstructor(constructorBuilder);
}
classBuilder.AddMethod(mapMethod);
AddRequiredMapMethods(
_entity,
descriptor,
classBuilder,
constructorBuilder,
new HashSet <string>());
CodeFileBuilder
.New()
.SetNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal)
.AddType(classBuilder)
.Build(writer);
}
