Wolverine + EF Core domain events are not collected/published when using AutoApplyTransactions or manual IUnitOfWork commit

[azamat-kholturaev]

🧩 Wolverine + EF Core domain events are not published (AutoApplyTransactions / manual UoW)

Description

I am using Wolverine + EF Core + PostgreSQL + RabbitMQ in a modular monolith.

I am trying to use Wolverine EF Core integration:

options.PublishDomainEventsFromEntityFrameworkCore<IHaveDomainEvents>(x => x.DomainEvents);

However, domain events raised inside my aggregate are not being collected or published.

Additionally:

• With AutoApplyTransactions() → BookOrder is not saved in DB at all
• With manual commit via IUnitOfWork → data may persist, but domain events are not published

---

Expected behavior

1. Aggregate raises domain event
2. EF Core tracks entity
3. Wolverine collects domain events on SaveChanges
4. Handler is executed
5. Integration event is published via RabbitMQ (outbox)

---

Actual behavior

• Domain events are raised
• EF Core tracks entity
• Wolverine does not publish domain events
• Handler is not executed
• Integration event is not sent to RabbitMQ
• With AutoApplyTransactions() the entity is not saved

---

Architecture flow

HTTP Request
   ↓
OrderBookCommand (IMessageBus.InvokeAsync)
   ↓
BookOrder aggregate is created
   ↓
AggregateRoot raises BookOrderPlacedDomainEvent
   ↓
EF Core tracks entity
   ↓
Wolverine should collect domain events from EF Core
   ↓
Handler maps domain event to integration event
   ↓
RabbitMQ publish through durable outbox

---

Aggregate Root

public abstract class AggregateRoot<TId> : Entity<TId>, IHaveDomainEvents
    where TId : notnull
{
    private readonly List<IDomainEvent> _domainEvents = [];

    public IReadOnlyCollection<IDomainEvent> DomainEvents => _domainEvents.AsReadOnly();

    protected void Raise(IDomainEvent domainEvent)
    {
        ArgumentNullException.ThrowIfNull(domainEvent);
        _domainEvents.Add(domainEvent);
    }

    public void ClearDomainEvents()
        => _domainEvents.Clear();
}

---

Domain Entity

public sealed class BookOrder : AggregateRoot<Guid>
{
    private BookOrder()
    {
    }

    public Guid BookId { get; private set; }
    public string BookTitle { get; private set; } = string.Empty;
    public string BookAuthor { get; private set; } = string.Empty;
    public decimal UnitPrice { get; private set; }
    public int Quantity { get; private set; }
    public decimal TotalPrice { get; private set; }
    public string CustomerName { get; private set; } = string.Empty;
    public string CustomerEmail { get; private set; } = string.Empty;
    public BookOrderStatus Status { get; private set; }

    public static BookOrder Create(
        Guid id,
        Book book,
        int quantity,
        string customerName,
        string customerEmail)
    {
        ArgumentOutOfRangeException.ThrowIfEqual(id, Guid.Empty);
        ArgumentNullException.ThrowIfNull(book);
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(quantity);

        if (string.IsNullOrWhiteSpace(customerName))
        {
            throw new ArgumentException("Customer name is required.", nameof(customerName));
        }

        if (string.IsNullOrWhiteSpace(customerEmail))
        {
            throw new ArgumentException("Customer email is required.", nameof(customerEmail));
        }

        var order = new BookOrder
        {
            Id = id,
            BookId = book.Id,
            BookTitle = book.Title,
            BookAuthor = book.Author,
            UnitPrice = book.Price,
            Quantity = quantity,
            TotalPrice = book.Price * quantity,
            CustomerName = customerName.Trim(),
            CustomerEmail = customerEmail.Trim(),
            Status = BookOrderStatus.Pending
        };

        order.Raise(new BookOrderPlacedDomainEvent(
            order.Id,
            order.BookId,
            order.BookTitle,
            order.Quantity,
            order.CustomerName,
            order.CustomerEmail,
            order.TotalPrice));

        return order;
    }

