automatic support for Marten's new async aggregation side effect model.

Closes GH-938. Also 3.0-beta-2

Directory.Build.props

@@ -12,7 +12,7 @@
  <ImplicitUsings>true</ImplicitUsings>
  <Nullable>enable</Nullable>
  <VersionPrefix>3.0.0</VersionPrefix>
- <VersionSuffix>beta-1</VersionSuffix>
+ <VersionSuffix>beta-2</VersionSuffix>
  <RepositoryUrl>$(PackageProjectUrl)</RepositoryUrl>
  <PublishRepositoryUrl>true</PublishRepositoryUrl>
  <EmbedUntrackedSources>true</EmbedUntrackedSources>

src/Persistence/MartenTests/AsyncDaemonIntegration/end_to_end_publish_messages_through_marten_to_wolverine.cs

@@ -0,0 +1,110 @@
+using System.Diagnostics;
+using IntegrationTests;
+using JasperFx.Core;
+using Marten;
+using Marten.Events;
+using Marten.Events.Aggregation;
+using Marten.Events.Daemon.Resiliency;
+using Marten.Events.Projections;
+using Marten.Metadata;
+using Microsoft.Extensions.Hosting;
+using Npgsql;
+using Shouldly;
+using Weasel.Postgresql;
+using Wolverine;
+using Wolverine.Marten;
+using Wolverine.Tracking;
+using Xunit.Sdk;
+
+namespace MartenTests.AsyncDaemonIntegration;
+
+public class end_to_end_publish_messages_through_marten_to_wolverine
+{
+ [Fact]
+ public async Task can_publish_messages_through_outbox()
+ {
+ await dropSchema();
+
+ using var host = await Host.CreateDefaultBuilder()
+ .UseWolverine(opts =>
+ {
+ opts.Services.AddMarten(m =>
+ {
+ m.Connection(Servers.PostgresConnectionString);
+ m.DatabaseSchemaName = "wolverine_side_effects";
+
+ m.Projections.Add<Projection3>(ProjectionLifecycle.Async);
+ })
+ .IntegrateWithWolverine()
+ .AddAsyncDaemon(DaemonMode.Solo);
+ 
+ opts.Policies.UseDurableLocalQueues();
+ }).StartAsync();
+
+ var streamId = Guid.NewGuid();
+
+ Func<IMessageContext, Task> publish = async _ =>
+ {
+ using var session = host.DocumentStore().LightweightSession();
+ session.Events.StartStream<SideEffects1>(streamId, new AEvent(), new AEvent(), new BEvent());
+ await session.SaveChangesAsync();
+ };
+
+ var tracked = await host
+ .TrackActivity()
+ .Timeout(30.Seconds())
+ .WaitForMessageToBeReceivedAt<GotB>(host)
+ .ExecuteAndWaitAsync(publish);
+
+ tracked.Executed.SingleMessage<GotB>()
+ .StreamId.ShouldBe(streamId);
+ }
+
+ private static async Task dropSchema()
+ {
+ using var conn = new NpgsqlConnection(Servers.PostgresConnectionString);
+ await conn.OpenAsync();
+ await conn.DropSchemaAsync("wolverine_side_effects");
+ await conn.CloseAsync();
+ }
+}
+
+public class Projection3: SingleStreamProjection<SideEffects1>
+{
+ public void Apply(SideEffects1 aggregate, AEvent _)
+ {
+ aggregate.A++;
+ }
+
+ public void Apply(SideEffects1 aggregate, BEvent _)
+ {
+
+ }
+
+ public override ValueTask RaiseSideEffects(IDocumentOperations operations, IEventSlice<SideEffects1> slice)
+ {
+ if (slice.Aggregate != null && slice.Events().OfType<IEvent<BEvent>>().Any())
+ {
+ slice.PublishMessage(new GotB(slice.Aggregate.Id));
+ }
+
+ return new ValueTask();
+ }
+}
+
+public record GotB(Guid StreamId);
+
+public static class GotBHandler
+{
+ public static void Handle(GotB message) => Debug.WriteLine("Got B for stream " + message.StreamId);
+}
+
+public class SideEffects1: IRevisioned
+{
+ public Guid Id { get; set; }
+ public int A { get; set; }
+ public int B { get; set; }
+ public int C { get; set; }
+ public int D { get; set; }
+ public int Version { get; set; }
+}

src/Persistence/Wolverine.Marten/AncillaryWolverineOptionsMartenExtensions.cs

@@ -2,6 +2,7 @@
 using JasperFx.Core.IoC;
 using JasperFx.Core.Reflection;
 using Marten;
+using Marten.Internal;
 using Marten.Storage;
 using Marten.Subscriptions;
 using Microsoft.Extensions.DependencyInjection;
@@ -56,6 +57,8 @@ public static MartenServiceCollectionExtensions.MartenStoreExpression<T> Integra
  "The schema name must be in all lower case characters");
  }
 
