CQRS Pattern in Elysia

Overview

Separate read and write operations

CQRS Pattern 2 implementations available

When to Use

When you need to abstract data access logic
When you want to make your code testable
When you need to support multiple data sources
When you want to decouple business logic from infrastructure

Available Implementations

Elysia Basic Server

Production-ready Elysia server with Swagger

npx hanma add elysia-basic --framework elysia

Swagger documentationGraceful shutdownError handling

Health Check Routes

Comprehensive health checks for liveness, readiness, and dependencies

npx hanma add elysia-health --framework elysia

Liveness probeReadiness probeDependency checks

Basic Example

// CQRS Pattern implementation example
// This shows the basic structure of cqrs pattern in Elysia

// Define your interface
interface IRepository {
  findAll(): Promise<T[]>;
  findById(id: string): Promise<T | null>;
  create(data: CreateDto): Promise<T>;
  update(id: string, data: UpdateDto): Promise<T>;
  delete(id: string): Promise<void>;
}

// Implement the pattern
class CQRSRepository implements IRepository {
  async findAll(): Promise<T[]> {
    // Implementation
  }

  async findById(id: string): Promise<T | null> {
    // Implementation
  }

  async create(data: CreateDto): Promise<T> {
    // Implementation
  }

  async update(id: string, data: UpdateDto): Promise<T> {
    // Implementation
  }

  async delete(id: string): Promise<void> {
    // Implementation
  }
}

// Use the pattern
const repository = new CQRSRepository();
const items = await repository.findAll();

Frequently Asked Questions

What is CQRS Pattern?

Separate read and write operations. It's a well-established software design pattern that helps organize code for better maintainability and testability.

How does CQRS Pattern work with Elysia?

Elysia provides excellent support for this pattern through its dependency injection system and middleware composition.

What are the benefits?

Improved testability, separation of concerns, easier maintenance, and flexibility to change implementations without affecting business logic.

When should I avoid this pattern?

For very simple applications with minimal logic, the pattern may add unnecessary complexity. Use judgment based on project requirements.