middleware variable source

Author: kirill-gerasimenko-da

src/Http/Wolverine.Http/HttpChain.Codegen.cs

@@ -57,6 +57,7 @@ void ICodeFile.AssembleTypes(GeneratedAssembly assembly)
 
             var loggedType = determineLogMarkerType();
 
+            handleMethod.Sources.Add(new MiddlewareVariableSource(Middleware));
             handleMethod.Sources.Add(new LoggerVariableSource(loggedType));
             handleMethod.Sources.Add(new MessageBusSource());
 

src/Http/WolverineWebApi/MiddlewareEndpoints.cs

@@ -129,4 +129,35 @@ public string Get(AuthenticatedRequest request)
     {
         return "All good.";
     }
-}
+}
+
+#region sample_middleware_created_dependency
+
+public class HttpMiddlewareUser
+{
+    public string Name { get; set; }
+}
+
+public class HttpServiceWithMiddlewareUser
+{
+    public HttpMiddlewareUser User { get; }
+
+    public HttpServiceWithMiddlewareUser(HttpMiddlewareUser user) => User = user;
+}
+
+public static class HttpMiddlewareUserCreatingMiddleware
+{
+    public static HttpMiddlewareUser Before() => new() { Name = "HttpTestUser" };
+}
+
+public class MiddlewareServiceDependencyEndpoint
+{
+    [WolverineGet("/middleware/service-dependency")]
+    public string Get(HttpServiceWithMiddlewareUser service, Recorder recorder)
+    {
+        recorder.Actions.Add($"Handler received Service with User: {service.User.Name}");
+        return $"User: {service.User.Name}";
+    }
+}
+
+#endregion

src/Http/WolverineWebApi/Program.cs

@@ -245,6 +245,8 @@ public static async Task<int> Main(string[] args)
             opts.AddMiddleware(typeof(LoadTodoMiddleware),
                 chain => chain.Method.HandlerType == typeof(UpdateEndpointWithMiddleware));
             opts.AddPolicy<LoadTodoPolicy>();
+            opts.AddMiddleware(typeof(HttpMiddlewareUserCreatingMiddleware),
+                chain => chain.Method.HandlerType == typeof(MiddlewareServiceDependencyEndpoint));
 
             #region sample_user_marten_compiled_query_policy
 

src/Testing/CoreTests/Acceptance/middleware_usage.cs

@@ -335,6 +335,30 @@ public async Task use_implied_middleware_that_is_inner_type()
             "Score touchdown"
         );
     }
+
+    [Fact]
+    public async Task service_with_middleware_created_dependency_in_constructor()
+    {
+        var list = await invokeMessage(new MessageWithServiceDependingOnMiddlewareType(),
+            handlers => handlers.AddMiddleware<MiddlewareUserCreatingMiddleware>());
+
+        list.ShouldHaveTheSameElementsAs(
+            "MiddlewareUserCreatingMiddleware.Before - Created User: TestUser",
+            "Handler received User: TestUser and Service with User: TestUser"
+        );
+    }
+
+    [Fact]
+    public async Task service_only_with_middleware_created_dependency_in_constructor()
+    {
+        var list = await invokeMessage(new MessageWithServiceOnlyDependingOnMiddlewareType(),
+            handlers => handlers.AddMiddleware<MiddlewareUserCreatingMiddleware>());
+
+        list.ShouldHaveTheSameElementsAs(
+            "MiddlewareUserCreatingMiddleware.Before - Created User: TestUser",
+            "Handler received Service with User: TestUser"
+        );
+    }
 }
 
 public class MiddlewareActivity
@@ -671,4 +695,52 @@ public static void BackOnDefense(Recorder recorder)
             recorder.Actions.Add("Score touchdown");
         }
     }
-}
+}
+
+#region service_with_middleware_created_dependency_in_constructor
+
+public class MessageWithServiceDependingOnMiddlewareType;
+public class MessageWithServiceOnlyDependingOnMiddlewareType;
+
+public class MiddlewareUser
+{
+    public string Name { get; set; }
+}
+
+public class ServiceWithMiddlewareUser
+{
+    public MiddlewareUser User { get; }
+
+    public ServiceWithMiddlewareUser(MiddlewareUser user)
+    {
+        User = user;
+    }
+}
+
+public class MiddlewareUserCreatingMiddleware
+{
+    public MiddlewareUser Before(Recorder recorder)
+    {
+        var user = new MiddlewareUser { Name = "TestUser" };
+        recorder.Actions.Add($"MiddlewareUserCreatingMiddleware.Before - Created User: {user.Name}");
+        return user;
+    }
+}
+
+public class MessageWithServiceDependingOnMiddlewareTypeHandler
+{
+    public void Handle(MessageWithServiceDependingOnMiddlewareType message, MiddlewareUser user, ServiceWithMiddlewareUser service, Recorder recorder)
+    {
+        recorder.Actions.Add($"Handler received User: {user.Name} and Service with User: {service.User.Name}");
+    }
+}
+
+public class MessageWithServiceOnlyDependingOnMiddlewareTypeHandler
+{
+    public void Handle(MessageWithServiceOnlyDependingOnMiddlewareType message, ServiceWithMiddlewareUser service, Recorder recorder)
+    {
+        recorder.Actions.Add($"Handler received Service with User: {service.User.Name}");
+    }
+}
+
+#endregion

src/Wolverine/Runtime/Handlers/HandlerChain.cs

@@ -211,6 +211,7 @@ void ICodeFile.AssembleTypes(GeneratedAssembly assembly)
 
         var handleMethod = _generatedType.MethodFor(nameof(MessageHandler.HandleAsync));
 
+        handleMethod.Sources.Add(new MiddlewareVariableSource(Middleware));
         handleMethod.Sources.Add(new LoggerVariableSource(MessageType));
         var envelopeVariable = new Variable(typeof(Envelope),
             $"context.{nameof(IMessageContext.Envelope)}");

src/Wolverine/Runtime/Handlers/MiddlewareVariableSource.cs

@@ -0,0 +1,32 @@
+using JasperFx.CodeGeneration.Frames;
+using JasperFx.CodeGeneration.Model;
+
+namespace Wolverine.Runtime.Handlers;
+
+/// <summary>
+/// Variable source that provides variables created by middleware frames
+/// so they can be found during service dependency resolution.
+/// This enables services with constructor dependencies on middleware-created types
+/// to be properly resolved.
+/// </summary>
+public class MiddlewareVariableSource : IVariableSource
+{
+    private readonly IReadOnlyList<Variable> _middlewareVariables;
+
+    public MiddlewareVariableSource(IEnumerable<Frame> middlewareFrames)
+    {
+        _middlewareVariables = middlewareFrames
+            .SelectMany(f => f.Creates)
+            .ToList();
+    }
+
+    public bool Matches(Type type)
+    {
+        return _middlewareVariables.Any(v => v.VariableType == type);
+    }
+
+    public Variable Create(Type type)
+    {
+        return _middlewareVariables.First(v => v.VariableType == type);
+    }
+}