    public void Confirm()
    {
        if (Status == BookOrderStatus.Confirmed)
        {
            return;
        }

        Status = BookOrderStatus.Confirmed;
        Touch();
    }
}

---

Domain Event

public sealed record BookOrderPlacedDomainEvent(
    Guid OrderId,
    Guid BookId,
    string BookTitle,
    int Quantity,
    string CustomerName,
    string CustomerEmail,
    decimal TotalPrice) : IDomainEvent;

---

Repository

internal sealed class BookOrderRepository(BooksDbContext dbContext) : IBookOrderRepository
{
    public async Task AddAsync(BookOrder order, CancellationToken cancellationToken)
    {
        await dbContext.BookOrders.AddAsync(order, cancellationToken);
    }

    public async Task<IReadOnlyCollection<BookOrder>> GetAllAsync(CancellationToken cancellationToken)
    {
        return await dbContext.BookOrders
            .OrderByDescending(order => order.CreatedAtUtc)
            .ToArrayAsync(cancellationToken);
    }

    public Task<BookOrder?> GetByIdAsync(Guid id, CancellationToken cancellationToken)
    {
        return dbContext.BookOrders
            .SingleOrDefaultAsync(order => order.Id == id, cancellationToken);
    }

    public Task<BookOrder?> GetForUpdateAsync(Guid id, CancellationToken cancellationToken)
    {
        return dbContext.BookOrders
            .SingleOrDefaultAsync(order => order.Id == id, cancellationToken);
    }
}

---

Infrastructure registration

using Avia.Books.Application.Abstractions;
using Avia.Books.Infrastructure.Persistence;
using Avia.Books.Infrastructure.Repositories;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace Avia.Books.Infrastructure;

public static class DependencyInjection
{
    public static IServiceCollection AddBooksInfrastructure(
        this IServiceCollection services,
        IConfiguration configuration)
    {
        var connectionString = configuration.GetConnectionString("BooksConnection")
            ?? configuration.GetConnectionString("DefaultConnection")
            ?? throw new InvalidOperationException("Connection string 'BooksConnection' or 'DefaultConnection' was not found.");

        services.AddDbContext<BooksDbContext>(options =>
        {
            options.UseNpgsql(
                connectionString,
                npgsql =>
                {
                    npgsql.MigrationsAssembly(typeof(BooksDbContext).Assembly.FullName);
                    npgsql.MigrationsHistoryTable("__EFMigrationsHistory", "books");
                });
        });

        services.AddScoped<IUnitOfWork>(serviceProvider => serviceProvider.GetRequiredService<BooksDbContext>());

        services.AddHostedService<BooksDbInitializer>();
        services.AddScoped<IBookCatalogRepository, BookCatalogRepository>();
        services.AddScoped<IBookOrderRepository, BookOrderRepository>();

        return services;
    }
}

---

Endpoint

private static async Task<IResult> OrderBookAsync(
    OrderBookRequest request,
    IMessageBus messageBus,
    CancellationToken cancellationToken)
{
    var result = await messageBus.InvokeAsync<Result<BookOrderResponse>>(
        new OrderBookCommand(
            request.BookId,
            request.Quantity,
            request.CustomerName,
            request.CustomerEmail),
        cancellationToken);

    if (result.IsFailure)
    {
        return Results.BadRequest(new
        {
            code = result.Error.Code,
            message = result.Error.Description
        });
    }

    return Results.Created($"/api/books/orders/{result.Value.Id}", result.Value);
}

---

Command Handler

using Avia.BuildingBlocks.Application.Results;
using Avia.Books.Application.Abstractions;
using Avia.Books.Application.Contracts;
using Avia.Books.Application.Errors;
using Avia.Books.Domain.Entities;

namespace Avia.Books.Application.Handlers;

