Cleanup result API. Fix a few other issues.

Author: ejsmith

README.md

@@ -375,6 +375,12 @@ The source generator provides compile-time errors for:
   - Ability to call `AddMediator` to entry assembly and have it register handlers in all assemblies
 - [ ] Clean architecture sample app
 - [ ] Modular monolith architecture sample app
+- [ ] Switch source generator package name back to Foundatio.Mediator (maybe Foundatio.Mediator.Abstractions)
+- [ ] Figure out issue with props / targets files not being included
+- [ ] See if we can support streaming with IAsyncEnumerable
+- [ ] Talk about lifetime. Handlers aren't registered in DI by default and are singleton instances. Just add your handler or services to DI if you want a different behavior.
+- [ ] Add GeneratedCodeAttribute
+- [ ] Talk about for tuple returns / cascading messages, if a middleware short circuits the response, the value will be returned as the first tuple item and all others will be null or default.
 
 ## 📄 License
 

samples/ConsoleSample/Handlers/Handlers.cs

@@ -23,15 +23,13 @@ public class OrderHandler
 {
     private static readonly Dictionary<string, Order> _orders = new();
     private readonly ILogger<OrderHandler> _logger;
-    private readonly IMediator _mediator;
 
-    public OrderHandler(ILogger<OrderHandler> logger, IMediator mediator)
+    public OrderHandler(ILogger<OrderHandler> logger)
     {
         _logger = logger;
-        _mediator = mediator;
     }
 
-    public async Task<Result<Order>> HandleAsync(CreateOrder command)
+    public async Task<(Result<Order> Order, OrderCreated? Event)> HandleAsync(CreateOrder command)
     {
         _logger.LogInformation("Creating order for customer {CustomerId} with amount {Amount}",
             command.CustomerId, command.Amount);
@@ -41,10 +39,9 @@ public async Task<Result<Order>> HandleAsync(CreateOrder command)
 
         _orders[orderId] = order;
 
-        // Publish event for other handlers to react
-        await _mediator.PublishAsync(new OrderCreated(orderId, command.CustomerId, command.Amount, order.CreatedAt));
+        await Task.CompletedTask; // Simulate async operation
 
-        return Result<Order>.Created(order, $"/orders/{orderId}");
+        return (Result<Order>.Created(order, $"/orders/{orderId}"), new OrderCreated(orderId, command.CustomerId, command.Amount, order.CreatedAt));
     }
 
     public Result<Order> Handle(GetOrder query)
@@ -53,19 +50,19 @@ public Result<Order> Handle(GetOrder query)
 
         if (!_orders.TryGetValue(query.OrderId, out var order))
         {
-            return Result<Order>.NotFound($"Order {query.OrderId} not found");
+            return Result.NotFound($"Order {query.OrderId} not found");
         }
 
         return order; // Implicit conversion to Result<Order>
     }
 
-    public async Task<Result<Order>> HandleAsync(UpdateOrder command)
+    public async Task<(Result<Order> Order, OrderUpdated? Event)> HandleAsync(UpdateOrder command)
     {
         _logger.LogInformation("Updating order {OrderId}", command.OrderId);
 
         if (!_orders.TryGetValue(command.OrderId, out var existingOrder))
         {
-            return Result<Order>.NotFound($"Order {command.OrderId} not found");
+            return (Result.NotFound($"Order {command.OrderId} not found"), null);
         }
 
         var updatedOrder = existingOrder with
@@ -77,26 +74,24 @@ public async Task<Result<Order>> HandleAsync(UpdateOrder command)
 
         _orders[command.OrderId] = updatedOrder;
 
-        // Publish event
-        await _mediator.PublishAsync(new OrderUpdated(command.OrderId, updatedOrder.Amount, updatedOrder.UpdatedAt.Value));
+        await Task.CompletedTask; // Simulate async operation
 
-        return updatedOrder;
+        return (updatedOrder, new OrderUpdated(command.OrderId, updatedOrder.Amount, updatedOrder.UpdatedAt.Value));
     }
 
-    public async Task<Result> HandleAsync(DeleteOrder command)
+    public async Task<(Result Order, OrderDeleted? Event)> HandleAsync(DeleteOrder command)
     {
         _logger.LogInformation("Deleting order {OrderId}", command.OrderId);
 
         if (!_orders.ContainsKey(command.OrderId))
         {
-            return Result.NotFound($"Order {command.OrderId} not found");
+            return (Result.NotFound($"Order {command.OrderId} not found"), null);
         }
 
         _orders.Remove(command.OrderId);
 
-        // Publish event
-        await _mediator.PublishAsync(new OrderDeleted(command.OrderId, DateTime.UtcNow));
+        await Task.CompletedTask; // Simulate async operation
 
-        return Result.NoContent();
+        return (Result.NoContent(), new OrderDeleted(command.OrderId, DateTime.UtcNow));
     }
 }

