ddd

Domain-Driven Design (DDD)

Philosophie

Le DDD est une approche de conception logicielle qui place le domaine métier au centre de toutes les décisions. Ce skill guide la découverte, la modélisation et l'implémentation de domaines complexes.

Principes fondamentaux

1. Le métier d'abord : Le code doit refléter fidèlement le domaine métier
2. Langage ubiquitaire : Un vocabulaire partagé entre développeurs et experts métier
3. Bounded Contexts : Des frontières claires entre sous-domaines
4. Modèle riche : La logique métier vit dans le domaine, pas dans les services

Ce que ce skill fait

• Accompagne la découverte d'un domaine métier via Event Storming, Domain Storytelling, Example Mapping
• Aide à identifier et délimiter les Bounded Contexts
• Guide la création d'un Ubiquitous Language
• Modélise les Entities, Value Objects, Aggregates
• Structure le code selon Clean Architecture

Ce que ce skill NE fait PAS

• Refactoring de legacy (→ skill dédié legacy-modernization)
• Implémentation technique bas niveau (→ backend-developer)
• Tests et validation (→ testing-process)
• Choix d'infrastructure (→ devops)

Architecture du Skill

ddd/
├── SKILL.md (ce fichier)
└── agents/
    ├── strategic/          # POURQUOI & QUOI - Niveau conceptuel (8 agents)
    │   ├── orchestrator.md
    │   ├── bounded-contexts.md
    │   ├── context-mapping.md
    │   ├── ubiquitous-language.md
    │   ├── core-domain-identification.md
    │   ├── event-storming.md
    │   ├── domain-storytelling.md
    │   └── example-mapping.md
    │
    ├── tactical/           # COMMENT - Niveau implémentation (17 agents)
    │   ├── orchestrator.md
    │   ├── entities.md
    │   ├── value-objects.md
    │   ├── aggregates.md
    │   ├── repositories.md
    │   ├── domain-services.md
    │   ├── domain-events.md
    │   ├── domain-errors.md
    │   ├── factories.md
    │   ├── specifications.md
    │   ├── domain-primitives.md
    │   ├── application-services.md
    │   ├── anti-corruption-layer.md
    │   ├── cqrs.md
    │   ├── event-sourcing.md
    │   ├── saga-process-manager.md
    │   └── clean-architecture.md
    │
    ├── tooling/            # OUTILS - Validation et qualité (3 agents)
    │   ├── model-validator.md
    │   ├── pattern-selector.md
    │   └── performance-guide.md
    │
    ├── templates/          # SCAFFOLDING - Templates de code (3 agents)
    │   ├── aggregate-template.md
    │   ├── value-object-template.md
    │   └── repository-template.md
    │
    ├── case-studies/       # EXEMPLES - Cas d'usage complets (2 agents)
    │   ├── e-commerce-domain.md
    │   └── anemic-to-rich-migration.md
    │
    └── integrations/       # INTÉGRATIONS - Frameworks (1 agent)
        └── nextjs-integration.md

Domaines et Agents

Strategic (Niveau conceptuel) - 8 agents

Tactical (Niveau implémentation) - 17 agents

Tooling (Outils) - 3 agents

Templates (Scaffolding) - 3 agents

Case Studies (Exemples) - 2 agents

Integrations (Frameworks) - 1 agent

Table de Routage

Routage Principal (Strategic vs Tactical)

Routage par Phase de Projet

Workflow Recommandé

┌─────────────────────────────────────────────────────────────────┐
│                        DÉCOUVERTE                                │
│  ┌─────────────┐    ┌──────────────┐    ┌─────────────────┐     │
│  │   Event     │───▶│   Domain     │───▶│    Example      │     │
│  │  Storming   │    │ Storytelling │    │    Mapping      │     │
│  └─────────────┘    └──────────────┘    └─────────────────┘     │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                      STRUCTURATION                               │
│  ┌─────────────┐    ┌──────────────┐    ┌─────────────────┐     │
│  │  Bounded    │───▶│   Context    │───▶│   Ubiquitous    │     │
│  │  Contexts   │    │   Mapping    │    │    Language     │     │
│  └─────────────┘    └──────────────┘    └─────────────────┘     │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                      MODÉLISATION                                │
│  ┌─────────────┐    ┌──────────────┐    ┌─────────────────┐     │
│  │  Entities   │───▶│    Value     │───▶│   Aggregates    │     │
│  │             │    │   Objects    │    │                 │     │
│  └─────────────┘    └──────────────┘    └─────────────────┘     │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                     IMPLÉMENTATION                               │
│  ┌─────────────┐    ┌──────────────┐    ┌─────────────────┐     │
│  │   Clean     │───▶│ Repositories │───▶│    Domain       │     │
│  │Architecture │    │              │    │   Services      │     │
│  └─────────────┘    └──────────────┘    └─────────────────┘     │
└─────────────────────────────────────────────────────────────────┘

Méthode de Découverte

Quand un utilisateur demande de modéliser un domaine, proposer le choix :

Quelle méthode de découverte préfères-tu ?

1. Event Storming - Idéal pour découverte globale, équipes nombreuses
2. Domain Storytelling - Idéal pour communication avec métiers, documentation
3. Example Mapping - Idéal pour user stories, règles précises, cas limites

Livrables

Redirections vers autres Skills

Exemples d'Utilisation

Exemple 1 : Découverte d'un nouveau domaine

User: Je dois modéliser un système de réservation de salles

DDD Skill:
1. Propose Event Storming pour découvrir les événements métier
2. Identifie les Bounded Contexts (Réservation, Salles, Utilisateurs, Facturation)
3. Construit le Context Map et l'Ubiquitous Language
4. Modélise les Aggregates (Reservation, Room, TimeSlot)

Exemple 2 : Modélisation tactique

User: Comment structurer mon agrégat Commande ?

DDD Skill (tactical/aggregates):
1. Identifie la racine d'agrégat (Order)
2. Définit les entités enfants (OrderLine)
3. Crée les Value Objects (Money, Address, OrderStatus)
4. Établit les invariants métier
5. Propose la structure Clean Architecture