public static class BookOrderingHandler
{
    public static async Task<Result<BookOrderResponse>> Handle(
        OrderBookCommand command,
        IBookCatalogRepository catalogRepository,
        IBookOrderRepository orderRepository,
        IUnitOfWork unitOfWork,
        CancellationToken cancellationToken)
    {
        if (command.Quantity <= 0)
        {
            return Result<BookOrderResponse>.Failure(BookErrors.InvalidQuantity);
        }

        if (string.IsNullOrWhiteSpace(command.CustomerName))
        {
            return Result<BookOrderResponse>.Failure(BookErrors.EmptyCustomerName);
        }

        if (string.IsNullOrWhiteSpace(command.CustomerEmail))
        {
            return Result<BookOrderResponse>.Failure(BookErrors.EmptyCustomerEmail);
        }

        var book = await catalogRepository.GetByIdAsync(command.BookId, cancellationToken);
        if (book is null)
        {
            return Result<BookOrderResponse>.Failure(BookErrors.BookNotFound);
        }

        var order = BookOrder.Create(
            Guid.NewGuid(),
            book,
            command.Quantity,
            command.CustomerName,
            command.CustomerEmail);

        await orderRepository.AddAsync(order, cancellationToken);

        // await unitOfWork.CommitAsync(cancellationToken);

        return Result<BookOrderResponse>.Success(MapOrder(order));
    }

    private static BookOrderResponse MapOrder(BookOrder order)
    {
        return new BookOrderResponse(
            order.Id,
            order.BookId,
            order.BookTitle,
            order.BookAuthor,
            order.UnitPrice,
            order.Quantity,
            order.TotalPrice,
            order.CustomerName,
            order.CustomerEmail,
            order.Status.ToString(),
            order.CreatedAtUtc);
    }
}

---

Domain → Integration handler

using Avia.Books.Application.Abstractions;
using Avia.Books.Domain.Events;
using Avia.Payments.Contracts.IntegrationEvents;

namespace Avia.Books.Application.Handlers;

public sealed class BookOrderIntegrationEventHandler
{
    public PaymentRequestedIntegrationEvent Handle(BookOrderPlacedDomainEvent domainEvent)
    {
        return new PaymentRequestedIntegrationEvent(
            "Books",
            domainEvent.OrderId,
            domainEvent.TotalPrice,
            domainEvent.CustomerEmail,
            $"Book order {domainEvent.OrderId} for {domainEvent.BookTitle}");
    }

    public async Task Handle(
        PaymentCompletedIntegrationEvent integrationEvent,
        IBookOrderRepository orderRepository,
        CancellationToken cancellationToken)
    {
        if (!string.Equals(integrationEvent.SourceModule, "Books", StringComparison.OrdinalIgnoreCase))
        {
            return;
        }

        var order = await orderRepository.GetForUpdateAsync(integrationEvent.SourceEntityId, cancellationToken);
        if (order is null)
        {
            return;
        }

        order.Confirm();
    }
}

---

Wolverine configuration

using Avia.Payments.Contracts.IntegrationEvents;
using Avia.Books.Infrastructure.Persistence;
using Avia.BuildingBlocks.Domain.Events;
using Wolverine.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using Avia.Payments.Presentation;
using Avia.Books.Presentation;
using Wolverine.Persistence;
using Wolverine.Postgresql;
using JasperFx.Resources;
using Wolverine.RabbitMQ;
using Wolverine;

var builder = WebApplication.CreateBuilder(args);

var mainConnectionString = builder.Configuration.GetConnectionString("DefaultConnection")
    ?? throw new InvalidOperationException("Connection string 'DefaultConnection' was not found.");

var rabbitMqUri = builder.Configuration["RabbitMq:Uri"]
    ?? throw new InvalidOperationException("RabbitMq:Uri was not found.");

builder.Services.AddOpenApi();

builder.Services.AddBooksModule(builder.Configuration);
builder.Services.AddPaymentsModule(builder.Configuration);

