Middleware starting to work

Sample/MyRequestMiddleware.cs

@@ -0,0 +1,21 @@
+namespace Sample;
+
+// [RegisterMiddleware]
+public class MyRequestMiddleware : IRequestMiddleware<MyMessageRequest, MyMessageResponse>
+{
+    public async Task<MyMessageResponse> Process(MyMessageRequest request, Func<Task<MyMessageResponse>> next, CancellationToken cancellationToken)
+    {
+        // BEFORE - If connected - pull from API after save to cache ELSE pull from cache 
+        var result = await next();
+        // AFTER = cache
+        return result;
+    }
+}
+
+public class CatchAllRequestMiddleware : IRequestMiddleware<IRequest<object>, object> 
+{
+    public Task<object> Process(IRequest<object> request, Func<Task<object>> next, CancellationToken cancellationToken)
+    {
+        throw new NotImplementedException();
+    }
+}

Sample/TriggerViewModel.cs

@@ -22,11 +22,11 @@ AppSqliteConnection data
                     this.Arg!,
                     this.FireAndForgetEvents
                 );
-                var response = await mediator.Send(request, this.cancelSource.Token);
+                var result = await mediator.Request(request, this.cancelSource.Token);
                 await data.Log(
                     "TriggerViewModel-Response",
                     new MyMessageEvent(
-                        response.Response, 
+                        result.Response, 
                         this.FireAndForgetEvents 
                     )
                 );

readme.md

@@ -155,6 +155,12 @@ public class MyViewModel : BaseViewModel,
 }
 ```
 
+## Request Middleware
+TODO
+
+## Event Covariance
+TODO
+
 ## Sample
 There is a sample in this repo.  You do not need any other part of Shiny, Prism, ReactiveUI, etc - those are included as I write things faster with it.
 Focus on the interfaces from the mediator & the mediator calls itself
@@ -170,8 +176,8 @@ Focus on the interfaces from the mediator & the mediator calls itself
 
 ## TODO
 * Explain Event Collectors 
+* Event Collectors for MAUI execute on main thread?
 * Streams - IAsyncEnumerable or IObservable
 * Source Generator Registration
   * Need to use a different method or not use extension methods - maybe AddHandlersFromAssemblyName or allow it to be custom named 
 * IEventHandler<IEvent> can handle ALL events?
-* Request Middleware - Covariance/catch-all

src/Shiny.Mediator.Contracts/IEvent.cs

@@ -1,6 +1,8 @@
 namespace Shiny.Mediator;
 
-public interface IEvent
-{
-
-}
+public interface IEvent { }
+
+/// <summary>
+/// This is a good base type if you want to make use of covariance in your handlers
+/// </summary>
+public record Event : IEvent;

src/Shiny.Mediator.Contracts/IRequest.cs

@@ -1,6 +1,6 @@
 namespace Shiny.Mediator;
 
-public interface IRequest
+public interface IRequest : IRequest<Unit>
 {
 }
 

src/Shiny.Mediator.SourceGenerators/MediatorSourceGenerator.cs

@@ -15,7 +15,7 @@ public class MediatorSourceGenerator : ISourceGenerator
     public void Initialize(GeneratorInitializationContext context)
     {
         context.RegisterForPostInitialization(x => x.AddSource(
-            "RegisterHandlerAttribute.g.cs", 
+            "MediatorAttributes.g.cs", 
             SourceText.From(
                 """
                 // <auto-generated>
@@ -28,7 +28,12 @@ public void Initialize(GeneratorInitializationContext context)
                 [System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple = false)]
                 internal sealed class RegisterHandlerAttribute: System.Attribute
                 {
-                    public RegisterHandlerAttribute() {}
+                    public RegisterHandlerAttribute(bool IsSingleton = true) {}
+                }
+                
+                internal sealed class RegisterMiddlewareAttribute: System.Attribute
+                {
+                    public RegisterMiddlewareAttribute(bool IsSingleton = true) {}
                 }
                 """,
                 Encoding.UTF8

src/Shiny.Mediator.SourceGenerators/RegisterHandlerAttributeSyntaxReceiver.cs

@@ -11,15 +11,20 @@ public class RegisterHandlerAttributeSyntaxReceiver : SyntaxReceiver
     protected override bool ShouldCollectClassSymbol(INamedTypeSymbol classSymbol)
     {
         var hasAttribute = classSymbol.HasAttribute("RegisterHandlerAttribute");
-        if (!hasAttribute)
-            return false;
+        if (hasAttribute)
+        {
+            // TODO: log error
+            if (classSymbol.IsImplements("Shiny.Mediator.IEventHandler`1"))
+                return false;
 
