1---2name: truchot-claude-skills-test-ddd3description: Domain-Driven Design (DDD)4---56# Domain-Driven Design (DDD)78## Philosophie910Le 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.1112### Principes fondamentaux13141. **Le métier d'abord** : Le code doit refléter fidèlement le domaine métier152. **Langage ubiquitaire** : Un vocabulaire partagé entre développeurs et experts métier163. **Bounded Contexts** : Des frontières claires entre sous-domaines174. **Modèle riche** : La logique métier vit dans le domaine, pas dans les services1819### Ce que ce skill fait2021- Accompagne la découverte d'un domaine métier via Event Storming, Domain Storytelling, Example Mapping22- Aide à identifier et délimiter les Bounded Contexts23- Guide la création d'un Ubiquitous Language24- Modélise les Entities, Value Objects, Aggregates25- Structure le code selon Clean Architecture2627### Ce que ce skill NE fait PAS2829- Refactoring de legacy (→ skill dédié `legacy-modernization`)30- Implémentation technique bas niveau (→ `backend-developer`)31- Tests et validation (→ `testing-process`)32- Choix d'infrastructure (→ `devops`)3334---3536## Architecture du Skill3738```39ddd/40├── SKILL.md (ce fichier)41└── agents/42 ├── strategic/ # POURQUOI & QUOI - Niveau conceptuel (8 agents)43 │ ├── orchestrator.md44 │ ├── bounded-contexts.md45 │ ├── context-mapping.md46 │ ├── ubiquitous-language.md47 │ ├── core-domain-identification.md48 │ ├── event-storming.md49 │ ├── domain-storytelling.md50 │ └── example-mapping.md51 │52 ├── tactical/ # COMMENT - Niveau implémentation (17 agents)53 │ ├── orchestrator.md54 │ ├── entities.md55 │ ├── value-objects.md56 │ ├── aggregates.md57 │ ├── repositories.md58 │ ├── domain-services.md59 │ ├── domain-events.md60 │ ├── domain-errors.md61 │ ├── factories.md62 │ ├── specifications.md63 │ ├── domain-primitives.md64 │ ├── application-services.md65 │ ├── anti-corruption-layer.md66 │ ├── cqrs.md67 │ ├── event-sourcing.md68 │ ├── saga-process-manager.md69 │ └── clean-architecture.md70 │71 ├── tooling/ # OUTILS - Validation et qualité (3 agents)72 │ ├── model-validator.md73 │ ├── pattern-selector.md74 │ └── performance-guide.md75 │76 ├── templates/ # SCAFFOLDING - Templates de code (3 agents)77 │ ├── aggregate-template.md78 │ ├── value-object-template.md79 │ └── repository-template.md80 │81 ├── case-studies/ # EXEMPLES - Cas d'usage complets (2 agents)82 │ ├── e-commerce-domain.md83 │ └── anemic-to-rich-migration.md84 │85 └── integrations/ # INTÉGRATIONS - Frameworks (1 agent)86 └── nextjs-integration.md87```8889---9091## Domaines et Agents9293### Strategic (Niveau conceptuel) - 8 agents9495| Agent | Responsabilité |96|-------|----------------|97| `orchestrator` | Route vers l'agent strategic approprié |98| `bounded-contexts` | Identifier et délimiter les contextes bornés |99| `context-mapping` | Définir les relations entre contextes (Shared Kernel, ACL, etc.) |100| `ubiquitous-language` | Construire le vocabulaire partagé équipe/métier |101| `core-domain-identification` | Classifier Core / Supporting / Generic domains |102| `event-storming` | Faciliter les ateliers de découverte par événements |103| `domain-storytelling` | Narration visuelle des processus métier |104| `example-mapping` | Découverte par exemples et règles métier (Given-When-Then) |105106### Tactical (Niveau implémentation) - 17 agents107108| Agent | Responsabilité |109|-------|----------------|110| `orchestrator` | Route vers l'agent tactical approprié |111| `entities` | Modéliser les entités avec identité et comportement |112| `value-objects` | Créer des objets valeur immuables |113| `aggregates` | Définir les agrégats, racines et invariants |114| `repositories` | Concevoir les interfaces de persistance |115| `domain-services` | Implémenter la logique métier transverse |116| `domain-events` | Modéliser les événements du domaine |117| `domain-errors` | Gestion des erreurs métier typées (Result, Either) |118| `factories` | Encapsuler la création complexe d'agrégats |119| `specifications` | Règles métier composables et réutilisables |120| `domain-primitives` | Types primitifs typés (IDs, Email, Money...) |121| `application-services` | Use Cases et orchestration applicative |122| `anti-corruption-layer` | Protéger le domaine des modèles externes/legacy |123| `cqrs` | Séparer les modèles de lecture et d'écriture |124| `event-sourcing` | Stocker l'état comme séquence d'événements |125| `saga-process-manager` | Orchestrer les processus multi-agrégats longs |126| `clean-architecture` | Structurer le code en couches concentriques |127128### Tooling (Outils) - 3 agents129130| Agent | Responsabilité |131|-------|----------------|132| `model-validator` | Auditer un modèle DDD, détecter les anti-patterns |133| `pattern-selector` | Aider à choisir le bon pattern selon le contexte |134| `performance-guide` | Optimisation performance (snapshots, aggregate sizing) |135136### Templates (Scaffolding) - 3 agents137138| Agent | Responsabilité |139|-------|----------------|140| `aggregate-template` | Template complet pour créer un Aggregate |141| `value-object-template` | Templates de Value Objects (Money, Email, Address...) |142| `repository-template` | Template interface + implémentation Repository |143144### Case Studies (Exemples) - 2 agents145146| Agent | Responsabilité |147|-------|----------------|148| `e-commerce-domain` | Cas complet e-commerce (Event Storming → Code) |149| `anemic-to-rich-migration` | Guide migration modèle anémique → Rich Domain |150151### Integrations (Frameworks) - 1 agent152153| Agent | Responsabilité |154|-------|----------------|155| `nextjs-integration` | Intégration DDD avec Next.js App Router |156157---158159## Table de Routage160161### Routage Principal (Strategic vs Tactical)162163| Mots-clés | Domaine | Agent par défaut |164|-----------|---------|------------------|165| bounded context, sous-domaine, frontière, périmètre | strategic | bounded-contexts |166| context map, relation, upstream, downstream, ACL | strategic | context-mapping |167| vocabulaire, glossaire, terme, langage, ubiquitous | strategic | ubiquitous-language |168| core domain, supporting, generic, priorisation, valeur stratégique | strategic | core-domain-identification |169| event storming, atelier, sticky, événement métier | strategic | event-storming |170| storytelling, processus, narration, pictogramme | strategic | domain-storytelling |171| example mapping, user story, règle, exemple, cas limite | strategic | example-mapping |172| entity, entité, identité, cycle de vie | tactical | entities |173| value object, valeur, immuable, égalité structurelle | tactical | value-objects |174| aggregate, agrégat, racine, invariant, consistance | tactical | aggregates |175| repository, persistance, collection, stockage | tactical | repositories |176| domain service, service métier, logique transverse | tactical | domain-services |177| domain event, événement, notification, réaction | tactical | domain-events |178| factory, création, construction, instanciation | tactical | factories |179| specification, règle métier, critère, filtre, policy | tactical | specifications |180| domain primitive, type, typage, id, email, money | tactical | domain-primitives |181| application service, use case, command, query, orchestration | tactical | application-services |182| anti-corruption layer, ACL, legacy, traduction, isolation, externe | tactical | anti-corruption-layer |183| cqrs, command, query, read model, projection, séparation lecture écriture | tactical | cqrs |184| event sourcing, event store, replay, snapshot, historique, audit trail | tactical | event-sourcing |185| saga, process manager, compensation, transaction distribuée, workflow long | tactical | saga-process-manager |186| clean architecture, couche, layer, adapter, port | tactical | clean-architecture |187| error, exception, domain error, result, either, validation error | tactical | domain-errors |188| audit, validation, anti-pattern, qualité, review, santé modèle | tooling | model-validator |189| quel pattern, choisir, décision, trade-off, comparaison, recommandation | tooling | pattern-selector |190| performance, optimisation, snapshot, aggregate size, scaling | tooling | performance-guide |191| template, scaffolding, générer, boilerplate, starter | templates | aggregate-template |192| créer aggregate, structure aggregate | templates | aggregate-template |193| créer value object, template vo | templates | value-object-template |194| template repository, persistence, mapper | templates | repository-template |195| case study, exemple complet, end-to-end, e-commerce | case-studies | e-commerce-domain |196| migration, anemic, rich domain, refactoring legacy, strangler | case-studies | anemic-to-rich-migration |197| nextjs, next.js, app router, server actions, api routes | integrations | nextjs-integration |198199### Routage par Phase de Projet200201| Phase | Agents recommandés |202|-------|-------------------|203| Découverte initiale | event-storming → domain-storytelling → ubiquitous-language |204| Priorisation | core-domain-identification |205| Délimitation | bounded-contexts → context-mapping |206| Spécification | example-mapping → ubiquitous-language |207| Modélisation | domain-primitives → entities → value-objects → aggregates |208| Patterns de base | factories → specifications → domain-events |209| Architecture | clean-architecture → repositories → application-services |210| Patterns avancés | cqrs → event-sourcing → saga-process-manager |211| Intégration externe | anti-corruption-layer → context-mapping |212| Aide à la décision | pattern-selector |213| Audit & Qualité | model-validator |214215---216217## Workflow Recommandé218219```220┌─────────────────────────────────────────────────────────────────┐221│ DÉCOUVERTE │222│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │223│ │ Event │───▶│ Domain │───▶│ Example │ │224│ │ Storming │ │ Storytelling │ │ Mapping │ │225│ └─────────────┘ └──────────────┘ └─────────────────┘ │226└─────────────────────────────────────────────────────────────────┘227 │228 ▼229┌─────────────────────────────────────────────────────────────────┐230│ STRUCTURATION │231│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │232│ │ Bounded │───▶│ Context │───▶│ Ubiquitous │ │233│ │ Contexts │ │ Mapping │ │ Language │ │234│ └─────────────┘ └──────────────┘ └─────────────────┘ │235└─────────────────────────────────────────────────────────────────┘236 │237 ▼238┌─────────────────────────────────────────────────────────────────┐239│ MODÉLISATION │240│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │241│ │ Entities │───▶│ Value │───▶│ Aggregates │ │242│ │ │ │ Objects │ │ │ │243│ └─────────────┘ └──────────────┘ └─────────────────┘ │244└─────────────────────────────────────────────────────────────────┘245 │246 ▼247┌─────────────────────────────────────────────────────────────────┐248│ IMPLÉMENTATION │249│ ┌─────────────┐ ┌──────────────┐ ┌─────────────────┐ │250│ │ Clean │───▶│ Repositories │───▶│ Domain │ │251│ │Architecture │ │ │ │ Services │ │252│ └─────────────┘ └──────────────┘ └─────────────────┘ │253└─────────────────────────────────────────────────────────────────┘254```255256---257258## Méthode de Découverte259260Quand un utilisateur demande de modéliser un domaine, proposer le choix :261262> **Quelle méthode de découverte préfères-tu ?**263> 1. **Event Storming** - Idéal pour découverte globale, équipes nombreuses264> 2. **Domain Storytelling** - Idéal pour communication avec métiers, documentation265> 3. **Example Mapping** - Idéal pour user stories, règles précises, cas limites266267---268269## Livrables270271| Livrable | Format | Agent source |272|----------|--------|--------------|273| Context Map | Diagramme Mermaid/PlantUML | context-mapping |274| Glossaire Ubiquitous Language | Markdown table | ubiquitous-language |275| Event Storming Board | Markdown structuré | event-storming |276| Modèle de domaine | Code + diagramme | aggregates |277| Structure Clean Architecture | Arborescence de dossiers | clean-architecture |278279---280281## Redirections vers autres Skills282283| Situation | Skill cible |284|-----------|-------------|285| Implémentation API/code détaillé | `backend-developer` |286| Tests unitaires/intégration | `testing-process` |287| Refactoring de legacy | `legacy-modernization` |288| Décisions d'infrastructure | `devops` |289| Architecture technique globale | `direction-technique` |290291---292293## Exemples d'Utilisation294295### Exemple 1 : Découverte d'un nouveau domaine296```297User: Je dois modéliser un système de réservation de salles298299DDD Skill:3001. Propose Event Storming pour découvrir les événements métier3012. Identifie les Bounded Contexts (Réservation, Salles, Utilisateurs, Facturation)3023. Construit le Context Map et l'Ubiquitous Language3034. Modélise les Aggregates (Reservation, Room, TimeSlot)304```305306### Exemple 2 : Modélisation tactique307```308User: Comment structurer mon agrégat Commande ?309310DDD Skill (tactical/aggregates):3111. Identifie la racine d'agrégat (Order)3122. Définit les entités enfants (OrderLine)3133. Crée les Value Objects (Money, Address, OrderStatus)3144. Établit les invariants métier3155. Propose la structure Clean Architecture316```317318---319> Converted and distributed by [TomeVault](https://tomevault.io/claim/truchot) — claim your Tome and manage your conversions.320<!-- tomevault:4.0:skill_md:2026-04-14 -->
tomevault-io