builder.Host.UseWolverine(options =>
{
    options.PersistMessagesWithPostgresql(mainConnectionString, "wolverine");
    options.UseEntityFrameworkCoreTransactions();
    options.PublishDomainEventsFromEntityFrameworkCore<IHaveDomainEvents>(x => x.DomainEvents);

    options.Policies.AutoApplyTransactions();
    options.Policies.UseDurableLocalQueues();
    options.EnableRemoteInvocation = false;
    options.Services.AddResourceSetupOnStartup();
    options.Discovery.IncludeAssembly(typeof(Avia.Books.Application.DependencyInjection).Assembly);

    // options.Discovery.IncludeAssembly(typeof(Avia.Payments.Application.DependencyInjection).Assembly);

    options.UseRabbitMq(new Uri(rabbitMqUri))
        .DeclareExchange("payments.requested", exchange => exchange.BindQueue("payments.requested"))
        .DeclareExchange("payments.completed", exchange => exchange.BindQueue("books.payments.completed"))
        .AutoProvision();

    options.PublishMessage<PaymentRequestedIntegrationEvent>()
        .ToRabbitExchange("payments.requested")
        .UseDurableOutbox();

    options.PublishMessage<PaymentCompletedIntegrationEvent>()
        .ToRabbitExchange("payments.completed")
        .UseDurableOutbox();

    options.ListenToRabbitQueue("payments.requested")
        .UseDurableInbox();

    options.ListenToRabbitQueue("books.payments.completed")
        .UseDurableInbox();
});

var app = builder.Build();

app.MapOpenApi();

if (app.Environment.IsDevelopment())
{
    app.UseSwaggerUI(options =>
    {
        options.SwaggerEndpoint("/openapi/v1.json", "Avia API v1");
        options.RoutePrefix = "swagger";
    });
}

app.UseHttpsRedirection();

app.MapGet("/health", () => Results.Ok(new
{
    application = "Avia",
    status = "ok"
}));

app.MapBooksEndpoints();
app.MapPaymentsEndpoints();

app.Run();

---

Step-by-step problem

1. OrderBookCommand is executed
2. BookOrder is created
3. BookOrderPlacedDomainEvent is raised
4. Entity is added to DbContext
5. Wolverine does not collect domain events
6. Domain event handler is not triggered
7. Integration event is not published

---

Questions

1. Does PublishDomainEventsFromEntityFrameworkCore require a specific handler pattern?
2. Does it only work when Wolverine controls SaveChanges()?
3. Is extra configuration required for modular monolith / multiple DbContexts?
4. Should domain event handlers be registered differently?
5. Is returning IntegrationEvent from Handle(DomainEvent) supported?
6. Why does AutoApplyTransactions() prevent entity persistence?

---

Environment

• .NET
• EF Core
• PostgreSQL
• Wolverine
• RabbitMQ

---

Notes

• Repository does not call SaveChangesAsync()
• Expecting Wolverine transaction middleware to handle persistence
• Domain events exist inside aggregate but are not dispatched

---

Any help would be appreciated

[jeremydmiller]

Hey man, this is about as non-idiomatic as you could possibly be with Wolverine and not really an architecture I would recommend with Wolverine. Try eliminating as many layers as you can and make your types public so Wolverine can build everything w/o IoC. I'd guess you're getting messed up by having to use service location. Might wanna read over Wolverine's Best Practices and try to conform to that.

[azamat-kholturaev]

Thanks for the feedback!
Could you please suggest what architecture or approach you would recommend when using Wolverine?
I’d really appreciate any guidance or best practices you find effective.

[jeremydmiller]

Start with the Best Practices and the Vertical Slice Architecture. Eliminate the repository layer. I'd push to return any domain events from the handler itself. Ditch the AggregateRoot idea too if you can make yourself do that. Wolverine will largely let you use pure functions for the handlers