Feature/build error type response

src/ModelValidationAsyncActionFilter.cs

@@ -10,6 +10,7 @@
 using System.Collections;
 using System.Linq;
 using System.Threading.Tasks;
+using FluentValidation.Results;
 
 namespace JSM.FluentValidation.AspNet.AsyncFilter
 {
@@ -125,9 +126,14 @@ private async Task ValidateAsync(object value, ModelStateDictionary modelState)
 
             var context = new ValidationContext<object>(value);
             var result = await validator.ValidateAsync(context);
-            result.AddToModelState(modelState, string.Empty);
+            var errorCode = GetErrorCodeWithPrefixRuleType(result);
+
+            result.AddToModelState(modelState, errorCode);
         }
 
+        private static string GetErrorCodeWithPrefixRuleType(ValidationResult result) => 
+            result.Errors.LastOrDefault(errorCode => errorCode.ErrorCode.Contains(RuleTypeConst.Prefix))?.ErrorCode;
+
         private IValidator GetValidator(Type targetType)
         {
             var validatorType = typeof(IValidator<>).MakeGenericType(targetType);

src/RuleTypeBuilderExtensions.cs

@@ -0,0 +1,34 @@
+using FluentValidation;
+using Microsoft.AspNetCore.Mvc;
+using System.Linq;
+
+namespace JSM.FluentValidation.AspNet.AsyncFilter
+{
+    /// <summary>
+    /// Extension to override error code with prefix and type.
+    /// </summary>
+    public static class RuleTypeBuilderExtensions
+    {
+        /// <summary>
+        /// Overrides the error code associated with this rule with prefix and type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <typeparam name="TProperty"></typeparam>
+        /// <param name="rule">The current rule</param>
+        /// <param name="type">The type used to override error code</param>
+        /// <returns></returns>
+        public static IRuleBuilderOptions<T, TProperty> WithRuleType<T, TProperty>(this IRuleBuilderOptions<T, TProperty> rule, string type)
+        {
+            string propertyName = "";
+
+            var options = rule.Configure(x => propertyName = x.GetDisplayName(null));
+
+            if (!string.IsNullOrEmpty(propertyName))
+                options.WithName(propertyName);
+
+            options.WithErrorCode($"{RuleTypeConst.Prefix}.{type}");
+
+            return options;
+        }
+    }
+}

src/RuleTypeConst.cs

@@ -0,0 +1,13 @@
+namespace JSM.FluentValidation.AspNet.AsyncFilter
+{
+    /// <summary>
+    /// Const used do configure method WithRuleType.
+    /// </summary>
+    public static class RuleTypeConst
+    {
+        /// <summary>
+        /// Prefix used to override property name.
+        /// </summary>
+        public const string Prefix = "_RuleType";
+    }
+}

tests/ModelValidationAsyncActionFilterWithRuleTypeTests.cs

@@ -0,0 +1,53 @@
+using FluentAssertions;
+using JSM.FluentValidation.AspNet.AsyncFilter.Tests.Support;
+using JSM.FluentValidation.AspNet.AsyncFilter.Tests.Support.Models;
+using JSM.FluentValidation.AspNet.AsyncFilter.Tests.Support.Startups;
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace JSM.FluentValidation.AspNet.AsyncFilter.Tests
+{
+    public class ModelValidationAsyncActionFilterWithRuleTypeTests : WebAppFixture<StartupWithDefaultOptions>
+    {
+        private const string ControllerWithRuleTypeEndpoint = "WithRuleType";
+        private HttpClient Client { get; }
+
+        public ModelValidationAsyncActionFilterWithRuleTypeTests() => Client = CreateClient();
+
+        [Fact(DisplayName = "Should return OK when payload is valid")]
+        public async Task OnActionExecutionAsync_PayloadIsValid_ReturnOk()
+        {
+            // Arrange
+            var payload = new TestPayloadWithRuleType { Text = "Test" };
+
+            // Act
+            var response = await Client.PostAsJsonAsync($"{ControllerWithRuleTypeEndpoint}/test-validator", payload);
+
+            // Assert
+            response.Should().Be200Ok();
+        }
+
+        [Fact(DisplayName = "Should return bad request when payload is invalid")]
+        public async Task OnActionExecutionAsync_PayloadIsInvalid_ReturnBadRequest()
+        {
+            // Arrange
+            var payload = new TestPayloadWithRuleType { Text = "" };
+
+            // Act
+            var response = await Client.PostAsJsonAsync($"{ControllerWithRuleTypeEndpoint}/test-validator", payload);
+
+            // Assert
+            response.Should().Be400BadRequest();
+            var responseDetails = await response.Content.ReadFromJsonAsync<ValidationProblemDetails>();
+            responseDetails.Title.Should().Be("One or more validation errors occurred.");
+            responseDetails.Errors.Should().BeEquivalentTo(new Dictionary<string, string[]>
+            {
+                { $"{RuleTypeConst.Prefix}.SOME_RULE.Text", new[] { "Text can't be null" } }
+            });
+        }
+    }
+}

tests/Support/Controllers/WithRuleTypeController.cs

@@ -0,0 +1,13 @@
+using JSM.FluentValidation.AspNet.AsyncFilter.Tests.Support.Models;
+using Microsoft.AspNetCore.Mvc;
+using System;
+
+namespace JSM.FluentValidation.AspNet.AsyncFilter.Tests.Support.Controllers
+{
+    [ApiController, Route("[controller]")]
+    public class WithRuleTypeController : ControllerBase
+    {
+        [HttpPost("test-validator")]
+        public IActionResult Post([FromBody] TestPayloadWithRuleType request) => Ok();
+    }
+}

tests/Support/Models/TestPayloadWithRuleType.cs

@@ -0,0 +1,20 @@
+using FluentValidation;
+
+namespace JSM.FluentValidation.AspNet.AsyncFilter.Tests.Support.Models
+{
+    public class TestPayloadWithRuleType
+    {
+        public string Text { get; set; }
+    }
+
+    public class TestPayloadWithRuleTypeValidator : AbstractValidator<TestPayloadWithRuleType>
+    {
+        public TestPayloadWithRuleTypeValidator()
+        {
+            RuleFor(x => x.Text)
+                .NotEmpty()
+                .WithMessage("Text can't be null")
+                .WithRuleType("SOME_RULE");
+        }
+    }
+}