cqrs

CQRS (Command Query Responsibility Segregation) Pattern

What Is It

CQRS separates read operations (Queries) from write operations (Commands) into different models. This allows each side to be optimized independently - the write model for complex business logic, and the read model for fast queries.

When to Use

• Complex domains - Different read/write requirements
• Performance optimization - Read-heavy workloads
• Event sourcing - Commands produce events, queries read projections
• Team separation - Different teams for read/write
• Scalability - Scale reads and writes independently

When NOT to Use

• Simple CRUD - Adds unnecessary complexity
• Small applications - Overhead not justified
• Similar read/write - No benefit from separation
• Single database - Limited optimization benefit

How to Implement

Implementation Steps

1. Define Command interfaces for writes
2. Define Query interfaces for reads
3. Create separate handlers for each
4. Build read models (projections) from events
5. Keep read and write models synchronized

TypeScript Implementation

// Command
interface CreateUserCommand {
  type: 'CreateUser';
  payload: { name: string; email: string };
}

// Query
interface GetUserQuery {
  type: 'GetUser';
  payload: { id: string };
}

// Command Handler
class UserCommandHandler {
  async handle(command: CreateUserCommand): Promise<string> {
    // Validate, apply business rules
    const user = this.userAggregate.create(command.payload);
    await this.repository.save(user);
    return user.id;
  }
}

// Query Handler
class UserQueryHandler {
  async handle(query: GetUserQuery): Promise<UserDTO> {
    // Read from optimized read model
    return this.readDb.query('SELECT * FROM user_views WHERE id = ?', [query.payload.id]);
  }
}

Code Examples

See examples/ directory for runnable TypeScript implementations:

• examples/cqrs.ts - Basic implementation with separate handlers
• examples/cqrs-advanced.ts - Real-world example with event projections

Related Patterns

• Event Sourcing - Often used with CQRS
• Event-Driven - Commands can produce events
• Repository - Write side uses repository pattern