-        if (classSymbol.IsImplements("Shiny.Mediator.IEventHandler`1"))
-            return false;
-
-        if (classSymbol.IsImplements("Shiny.Mediator.IRequestHandler`1"))
-            return false;
-
+            if (classSymbol.IsImplements("Shiny.Mediator.IRequestHandler`1"))
+                return false;
+        }
+        hasAttribute = classSymbol.HasAttribute("RegisterMiddleware");
+        if (hasAttribute)
+        {
+            return true;
+        }
         return false;
     }
 }

src/Shiny.Mediator/IRequestHandler.cs

@@ -1,12 +1,12 @@
 namespace Shiny.Mediator;
 
-public interface IRequestHandler<in TRequest> where TRequest : notnull, IRequest
+public interface IRequestHandler<TRequest> where TRequest : notnull, IRequest
 {
     Task Handle(TRequest request, CancellationToken cancellationToken);
 }
 
 
-public interface IRequestHandler<in TRequest, TResult> where TRequest : notnull, IRequest<TResult>
+public interface IRequestHandler<TRequest, TResult> where TRequest : notnull, IRequest<TResult>
 {
     Task<TResult> Handle(TRequest request, CancellationToken cancellationToken);
 }

src/Shiny.Mediator/IRequestMiddleware.cs

@@ -1,13 +1,7 @@
-// using Shiny.Mediator;
-//
-// // TODO: how do I register an "ALL" middleware
-//
-// // TODO: execution duration timer
-//
-// // TODO: catch all could be IRequest or IRequest<T>?  Could use an IRequest<Void>?
-// public interface IRequestMiddleware<TRequest, TResult> where TRequest : IRequest<TResult>
-// {
-//     // intercept with connectivity, if offline go to cache, if online go to remote
-//     // if went to remote, post execute stores to cache
-//     Task<TResult> Process(TRequest request, IRequestMiddleware<TRequest, TResult> next, CancellationToken cancellationToken);
-// }
+using Shiny.Mediator;
+
+
+public interface IRequestMiddleware<in TRequest, TResult> where TRequest : IRequest<TResult>
+{
+    Task<TResult> Process(TRequest request, Func<Task<TResult>> next, CancellationToken cancellationToken);
+}

src/Shiny.Mediator/Impl/DefaultRequestSender.cs