+ expression.Services.AddSingleton<IConfigureMarten<T>, MartenOverrides<T>>();
+
  expression.Services.AddSingleton<IAncillaryMessageStore>(s =>
  {
  var store = s.GetRequiredService<T>().As<DocumentStore>();

src/Persistence/Wolverine.Marten/MartenIntegration.cs

@@ -1,10 +1,12 @@
 using JasperFx.Core.Reflection;
 using Marten;
 using Marten.Events;
+using Marten.Internal;
 using Marten.Schema;
 using Microsoft.Extensions.DependencyInjection;
 using Wolverine.Marten.Codegen;
 using Wolverine.Marten.Persistence.Sagas;
+using Wolverine.Marten.Publishing;
 using Wolverine.Persistence.Sagas;
 using Wolverine.Postgresql.Transport;
 using Wolverine.Runtime;
@@ -57,10 +59,12 @@ EventForwardingTransform<T> IEventForwarding.SubscribeToEvent<T>()
  }
 }
 
-internal class SagasShouldUseNumericRevisions : IConfigureMarten
+internal class MartenOverrides : IConfigureMarten
 {
  public void Configure(IServiceProvider services, StoreOptions options)
  {
+ options.Events.MessageOutbox = new MartenToWolverineOutbox(services);
+
  options.Policies.ForAllDocuments(mapping =>
  {
  if (mapping.DocumentType.CanBeCastTo<Saga>())
@@ -72,6 +76,8 @@ public void Configure(IServiceProvider services, StoreOptions options)
  }
 }
 
+internal class MartenOverrides<T> : MartenOverrides, IConfigureMarten<T> where T : IDocumentStore{}
+
 internal class EventWrapperForwarder : IHandledTypeRule
 {
  public bool TryFindHandledType(Type concreteType, out Type handlerType)

src/Persistence/Wolverine.Marten/Publishing/MartenToWolverineMessageBatch.cs

@@ -0,0 +1,25 @@
+using Marten;
+using Marten.Events.Aggregation;
+using Marten.Internal.Sessions;
+using Marten.Services;
+using Wolverine.Runtime;
+
+namespace Wolverine.Marten.Publishing;
+
+internal class MartenToWolverineMessageBatch(MessageContext Context, DocumentSessionBase Session) : IMessageBatch
+{
+ public async ValueTask PublishAsync<T>(T message)
+ {
+ await Context.PublishAsync(message);
+ }
+
+ public Task AfterCommitAsync(IDocumentSession session, IChangeSet commit, CancellationToken token)
+ {
+ return Context.FlushOutgoingMessagesAsync();
+ }
+
+ public Task BeforeCommitAsync(IDocumentSession session, IChangeSet commit, CancellationToken token)
+ {
+ return Task.CompletedTask;
+ }
+}

src/Persistence/Wolverine.Marten/Publishing/MartenToWolverineOutbox.cs

@@ -0,0 +1,24 @@
+using Marten.Events.Aggregation;
+using Marten.Internal.Sessions;
+using Microsoft.Extensions.DependencyInjection;
+using Wolverine.Runtime;
+
+namespace Wolverine.Marten.Publishing;
+
+internal class MartenToWolverineOutbox : IMessageOutbox
+{
+ private readonly Lazy<IWolverineRuntime> _runtime;
+
+ public MartenToWolverineOutbox(IServiceProvider services)
+ {
+ _runtime = new Lazy<IWolverineRuntime>(() => services.GetRequiredService<IWolverineRuntime>());
+ }
+
+ public async ValueTask<IMessageBatch> CreateBatch(DocumentSessionBase session)
+ {
+ var context = new MessageContext(_runtime.Value, session.TenantId);
+ await context.EnlistInOutboxAsync(new MartenEnvelopeTransaction(session, context));
+
+ return new MartenToWolverineMessageBatch(context, session);
+ }
+}

src/Persistence/Wolverine.Marten/Wolverine.Marten.csproj

@@ -12,7 +12,7 @@
  <ProjectReference Include="..\Wolverine.Postgresql\Wolverine.Postgresql.csproj"/>
  </ItemGroup>
  <ItemGroup>
- <PackageReference Include="Marten.CommandLine" Version="7.26.2" />
+ <PackageReference Include="Marten.CommandLine" Version="7.27.0" />
  </ItemGroup>
  <ItemGroup>
  <Compile Remove="CritterStackHostBuilder.cs" />

src/Persistence/Wolverine.Marten/WolverineOptionsMartenExtensions.cs

@@ -94,7 +94,7 @@ public static MartenServiceCollectionExtensions.MartenConfigurationExpression In
  expression.Services.AddType(typeof(IDatabaseSource), typeof(MartenMessageDatabaseDiscovery),
  ServiceLifetime.Singleton);
 
- expression.Services.AddSingleton<IConfigureMarten, SagasShouldUseNumericRevisions>();
+ expression.Services.AddSingleton<IConfigureMarten, MartenOverrides>();
 
  expression.Services.AddSingleton<IWolverineExtension>(new MartenIntegration
  {