cqrs-implementation by wshobson

CQRS Implementation

Comprehensive guide to implementing CQRS (Command Query Responsibility Segregation) patterns.

When to Use This Skill

Separating read and write concerns
Scaling reads independently from writes
Building event-sourced systems
Optimizing complex query scenarios
Different read/write data models needed
High-performance reporting requirements

Core Concepts

1. CQRS Architecture

                    ┌─────────────┐
                    │   Client    │
                    └──────┬──────┘
                           │
              ┌────────────┴────────────┐
              │                         │
              ▼                         ▼
       ┌─────────────┐          ┌─────────────┐
       │  Commands   │          │   Queries   │
       │    API      │          │    API      │
       └──────┬──────┘          └──────┬──────┘
              │                         │
              ▼                         ▼
       ┌─────────────┐          ┌─────────────┐
       │  Command    │          │   Query     │
       │  Handlers   │          │  Handlers   │
       └──────┬──────┘          └──────┬──────┘
              │                         │
              ▼                         ▼
       ┌─────────────┐          ┌─────────────┐
       │   Write     │─────────►│    Read     │
       │   Model     │  Events  │   Model     │
       └─────────────┘          └─────────────┘

2. Key Components

Component	Responsibility
Command	Intent to change state
Command Handler	Validates and executes commands
Event	Record of state change
Query	Request for data
Query Handler	Retrieves data from read model
Projector	Updates read model from events

Templates and detailed worked examples

Full template library and detailed worked examples live in references/details.md. Read that file when you need the concrete templates.

Best Practices

Do's

Separate command and query models - Different needs
Use eventual consistency - Accept propagation delay
Validate in command handlers - Before state change
Denormalize read models - Optimize for queries
Version your events - For schema evolution

Don'ts

Don't query in commands - Use only for writes
Don't couple read/write schemas - Independent evolution
Don't over-engineer - Start simple
Don't ignore consistency SLAs - Define acceptable lag

Third-party checks

No alerts16d5 checks · Risk SAFE

Gen Agent Trust Hub16d
The skill provides architectural templates for implementing the Command Query Responsibility Segregation (CQRS) pattern. The code samples follow security best practices, including the use of parameterized SQL queries to prevent injection attacks.
Socket16d
No alerts
Snyk16d
Risk: LOW · No issues
Runlayer6mo
1 file scanned · No issues
ZeroLeaks5mo
Score: 93/100 · 2 sections analyzed

What it does

Implements Command Query Responsibility Segregation to separate read and write models, enabling independent scaling and optimized query performance. Use this skill when building event-sourced systems, scaling reads separately from writes, or designing systems with different read/write data schemas.

Generated from the current SKILL.md.

Frequently asked

What programming language or framework does this skill target?

The SKILL.md does not specify a particular language or framework. It provides general CQRS pattern guidance applicable across architectures.

Does this skill include code templates?

Yes. Detailed templates and worked examples are provided in `references/details.md`.

When should I use CQRS instead of a simpler architecture?

Use CQRS when separating read and write concerns, scaling reads independently, building event-sourced systems, or optimizing complex queries with different read/write data models.

Does this skill address eventual consistency?

Yes. The skill recommends using eventual consistency and accepting propagation delay between write and read models as a core practice.

Generated from the current SKILL.md. These answers refresh after source changes.

/cqrs-implementation

SKILL.md