Applying CQRS and DDD in Laravel

CQRS (Command Query Responsibility Segregation) and DDD (Domain-Driven Design) are two powerful architectural patterns that can greatly improve the maintainability and scalability of complex web applications. This guide explains how to apply CQRS and DDD in a Laravel project.

What is CQRS?

CQRS stands for Command Query Responsibility Segregation. It separates the read and write operations of an application into different models.

Key Concepts:

• Command Model: Handles data modifications (writes).
• Query Model: Handles data retrieval (reads).

Benefits of CQRS:

• Improved scalability.
• Simplified domain logic.
• Better data consistency.

What is DDD?

DDD (Domain-Driven Design) is an approach focused on modeling the core business logic of an application through entities, value objects, aggregates, and domain services.

Core Concepts:

• Entity: Objects with a unique identity (e.g., User).
• Value Object: Immutable objects without identity.
• Aggregate: A cluster of entities treated as a single unit.
• Domain Service: Encapsulates domain logic not tied to a specific entity.

Applying CQRS and DDD in Laravel

Step 1: Project Structure

Organize your Laravel project for CQRS and DDD.

app/
├── Domain/
│   ├── Entities/
│   ├── ValueObjects/
│   └── Services/
├── Application/
│   ├── Commands/
│   ├── Queries/
│   └── Handlers/
├── Infrastructure/
│   ├── Repositories/
│   └── Persistence/
└── Http/
    ├── Controllers/

Step 2: Define Entities and Value Objects

User Entity:

namespace App\Domain\Entities;

class User {
    private $id;
    private $name;

    public function __construct($id, $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

Step 3: Implement a Command

CreateUserCommand:

namespace App\Application\Commands;

class CreateUserCommand {
    public $name;

    public function __construct(string $name) {
        $this->name = $name;
    }
}

Step 4: Implement a Command Handler

CreateUserHandler:

namespace App\Application\Handlers;

use App\Application\Commands\CreateUserCommand;
use App\Domain\Entities\User;

class CreateUserHandler {
    public function handle(CreateUserCommand $command) {
        $user = new User(uniqid(), $command->name);
        // Persist to the database or repository
    }
}

Step 5: Implement a Query

GetUserByIdQuery:

namespace App\Application\Queries;

class GetUserByIdQuery {
    public $userId;

    public function __construct(string $userId) {
        $this->userId = $userId;
    }
}

Step 6: Implement a Query Handler

GetUserByIdHandler:

namespace App\Application\Handlers;

use App\Application\Queries\GetUserByIdQuery;
use App\Domain\Entities\User;

class GetUserByIdHandler {
    public function handle(GetUserByIdQuery $query) {
        // Fetch user from repository
        return new User($query->userId, 'John Doe');
    }
}

Step 7: Controller Example

namespace App\Http\Controllers;

use App\Application\Commands\CreateUserCommand;
use App\Application\Handlers\CreateUserHandler;
use Illuminate\Http\Request;

class UserController extends Controller {
    private $handler;

    public function __construct(CreateUserHandler $handler) {
        $this->handler = $handler;
    }

    public function create(Request $request) {
        $command = new CreateUserCommand($request->input('name'));
        $this->handler->handle($command);
        return response()->json(['message' => 'User created successfully']);
    }
}

Benefits of Using CQRS and DDD Together in Laravel

• Separation of Concerns: Clear distinction between reading and writing operations.
• Better Domain Modeling: Code better reflects the business logic.
• Improved Testability: Decoupled logic is easier to test.

Conclusion

By combining CQRS and DDD in a Laravel project, you can create scalable, maintainable, and more testable applications. Start small and incrementally apply these principles to achieve a clean and efficient codebase.