ddd-aggregate-generator

DDD Aggregate Generator

Model a domain with proper DDD building blocks: an aggregate root that protects its invariants, value objects for concepts, and domain events — no anemic bags of public setters.

Input — point it at your project

Works on a target: a file, folder, project/solution, or GitHub URL. If a domain layer exists, match its base types (Entity, AggregateRoot, ValueObject). Detect with: grep -rn "AggregateRoot\|ValueObject\|: Entity\|IDomainEvent" --include=*.cs <target>.

Aggregate root (invariants protected)

public sealed class Order : AggregateRoot
{
    private readonly List<OrderLine> _lines = new();
    public IReadOnlyList<OrderLine> Lines => _lines.AsReadOnly();
    public OrderStatus Status { get; private set; }
    public Money Total { get; private set; }

    private Order() { }                              // EF

    public static Result<Order> Create(CustomerId customer, IEnumerable<OrderLine> lines)
    {
        var list = lines.ToList();
        if (list.Count == 0) return Error.Validation("Order needs at least one line");
        var order = new Order { Status = OrderStatus.Pending };
        order._lines.AddRange(list);
        order.Total = Money.Sum(list.Select(l => l.LineTotal));
        order.Raise(new OrderCreated(order.Id));     // domain event
        return order;
    }

    public Result Confirm()
    {
        if (Status != OrderStatus.Pending) return Error.Conflict("Only pending orders can be confirmed");
        Status = OrderStatus.Confirmed;
        Raise(new OrderConfirmed(Id));
        return Result.Success();
    }
}

Value object

public sealed record Money(decimal Amount, string Currency)
{
    public static Money Sum(IEnumerable<Money> items) { /* guard same currency */ }
    public static implicit operator decimal(Money m) => m.Amount;
}

Records give value equality for free; add guards in the constructor.

Domain events

Raised inside the aggregate (Raise(...)), collected on the base type, dispatched after SaveChanges (outbox or MediatR). Keep events immutable and past-tense.