Fix issue with untyped handler

Author: ejsmith

samples/CleanArchitectureSample/src/Common.Module/Middleware/ValidationMiddleware.cs

@@ -1,13 +1,27 @@
+using System.Collections.Concurrent;
 using Foundatio.Mediator;
 using MiniValidation;
 
 namespace Common.Module.Middleware;
 
+/// <summary>
+/// Apply this attribute to a message to skip validation.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
+public sealed class SkipValidationAttribute : Attribute { }
+
 [Middleware(5)]
 public static class ValidationMiddleware
 {
-    public static HandlerResult Before(IValidatable message)
+    private static readonly ConcurrentDictionary<Type, bool> _skipValidationCache = new();
+
+    public static HandlerResult Before(object message)
     {
+        // Skip validation if the message is decorated with [SkipValidation] (memoized)
+        if (_skipValidationCache.GetOrAdd(message.GetType(), static t =>
+            t.GetCustomAttributes(typeof(SkipValidationAttribute), false).Length > 0))
+            return HandlerResult.Continue();
+
         if (MiniValidator.TryValidate(message, out var errors))
             return HandlerResult.Continue();
 
@@ -16,5 +30,3 @@ public static HandlerResult Before(IValidatable message)
         return Result.Invalid(validationErrors);
     }
 }
-
-public interface IValidatable { }

samples/CleanArchitectureSample/src/Orders.Module/Messages/OrderMessages.cs

@@ -1,5 +1,4 @@
 using System.ComponentModel.DataAnnotations;
-using Common.Module.Middleware;
 using Foundatio.Mediator;
 using Orders.Module.Domain;
 
@@ -17,16 +16,17 @@ public record CreateOrder(
 
     [Required(ErrorMessage = "Description is required")]
     [StringLength(200, MinimumLength = 5, ErrorMessage = "Description must be between 5 and 200 characters")]
-    string Description) : IValidatable, ICommand<Result<Order>>;
+    string Description) : ICommand<Result<Order>>;
 
 public record UpdateOrder(
     [Required] string OrderId,
     decimal? Amount,
     string? Description,
-    OrderStatus? Status) : IValidatable, ICommand<Result<Order>>;
+    OrderStatus? Status) : ICommand<Result<Order>>;
 
-public record DeleteOrder([Required] string OrderId) : IValidatable, ICommand<Result>;
+public record DeleteOrder([Required] string OrderId) : ICommand<Result>;
 
 // Queries
-public record GetOrder([Required] string OrderId) : IValidatable, IQuery<Result<Order>>;
+public record GetOrder([Required] string OrderId) : IQuery<Result<Order>>;
+
 public record GetOrders() : IQuery<Result<List<Order>>>;

samples/CleanArchitectureSample/src/Products.Module/Messages/ProductMessages.cs

@@ -1,5 +1,4 @@
 using System.ComponentModel.DataAnnotations;
-using Common.Module.Middleware;
 using Foundatio.Mediator;
 using Products.Module.Domain;
 
@@ -20,18 +19,19 @@ public record CreateProduct(
     decimal Price,
 
     [Range(0, 1000000, ErrorMessage = "Stock quantity must be between 0 and 1,000,000")]
-    int StockQuantity = 0) : IValidatable, ICommand<Result<Product>>;
+    int StockQuantity = 0) : ICommand<Result<Product>>;
 
 public record UpdateProduct(
     [Required] string ProductId,
     string? Name,
     string? Description,
     decimal? Price,
     int? StockQuantity,
-    ProductStatus? Status) : IValidatable, ICommand<Result<Product>>;
+    ProductStatus? Status) : ICommand<Result<Product>>;
 
-public record DeleteProduct([Required] string ProductId) : IValidatable, ICommand<Result>;
+public record DeleteProduct([Required] string ProductId) : ICommand<Result>;
 
 // Queries
-public record GetProduct([Required] string ProductId) : IValidatable, IQuery<Result<Product>>;
+public record GetProduct([Required] string ProductId) : IQuery<Result<Product>>;
+
 public record GetProducts() : IQuery<Result<List<Product>>>;

src/Foundatio.Mediator/HandlerGenerator.cs