samples/ConsoleSample/SampleRunner.cs

@@ -77,15 +77,15 @@ private async Task RunOrderCrudExamples()
         }
         else
         {
-            Console.WriteLine($"❌ Failed to create order: {string.Join(", ", createResult.Errors)}\n");
+            Console.WriteLine($"❌ Failed to create order: {createResult.Message}\n");
         }
 
         // Demonstrate validation errors
         Console.WriteLine("🚫 Testing validation errors...");
         var invalidResult = await _mediator.InvokeAsync<Result<Order>>(new CreateOrder("", -100m, "Invalid order"));
         if (!invalidResult.IsSuccess)
         {
-            Console.WriteLine($"❌ Validation failed as expected: {string.Join(", ", invalidResult.Errors)}\n");
+            Console.WriteLine($"❌ Validation failed as expected: {invalidResult.Message}\n");
         }
     }
 

src/Foundatio.Mediator.SourceGenerator/HandlerGenerator.cs

@@ -183,7 +183,11 @@ private static void GenerateHandleMethod(IndentedStringBuilder source, HandlerIn
                 result = handler.HasReturnValue ? $" ({handler.ReturnType.UnwrappedFullName}){m.Middleware.Identifier.ToCamelCase()}Result.Value!" : "";
                 if (handler.ReturnType.IsResult)
                 {
-                    result = $" {m.Middleware.Identifier.ToCamelCase()}Result.Value is Foundatio.Mediator.Result result ? ({handler.ReturnType.UnwrappedFullName})result : ({handler.ReturnType.UnwrappedFullName}?){m.Middleware.Identifier.ToCamelCase()}Result.Value ?? default({handler.ReturnType.UnwrappedFullName})!";
+                    result = $" {m.Middleware.Identifier.ToCamelCase()}Result.Value is Foundatio.Mediator.Result result ? ({handler.ReturnType.UnwrappedFullName})result : ({handler.ReturnType.UnwrappedFullName}?){m.Middleware.Identifier.ToCamelCase()}Result.Value!";
+                }
+                else if (handler.ReturnType.IsTuple)
+                {
+                    result = $" (({m.Middleware.Identifier.ToCamelCase()}Result.Value is Foundatio.Mediator.Result result ? ({handler.ReturnType.TupleItems.First().TypeFullName})result : ({handler.ReturnType.TupleItems.First().TypeFullName}?){m.Middleware.Identifier.ToCamelCase()}Result.Value!), {String.Join(", ", handler.ReturnType.TupleItems.Skip(1).Select(i => i.IsNullable ? "null" : "default"))})";
                 }
                 source.AppendLine($"if ({m.Middleware.Identifier.ToCamelCase()}Result.IsShortCircuited)");
                 source.AppendLine("{");
@@ -296,13 +300,13 @@ private static void GenerateUntypedHandleMethod(IndentedStringBuilder source, Ha
                         {
                             if (!r.IsSuccess)
                             {
-                            throw new InvalidCastException($"Handler returned failed result with status {r.Status} for requested type { responseType?.Name ?? "null" }");
+                                throw new InvalidCastException($"Handler returned failed result with status {r.Status} for requested type { responseType?.Name ?? "null" }");
                             }
 
                             var resultValue = r.GetValue();
                             if (resultValue != null && responseType.IsAssignableFrom(resultValue.GetType()))
                             {
-                            return resultValue;
+                                return resultValue;
                             }
                         }
                         """);
@@ -341,7 +345,7 @@ private static void GenerateInterceptorMethod(IndentedStringBuilder source, Hand
     {
         string interceptorMethod = $"Intercept{methodName}{methodIndex}";
         string handlerMethod = GetHandlerMethodName(handler);
-        bool methodIsAsync = methodName.EndsWith("Async");
+        bool methodIsAsync = methodName.EndsWith("Async") || handler.IsAsync;
 
         foreach (var callSite in callSites)
         {
@@ -366,7 +370,17 @@ private static void GenerateInterceptorMethod(IndentedStringBuilder source, Hand
             source.AppendLine($"var result = {asyncModifier}{handlerMethod}(mediator, typedMessage, cancellationToken);");
             source.AppendLine();
 
-            GenerateOptimizedTupleHandling(source, handler, responseType);
+            var returnItem = handler.ReturnType.TupleItems.FirstOrDefault(i => i.TypeFullName == responseType.FullName);
+            var publishItems = handler.ReturnType.TupleItems.Except([returnItem]);
+
+            foreach (var publishItem in publishItems)
+            {
+                source.AppendLineIf($"if (result.{publishItem.Name} != null)", publishItem.IsNullable);
+                source.AppendIf("    ", publishItem.IsNullable).AppendLine($"await mediator.PublishAsync(result.{publishItem.Name}, cancellationToken);");
+            }
+            source.AppendLineIf(publishItems.Any());
+
+            source.AppendLine($"return result.{returnItem.Name};");
         }
         else
         {
@@ -493,87 +507,9 @@ private static void GenerateGetOrCreateHandler(IndentedStringBuilder source, Han
                 """);
     }
 
