1---2name: ddd3description: |4 Domain-Driven Design - Modélisation métier et conception de domaines complexes.5 Utilise ce skill quand: (1) tu dois comprendre un domaine métier complexe,6 (2) tu veux identifier les bounded contexts d'un système, (3) tu dois créer7 un ubiquitous language partagé, (4) tu veux modéliser des entités et agrégats,8 (5) tu dois structurer du code selon Clean Architecture.9metadata:10 version: 1.0.011 status: active12 level: transversal13 domains:14 - strategic15 - tactical16 - tooling17 - templates18 - case-studies19 - integrations20---2122# Domain-Driven Design (DDD)2324## Philosophie2526Le 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.2728### Principes fondamentaux29301. **Le métier d'abord** : Le code doit refléter fidèlement le domaine métier312. **Langage ubiquitaire** : Un vocabulaire partagé entre développeurs et experts métier323. **Bounded Contexts** : Des frontières claires entre sous-domaines334. **Modèle riche** : La logique métier vit dans le domaine, pas dans les services3435### Ce que ce skill fait3637- Accompagne la découverte d'un domaine métier via Event Storming, Domain Storytelling, Example Mapping38- Aide à identifier et délimiter les Bounded Contexts39- Guide la création d'un Ubiquitous Language40- Modélise les Entities, Value Objects, Aggregates41- Structure le code selon Clean Architecture4243### Ce que ce skill NE fait PAS4445- Refactoring de legacy (→ skill dédié `legacy-modernization`)46- Implémentation technique bas niveau (→ `backend-developer`)47- Tests et validation (→ `testing-process`)48- Choix d'infrastructure (→ `devops`)4950---5152## Architecture du Skill5354```55ddd/56├── SKILL.md (ce fichier)57└── agents/58 ├── strategic/ # POURQUOI & QUOI - Niveau conceptuel (8 agents)59 │ ├── orchestrator.md60 │ ├── bounded-contexts.md61 │ ├── context-mapping.md62 │ ├── ubiquitous-language.md63 │ ├── core-domain-identification.md64 │ ├── event-storming.md65 │ ├── domain-storytelling.md66 │ └── example-mapping.md67 │68 ├── tactical/ # COMMENT - Niveau implémentation (17 agents)69 │ ├── orchestrator.md70 │ ├── entities.md71 │ ├── value-objects.md72 │ ├── aggregates.md73 │ ├── repositories.md74 │ ├── domain-services.md75 │ ├── domain-events.md76 │ ├── domain-errors.md77 │ ├── factories.md78 │ ├── specifications.md79 │ ├── domain-primitives.md80 │ ├── application-services.md81 │ ├── anti-corruption-layer.md82 │ ├── cqrs.md83 │ ├── event-sourcing.md84 │ ├── saga-process-manager.md85 │ └── clean-architecture.md86 │87 ├── tooling/ # OUTILS - Validation et qualité (3 agents)88 │ ├── model-validator.md89 │ ├── pattern-selector.md90 │ └── performance-guide.md91 │92 ├── templates/ # SCAFFOLDING - Templates de code (3 agents)93 │ ├── aggregate-template.md94 │ ├── value-object-template.md95 │ └── repository-template.md96 │97 ├── case-studies/ # EXEMPLES - Cas d'usage complets (2 agents)98 │ ├── e-commerce-domain.md99 │ └── anemic-to-rich-migration.md100 │101 └── integrations/ # INTÉGRATIONS - Frameworks (1 agent)102 └── nextjs-integration.md103```104105---106107## Domaines et Agents108109### Strategic (Niveau conceptuel) - 8 agents110111| Agent | Responsabilité |112|-------|----------------|113| `orchestrator` | Route vers l'agent strategic approprié |114| `bounded-contexts` | Identifier et délimiter les contextes bornés |115| `context-mapping` | Définir les relations entre contextes (Shared Kernel, ACL, etc.) |116| `ubiquitous-language` | Construire le vocabulaire partagé équipe/métier |117| `core-domain-identification` | Classifier Core / Supporting / Generic domains |118| `event-storming` | Faciliter les ateliers de découverte par événements |119| `domain-storytelling` | Narration visuelle des processus métier |120| `example-mapping` | Découverte par exemples et règles métier (Given-When-Then) |121122### Tactical (Niveau implémentation) - 17 agents123124| Agent | Responsabilité |125|-------|----------------|126| `orchestrator` | Route vers l'agent tactical approprié |127| `entities` | Modéliser les entités avec identité et comportement |128| `value-objects` | Créer des objets valeur immuables |129| `aggregates` | Définir les agrégats, racines et invariants |130| `repositories` | Concevoir les interfaces de persistance |131| `domain-services` | Implémenter la logique métier transverse |132| `domain-events` | Modéliser les événements du domaine |133| `domain-errors` | Gestion des erreurs métier typées (Result, Either) |134| `factories` | Encapsuler la création complexe d'agrégats |135| `specifications` | Règles métier composables et réutilisables |136| `domain-primitives` | Types primitifs typés (IDs, Email, Money...) |137| `application-services` | Use Cases et orchestration applicative |138| `anti-corruption-layer` | Protéger le domaine des modèles externes/legacy |139| `cqrs` | Séparer les modèles de lecture et d'écriture |140| `event-sourcing` | Stocker l'état comme séquence d'événements |141| `saga-process-manager` | Orchestrer les processus multi-agrégats longs |142| `clean-architecture` | Structurer le code en couches concentriques |143144### Tooling (Outils) - 3 agents145146| Agent | Responsabilité |147|-------|----------------|148| `model-validator` | Auditer un modèle DDD, détecter les anti-patterns |149| `pattern-selector` | Aider à choisir le bon pattern selon le contexte |150| `performance-guide` | Optimisation performance (snapshots, aggregate sizing) |151152### Templates (Scaffolding) - 3 agents153154| Agent | Responsabilité |155|-------|----------------|156| `aggregate-template` | Template complet pour créer un Aggregate |157| `value-object-template` | Templates de Value Objects (Money, Email, Address...) |158| `repository-template` | Template interface + implémentation Repository |159160### Case Studies (Exemples) - 2 agents161162| Agent | Responsabilité |163|-------|----------------|164| `e-commerce-domain` | Cas complet e-commerce (Event Storming → Code) |165| `anemic-to-rich-migration` | Guide migration modèle anémique → Rich Domain |166167### Integrations (Frameworks) - 1 agent168169| Agent | Responsabilité |170|-------|----------------|171| `nextjs-integration` | Intégration DDD avec Next.js App Router |172173---174175## Table de Routage176177### Routage Principal (Strategic vs Tactical)178179| Mots-clés | Domaine | Agent par défaut |180|-----------|---------|------------------|181| bounded context, sous-domaine, frontière, périmètre | strategic | bounded-contexts |182| context map, relation, upstream, downstream, ACL | strategic | context-mapping |183| vocabulaire, glossaire, terme, langage, ubiquitous | strategic | ubiquitous-language |184| core domain, supporting, generic, priorisation, valeur stratégique | strategic | core-domain-identification |185| event storming, atelier, sticky, événement métier | strategic | event-storming |186| storytelling, processus, narration, pictogramme | strategic | domain-storytelling |187| example mapping, user story, règle, exemple, cas limite | strategic | example-mapping |188| entity, entité, identité, cycle de vie | tactical | entities |189| value object, valeur, immuable, égalité structurelle | tactical | value-objects |190| aggregate, agrégat, racine, invariant, consistance | tactical | aggregates |191| repository, persistance, collection, stockage | tactical | repositories |192| domain service, service métier, logique transverse | tactical | domain-services |193| domain event, événement, notification, réaction | tactical | domain-events |194| factory, création, construction, instanciation | tactical | factories |195| specification, règle métier, critère, filtre, policy | tactical | specifications |196| domain primitive, type, typage, id, email, money | tactical | domain-primitives |197| application service, use case, command, query, orchestration | tactical | application-services |198| anti-corruption layer, ACL, legacy, traduction, isolation, externe | tactical | anti-corruption-layer |199| cqrs, command, query, read model, projection, séparation lecture écriture | tactical | cqrs |200| event sourcing, event store, replay, snapshot, historique, audit trail | tactical | event-sourcing |201| saga, process manager, compensation, transaction distribuée, workflow long | tactical | saga-process-manager |202| clean architecture, couche, layer, adapter, port | tactical | clean-architecture |203| error, exception, domain error, result, either, validation error | tactical | domain-errors |204| audit, validation, anti-pattern, qualité, review, santé modèle | tooling | model-validator |205| quel pattern, choisir, décision, trade-off, comparaison, recommandation | tooling | pattern-selector |206| performance, optimisation, snapshot, aggregate size, scaling | tooling | performance-guide |207| template, scaffolding, générer, boilerplate, starter | templates | aggregate-template |208| créer aggregate, structure aggregate | templates | aggregate-template |209| créer value object, template vo | templates | value-object-template |210| template repository, persistence, mapper | templates | repository-template |211| case study, exemple complet, end-to-end, e-commerce | case-studies | e-commerce-domain |212| migration, anemic, rich domain, refactoring legacy, strangler | case-studies | anemic-to-rich-migration |213| nextjs, next.js, app router, server actions, api routes | integrations | nextjs-integration |214215### Routage par Phase de Projet216217| Phase | Agents recommandés |218|-------|-------------------|219| Découverte initiale | event-storming → domain-storytelling → ubiquitous-language |220| Priorisation | core-domain-identification |221| Délimitation | bounded-contexts → context-mapping |222| Spécification | example-mapping → ubiquitous-language |223| Modélisation | domain-primitives → entities → value-objects → aggregates |224| Patterns de base | factories → specifications → domain-events |225| Architecture | clean-architecture → repositories → application-services |226| Patterns avancés | cqrs → event-sourcing → saga-process-manager |227| Intégration externe | anti-corruption-layer → context-mapping |228| Aide à la décision | pattern-selector |229| Audit & Qualité | model-validator |230231---232233## Workflow Recommandé234235```236┌─────────────────────────────────────────────────────────────────┐237│ DÉCOUVERTE │238│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │239│ │ Event │───▶│ Domain │───▶│ Example │ │240│ │ Storming │ │ Storytelling │ │ Mapping │ │241│ └─────────────┘ └──────────────┘ └─────────────────┘ │242└─────────────────────────────────────────────────────────────────┘243 │244 ▼245┌─────────────────────────────────────────────────────────────────┐246│ STRUCTURATION │247│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │248│ │ Bounded │───▶│ Context │───▶│ Ubiquitous │ │249│ │ Contexts │ │ Mapping │ │ Language │ │250│ └─────────────┘ └──────────────┘ └─────────────────┘ │251└─────────────────────────────────────────────────────────────────┘252 │253 ▼254┌─────────────────────────────────────────────────────────────────┐255│ MODÉLISATION │256│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │257│ │ Entities │───▶│ Value │───▶│ Aggregates │ │258│ │ │ │ Objects │ │ │ │259│ └─────────────┘ └──────────────┘ └─────────────────┘ │260└─────────────────────────────────────────────────────────────────┘261 │262 ▼263┌─────────────────────────────────────────────────────────────────┐264│ IMPLÉMENTATION │265│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │266│ │ Clean │───▶│ Repositories │───▶│ Domain │ │267│ │Architecture │ │ │ │ Services │ │268│ └─────────────┘ └──────────────┘ └─────────────────┘ │269└─────────────────────────────────────────────────────────────────┘270```271272---273274## Méthode de Découverte275276Quand un utilisateur demande de modéliser un domaine, proposer le choix :277278> **Quelle méthode de découverte préfères-tu ?**279> 1. **Event Storming** - Idéal pour découverte globale, équipes nombreuses280> 2. **Domain Storytelling** - Idéal pour communication avec métiers, documentation281> 3. **Example Mapping** - Idéal pour user stories, règles précises, cas limites282283---284285## Livrables286287| Livrable | Format | Agent source |288|----------|--------|--------------|289| Context Map | Diagramme Mermaid/PlantUML | context-mapping |290| Glossaire Ubiquitous Language | Markdown table | ubiquitous-language |291| Event Storming Board | Markdown structuré | event-storming |292| Modèle de domaine | Code + diagramme | aggregates |293| Structure Clean Architecture | Arborescence de dossiers | clean-architecture |294295---296297## Redirections vers autres Skills298299| Situation | Skill cible |300|-----------|-------------|301| Implémentation API/code détaillé | `backend-developer` |302| Tests unitaires/intégration | `testing-process` |303| Refactoring de legacy | `legacy-modernization` |304| Décisions d'infrastructure | `devops` |305| Architecture technique globale | `direction-technique` |306307---308309## Exemples d'Utilisation310311### Exemple 1 : Découverte d'un nouveau domaine312```313User: Je dois modéliser un système de réservation de salles314315DDD Skill:3161. Propose Event Storming pour découvrir les événements métier3172. Identifie les Bounded Contexts (Réservation, Salles, Utilisateurs, Facturation)3183. Construit le Context Map et l'Ubiquitous Language3194. Modélise les Aggregates (Reservation, Room, TimeSlot)320```321322### Exemple 2 : Modélisation tactique323```324User: Comment structurer mon agrégat Commande ?325326DDD Skill (tactical/aggregates):3271. Identifie la racine d'agrégat (Order)3282. Définit les entités enfants (OrderLine)3293. Crée les Value Objects (Money, Address, OrderStatus)3304. Établit les invariants métier3315. Propose la structure Clean Architecture332```
truchot