@@ -7,35 +7,84 @@ namespace Shiny.Mediator.Impl;
 
 public class DefaultRequestSender(IServiceProvider services) : IRequestSender
 {
-    public async Task Send<TRequest>(TRequest request, CancellationToken cancellationToken = default) where TRequest : IRequest
+    public async Task Send<TRequest>(TRequest request, CancellationToken cancellationToken) where TRequest : IRequest
     {
-        // TODO: middleware execution should support contravariance
         using var scope = services.CreateScope();
         var handlers = scope.ServiceProvider.GetServices<IRequestHandler<TRequest>>().ToList();
         AssertRequestHandlers(handlers.Count, request);
 
-        // TODO: pipelines
-        await handlers
-            .First()
-            .Handle(request, cancellationToken)
-            .ConfigureAwait(false);
+        await this.ExecuteMiddleware(
+            scope, 
+            (IRequest<Unit>)request, 
+            async () =>
+            {
+                await handlers
+                    .First()
+                    .Handle(request, cancellationToken)
+                    .ConfigureAwait(false);
+                return Unit.Value;
+            },
+            cancellationToken
+        )
+        .ConfigureAwait(false);
     }
 
 
-    public async Task<TResult> Send<TResult>(IRequest<TResult> request, CancellationToken cancellationToken = default)
+    public async Task<TResult> Request<TResult>(IRequest<TResult> request, CancellationToken cancellationToken = default)
     {
         var handlerType = typeof(IRequestHandler<,>).MakeGenericType(request.GetType(), typeof(TResult));
-
-        // TODO: middleware execution should support contravariance
         using var scope = services.CreateScope();
         var handlers = scope.ServiceProvider.GetServices(handlerType).ToList();
         AssertRequestHandlers(handlers.Count, request);
 
-        var handler = handlers.First();
-        var handleMethod = handlerType.GetMethod("Handle", BindingFlags.Instance | BindingFlags.Public)!;
-        var resultTask = (Task<TResult>)handleMethod.Invoke(handler, [request, cancellationToken])!;
-        var result = await resultTask.ConfigureAwait(false);
-
+        Func<Task<TResult>> execute = async () =>
+        {
+            var handler = handlers.First();
+            var handleMethod = handlerType.GetMethod("Handle", BindingFlags.Instance | BindingFlags.Public)!;
+            var resultTask = (Task<TResult>)handleMethod.Invoke(handler, [request, cancellationToken])!;
+            var result = await resultTask.ConfigureAwait(false);
+            return result;
+        };
+        var result = await this.ExecuteMiddleware(scope, request, execute, cancellationToken).ConfigureAwait(false);
+        return result;
+    }
+
+
+    async Task<TResult> ExecuteMiddleware<TRequest, TResult>(
+        IServiceScope scope, 
+        TRequest request, 
+        Func<Task<TResult>> initialExecute, 
+        CancellationToken cancellationToken
+    ) where TRequest : IRequest<TResult>
+    {
+        var middlewareType = typeof(IRequestMiddleware<,>).MakeGenericType(request.GetType(), typeof(TResult));
+        var middlewareMethod = middlewareType.GetMethod("Process", BindingFlags.Instance | BindingFlags.Public)!;
+        var middlewares = scope.ServiceProvider.GetServices(middlewareType).ToList();
+
+        // middlewares.Reverse();
+        // foreach (var middleware in middlewares)
+        // {
+        //     var next = () =>
+        //     {
+        //         return (Task<TResult>)middlewareMethod.Invoke(middleware, [
+        //             request, 
+        //             next, 
+        //             cancellationToken
+        //         ]);
+        //     };
+        // }
+        //
+        // await next!.Invoke().ConfigureAwait(false);
+        // we setup execution in reverse - with the top being our start/await point
+        // middlewares.Reverse();
+        // var next = initialExecute;
+        //
+        // foreach (var middleware in middlewares)
+        //     next = () => (Task<TResult>)middlewareMethod.Invoke(middleware, [request, next, cancellationToken]);
+        //
+        // var result = await next().ConfigureAwait(false);
+        // return result;
+        var result = await initialExecute.Invoke().ConfigureAwait(false);
         return result;
     }
 

src/Shiny.Mediator/Impl/Mediator.cs

@@ -8,8 +8,8 @@ public class Mediator(
     IEventPublisher eventPublisher
 ) : IMediator
 {
-    public Task<TResult> Send<TResult>(IRequest<TResult> request, CancellationToken cancellationToken = default)
-        => requestSender.Send(request, cancellationToken);
+    public Task<TResult> Request<TResult>(IRequest<TResult> request, CancellationToken cancellationToken = default)
+        => requestSender.Request(request, cancellationToken);
 
     public Task Send<TRequest>(TRequest request, CancellationToken cancellationToken = default) where TRequest : IRequest
         => requestSender.Send(request, cancellationToken);

src/Shiny.Mediator/Infrastructure/IRequestSender.cs

@@ -4,8 +4,6 @@ public interface IRequestSender
 {
     // Task Send(object arg, CancellationToken cancellationToken = default)
     // Task<object?> Send(object arg, CancellationToken cancellationToken = default);
-
-
 
     /// <summary>
     /// 
@@ -14,7 +12,7 @@ public interface IRequestSender
     /// <param name="cancellationToken"></param>
     /// <typeparam name="TResult"></typeparam>
     /// <returns></returns>
-    Task<TResult> Send<TResult>(
+    Task<TResult> Request<TResult>(
         IRequest<TResult> request,
         CancellationToken cancellationToken = default
     );

src/Shiny.Mediator/Middleware/ExceptionHandlerMiddleware.cs

@@ -0,0 +1,18 @@
+namespace Shiny.Mediator.Middleware;
+
+public class ExceptionHandlerMiddleware<TRequest, TResult> : IRequestMiddleware<TRequest, TResult> where TRequest : IRequest<TResult>
+{
+    public async Task<TResult> Process(TRequest request, Func<Task<TResult>> next, CancellationToken cancellationToken)
+    {
+        try
+        {
+            return await next();
+
+        }
+        catch (Exception ex)
+        {
+            // TODO: log, trap?
+            throw;
+        }
+    }
+}

src/Shiny.Mediator/Middleware/TimedMiddleware.cs

@@ -1,18 +1,18 @@
-// using System.Diagnostics;
-//
-// namespace Shiny.Mediator.Middleware;
-//
-// public class TimedMiddleware<TRequest, TResult> : IRequestMiddleware<TRequest, TResult> where TRequest : IRequest<TResult>
-// {
-//     public async Task<TResult> Process(TRequest request, IRequestMiddleware<TRequest, TResult> next, CancellationToken cancellationToken)
-//     {
-//         var sw = new Stopwatch();
-//         sw.Start();
-//         var result = await next(request, cancellationToken);
-//         sw.Stop();
-//         
-//         // TODO: alert on long?
-//         return result;
-//     }
-// }
+using System.Diagnostics;
+
+namespace Shiny.Mediator.Middleware;
+
+public class TimedMiddleware<TRequest, TResult> : IRequestMiddleware<TRequest, TResult> where TRequest : IRequest<TResult>
+{
+    public async Task<TResult> Process(TRequest request, Func<Task<TResult>> next, CancellationToken cancellationToken)
+    {
+        var sw = new Stopwatch();
+        sw.Start();
+        var result = await next();
+        sw.Stop();
+
+        // TODO: alert on long?
+        return result;
+    }
+}