// Aggregate root with encapsulated business logic
public class Order : AggregateRoot
{
    private readonly List<OrderLine> _lines = [];

    public IReadOnlyCollection<OrderLine> Lines => _lines.AsReadOnly();

    public void AddLine(Product product, int quantity)
    {
        if (quantity <= 0)
            throw new DomainException("Quantity must be positive");

        _lines.Add(new OrderLine(product, quantity));
        AddDomainEvent(new OrderLineAddedEvent(Id, product.Id, quantity));
    }
}

// Repository implementation with EF Core
public class OrderRepository(AppDbContext db) : IOrderRepository
{
    public async Task<Order?> GetByIdAsync(Guid id, CancellationToken ct) =>
        await db.Orders
            .Include(o => o.Lines)
            .FirstOrDefaultAsync(o => o.Id == id, ct);

    public async Task SaveAsync(Order order, CancellationToken ct)
    {
        db.Orders.Update(order);
        await db.SaveChangesAsync(ct);
    }
}

// Application service orchestrates domain operations
public class OrderService(
    IOrderRepository orders,
    IProductRepository products,
    IEventPublisher events)
{
    public async Task<OrderDto> AddLineAsync(
        Guid orderId,
        AddLineCommand command,
        CancellationToken ct = default)
    {
        // Validate input at boundary
        ArgumentNullException.ThrowIfNull(command);

        var order = await orders.GetByIdAsync(orderId, ct)
            ?? throw new NotFoundException($"Order {orderId} not found");

        var product = await products.GetByIdAsync(command.ProductId, ct)
            ?? throw new NotFoundException($"Product {command.ProductId} not found");

        // Execute domain logic (business rules in aggregate)
        order.AddLine(product, command.Quantity);

        // Persist and publish events
        await orders.SaveAsync(order, ct);
        await events.PublishAsync(order.DomainEvents, ct);

        return order.ToDto();
    }
}

var orders = app.MapGroup("/api/orders")
    .WithTags("Orders")
    .RequireAuthorization();

orders.MapPost("/{orderId:guid}/lines", async (
    Guid orderId,
    AddLineCommand command,
    OrderService service,
    CancellationToken ct) =>
{
    var result = await service.AddLineAsync(orderId, command, ct);
    return Results.Ok(result);
})
.WithName("AddOrderLine")
.Produces<OrderDto>()
.ProducesProblem(StatusCodes.Status404NotFound);

[ApiController]
[Route("api/[controller]")]
public class OrdersController(OrderService orderService) : ControllerBase
{
    /// <summary>
    /// Adds a line item to an existing order.
    /// </summary>
    [HttpPost("{orderId:guid}/lines")]
    [ProducesResponseType<OrderDto>(StatusCodes.Status200OK)]
    [ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> AddLine(
        Guid orderId,
        AddLineCommand command,
        CancellationToken ct)
    {
        var result = await orderService.AddLineAsync(orderId, command, ct);
        return Ok(result);
    }
}