Cosmos.EventSourcing.CritterStack 0.1.7

Cosmos.EventSourcing.CritterStack

Implementación completa de Event Sourcing y CQRS usando Wolverine y Marten (CritterStack).

Descripción

Este paquete proporciona implementaciones listas para producción de todas las abstracciones definidas en Cosmos.EventSourcing.Abstractions. Utiliza Wolverine para mensajería y mediación, y Marten como Event Store y Document Database sobre PostgreSQL.

CritterStack es el nombre de la combinación de Wolverine + Marten, dos poderosas herramientas del ecosistema .NET.

Características

Event Store

• MartenEventStore: Implementación de IEventStore usando Marten
• Soporte para recuperar agregados por ID, versión o timestamp
• Soporte para verificar existencia de agregados con ExistsAsync<T>
• Persistencia de eventos en PostgreSQL

Command Routing

• WolverineCommandRouter: Router de comandos usando Wolverine
• Soporte para comandos con y sin valor de retorno
• Integración con multi-tenancy

Query Routing

• WolverineQueryRouter: Router de consultas usando Wolverine
• Ejecución distribuida de queries

Projection Store

• MartenProjectionStore: Almacén de proyecciones usando Marten
• Operaciones CRUD sobre proyecciones/vistas de lectura

Instalación

dotnet add package Cosmos.EventSourcing.CritterStack

Este paquete incluye automáticamente las dependencias de:

• Cosmos.EventSourcing.Abstractions
• Cosmos.MultiTenancy

Configuración

Registrar Servicios (con IHostBuilder)

using Cosmos.EventSourcing.CritterStack;

var builder = WebApplication.CreateBuilder(args);

// Configura Wolverine + Marten para comandos
builder.Host.UsarWolverineParaComandos(
    dominioAssembly: typeof(MiAgregado).Assembly,
    martenConnectionString: builder.Configuration.GetConnectionString("Postgres")!,
    databaseSchemaName: "mi_servicio",
    isDevelopment: builder.Environment.IsDevelopment()
);

// Registra el router de comandos
builder.Services.AgregarWolverineCommandRouter();

// Registra el router de consultas
builder.Services.AgregarWolverineQueryRouter();

var app = builder.Build();
app.Run();

Configuración Serverless (Azure Functions)

// Para entornos serverless usa AgregarWolverineParaComandosServerless
builder.Services.AgregarWolverineParaComandosServerless(
    dominioAssembly: typeof(MiAgregado).Assembly,
    martenConnectionString: connectionString,
    databaseSchemaName: "mi_servicio",
    isDevelopment: false
);

Uso

Implementar Command Handlers con Wolverine

using Cosmos.EventSourcing.Abstractions.Commands;

public record CreateOrder(string OrderId, string CustomerId);

// Los handlers son descubiertos automáticamente por Wolverine
public class CreateOrderHandler
{
    private readonly IEventStore _eventStore;

    public CreateOrderHandler(IEventStore eventStore)
    {
        _eventStore = eventStore;
    }

    public async Task Handle(CreateOrder command, CancellationToken ct)
    {
        var order = new Order(command.OrderId, command.CustomerId);

        _eventStore.Save(order);
        await _eventStore.SaveChangesAsync();
    }
}

Ejecutar Comandos con el Router

public class OrderController : ControllerBase
{
    private readonly ICommandRouter _commandRouter;

    public OrderController(ICommandRouter commandRouter)
    {
        _commandRouter = commandRouter;
    }

    [HttpPost]
    public async Task<IActionResult> CreateOrder(CreateOrderRequest request)
    {
        var command = new CreateOrder(Guid.NewGuid().ToString(), request.CustomerId);

        await _commandRouter.InvokeAsync(command, HttpContext.RequestAborted);

        return Ok(new { OrderId = command.OrderId });
    }
}

Implementar Query Handlers

public record GetOrderById(string OrderId);

public class GetOrderByIdHandler
{
    private readonly IProjectionStore _projectionStore;

    public GetOrderByIdHandler(IProjectionStore projectionStore)
    {
        _projectionStore = projectionStore;
    }

    public async Task<OrderDto?> Handle(GetOrderById query, CancellationToken ct)
    {
        return await _projectionStore.GetByIdAsync<OrderDto>(query.OrderId, ct);
    }
}

Trabajar con Proyecciones

using Cosmos.EventSourcing.Linq.Extensions;

public class OrderQueryService
{
    private readonly IQuerySession _querySession;

    public OrderQueryService(IQuerySession querySession)
    {
        _querySession = querySession;
    }

    public async Task<IReadOnlyList<OrderDto>> GetCustomerOrdersAsync(
        string customerId,
        CancellationToken ct)
    {
        var orders = await _querySession
            .Query<OrderDto>()
            .Where(o => o.CustomerId == customerId)
            .OrderByDescending(o => o.CreatedAt)
            .ToListAsync(ct);

        return orders;
    }
}

Multi-Tenancy

Este paquete incluye soporte para multi-tenancy a través de Cosmos.MultiTenancy. Los routers de comandos y queries utilizan automáticamente el TenantResolver para ejecutar operaciones en el contexto del tenant correcto:

// El WolverineCommandRouter usa automáticamente el TenantId
await _commandRouter.InvokeAsync(command, ct);
// Internamente: messageBus.InvokeForTenantAsync(tenantId, command, ct)

Requisitos

• .NET 10.0 o superior
• PostgreSQL 12+ (para Marten)

Dependencias

• Marten (v8.23.0) - Event Store y Document DB
• WolverineFx.Marten (v5.18.0) - Integración Wolverine-Marten
• Cosmos.EventSourcing.Abstractions
• Cosmos.MultiTenancy

Recursos

• Documentación de Wolverine
• Documentación de Marten
• CritterStack

Licencia

Copyright © Cosmos. Todos los derechos reservados.