Add JsonIgnore attribute support to Minimal API validation generator

src/Shared/RoslynUtils/WellKnownTypeData.cs

@@ -119,6 +119,7 @@ public enum WellKnownType
         Microsoft_AspNetCore_Authorization_IAuthorizeData,
         System_AttributeUsageAttribute,
         System_Text_Json_Serialization_JsonDerivedTypeAttribute,
+        System_Text_Json_Serialization_JsonIgnoreAttribute,
         System_ComponentModel_DataAnnotations_DisplayAttribute,
         System_ComponentModel_DataAnnotations_ValidationAttribute,
         System_ComponentModel_DataAnnotations_RequiredAttribute,
@@ -240,6 +241,7 @@ public enum WellKnownType
         "Microsoft.AspNetCore.Authorization.IAuthorizeData",
         "System.AttributeUsageAttribute",
         "System.Text.Json.Serialization.JsonDerivedTypeAttribute",
+        "System.Text.Json.Serialization.JsonIgnoreAttribute",
         "System.ComponentModel.DataAnnotations.DisplayAttribute",
         "System.ComponentModel.DataAnnotations.ValidationAttribute",
         "System.ComponentModel.DataAnnotations.RequiredAttribute",

src/Validation/gen/Extensions/ITypeSymbolExtensions.cs

@@ -152,4 +152,16 @@ attr.AttributeClass is not null &&
             (attr.AttributeClass.ImplementsInterface(fromServiceMetadataSymbol) ||
              SymbolEqualityComparer.Default.Equals(attr.AttributeClass, fromKeyedServiceAttributeSymbol)));
     }
+
+    /// <summary>
+    /// Checks if the property is marked with [JsonIgnore] attribute.
+    /// </summary>
+    /// <param name="property">The property to check.</param>
+    /// <param name="jsonIgnoreAttributeSymbol">The symbol representing the [JsonIgnore] attribute.</param>
+    internal static bool IsJsonIgnoredProperty(this IPropertySymbol property, INamedTypeSymbol jsonIgnoreAttributeSymbol)
+    {
+        return property.GetAttributes().Any(attr =>
+            attr.AttributeClass is not null &&
+            SymbolEqualityComparer.Default.Equals(attr.AttributeClass, jsonIgnoreAttributeSymbol));
+    }
 }

src/Validation/gen/Models/RequiredSymbols.cs

@@ -11,6 +11,7 @@ internal sealed record class RequiredSymbols(
     INamedTypeSymbol IEnumerable,
     INamedTypeSymbol IValidatableObject,
     INamedTypeSymbol JsonDerivedTypeAttribute,
+    INamedTypeSymbol JsonIgnoreAttribute,
     INamedTypeSymbol RequiredAttribute,
     INamedTypeSymbol CustomValidationAttribute,
     INamedTypeSymbol HttpContext,

src/Validation/gen/Parsers/ValidationsGenerator.TypesParser.cs

@@ -114,6 +114,8 @@ internal ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITypeSymb
             WellKnownTypeData.WellKnownType.Microsoft_AspNetCore_Http_Metadata_IFromServiceMetadata);
         var fromKeyedServiceAttributeSymbol = wellKnownTypes.Get(
             WellKnownTypeData.WellKnownType.Microsoft_Extensions_DependencyInjection_FromKeyedServicesAttribute);
+        var jsonIgnoreAttributeSymbol = wellKnownTypes.Get(
+            WellKnownTypeData.WellKnownType.System_Text_Json_Serialization_JsonIgnoreAttribute);
 
         // Special handling for record types to extract properties from
         // the primary constructor.
@@ -148,6 +150,12 @@ internal ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITypeSymb
                             continue;
                         }
 
