protected virtual IEnumerable <MemberDeclarationSyntax> GenerateHeaderProperties()
{
var nameFormatter = Context.NameFormatterSelector.GetFormatter(NameKind.Property);
foreach (var header in Element.GetHeaders())
{
ILocatedOpenApiElement <OpenApiSchema> schemaElement = header.GetSchemaOrDefault();
ITypeGenerator schemaGenerator = Context.SchemaGeneratorRegistry.Get(schemaElement);
yield return(PropertyDeclaration(schemaGenerator.TypeName, nameFormatter.Format(header.Key))
.AddElementAnnotation(header, Context.ElementRegistry)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddAccessorListAccessors(
AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)),
AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken))));
if (schemaElement.Element.Reference == null)
{
foreach (var memberDeclaration in schemaGenerator.Generate())
{
yield return(memberDeclaration);
}
}
}
}
protected virtual StatementSyntax GenerateRequestMessageVariable(
ILocatedOpenApiElement <OpenApiOperation> operation) =>
MethodHelpers.LocalVariableDeclarationWithInitializer(RequestMessageVariableName,
ObjectCreationExpression(WellKnownTypes.System.Net.Http.HttpRequestMessage.Name)
.AddArgumentListArguments(
Argument(GetRequestMethod(operation)),
Argument(BuildUriMethodGenerator.InvokeBuildUri(ThisExpression()))));
protected virtual IEnumerable <StatementSyntax> GenerateStatements(
ILocatedOpenApiElement <OpenApiOperation> operation)
{
var requestBody = operation.GetRequestBody();
ILocatedOpenApiElement <OpenApiMediaType>?mediaType;
if (requestBody == null || (mediaType = MediaTypeSelector.Select(requestBody)) == null)
{
yield return(ReturnStatement(LiteralExpression(SyntaxKind.NullLiteralExpression)));
yield break;
}
var createContentExpression =
InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SerializationNamespace.TypeSerializerRegistryExtensions,
IdentifierName("Serialize")))
.AddArgumentListArguments(
Argument(IdentifierName(TypeSerializerRegistryParameterName)),
Argument(IdentifierName(RequestTypeGenerator.BodyPropertyName)),
Argument(SyntaxHelpers.StringLiteral(mediaType.Key)));
yield return(ReturnStatement(ConditionalExpression(
IsPatternExpression(
IdentifierName(RequestTypeGenerator.BodyPropertyName),
ConstantPattern(LiteralExpression(SyntaxKind.NullLiteralExpression))),
LiteralExpression(SyntaxKind.NullLiteralExpression),
createContentExpression)));
}
public RequestBodyTypeGenerator(ILocatedOpenApiElement <OpenApiRequestBody> requestBodyElement,
GenerationContext context, IMediaTypeSelector mediaTypeSelector)
{
RequestBodyElement = requestBodyElement ?? throw new ArgumentNullException(nameof(requestBodyElement));
Context = context ?? throw new ArgumentNullException(nameof(context));
MediaTypeSelector = mediaTypeSelector ?? throw new ArgumentNullException(nameof(mediaTypeSelector));
}
protected virtual EnumMemberDeclarationSyntax?CreateEnumMember(
ILocatedOpenApiElement <OpenApiSchema> schemaElement,
IOpenApiAny value,
INameFormatter nameFormatter,
NamingContext namingContext)
{
if (value.AnyType != AnyType.Primitive)
{
return(null);
}
var primitive = (IOpenApiPrimitive)value;
if (primitive.PrimitiveType != PrimitiveType.String)
{
return(null);
}
var stringPrimitive = (OpenApiPrimitive <string>)primitive;
string memberName = namingContext.RegisterName(nameFormatter.Format(stringPrimitive.Value));
return(SyntaxFactory.EnumMemberDeclaration(memberName)
.AddAttributeLists(SyntaxFactory.AttributeList().AddAttributes(
CreateEnumMemberAttribute(stringPrimitive.Value))));
}
public MethodDeclarationSyntax?Generate(ILocatedOpenApiElement <OpenApiResponse> response)
{
if (response.Element.Content == null)
{
return(null);
}
ILocatedOpenApiElement <OpenApiMediaType>?mediaType = MediaTypeSelector.Select(response);
ILocatedOpenApiElement <OpenApiSchema>? schema = mediaType?.GetSchema();
if (schema == null)
{
return(null);
}
ITypeGenerator schemaGenerator = Context.SchemaGeneratorRegistry.Get(schema);
TypeSyntax returnType = schemaGenerator.TypeName;
return(MethodDeclaration(
WellKnownTypes.System.Threading.Tasks.ValueTaskT.Name(returnType),
GetBodyMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.AsyncKeyword))
.WithBody(Block(GenerateStatements(response, returnType))));
}
private IEnumerable <MethodDeclarationSyntax> GenerateExtensions(
ILocatedOpenApiElement <OpenApiResponses> responseSet)
{
var nameFormatter = _context.NameFormatterSelector.GetFormatter(NameKind.Method);
TypeSyntax interfaceTypeName = _context.TypeGeneratorRegistry.Get(responseSet).TypeInfo.Name;
foreach (var response in responseSet.GetResponses())
{
string responseCode = Enum.TryParse <HttpStatusCode>(response.Key, out var statusCode)
? _httpResponseCodeNameProvider.GetName(statusCode)
: response.Key;
TypeSyntax typeName = _context.TypeGeneratorRegistry.Get(response).TypeInfo.Name;
yield return(MethodDeclaration(typeName, nameFormatter.Format("As-" + responseCode))
.AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
Parameter(Identifier("response"))
.WithType(interfaceTypeName)
.AddModifiers(Token(SyntaxKind.ThisKeyword)))
.WithExpressionBody(ArrowExpressionClause(
BinaryExpression(SyntaxKind.CoalesceExpression,
BinaryExpression(SyntaxKind.AsExpression,
IdentifierName("response"),
typeName),
ThrowExpression(ObjectCreationExpression(_responsesNamespace.StatusCodeMismatchException)
.AddArgumentListArguments(
Argument(IdentifierName("response")),
Argument(TypeOfExpression(typeName))))))));
}
}
public MethodDeclarationSyntax GenerateHeader(ILocatedOpenApiElement <OpenApiOperation> operation) =>
MethodDeclaration(
PredefinedType(Token(SyntaxKind.VoidKeyword)),
AddHeadersMethodName)
.AddParameterListParameters(
Parameter(Identifier(RequestMessageParameterName))
.WithType(WellKnownTypes.System.Net.Http.HttpRequestMessage.Name));
public static IEnumerable <ILocatedOpenApiElement <OpenApiSchema> > GetAllSchemas(
this ILocatedOpenApiElement <OpenApiOperation> operation)
{
var requestBody = operation.GetRequestBody();
if (requestBody is not null && !requestBody.IsReference())
{
var requestSchemas = requestBody
.GetMediaTypes()
.Select(p => p.GetSchema())
.Where(p => p is not null && !p.IsReference())
.SelectMany(p => p !.GetAllSchemas());
foreach (var schema in requestSchemas)
{
yield return(schema);
}
}
foreach (var responseSchema in operation
.GetResponseSet()
.GetResponses()
.Where(p => !p.IsReference())
.GetAllSchemas())
{
yield return(responseSchema);
}
}
public OpenApiEnrichmentContext(CSharpCompilation compilation, SyntaxTree syntaxTree,
ILocatedOpenApiElement <TElement> locatedElement)
{
Compilation = compilation ?? throw new ArgumentNullException(nameof(compilation));
SyntaxTree = syntaxTree ?? throw new ArgumentNullException(nameof(syntaxTree));
LocatedElement = locatedElement ?? throw new ArgumentNullException(nameof(locatedElement));
}
protected virtual PropertyDeclarationSyntax CreatePropertyDeclaration <T>(ILocatedOpenApiElement <T> parameter, string className,
ILocatedOpenApiElement <OpenApiSchema> schema, string?nameOverride = null)
where T : IOpenApiElement
{
string propertyName = Context.NameFormatterSelector.GetFormatter(NameKind.Property).Format(
nameOverride ?? parameter.Key);
if (propertyName == className)
{
// Properties can't have the same name as the class/interface
propertyName += "Value";
}
var typeName = Context.TypeNameProvider.GetName(schema);
var propertyDeclaration = PropertyDeclaration(typeName, propertyName)
.AddElementAnnotation(parameter, Context.ElementRegistry)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddAccessorListAccessors(
AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)),
AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
return(propertyDeclaration);
}
public MethodDeclarationSyntax GenerateHeader(ILocatedOpenApiElement <OpenApiOperation> operation) =>
MethodDeclaration(
WellKnownTypes.System.Net.Http.HttpRequestMessage.Name,
BuildRequestMethodName)
.AddParameterListParameters(
Parameter(Identifier(TypeSerializerRegistryParameterName))
.WithType(SerializationNamespace.ITypeSerializerRegistry));
public IEnumerable <BaseMethodDeclarationSyntax> Generate(ILocatedOpenApiElement <OpenApiResponse> response, string className)
{
if (!response.IsRoot() && response.Element.Reference != null)
{
// Do not generator for responses within operations that are references to components, these will inherit
// their get body method from the component base class
yield break;
}
if (response.Element.Content == null)
{
yield break;
}
ILocatedOpenApiElement <OpenApiMediaType>?mediaType = MediaTypeSelector.Select(response);
ILocatedOpenApiElement <OpenApiSchema>? schema = mediaType?.GetSchema();
if (schema == null)
{
yield break;
}
ITypeGenerator schemaGenerator = Context.TypeGeneratorRegistry.Get(schema);
TypeSyntax returnType = schemaGenerator.TypeInfo.Name;
yield return(MethodDeclaration(
WellKnownTypes.System.Threading.Tasks.ValueTaskT.Name(returnType),
GetBodyMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.AsyncKeyword))
.WithBody(Block(GenerateStatements(response, returnType))));
}
public MethodDeclarationSyntax Generate(ILocatedOpenApiElement <OpenApiOperation> operation)
{
var propertyNameFormatter = Context.NameFormatterSelector.GetFormatter(NameKind.Property);
var path = (LocatedOpenApiElement <OpenApiPathItem>)operation.Parent !;
ExpressionSyntax pathExpression = PathParser.Parse(path.Key).ToInterpolatedStringExpression(
pathSegment =>
{
OpenApiParameter?parameter = operation.Element.Parameters.FirstOrDefault(
p => p.Name == pathSegment.Value);
if (parameter == null)
{
throw new InvalidOperationException(
$"Missing path parameter '{pathSegment.Value}' in operation '{operation.Element.OperationId}'.");
}
return(InvocationExpression(MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
SerializationNamespace.PathSegmentSerializerInstance,
IdentifierName("Serialize")))
.AddArgumentListArguments(
Argument(SyntaxHelpers.StringLiteral(pathSegment.Value)),
Argument(IdentifierName(propertyNameFormatter.Format(pathSegment.Value))),
Argument(GetStyleExpression(parameter)),
Argument(GetExplodeExpression(parameter))));
});
OpenApiParameter[] queryParameters = operation.Element.Parameters
.Where(p => (p.In ?? ParameterLocation.Query) == ParameterLocation.Query)
.ToArray();
if (queryParameters.Length > 0)
{
NameSyntax keyValuePairType = WellKnownTypes.System.Collections.Generic.KeyValuePair.Name(
PredefinedType(Token(SyntaxKind.StringKeyword)),
PredefinedType(Token(SyntaxKind.ObjectKeyword)));
ExpressionSyntax buildArrayExpression = ArrayCreationExpression(
ArrayType(keyValuePairType)
.AddRankSpecifiers(ArrayRankSpecifier().AddSizes(OmittedArraySizeExpression())))
.WithInitializer(InitializerExpression(SyntaxKind.ArrayInitializerExpression,
SeparatedList <ExpressionSyntax>(queryParameters
.Select(parameter => ObjectCreationExpression(keyValuePairType)
.AddArgumentListArguments(
Argument(SyntaxHelpers.StringLiteral(parameter.Name)),
Argument(IdentifierName(propertyNameFormatter.Format(parameter.Name))))))));
pathExpression = WellKnownTypes.Yardarm.Client.OperationHelpers.AddQueryParameters(
pathExpression, buildArrayExpression);
}
return(MethodDeclaration(
PredefinedType(Token(SyntaxKind.StringKeyword)),
BuildUriMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithExpressionBody(ArrowExpressionClause(
pathExpression)));
}
public override IEnumerable <MemberDeclarationSyntax> Generate()
{
ILocatedOpenApiElement <OpenApiSchema> itemSchema = GetItemSchema();
return(itemSchema.Element.Reference is null
? Context.TypeGeneratorRegistry.Get(itemSchema).Generate()
: Enumerable.Empty <MemberDeclarationSyntax>());
}
public UnknownResponseTypeGenerator(ILocatedOpenApiElement <OpenApiUnknownResponse> responseElement, GenerationContext context,
ISerializationNamespace serializationNamespace,
IResponsesNamespace responsesNamespace)
: base(responseElement, context)
{
SerializationNamespace = serializationNamespace ?? throw new ArgumentNullException(nameof(serializationNamespace));
ResponsesNamespace = responsesNamespace ?? throw new ArgumentNullException(nameof(responsesNamespace));
}
public ResponseSetTypeGenerator(ILocatedOpenApiElement <OpenApiResponses> element, GenerationContext context,
IResponsesNamespace responsesNamespace)
: base(element, context)
{
ResponsesNamespace = responsesNamespace ?? throw new ArgumentNullException(nameof(responsesNamespace));
Operation = element.Parent?.Element as OpenApiOperation ?? throw new ArgumentException("Parent must be an OpenApiOperation", nameof(element));
}
public SerializerDescriptorWithPriority?Select(ILocatedOpenApiElement <OpenApiMediaType> mediaType)
{
if (_descriptors.TryGetValue(mediaType.Key, out SerializerDescriptorWithPriority descriptor))
{
return(descriptor);
}
return(null);
}
public MethodDeclarationSyntax Generate(ILocatedOpenApiElement <OpenApiOperation> operation) =>
MethodDeclaration(
NullableType(WellKnownTypes.System.Net.Http.HttpContent.Name),
BuildContentMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddParameterListParameters(
Parameter(Identifier(TypeSerializerRegistryParameterName))
.WithType(SerializationNamespace.ITypeSerializerRegistry))
.WithBody(Block(GenerateStatements(operation)));
public IEnumerable <BaseTypeSyntax> GetBaseTypes(ILocatedOpenApiElement <OpenApiSchema> schema)
{
if (!_inheritance.TryGetValue(schema, out var list))
{
return(Enumerable.Empty <BaseTypeSyntax>());
}
return(list);
}
public ITypeGenerator Create(ILocatedOpenApiElement <OpenApiSecurityScheme> element)
{
return(element.Element.Type switch
{
SecuritySchemeType.Http => element.Element.Scheme switch
{
"bearer" => new BearerSecuritySchemeTypeGenerator(element, _context, _authenticationNamespace),
_ => new NoopSecuritySchemeTypeGenerator(element, _context, _authenticationNamespace, _logger)
},
public static IEnumerable <ILocatedOpenApiElement> Parents(this ILocatedOpenApiElement element)
{
var current = element;
while (current.Parent != null)
{
current = current.Parent;
yield return(current);
}
}
private ClassDeclarationSyntax GenerateExtensionClass(ILocatedOpenApiElement <OpenApiResponses> responseSet)
{
var operation = (ILocatedOpenApiElement <OpenApiOperation>)responseSet.Parent !;
var nameFormatter = _context.NameFormatterSelector.GetFormatter(NameKind.Class);
return(ClassDeclaration(nameFormatter.Format(operation.Element.OperationId + "-ResponseExtensions"))
.AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword))
.AddMembers(GenerateExtensions(responseSet).ToArray <MemberDeclarationSyntax>()));
}
public TagTypeGenerator(ILocatedOpenApiElement <OpenApiTag> tagElement, GenerationContext context,
ISerializationNamespace serializationNamespace, IAuthenticationNamespace authenticationNamespace,
IOperationMethodGenerator operationMethodGenerator)
: base(tagElement, context)
{
_serializationNamespace = serializationNamespace ?? throw new ArgumentNullException(nameof(serializationNamespace));
_authenticationNamespace = authenticationNamespace ??
throw new ArgumentNullException(nameof(authenticationNamespace));
_operationMethodGenerator = operationMethodGenerator ?? throw new ArgumentNullException(nameof(operationMethodGenerator));
}
public DiscriminatorConverterTypeGenerator(ILocatedOpenApiElement <OpenApiSchema> element,
GenerationContext context, ITypeGenerator?parent, IJsonSerializationNamespace jsonSerializationNamespace,
IRootNamespace rootNamespace)
: base(element, context, parent)
{
_jsonSerializationNamespace = jsonSerializationNamespace ??
throw new ArgumentNullException(nameof(jsonSerializationNamespace));
_typeName = BuildTypeName(rootNamespace);
}
public ITypeGenerator Get(ILocatedOpenApiElement element, Type generatorCategory)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
return((ITypeGenerator)_getTypedMethod.MakeGenericMethod(element.ElementType, generatorCategory)
.Invoke(this, new object[] { element }) !);
}
public RequestTypeGenerator(ILocatedOpenApiElement <OpenApiOperation> operationElement,
GenerationContext context, IMediaTypeSelector mediaTypeSelector,
IList <IRequestMemberGenerator> memberGenerators,
IRequestsNamespace requestsNamespace, ISerializerSelector serializerSelector)
: base(operationElement, context, null)
{
MediaTypeSelector = mediaTypeSelector ?? throw new ArgumentNullException(nameof(mediaTypeSelector));
MemberGenerators = memberGenerators ?? throw new ArgumentNullException(nameof(memberGenerators));
RequestsNamespace = requestsNamespace ?? throw new ArgumentNullException(nameof(requestsNamespace));
SerializerSelector = serializerSelector ?? throw new ArgumentNullException(nameof(serializerSelector));
}
public static ILocatedOpenApiElement <OpenApiUnknownResponse> GetUnknownResponse(
this ILocatedOpenApiElement <OpenApiResponses> responses)
{
if (responses == null)
{
throw new ArgumentNullException(nameof(responses));
}
return(responses.CreateChild(_unknownResponses.GetOrCreateValue(responses.Element),
OpenApiUnknownResponse.Key));
}
public bool TryGet <T>(string key, [MaybeNullWhen(false)] out ILocatedOpenApiElement <T> element)
where T : IOpenApiElement
{
if (!_registry.TryGetValue(key, out var untypedElement))
{
element = null;
return(false);
}
element = (ILocatedOpenApiElement <T>)untypedElement;
return(true);
}
public string Add <T>(ILocatedOpenApiElement <T> element)
where T : IOpenApiElement
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
var key = Guid.NewGuid().ToString();
_registry.TryAdd(key, element);
return(key);
}
