copilot-instructions clean-architecture-code.instructions.md

Clean Architecture principles

• Domain-driven design with domain at the center
• Application layer coordinates use cases
• Infrastructure isolated from domain
• Presentation depends only on application
• Strict dependency inversion
• Business rules in domain without external dependencies

// Domain: entities, value objects, domain services, interfaces
// Application: use cases, application services, DTOs, ports
// Infrastructure: repositories, external services, frameworks
// Presentation: controllers, views, CLI, APIs

SOLID principles

• Strict Single Responsibility
• Open/Closed via abstractions
• Liskov Substitution respected
• Interface Segregation with focused contracts
• Dependency Inversion with stable abstractions

// Interface with single method for segregation
public interface IOrderValidator { bool IsValid(Order order); }

Domain modeling

• Entities with identity
• Immutable value objects
• Aggregates as consistency boundaries
• Domain events for communication
• Consistent ubiquitous language
• Business rules encapsulated

public class Order : AggregateRoot
{
    public Guid Id { get; private set; }
    // Value Object
    public Money Amount { get; private set; }
    // Domain Event
    public void RaiseEvent(OrderCreatedEvent e) { /* ... */ }
}

Use case design

• Application services coordinate
• Command/query separation
• Input/output DTOs
• Validation in application layer
• Authorization separated from business logic
• Clear transactional boundaries

public class CreateOrderUseCase
{
    public async Task Execute(CreateOrderDto dto) { /* validate, authorize, transact */ }
}

Dependency management

• Abstractions in domain
• Implementations in infrastructure
• Dependency injection container
• Externalized configuration
• Environment-specific settings
• Feature toggles when appropriate

// DI
services.AddScoped<IOrderRepository, SqlOrderRepository>();

Testing strategy

• Isolated unit tests for domain
• Integration tests for infrastructure
• Acceptance tests for use cases
• Test doubles for dependencies
• Consistent AAA pattern
• Deterministic tests

[Fact]
public void Should_CreateOrder()
{
    // Arrange
    var mockRepo = new Mock<IOrderRepository>();
    // Act
    var result = useCase.Execute(dto);
    // Assert
    Assert.NotNull(result);
}