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

•Le métier d'abord : Le code doit refléter fidèlement le domaine métier
•Langage ubiquitaire : Un vocabulaire partagé entre développeurs et experts métier
•Bounded Contexts : Des frontières claires entre sous-domaines
•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

code

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

Agent	Responsabilité
`orchestrator`	Route vers l'agent strategic approprié
`bounded-contexts`	Identifier et délimiter les contextes bornés
`context-mapping`	Définir les relations entre contextes (Shared Kernel, ACL, etc.)
`ubiquitous-language`	Construire le vocabulaire partagé équipe/métier
`core-domain-identification`	Classifier Core / Supporting / Generic domains
`event-storming`	Faciliter les ateliers de découverte par événements
`domain-storytelling`	Narration visuelle des processus métier
`example-mapping`	Découverte par exemples et règles métier (Given-When-Then)

Tactical (Niveau implémentation) - 17 agents

Agent	Responsabilité
`orchestrator`	Route vers l'agent tactical approprié
`entities`	Modéliser les entités avec identité et comportement
`value-objects`	Créer des objets valeur immuables
`aggregates`	Définir les agrégats, racines et invariants
`repositories`	Concevoir les interfaces de persistance
`domain-services`	Implémenter la logique métier transverse
`domain-events`	Modéliser les événements du domaine
`domain-errors`	Gestion des erreurs métier typées (Result, Either)
`factories`	Encapsuler la création complexe d'agrégats
`specifications`	Règles métier composables et réutilisables
`domain-primitives`	Types primitifs typés (IDs, Email, Money...)
`application-services`	Use Cases et orchestration applicative
`anti-corruption-layer`	Protéger le domaine des modèles externes/legacy
`cqrs`	Séparer les modèles de lecture et d'écriture
`event-sourcing`	Stocker l'état comme séquence d'événements
`saga-process-manager`	Orchestrer les processus multi-agrégats longs
`clean-architecture`	Structurer le code en couches concentriques

Tooling (Outils) - 3 agents

Agent	Responsabilité
`model-validator`	Auditer un modèle DDD, détecter les anti-patterns
`pattern-selector`	Aider à choisir le bon pattern selon le contexte
`performance-guide`	Optimisation performance (snapshots, aggregate sizing)

Templates (Scaffolding) - 3 agents

Agent	Responsabilité
`aggregate-template`	Template complet pour créer un Aggregate
`value-object-template`	Templates de Value Objects (Money, Email, Address...)
`repository-template`	Template interface + implémentation Repository

Case Studies (Exemples) - 2 agents

Agent	Responsabilité
`e-commerce-domain`	Cas complet e-commerce (Event Storming → Code)
`anemic-to-rich-migration`	Guide migration modèle anémique → Rich Domain

Integrations (Frameworks) - 1 agent

Agent	Responsabilité
`nextjs-integration`	Intégration DDD avec Next.js App Router

Table de Routage

Routage Principal (Strategic vs Tactical)

Mots-clés	Domaine	Agent par défaut
bounded context, sous-domaine, frontière, périmètre	strategic	bounded-contexts
context map, relation, upstream, downstream, ACL	strategic	context-mapping
vocabulaire, glossaire, terme, langage, ubiquitous	strategic	ubiquitous-language
core domain, supporting, generic, priorisation, valeur stratégique	strategic	core-domain-identification
event storming, atelier, sticky, événement métier	strategic	event-storming
storytelling, processus, narration, pictogramme	strategic	domain-storytelling
example mapping, user story, règle, exemple, cas limite	strategic	example-mapping
entity, entité, identité, cycle de vie	tactical	entities
value object, valeur, immuable, égalité structurelle	tactical	value-objects
aggregate, agrégat, racine, invariant, consistance	tactical	aggregates
repository, persistance, collection, stockage	tactical	repositories
domain service, service métier, logique transverse	tactical	domain-services
domain event, événement, notification, réaction	tactical	domain-events
factory, création, construction, instanciation	tactical	factories
specification, règle métier, critère, filtre, policy	tactical	specifications
domain primitive, type, typage, id, email, money	tactical	domain-primitives
application service, use case, command, query, orchestration	tactical	application-services
anti-corruption layer, ACL, legacy, traduction, isolation, externe	tactical	anti-corruption-layer
cqrs, command, query, read model, projection, séparation lecture écriture	tactical	cqrs
event sourcing, event store, replay, snapshot, historique, audit trail	tactical	event-sourcing
saga, process manager, compensation, transaction distribuée, workflow long	tactical	saga-process-manager
clean architecture, couche, layer, adapter, port	tactical	clean-architecture
error, exception, domain error, result, either, validation error	tactical	domain-errors
audit, validation, anti-pattern, qualité, review, santé modèle	tooling	model-validator
quel pattern, choisir, décision, trade-off, comparaison, recommandation	tooling	pattern-selector
performance, optimisation, snapshot, aggregate size, scaling	tooling	performance-guide
template, scaffolding, générer, boilerplate, starter	templates	aggregate-template
créer aggregate, structure aggregate	templates	aggregate-template
créer value object, template vo	templates	value-object-template
template repository, persistence, mapper	templates	repository-template
case study, exemple complet, end-to-end, e-commerce	case-studies	e-commerce-domain
migration, anemic, rich domain, refactoring legacy, strangler	case-studies	anemic-to-rich-migration
nextjs, next.js, app router, server actions, api routes	integrations	nextjs-integration

Routage par Phase de Projet

Phase	Agents recommandés
Découverte initiale	event-storming → domain-storytelling → ubiquitous-language
Priorisation	core-domain-identification
Délimitation	bounded-contexts → context-mapping
Spécification	example-mapping → ubiquitous-language
Modélisation	domain-primitives → entities → value-objects → aggregates
Patterns de base	factories → specifications → domain-events
Architecture	clean-architecture → repositories → application-services
Patterns avancés	cqrs → event-sourcing → saga-process-manager
Intégration externe	anti-corruption-layer → context-mapping
Aide à la décision	pattern-selector
Audit & Qualité	model-validator

Workflow Recommandé

code

┌─────────────────────────────────────────────────────────────────┐
│                        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 ?

•Event Storming - Idéal pour découverte globale, équipes nombreuses

•Domain Storytelling - Idéal pour communication avec métiers, documentation

•Example Mapping - Idéal pour user stories, règles précises, cas limites

Livrables

Livrable	Format	Agent source
Context Map	Diagramme Mermaid/PlantUML	context-mapping
Glossaire Ubiquitous Language	Markdown table	ubiquitous-language
Event Storming Board	Markdown structuré	event-storming
Modèle de domaine	Code + diagramme	aggregates
Structure Clean Architecture	Arborescence de dossiers	clean-architecture

Redirections vers autres Skills

Situation	Skill cible
Implémentation API/code détaillé	`backend-developer`
Tests unitaires/intégration	`testing-process`
Refactoring de legacy	`legacy-modernization`
Décisions d'infrastructure	`devops`
Architecture technique globale	`direction-technique`

Exemples d'Utilisation

Exemple 1 : Découverte d'un nouveau domaine

code

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

code

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