@@ -324,7 +324,7 @@ private static void GenerateHandleItemMethods(IndentedStringBuilder source, Hand
     /// <param name="resultVar">Variable name to store the handler result.</param>
     /// <param name="messageVar">Variable name containing the typed message (default: "message").</param>
     /// <param name="targetTupleIndex">For tuple return types, the index of the tuple item this method returns (0 = Item1, 1 = Item2, etc.). -1 for non-tuple handlers.</param>
-    private static void EmitHandlerInvocationCode(IndentedStringBuilder source, HandlerInfo handler, GeneratorConfiguration configuration, string resultVar, string messageVar = "message", int targetTupleIndex = 0)
+    private static void EmitHandlerInvocationCode(IndentedStringBuilder source, HandlerInfo handler, GeneratorConfiguration configuration, string resultVar, string messageVar = "message", int targetTupleIndex = 0, bool isUntypedMethod = false)
     {
         var variables = new Dictionary<string, string> { ["System.IServiceProvider"] = "serviceProvider" };
 
@@ -359,7 +359,7 @@ private static void EmitHandlerInvocationCode(IndentedStringBuilder source, Hand
         else
         {
             // Original code path - no Execute middleware
-            EmitPipelineCode(source, handler, beforeMiddleware, afterMiddleware, finallyMiddleware, configuration, variables, resultVar, messageVar, targetTupleIndex, requiresTryCatch);
+            EmitPipelineCode(source, handler, beforeMiddleware, afterMiddleware, finallyMiddleware, configuration, variables, resultVar, messageVar, targetTupleIndex, requiresTryCatch, isUntypedMethod: isUntypedMethod);
         }
     }
 
@@ -396,8 +396,8 @@ private static void EmitExecuteMiddlewareChain(
             source.AppendLine($"{handler.ReturnType.UnwrappedFullName}{(allowNull ? "?" : "")} innerResult = default;");
         }
 
-        // Emit the full pipeline inside the delegate
-        EmitPipelineCode(source, handler, beforeMiddleware, afterMiddleware, finallyMiddleware, configuration, innerVariables, "innerResult", messageVar, targetTupleIndex, requiresTryCatch, insideExecuteDelegate: true);
+        // Emit the full pipeline inside the delegate - isUntypedMethod is false here because we're inside a delegate that returns object?
+        EmitPipelineCode(source, handler, beforeMiddleware, afterMiddleware, finallyMiddleware, configuration, innerVariables, "innerResult", messageVar, targetTupleIndex, requiresTryCatch, insideExecuteDelegate: true, isUntypedMethod: false);
 
         source.AppendLine(handler.HasReturnValue ? "return innerResult;" : "return null;");
         source.DecrementIndent();
@@ -483,6 +483,8 @@ private static string BuildExecuteParameters(IndentedStringBuilder source, Equat
     /// </summary>
     /// <param name="insideExecuteDelegate">When true, we're inside an Execute middleware delegate and short-circuit
     /// returns should return the full tuple type (not just one item) since the delegate returns object?.</param>
+    /// <param name="isUntypedMethod">When true, we're generating UntypedHandleAsync which returns ValueTask&lt;object?&gt;,
+    /// so void handlers should return null instead of just return.</param>
     private static void EmitPipelineCode(
         IndentedStringBuilder source,
         HandlerInfo handler,
@@ -495,7 +497,8 @@ private static void EmitPipelineCode(
         string messageVar,
         int targetTupleIndex,
         bool requiresTryCatch,
-        bool insideExecuteDelegate = false)
+        bool insideExecuteDelegate = false,
+        bool isUntypedMethod = false)
     {
         // Main execution with optional try-catch-finally
         if (requiresTryCatch)
@@ -510,7 +513,7 @@ private static void EmitPipelineCode(
             variables["System.Exception"] = "exception";
         }
 
-        EmitBeforeMiddlewareCalls(source, beforeMiddleware, handler, variables, messageVar, targetTupleIndex, insideExecuteDelegate);
+        EmitBeforeMiddlewareCalls(source, beforeMiddleware, handler, variables, messageVar, targetTupleIndex, insideExecuteDelegate, isUntypedMethod);
         EmitHandlerInvocation(source, handler, variables, resultVar, messageVar);
         EmitAfterMiddlewareCalls(source, afterMiddleware, variables, messageVar);
 
@@ -632,7 +635,8 @@ private static void EmitBeforeMiddlewareCalls(
         Dictionary<string, string> variables,
         string messageVar,
         int targetTupleIndex,
-        bool insideExecuteDelegate = false)
+        bool insideExecuteDelegate = false,
+        bool isUntypedMethod = false)
     {
         foreach (var m in beforeMiddleware)
         {
@@ -645,7 +649,7 @@ private static void EmitBeforeMiddlewareCalls(
 
             if (m.Method.ReturnType.IsHandlerResult)
             {
-                EmitShortCircuitCheck(source, m, handler, targetTupleIndex, insideExecuteDelegate);
+                EmitShortCircuitCheck(source, m, handler, targetTupleIndex, insideExecuteDelegate, isUntypedMethod);
             }
         }
         source.AppendLineIf(beforeMiddleware.Any());
@@ -656,7 +660,8 @@ private static void EmitShortCircuitCheck(
         (MiddlewareMethodInfo Method, MiddlewareInfo Middleware) m,
         HandlerInfo handler,
         int targetTupleIndex,
-        bool insideExecuteDelegate = false)
+        bool insideExecuteDelegate = false,
+        bool isUntypedMethod = false)
     {
         string resultVarName = $"{m.Middleware.Identifier.ToCamelCase()}Result";
         string valueAccess = m.Method.ReturnType.IsGeneric ? $"{resultVarName}.Value" : $"{resultVarName}.Value!";
@@ -682,7 +687,9 @@ private static void EmitShortCircuitCheck(
         }
         else
         {
-            source.AppendLine("    return;");
+            // For void handlers: UntypedHandleAsync returns ValueTask<object?> so needs "return null"
+            // Typed HandleAsync returns ValueTask so needs just "return"
+            source.AppendLine(isUntypedMethod ? "    return null;" : "    return;");
         }
 
         source.AppendLine("}");
@@ -870,7 +877,7 @@ private static void GenerateUntypedHandleMethod(IndentedStringBuilder source, Ha
         source.AppendLine("var serviceProvider = (System.IServiceProvider)mediator;");
 
         // Emit the handler invocation code - use "typedMessage" since we cast the object message above
-        EmitHandlerInvocationCode(source, handler, configuration, "result", "typedMessage");
+        EmitHandlerInvocationCode(source, handler, configuration, "result", "typedMessage", isUntypedMethod: true);
 
         // For tuple returns, use PublishCascadingMessagesAsync for runtime dispatch
         if (handler.ReturnType.IsTuple)