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); }