You are currently viewing Clean DDD Lessons: Project Structure and Naming Conventions

Clean DDD Lessons: Project Structure and Naming Conventions

Domain-Driven Design (DDD) emphasizes the importance of modeling software based on the domain it operates in, leading to more maintainable and scalable systems. However, adopting DDD can sometimes be challenging, especially when it comes to organizing project structure and naming conventions. In this tutorial, we’ll explore best practices for structuring DDD projects and establishing clean naming conventions to enhance readability and maintainability.

1. Project Structure:
Organizing your DDD project structure is crucial for clarity and maintainability. Here’s a recommended structure:

  • Application Layer: Contains application services orchestrating the flow of data and interacting with the domain.
  • Domain Layer: Represents the core domain logic, including entities, value objects, aggregates, and domain services.
  • Infrastructure Layer: Handles external concerns such as database access, messaging, and external services.
├── src/
│   ├── Application/
│   │   ├── Services/
│   │   ├── DTOs/
│   │   └── ...
│   ├── Domain/
│   │   ├── Entities/
│   │   ├── ValueObjects/
│   │   ├── Aggregates/
│   │   ├── Repositories/
│   │   └── ...
│   └── Infrastructure/
│       ├── Persistence/
│       ├── Messaging/
│       ├── ExternalServices/
│       └── ...
└── tests/
    ├── Application/
    ├── Domain/
    └── Infrastructure/

2. Naming Conventions:
Clear and consistent naming conventions are essential for understanding the purpose and role of each component in your DDD project. Here are some conventions to follow:

  • Entities: Use singular nouns to represent domain entities.
    Example: User, Order, Product.
  • Value Objects: Use descriptive names indicating their role in the domain.
    Example: EmailAddress, Money, Address.
  • Aggregates: Use a name that reflects the aggregate’s consistency boundary.
    Example: OrderAggregate, UserAccount.
  • Repositories: Append “Repository” to the entity name.
    Example: UserRepository, OrderRepository.
  • Application Services: Use verbs or action-based names to indicate their purpose.
    Example: UserService, OrderProcessingService.

3. Code Examples:
Let’s see how these naming conventions apply in code:

// User Entity
class User {
    // Properties and methods

// EmailAddress Value Object
class EmailAddress {
    // Properties and methods

// UserRepository Interface
interface UserRepository {
    public function getById(int $userId): ?User;
    // Other repository methods

// UserService Application Service
class UserService {
    private $userRepository;

    public function __construct(UserRepository $userRepository) {
        $this->userRepository = $userRepository;

    public function getUserById(int $userId): ?User {
        return $this->userRepository->getById($userId);

By adhering to clean project structure and naming conventions in your DDD projects, you can enhance readability, maintainability, and scalability. Consistency and clarity in naming help developers better understand the domain model and collaborate effectively. Start applying these practices in your DDD projects for more robust and maintainable software solutions.

Leave a Reply