+                        // Skip properties that have JsonIgnore attribute
+                        if (correspondingProperty.IsJsonIgnoredProperty(jsonIgnoreAttributeSymbol))
+                        {
+                            continue;
+                        }
+
                         // Check if the property's type is validatable, this resolves
                         // validatable types in the inheritance hierarchy
                         var hasValidatableType = TryExtractValidatableType(
@@ -186,6 +194,12 @@ internal ImmutableArray<ValidatableProperty> ExtractValidatableMembers(ITypeSymb
                 continue;
             }
 
+            // Skip properties that have JsonIgnore attribute
+            if (member.IsJsonIgnoredProperty(jsonIgnoreAttributeSymbol))
+            {
+                continue;
+            }
+
             var hasValidatableType = TryExtractValidatableType(member.Type, wellKnownTypes, ref validatableTypes, ref visitedTypes);
             var attributes = ExtractValidationAttributes(member, wellKnownTypes, out var isRequired);
 

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/ValidationsGenerator.ComplexType.cs

@@ -7,6 +7,153 @@ namespace Microsoft.Extensions.Validation.GeneratorTests;
 
 public partial class ValidationsGeneratorTests : ValidationsGeneratorTestBase
 {
+    [Fact]
+    public async Task CanValidateComplexTypesWithJsonIgnore()
+    {
+        // Arrange
+        var source = """
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Validation;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json.Serialization;
+
+var builder = WebApplication.CreateBuilder();
+
+builder.Services.AddValidation();
+
+var app = builder.Build();
+
+app.MapPost("/complex-type-with-json-ignore", (ComplexTypeWithJsonIgnore complexType) => Results.Ok("Passed"!));
+app.MapPost("/record-type-with-json-ignore", (RecordTypeWithJsonIgnore recordType) => Results.Ok("Passed"!));
+
+app.Run();
+
+public class ComplexTypeWithJsonIgnore
+{
+    [Range(10, 100)]
+    public int ValidatedProperty { get; set; } = 10;
+
+    [JsonIgnore]
+    [Required] // This should be ignored because of [JsonIgnore]
+    public string IgnoredProperty { get; set; } = null!;
+
+    [JsonIgnore]
+    public CircularReferenceType? CircularReference { get; set; }
+}
+
+public class CircularReferenceType
+{
+    [JsonIgnore]
+    public ComplexTypeWithJsonIgnore? Parent { get; set; }
+
+    public string Name { get; set; } = "test";
+}
+
+public record RecordTypeWithJsonIgnore
+{
+    [Range(10, 100)]
+    public int ValidatedProperty { get; set; } = 10;
+
+    [JsonIgnore]
+    [Required] // This should be ignored because of [JsonIgnore]
+    public string IgnoredProperty { get; set; } = null!;
+
+    [JsonIgnore]
+    public CircularReferenceRecord? CircularReference { get; set; }
+}
+
+public record CircularReferenceRecord
+{
+    [JsonIgnore]
+    public RecordTypeWithJsonIgnore? Parent { get; set; }
+
+    public string Name { get; set; } = "test";
+}
+""";
+        await Verify(source, out var compilation);
+        await VerifyEndpoint(compilation, "/complex-type-with-json-ignore", async (endpoint, serviceProvider) =>
+        {
+            await ValidInputWithJsonIgnoreProducesNoWarnings(endpoint);
+            await InvalidValidatedPropertyProducesError(endpoint);
+
+            async Task ValidInputWithJsonIgnoreProducesNoWarnings(Endpoint endpoint)
+            {
+                var payload = """
+                {
+                    "ValidatedProperty": 50
+                }
+                """;
+                var context = CreateHttpContextWithPayload(payload, serviceProvider);
+                await endpoint.RequestDelegate(context);
+
+                Assert.Equal(200, context.Response.StatusCode);
+            }
+
+            async Task InvalidValidatedPropertyProducesError(Endpoint endpoint)
+            {
+                var payload = """
+                {
+                    "ValidatedProperty": 5
+                }
+                """;
+                var context = CreateHttpContextWithPayload(payload, serviceProvider);
+
+                await endpoint.RequestDelegate(context);
+
+                var problemDetails = await AssertBadRequest(context);
+                Assert.Collection(problemDetails.Errors, kvp =>
+                {
+                    Assert.Equal("ValidatedProperty", kvp.Key);
+                    Assert.Equal("The field ValidatedProperty must be between 10 and 100.", kvp.Value.Single());
+                });
+            }
+        });
+
+        await VerifyEndpoint(compilation, "/record-type-with-json-ignore", async (endpoint, serviceProvider) =>
+        {
+            await ValidInputWithJsonIgnoreProducesNoWarningsForRecord(endpoint);
+            await InvalidValidatedPropertyProducesErrorForRecord(endpoint);
+
+            async Task ValidInputWithJsonIgnoreProducesNoWarningsForRecord(Endpoint endpoint)
+            {
+                var payload = """
+                {
+                    "ValidatedProperty": 50
+                }
+                """;
+                var context = CreateHttpContextWithPayload(payload, serviceProvider);
+                await endpoint.RequestDelegate(context);
+
+                Assert.Equal(200, context.Response.StatusCode);
+            }
+
+            async Task InvalidValidatedPropertyProducesErrorForRecord(Endpoint endpoint)
+            {
+                var payload = """
+                {
+                    "ValidatedProperty": 5
+                }
+                """;
+                var context = CreateHttpContextWithPayload(payload, serviceProvider);
+
+                await endpoint.RequestDelegate(context);
+
+                var problemDetails = await AssertBadRequest(context);
+                Assert.Collection(problemDetails.Errors, kvp =>
+                {
+                    Assert.Equal("ValidatedProperty", kvp.Key);
+                    Assert.Equal("The field ValidatedProperty must be between 10 and 100.", kvp.Value.Single());
+                });
+            }
+        });
+    }
     [Fact]
     public async Task CanValidateComplexTypes()
     {