-    private static void GenerateOptimizedTupleHandling(IndentedStringBuilder source, HandlerInfo handler, TypeSymbolInfo responseType)
-    {
-        var tupleFields = handler.ReturnType.TupleItems.ToList();
-
-        if (tupleFields.Count == 0)
-        {
-            source.AppendLine($"return default({responseType.FullName});");
-            return;
-        }
-
-        int returnItemIndex = -1;
-        var publishItems = new List<int>();
-
-        for (int i = 0; i < tupleFields.Count; i++)
-        {
-            var tupleItem = tupleFields[i];
-            string fieldType = tupleItem.TypeFullName;
-
-            if (fieldType == responseType.FullName)
-            {
-                if (returnItemIndex == -1)
-                {
-                    returnItemIndex = i;
-                }
-                else
-                {
-                    publishItems.Add(i);
-                }
-            }
-            else
-            {
-                publishItems.Add(i);
-            }
-        }
-
-        foreach (int publishIndex in publishItems)
-        {
-            var tupleItem = tupleFields[publishIndex];
-            string itemAccess = $"result.{tupleItem.Name}";
-
-            bool needsNullCheck = tupleItem.IsNullable;
-
-            if (responseType.IsTask)
-            {
-                if (needsNullCheck)
-                {
-                    source.AppendLine($"if ({itemAccess} != null) await mediator.PublishAsync({itemAccess}, cancellationToken);");
-                }
-                else
-                {
-                    source.AppendLine($"await mediator.PublishAsync({itemAccess}, cancellationToken);");
-                }
-            }
-            else
-            {
-                if (needsNullCheck)
-                {
-                    source.AppendLine($"if ({itemAccess} != null) mediator.PublishAsync({itemAccess}, CancellationToken.None).GetAwaiter().GetResult();");
-                }
-                else
-                {
-                    source.AppendLine($"mediator.PublishAsync({itemAccess}, CancellationToken.None).GetAwaiter().GetResult();");
-                }
-            }
-        }
-
-        source.AppendLine();
-        if (returnItemIndex >= 0)
-        {
-            var returnTupleItem = tupleFields[returnItemIndex];
-            source.AppendLine($"return result.{returnTupleItem.Name};");
-        }
-        else
-        {
-            source.AppendLine($"return default({responseType.UnwrappedFullName})!;");
-        }
-    }
-
     public static string GetHandlerClassName(HandlerInfo handler)
     {
-        return $"{handler.Identifier}_{handler.MessageType.Identifier}_Wrapper";
+        return $"{handler.Identifier}_{handler.MessageType.Identifier}_Handler";
     }
 
     public static string GetHandlerMethodName(HandlerInfo handler)

src/Foundatio.Mediator.SourceGenerator/Models/HandlerInfo.cs

@@ -10,7 +10,7 @@ internal readonly record struct HandlerInfo
     public TypeSymbolInfo MessageType { get; init; }
     public bool HasReturnValue => !ReturnType.IsVoid;
     public TypeSymbolInfo ReturnType { get; init; }
-    public bool IsAsync => ReturnType.IsTask || Middleware.Any(m => m.IsAsync);
+    public bool IsAsync => ReturnType.IsTask || ReturnType.IsTuple || Middleware.Any(m => m.IsAsync);
     public bool IsStatic { get; init; }
     public EquatableArray<ParameterInfo> Parameters { get; init; }
     public EquatableArray<CallSiteInfo> CallSites { get; init; }

src/Foundatio.Mediator.SourceGenerator/Utility/TypeExtensions.cs

@@ -154,6 +154,7 @@ internal static EquatableArray<TupleItemInfo> GetTupleItems(this ITypeSymbol typ
             {
                 Name = e.Name ?? e.CorrespondingTupleField!.Name,
                 Field = e.CorrespondingTupleField!.Name,
+                IsNullable = e.Type.IsNullable(compilation),
                 TypeFullName = e.Type.ToDisplayString()
             }).ToArray());
     }

src/Foundatio.Mediator/IResult.cs

@@ -25,4 +25,19 @@ public interface IResult
     /// </summary>
     /// <returns>The result value.</returns>
     object? GetValue();
+
+    /// <summary>
+    /// Gets the status of the result.
+    /// </summary>
+    string Message { get; }
+
+    /// <summary>
+    /// Gets the location of a newly created resource (for Created status).
+    /// </summary>
+    string Location { get; }
+
+    /// <summary>
+    /// Gets the validation errors associated with the result.
+    /// </summary>
+    IEnumerable<ValidationError> ValidationErrors { get; }
 }