Set readOnly status for properties

Author: captainsafia

src/OpenApi/src/Extensions/JsonNodeSchemaExtensions.cs

@@ -388,4 +388,22 @@ internal static void ApplyNullabilityContextInfo(this JsonNode schema, JsonPrope
             schema[OpenApiSchemaKeywords.NullableKeyword] = true;
         }
     }
+
+    /// <summary>
+    /// Apply `readOnly` to the schema based on the presence of the <see cref="ReadOnlyAttribute"/> or whether the
+    /// property exposes a setter.
+    /// </summary>
+    /// <param name="schema"></param>
+    /// <param name="attributeProvider"></param>
+    internal static void ApplyReadOnly(this JsonNode schema, ICustomAttributeProvider attributeProvider)
+    {
+        if (attributeProvider is PropertyInfo jsonPropertyInfo)
+        {
+            schema[OpenApiSchemaKeywords.ReadOnlyKeyword] = !jsonPropertyInfo.CanWrite;
+        }
+        if (attributeProvider.GetCustomAttributes(inherit: false).OfType<ReadOnlyAttribute>().SingleOrDefault() is { } readOnlyAttribute)
+        {
+            schema[OpenApiSchemaKeywords.ReadOnlyKeyword] = readOnlyAttribute.IsReadOnly;
+        }
+    }
 }

src/OpenApi/src/Schemas/OpenApiJsonSchema.Helpers.cs

@@ -294,6 +294,10 @@ public static void ReadProperty(ref Utf8JsonReader reader, string propertyName,
                 reader.Read();
                 schema.Extensions.Add(OpenApiConstants.SchemaId, new OpenApiString(reader.GetString()));
                 break;
+            case OpenApiSchemaKeywords.ReadOnlyKeyword:
+                reader.Read();
+                schema.ReadOnly = reader.GetBoolean();
+                break;
             default:
                 reader.Skip();
                 break;

src/OpenApi/src/Schemas/OpenApiSchemaKeywords.cs

@@ -25,4 +25,5 @@ internal class OpenApiSchemaKeywords
     public const string MaxItemsKeyword = "maxItems";
     public const string RefKeyword = "$ref";
     public const string SchemaIdKeyword = "x-schema-id";
+    public const string ReadOnlyKeyword = "readOnly";
 }

src/OpenApi/src/Services/Schemas/OpenApiSchemaService.cs

@@ -93,6 +93,7 @@ internal sealed class OpenApiSchemaService(
             if (context.PropertyInfo is { AttributeProvider: { } attributeProvider } jsonPropertyInfo)
             {
                 schema.ApplyNullabilityContextInfo(jsonPropertyInfo);
+                schema.ApplyReadOnly(attributeProvider);
                 if (attributeProvider.GetCustomAttributes(inherit: false).OfType<ValidationAttribute>() is { } validationAttributes)
                 {
                     schema.ApplyValidationAttributes(validationAttributes);

src/OpenApi/test/Services/OpenApiDocumentService/OpenApiDocumentServiceTests.RequestBody.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.ComponentModel;
 using System.IO.Pipelines;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
@@ -1039,4 +1040,43 @@ static void VerifyDocument(OpenApiDocument document)
     private void ActionWithStream(Stream stream) { }
     [Route("/pipereader")]
     private void ActionWithPipeReader(PipeReader pipeReader) { }
+
+    [Fact]
+    public async Task GetOpenApiRequestBody_AppliesReadOnlyOnProperties()
+    {
+        // Arrange
+        var builder = CreateBuilder();
+
+        // Act
+        builder.MapPost("/", (TypeWithReadOnlyProperties model) => { });
+
+        // Assert
+        await VerifyOpenApiDocument(builder, document =>
+        {
+            var paths = Assert.Single(document.Paths.Values);
+            var operation = paths.Operations[OperationType.Post];
+            var content = Assert.Single(operation.RequestBody.Content);
+            var schema = content.Value.Schema;
+            Assert.NotNull(schema.Properties);
+            Assert.Collection(schema.Properties,
+                property =>
+                {
+                    Assert.Equal("computedProperty", property.Key);
+                    Assert.True(property.Value.ReadOnly);
+                },
+                property =>
+                {
+                    Assert.Equal("readOnlyProperty", property.Key);
+                    Assert.True(property.Value.ReadOnly);
+                });
+        });
+    }
+
+    private class TypeWithReadOnlyProperties
+    {
+        public int ComputedProperty { get; } = 42;
+
+        [ReadOnly(true)]
+        public int ReadOnlyProperty { get; set; }
+    }
 }