👁 Image
Cosmos.EventSourcing.CritterStack 1.2.3

Cosmos.EventSourcing.CritterStack

👁 NuGet

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

Los routers de comandos y queries inyectan ITenantResolver (de Cosmos.MultiTenancy) y ejecutan operaciones en el contexto del tenant resuelto:

// El WolverineCommandRouter usa el TenantId del ITenantResolver registrado
await _commandRouter.InvokeAsync(command, ct);
// Internamente: messageBus.InvokeForTenantAsync(tenantResolver.TenantId, command, ct)

AgregarWolverineCommandRouter y AgregarWolverineQueryRouter no registran un ITenantResolver por defecto. El consumidor debe registrar una implementación (por ejemplo AgregarTenantResolverConHeadersConfiables() de Cosmos.MultiTenancy.AspNetCore para servicios ASP.NET Core); sin eso, los routers fallarán al resolver la dependencia en runtime.

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.