existingArc = arcRepository.findById(id);
+ if (existingArc.isEmpty()) {
+ throw new IllegalArgumentException("Arc non trouvé avec l'ID: " + id);
+ }
+
+ Arc arc = existingArc.get();
+ arc.setName(updated.getName());
+ arc.setDescription(updated.getDescription());
+ arc.setOrder(updated.getOrder());
+ arc.setThemes(updated.getThemes());
+ arc.setStakes(updated.getStakes());
+ arc.setGmNotes(updated.getGmNotes());
+ arc.setRewards(updated.getRewards());
+ arc.setResolution(updated.getResolution());
+ arc.setRelatedPageIds(updated.getRelatedPageIds());
+ return arcRepository.save(arc);
+ }
+
+ public void deleteArc(String id) {
+ arcRepository.deleteById(id);
+ }
+
+ public boolean arcExists(String id) {
+ return arcRepository.existsById(id);
+ }
+}
diff --git a/core/src/main/java/com/loremind/application/campaigncontext/CampaignService.java b/core/src/main/java/com/loremind/application/campaigncontext/CampaignService.java
new file mode 100644
index 0000000..48dbcac
--- /dev/null
+++ b/core/src/main/java/com/loremind/application/campaigncontext/CampaignService.java
@@ -0,0 +1,84 @@
+package com.loremind.application.campaigncontext;
+
+import com.loremind.domain.campaigncontext.Campaign;
+import com.loremind.domain.campaigncontext.ports.CampaignRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service d'application pour le contexte Campaign.
+ * Orchestre la logique métier en utilisant le Port CampaignRepository.
+ * Fait partie de la couche Application de l'Architecture Hexagonale.
+ */
+@Service
+public class CampaignService {
+
+ private final CampaignRepository campaignRepository;
+
+ public CampaignService(CampaignRepository campaignRepository) {
+ this.campaignRepository = campaignRepository;
+ }
+
+ /**
+ * Parameter Object pour la création / mise à jour d'une Campaign.
+ * Évite une signature à rallonge et rend les évolutions futures (theme,
+ * coverImageUrl, etc.) sans casser les appelants.
+ *
+ * {@code loreId} est nullable : une campagne peut exister sans univers associé.
+ */
+ public record CampaignData(String name, String description, String loreId) {}
+
+ public Campaign createCampaign(CampaignData data) {
+ Campaign campaign = Campaign.builder()
+ .name(data.name())
+ .description(data.description())
+ .loreId(normalizeLoreId(data.loreId()))
+ .arcsCount(0)
+ .build();
+ return campaignRepository.save(campaign);
+ }
+
+ public Optional getCampaignById(String id) {
+ return campaignRepository.findById(id);
+ }
+
+ public List getAllCampaigns() {
+ return campaignRepository.findAll();
+ }
+
+ public Campaign updateCampaign(String id, CampaignData data) {
+ Optional existingCampaign = campaignRepository.findById(id);
+ if (existingCampaign.isEmpty()) {
+ throw new IllegalArgumentException("Campaign non trouvé avec l'ID: " + id);
+ }
+
+ Campaign campaign = existingCampaign.get();
+ campaign.setName(data.name());
+ campaign.setDescription(data.description());
+ campaign.setLoreId(normalizeLoreId(data.loreId()));
+ return campaignRepository.save(campaign);
+ }
+
+ /**
+ * Normalise un loreId entrant : une chaîne vide/blanche est traitée comme "pas de lien".
+ * Utile car les payloads JSON peuvent envoyer "" au lieu de null.
+ */
+ private String normalizeLoreId(String loreId) {
+ return (loreId == null || loreId.isBlank()) ? null : loreId;
+ }
+
+ public void deleteCampaign(String id) {
+ campaignRepository.deleteById(id);
+ }
+
+ public boolean campaignExists(String id) {
+ return campaignRepository.existsById(id);
+ }
+
+ public List searchCampaigns(String query) {
+ if (query == null || query.isBlank()) return List.of();
+ return campaignRepository.searchByName(query.trim());
+ }
+}
diff --git a/core/src/main/java/com/loremind/application/campaigncontext/ChapterService.java b/core/src/main/java/com/loremind/application/campaigncontext/ChapterService.java
new file mode 100644
index 0000000..427e960
--- /dev/null
+++ b/core/src/main/java/com/loremind/application/campaigncontext/ChapterService.java
@@ -0,0 +1,73 @@
+package com.loremind.application.campaigncontext;
+
+import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service d'application pour le contexte Chapter.
+ * Orchestre la logique métier en utilisant le Port ChapterRepository.
+ * Fait partie de la couche Application de l'Architecture Hexagonale.
+ */
+@Service
+public class ChapterService {
+
+ private final ChapterRepository chapterRepository;
+
+ public ChapterService(ChapterRepository chapterRepository) {
+ this.chapterRepository = chapterRepository;
+ }
+
+ public Chapter createChapter(String name, String description, String arcId, int order) {
+ Chapter chapter = Chapter.builder()
+ .name(name)
+ .description(description)
+ .arcId(arcId)
+ .order(order)
+ .build();
+ return chapterRepository.save(chapter);
+ }
+
+ public Optional getChapterById(String id) {
+ return chapterRepository.findById(id);
+ }
+
+ public List getAllChapters() {
+ return chapterRepository.findAll();
+ }
+
+ public List getChaptersByArcId(String arcId) {
+ return chapterRepository.findByArcId(arcId);
+ }
+
+ /**
+ * Met à jour un Chapter avec tous ses champs narratifs (Parameter Object pattern).
+ */
+ public Chapter updateChapter(String id, Chapter updated) {
+ Optional existingChapter = chapterRepository.findById(id);
+ if (existingChapter.isEmpty()) {
+ throw new IllegalArgumentException("Chapter non trouvé avec l'ID: " + id);
+ }
+
+ Chapter chapter = existingChapter.get();
+ chapter.setName(updated.getName());
+ chapter.setDescription(updated.getDescription());
+ chapter.setOrder(updated.getOrder());
+ chapter.setGmNotes(updated.getGmNotes());
+ chapter.setPlayerObjectives(updated.getPlayerObjectives());
+ chapter.setNarrativeStakes(updated.getNarrativeStakes());
+ chapter.setRelatedPageIds(updated.getRelatedPageIds());
+ return chapterRepository.save(chapter);
+ }
+
+ public void deleteChapter(String id) {
+ chapterRepository.deleteById(id);
+ }
+
+ public boolean chapterExists(String id) {
+ return chapterRepository.existsById(id);
+ }
+}
diff --git a/core/src/main/java/com/loremind/application/campaigncontext/SceneService.java b/core/src/main/java/com/loremind/application/campaigncontext/SceneService.java
new file mode 100644
index 0000000..810a977
--- /dev/null
+++ b/core/src/main/java/com/loremind/application/campaigncontext/SceneService.java
@@ -0,0 +1,78 @@
+package com.loremind.application.campaigncontext;
+
+import com.loremind.domain.campaigncontext.Scene;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service d'application pour le contexte Scene.
+ * Orchestre la logique métier en utilisant le Port SceneRepository.
+ * Fait partie de la couche Application de l'Architecture Hexagonale.
+ */
+@Service
+public class SceneService {
+
+ private final SceneRepository sceneRepository;
+
+ public SceneService(SceneRepository sceneRepository) {
+ this.sceneRepository = sceneRepository;
+ }
+
+ public Scene createScene(String name, String description, String chapterId, int order) {
+ Scene scene = Scene.builder()
+ .name(name)
+ .description(description)
+ .chapterId(chapterId)
+ .order(order)
+ .build();
+ return sceneRepository.save(scene);
+ }
+
+ public Optional getSceneById(String id) {
+ return sceneRepository.findById(id);
+ }
+
+ public List getAllScenes() {
+ return sceneRepository.findAll();
+ }
+
+ public List getScenesByChapterId(String chapterId) {
+ return sceneRepository.findByChapterId(chapterId);
+ }
+
+ /**
+ * Met à jour une Scene avec tous ses champs narratifs (Parameter Object pattern).
+ */
+ public Scene updateScene(String id, Scene updated) {
+ Optional existingScene = sceneRepository.findById(id);
+ if (existingScene.isEmpty()) {
+ throw new IllegalArgumentException("Scene non trouvée avec l'ID: " + id);
+ }
+
+ Scene scene = existingScene.get();
+ scene.setName(updated.getName());
+ scene.setDescription(updated.getDescription());
+ scene.setOrder(updated.getOrder());
+ scene.setLocation(updated.getLocation());
+ scene.setTiming(updated.getTiming());
+ scene.setAtmosphere(updated.getAtmosphere());
+ scene.setPlayerNarration(updated.getPlayerNarration());
+ scene.setGmSecretNotes(updated.getGmSecretNotes());
+ scene.setChoicesConsequences(updated.getChoicesConsequences());
+ scene.setCombatDifficulty(updated.getCombatDifficulty());
+ scene.setEnemies(updated.getEnemies());
+ scene.setRelatedPageIds(updated.getRelatedPageIds());
+ return sceneRepository.save(scene);
+ }
+
+ public void deleteScene(String id) {
+ sceneRepository.deleteById(id);
+ }
+
+ public boolean sceneExists(String id) {
+ return sceneRepository.existsById(id);
+ }
+}
diff --git a/core/src/main/java/com/loremind/application/lorecontext/LoreNodeService.java b/core/src/main/java/com/loremind/application/lorecontext/LoreNodeService.java
new file mode 100644
index 0000000..42efb13
--- /dev/null
+++ b/core/src/main/java/com/loremind/application/lorecontext/LoreNodeService.java
@@ -0,0 +1,78 @@
+package com.loremind.application.lorecontext;
+
+import com.loremind.domain.lorecontext.LoreNode;
+import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service d'application pour le contexte LoreNode.
+ * Orchestre la logique métier en utilisant le Port LoreNodeRepository.
+ * Fait partie de la couche Application de l'Architecture Hexagonale.
+ */
+@Service
+public class LoreNodeService {
+
+ private final LoreNodeRepository loreNodeRepository;
+
+ public LoreNodeService(LoreNodeRepository loreNodeRepository) {
+ this.loreNodeRepository = loreNodeRepository;
+ }
+
+ /**
+ * Crée un LoreNode (dossier) à partir d'un "objet changes" porteur des valeurs
+ * souhaitées (pattern Parameter Object) : évite les signatures qui gonflent
+ * à chaque ajout de champ.
+ */
+ public LoreNode createLoreNode(LoreNode changes) {
+ LoreNode loreNode = LoreNode.builder()
+ .name(changes.getName())
+ .icon(changes.getIcon())
+ .parentId(changes.getParentId())
+ .loreId(changes.getLoreId())
+ .build();
+ return loreNodeRepository.save(loreNode);
+ }
+
+ public Optional getLoreNodeById(String id) {
+ return loreNodeRepository.findById(id);
+ }
+
+ public List getAllLoreNodes() {
+ return loreNodeRepository.findAll();
+ }
+
+ public List getLoreNodesByLoreId(String loreId) {
+ return loreNodeRepository.findByLoreId(loreId);
+ }
+
+ public List getLoreNodesByParentId(String parentId) {
+ return loreNodeRepository.findByParentId(parentId);
+ }
+
+ public List searchLoreNodes(String query) {
+ if (query == null || query.isBlank()) return List.of();
+ return loreNodeRepository.searchByName(query.trim());
+ }
+
+ public LoreNode updateLoreNode(String id, LoreNode changes) {
+ LoreNode existing = loreNodeRepository.findById(id)
+ .orElseThrow(() -> new IllegalArgumentException("LoreNode non trouvé avec l'ID: " + id));
+
+ existing.setName(changes.getName());
+ existing.setIcon(changes.getIcon());
+ existing.setParentId(changes.getParentId());
+ // loreId volontairement immuable (un dossier ne migre pas d'un Lore à l'autre).
+ return loreNodeRepository.save(existing);
+ }
+
+ public void deleteLoreNode(String id) {
+ loreNodeRepository.deleteById(id);
+ }
+
+ public boolean loreNodeExists(String id) {
+ return loreNodeRepository.existsById(id);
+ }
+}
diff --git a/core/src/main/java/com/loremind/application/lorecontext/LoreService.java b/core/src/main/java/com/loremind/application/lorecontext/LoreService.java
new file mode 100644
index 0000000..e62be04
--- /dev/null
+++ b/core/src/main/java/com/loremind/application/lorecontext/LoreService.java
@@ -0,0 +1,93 @@
+package com.loremind.application.lorecontext;
+
+import com.loremind.domain.lorecontext.Lore;
+import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
+import com.loremind.domain.lorecontext.ports.LoreRepository;
+import com.loremind.domain.lorecontext.ports.PageRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Service d'application pour le contexte Lore.
+ * Orchestre la logique métier en utilisant le Port LoreRepository.
+ * Fait partie de la couche Application de l'Architecture Hexagonale.
+ *
+ * Note: les compteurs nodeCount/pageCount sont calculés à la volée via
+ * countByLoreId sur les ports LoreNode et Page, plutôt que stockés en BDD
+ * (la colonne existe encore mais n'est plus fiable). Source of truth = les
+ * tables nodes/pages elles-mêmes, jamais de désync possible.
+ */
+@Service
+public class LoreService {
+
+ private final LoreRepository loreRepository;
+ private final LoreNodeRepository loreNodeRepository;
+ private final PageRepository pageRepository;
+
+ public LoreService(LoreRepository loreRepository,
+ LoreNodeRepository loreNodeRepository,
+ PageRepository pageRepository) {
+ this.loreRepository = loreRepository;
+ this.loreNodeRepository = loreNodeRepository;
+ this.pageRepository = pageRepository;
+ }
+
+ public Lore createLore(String name, String description) {
+ Lore lore = Lore.builder()
+ .name(name)
+ .description(description)
+ .nodeCount(0)
+ .pageCount(0)
+ .build();
+ return loreRepository.save(lore);
+ }
+
+ public Optional getLoreById(String id) {
+ return loreRepository.findById(id).map(this::withCounts);
+ }
+
+ public List getAllLores() {
+ return loreRepository.findAll().stream()
+ .map(this::withCounts)
+ .collect(Collectors.toList());
+ }
+
+ /**
+ * Enrichit un Lore avec les compteurs calculés à la volée.
+ * N+1 acceptable à l'échelle actuelle (quelques dizaines de Lores max).
+ */
+ private Lore withCounts(Lore lore) {
+ lore.setNodeCount((int) loreNodeRepository.countByLoreId(lore.getId()));
+ lore.setPageCount((int) pageRepository.countByLoreId(lore.getId()));
+ return lore;
+ }
+
+ /** Recherche par nom (ILIKE). Résultats sans compteurs — pas utile pour la command palette. */
+ public List searchLores(String query) {
+ if (query == null || query.isBlank()) return List.of();
+ return loreRepository.searchByName(query.trim());
+ }
+
+ public Lore updateLore(String id, String name, String description) {
+ Optional existingLore = loreRepository.findById(id);
+ if (existingLore.isEmpty()) {
+ throw new IllegalArgumentException("Lore non trouvé avec l'ID: " + id);
+ }
+
+ Lore lore = existingLore.get();
+ lore.setName(name);
+ lore.setDescription(description);
+ return loreRepository.save(lore);
+ }
+
+ public void deleteLore(String id) {
+ loreRepository.deleteById(id);
+ }
+
+ public boolean loreExists(String id) {
+ return loreRepository.existsById(id);
+ }
+}
diff --git a/core/src/main/java/com/loremind/application/lorecontext/PageService.java b/core/src/main/java/com/loremind/application/lorecontext/PageService.java
new file mode 100644
index 0000000..c8d2058
--- /dev/null
+++ b/core/src/main/java/com/loremind/application/lorecontext/PageService.java
@@ -0,0 +1,95 @@
+package com.loremind.application.lorecontext;
+
+import com.loremind.domain.lorecontext.Page;
+import com.loremind.domain.lorecontext.ports.PageRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service d'application pour le contexte Page.
+ * Orchestre la logique métier via le Port PageRepository.
+ * Couche Application de l'Architecture Hexagonale.
+ */
+@Service
+public class PageService {
+
+ private final PageRepository pageRepository;
+
+ public PageService(PageRepository pageRepository) {
+ this.pageRepository = pageRepository;
+ }
+
+ /** Création MVP : seuls les champs structurels sont requis. Le contenu est
+ * enrichi plus tard depuis l'écran d'édition. */
+ public Page createPage(String loreId, String nodeId, String templateId, String title) {
+ Page page = Page.builder()
+ .loreId(loreId)
+ .nodeId(nodeId)
+ .templateId(templateId)
+ .title(title)
+ .values(new HashMap<>())
+ .tags(new ArrayList<>())
+ .relatedPageIds(new ArrayList<>())
+ .build();
+ return pageRepository.save(page);
+ }
+
+ public Optional getPageById(String id) {
+ return pageRepository.findById(id);
+ }
+
+ public List getAllPages() {
+ return pageRepository.findAll();
+ }
+
+ public List getPagesByLoreId(String loreId) {
+ return pageRepository.findByLoreId(loreId);
+ }
+
+ public List getPagesByNodeId(String nodeId) {
+ return pageRepository.findByNodeId(nodeId);
+ }
+
+ public List searchPages(String query) {
+ if (query == null || query.isBlank()) return List.of();
+ return pageRepository.searchByTitle(query.trim());
+ }
+
+ /**
+ * Met à jour une page existante.
+ * Parameter Object pattern : le controller construit une Page "changes"
+ * avec les nouvelles valeurs, le service recharge et applique les champs modifiables.
+ * Les champs structurels immuables sont : id, loreId, templateId.
+ * Le nodeId est mutable (déplacement d'une page d'un noeud à l'autre).
+ */
+ public Page updatePage(String id, Page changes) {
+ Page existing = pageRepository.findById(id)
+ .orElseThrow(() -> new IllegalArgumentException("Page non trouvée avec l'ID: " + id));
+
+ existing.setTitle(changes.getTitle());
+ existing.setNodeId(changes.getNodeId());
+ existing.setValues(changes.getValues() != null
+ ? new HashMap<>(changes.getValues())
+ : new HashMap<>());
+ existing.setNotes(changes.getNotes());
+ existing.setTags(changes.getTags() != null
+ ? new ArrayList<>(changes.getTags())
+ : new ArrayList<>());
+ existing.setRelatedPageIds(changes.getRelatedPageIds() != null
+ ? new ArrayList<>(changes.getRelatedPageIds())
+ : new ArrayList<>());
+ return pageRepository.save(existing);
+ }
+
+ public void deletePage(String id) {
+ pageRepository.deleteById(id);
+ }
+
+ public boolean pageExists(String id) {
+ return pageRepository.existsById(id);
+ }
+}
diff --git a/core/src/main/java/com/loremind/application/lorecontext/TemplateService.java b/core/src/main/java/com/loremind/application/lorecontext/TemplateService.java
new file mode 100644
index 0000000..4d89608
--- /dev/null
+++ b/core/src/main/java/com/loremind/application/lorecontext/TemplateService.java
@@ -0,0 +1,84 @@
+package com.loremind.application.lorecontext;
+
+import com.loremind.domain.lorecontext.Template;
+import com.loremind.domain.lorecontext.ports.TemplateRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Service d'application pour le contexte Template.
+ * Orchestre la logique métier via le Port TemplateRepository.
+ * Couche Application de l'Architecture Hexagonale.
+ */
+@Service
+public class TemplateService {
+
+ private final TemplateRepository templateRepository;
+
+ public TemplateService(TemplateRepository templateRepository) {
+ this.templateRepository = templateRepository;
+ }
+
+ public Template createTemplate(String loreId,
+ String name,
+ String description,
+ String defaultNodeId,
+ List fields) {
+ Template template = Template.builder()
+ .loreId(loreId)
+ .name(name)
+ .description(description)
+ .defaultNodeId(defaultNodeId)
+ .fields(fields != null ? new ArrayList<>(fields) : new ArrayList<>())
+ .build();
+ return templateRepository.save(template);
+ }
+
+ public Optional getTemplateById(String id) {
+ return templateRepository.findById(id);
+ }
+
+ public List getAllTemplates() {
+ return templateRepository.findAll();
+ }
+
+ public List getTemplatesByLoreId(String loreId) {
+ return templateRepository.findByLoreId(loreId);
+ }
+
+ public List searchTemplates(String query) {
+ if (query == null || query.isBlank()) return List.of();
+ return templateRepository.searchByName(query.trim());
+ }
+
+ /**
+ * Met à jour un Template existant.
+ * Pattern Parameter Object via l'entité Template elle-même :
+ * le controller construit un Template avec les champs à modifier, le service
+ * recharge l'existant et applique les changements.
+ */
+ public Template updateTemplate(String id, Template changes) {
+ Template existing = templateRepository.findById(id)
+ .orElseThrow(() -> new IllegalArgumentException("Template non trouvé avec l'ID: " + id));
+
+ existing.setName(changes.getName());
+ existing.setDescription(changes.getDescription());
+ existing.setDefaultNodeId(changes.getDefaultNodeId());
+ existing.setFields(changes.getFields() != null
+ ? new ArrayList<>(changes.getFields())
+ : new ArrayList<>());
+ // loreId volontairement immuable : un template ne migre pas d'un Lore à l'autre.
+ return templateRepository.save(existing);
+ }
+
+ public void deleteTemplate(String id) {
+ templateRepository.deleteById(id);
+ }
+
+ public boolean templateExists(String id) {
+ return templateRepository.existsById(id);
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/Arc.java b/core/src/main/java/com/loremind/domain/campaigncontext/Arc.java
new file mode 100644
index 0000000..0b6c64e
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/Arc.java
@@ -0,0 +1,60 @@
+package com.loremind.domain.campaigncontext;
+
+import lombok.Builder;
+import lombok.Data;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entité de domaine représentant un Arc narratif.
+ * Division majeure d'une Campaign (ex: "L'arc sombre").
+ * Entité pure du domaine, sans dépendance technique.
+ */
+@Data
+@Builder
+public class Arc {
+
+ private String id;
+ private String name;
+ private String description; // = Synopsis dans l'UI
+ private String campaignId; // Référence vers la Campaign parente
+ private int order; // Ordre de l'arc dans la campagne
+
+ // Champs narratifs enrichis (voir docs/maquettes/campagne/détail/)
+ private String themes; // Thèmes principaux explorés dans cet arc
+ private String stakes; // Enjeux globaux pour les personnages
+ private String gmNotes; // Notes privées du MJ (non exportées vers FoundryVTT)
+ private String rewards; // Récompenses et progression
+ private String resolution; // Dénouement prévu
+
+ /**
+ * IDs des pages du Lore associées à cet arc (weak cross-context references).
+ * Permet au MJ de lier des PNJ, lieux ou lore items qui jouent un rôle dans cet arc.
+ * Ne contient que des IDs ; pas d'import du Lore Context (respect des Bounded Contexts).
+ * Initialisé en {@link ArrayList} vide dans le builder pour éviter les NPE.
+ */
+ @Builder.Default
+ private List relatedPageIds = new ArrayList<>();
+
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+
+ // ─────────────── Méthodes métier ───────────────
+
+ /** Ajoute un lien vers une page du Lore (idempotent : pas de doublon). */
+ public void linkPage(String pageId) {
+ if (relatedPageIds == null) relatedPageIds = new ArrayList<>();
+ if (!relatedPageIds.contains(pageId)) {
+ relatedPageIds.add(pageId);
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+
+ /** Retire un lien vers une page du Lore (sans erreur si absent). */
+ public void unlinkPage(String pageId) {
+ if (relatedPageIds != null && relatedPageIds.remove(pageId)) {
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/Campaign.java b/core/src/main/java/com/loremind/domain/campaigncontext/Campaign.java
new file mode 100644
index 0000000..55c4dbc
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/Campaign.java
@@ -0,0 +1,59 @@
+package com.loremind.domain.campaigncontext;
+
+import lombok.Builder;
+import lombok.Data;
+import java.time.LocalDateTime;
+
+/**
+ * Entité de domaine représentant une Campaign.
+ * Conteneur global pour organiser la narration d'une campagne.
+ * Entité pure du domaine, sans dépendance technique.
+ */
+@Data
+@Builder
+public class Campaign {
+
+ private String id;
+ private String name;
+ private String description;
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+ private int arcsCount;
+
+ /**
+ * Référence faible (weak reference) vers un Lore.
+ * Nullable : une campagne peut exister sans univers associé (one-shot, test, pitch libre).
+ * Ce n'est qu'un ID : le Campaign Context ne dépend PAS du Lore Context
+ * (respect des Bounded Contexts en DDD).
+ */
+ private String loreId;
+
+ /** Associe cette campagne à un Lore existant. */
+ public void linkToLore(String loreId) {
+ this.loreId = loreId;
+ this.updatedAt = LocalDateTime.now();
+ }
+
+ /** Retire l'association à un Lore (la campagne redevient "universe-agnostic"). */
+ public void unlinkFromLore() {
+ this.loreId = null;
+ this.updatedAt = LocalDateTime.now();
+ }
+
+ public boolean isLinkedToLore() {
+ return this.loreId != null && !this.loreId.isBlank();
+ }
+
+ // Méthode métier pour gérer le nombre d'arcs
+ public void incrementArcsCount() {
+ this.arcsCount++;
+ this.updatedAt = LocalDateTime.now();
+ }
+
+ public void decrementArcsCount() {
+ if (this.arcsCount > 0) {
+ this.arcsCount--;
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/Chapter.java b/core/src/main/java/com/loremind/domain/campaigncontext/Chapter.java
new file mode 100644
index 0000000..1caa4d9
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/Chapter.java
@@ -0,0 +1,54 @@
+package com.loremind.domain.campaigncontext;
+
+import lombok.Builder;
+import lombok.Data;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entité de domaine représentant un Chapter.
+ * Subdivision d'un Arc (ex: "Chapitre 1: Le début").
+ * Entité pure du domaine, sans dépendance technique.
+ */
+@Data
+@Builder
+public class Chapter {
+
+ private String id;
+ private String name;
+ private String description; // = Synopsis du chapitre dans l'UI
+ private String arcId; // Référence vers l'Arc parent
+ private int order; // Ordre du chapitre dans l'arc
+
+ // Champs narratifs enrichis (voir docs/maquettes/campagne/détail/)
+ private String gmNotes; // Notes privées du MJ (non exportées vers FoundryVTT)
+ private String playerObjectives; // Objectifs des joueurs dans ce chapitre
+ private String narrativeStakes; // Enjeux narratifs dramatiques
+
+ /**
+ * IDs des pages du Lore associées à ce chapitre (weak cross-context references).
+ * Permet au MJ de lier des PNJ / lieux / éléments du Lore qui apparaissent dans ce chapitre.
+ */
+ @Builder.Default
+ private List relatedPageIds = new ArrayList<>();
+
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+
+ // ─────────────── Méthodes métier ───────────────
+
+ public void linkPage(String pageId) {
+ if (relatedPageIds == null) relatedPageIds = new ArrayList<>();
+ if (!relatedPageIds.contains(pageId)) {
+ relatedPageIds.add(pageId);
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+
+ public void unlinkPage(String pageId) {
+ if (relatedPageIds != null && relatedPageIds.remove(pageId)) {
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/Scene.java b/core/src/main/java/com/loremind/domain/campaigncontext/Scene.java
new file mode 100644
index 0000000..1b2c4b5
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/Scene.java
@@ -0,0 +1,67 @@
+package com.loremind.domain.campaigncontext;
+
+import lombok.Builder;
+import lombok.Data;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entité de domaine représentant une Scene.
+ * Unité de jeu la plus fine, subdivision d'un Chapter (ex: "Scène 1: L'auberge").
+ * Entité pure du domaine, sans dépendance technique.
+ */
+@Data
+@Builder
+public class Scene {
+
+ private String id;
+ private String name;
+ private String description; // = Description courte dans l'UI
+ private String chapterId; // Référence vers le Chapter parent
+ private int order; // Ordre de la scène dans le chapitre
+
+ // === Contexte et ambiance ===
+ private String location; // Lieu de la scène (ex: Taverne du Dragon d'Or)
+ private String timing; // Moment (ex: Soir, à la tombée de la nuit)
+ private String atmosphere; // Ambiance générale (sons, odeurs, émotions...)
+
+ // === Narration pour les joueurs ===
+ private String playerNarration; // Texte lu directement aux joueurs
+
+ // === Notes et secrets du MJ (privé) ===
+ private String gmSecretNotes; // Informations cachées, non visibles par les joueurs
+
+ // === Choix et conséquences ===
+ private String choicesConsequences; // Options offertes aux joueurs et leurs conséquences
+
+ // === Combat ou rencontre ===
+ private String combatDifficulty; // Difficulté estimée
+ private String enemies; // Liste des ennemis et créatures
+
+ /**
+ * IDs des pages du Lore associées à cette scène (weak cross-context references).
+ * Très utile pour la préparation : épingler un lieu, un PNJ, une créature à une scène.
+ */
+ @Builder.Default
+ private List relatedPageIds = new ArrayList<>();
+
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+
+ // ─────────────── Méthodes métier ───────────────
+
+ public void linkPage(String pageId) {
+ if (relatedPageIds == null) relatedPageIds = new ArrayList<>();
+ if (!relatedPageIds.contains(pageId)) {
+ relatedPageIds.add(pageId);
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+
+ public void unlinkPage(String pageId) {
+ if (relatedPageIds != null && relatedPageIds.remove(pageId)) {
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/ports/ArcRepository.java b/core/src/main/java/com/loremind/domain/campaigncontext/ports/ArcRepository.java
new file mode 100644
index 0000000..c39fd8d
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/ArcRepository.java
@@ -0,0 +1,24 @@
+package com.loremind.domain.campaigncontext.ports;
+
+import com.loremind.domain.campaigncontext.Arc;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des Arcs.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ */
+public interface ArcRepository {
+
+ Arc save(Arc arc);
+
+ Optional findById(String id);
+
+ List findByCampaignId(String campaignId);
+
+ List findAll();
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/ports/CampaignRepository.java b/core/src/main/java/com/loremind/domain/campaigncontext/ports/CampaignRepository.java
new file mode 100644
index 0000000..b763726
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/CampaignRepository.java
@@ -0,0 +1,24 @@
+package com.loremind.domain.campaigncontext.ports;
+
+import com.loremind.domain.campaigncontext.Campaign;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des Campaigns.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ */
+public interface CampaignRepository {
+
+ Campaign save(Campaign campaign);
+
+ Optional findById(String id);
+
+ List findAll();
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+
+ List searchByName(String query);
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/ports/ChapterRepository.java b/core/src/main/java/com/loremind/domain/campaigncontext/ports/ChapterRepository.java
new file mode 100644
index 0000000..091a1d1
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/ChapterRepository.java
@@ -0,0 +1,24 @@
+package com.loremind.domain.campaigncontext.ports;
+
+import com.loremind.domain.campaigncontext.Chapter;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des Chapters.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ */
+public interface ChapterRepository {
+
+ Chapter save(Chapter chapter);
+
+ Optional findById(String id);
+
+ List findByArcId(String arcId);
+
+ List findAll();
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+}
diff --git a/core/src/main/java/com/loremind/domain/campaigncontext/ports/SceneRepository.java b/core/src/main/java/com/loremind/domain/campaigncontext/ports/SceneRepository.java
new file mode 100644
index 0000000..a4c2dd9
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/campaigncontext/ports/SceneRepository.java
@@ -0,0 +1,24 @@
+package com.loremind.domain.campaigncontext.ports;
+
+import com.loremind.domain.campaigncontext.Scene;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des Scenes.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ */
+public interface SceneRepository {
+
+ Scene save(Scene scene);
+
+ Optional findById(String id);
+
+ List findByChapterId(String chapterId);
+
+ List findAll();
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/Lore.java b/core/src/main/java/com/loremind/domain/lorecontext/Lore.java
new file mode 100644
index 0000000..fa321f6
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/Lore.java
@@ -0,0 +1,48 @@
+package com.loremind.domain.lorecontext;
+
+import lombok.Builder;
+import lombok.Data;
+import java.time.LocalDateTime;
+
+/**
+ * Entité de domaine représentant un Univers de jeu (Lore).
+ * Conteneur global pour organiser la connaissance d'un monde.
+ * C'est une entité pure du domaine, sans dépendance technique (pas de JPA).
+ */
+@Data
+@Builder
+public class Lore {
+
+ private String id;
+ private String name;
+ private String description;
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+ private int nodeCount;
+ private int pageCount;
+
+ // Méthodes métier pour gérer les métriques
+ public void incrementNodeCount() {
+ this.nodeCount++;
+ this.updatedAt = LocalDateTime.now();
+ }
+
+ public void decrementNodeCount() {
+ if (this.nodeCount > 0) {
+ this.nodeCount--;
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+
+ public void incrementPageCount() {
+ this.pageCount++;
+ this.updatedAt = LocalDateTime.now();
+ }
+
+ public void decrementPageCount() {
+ if (this.pageCount > 0) {
+ this.pageCount--;
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/LoreNode.java b/core/src/main/java/com/loremind/domain/lorecontext/LoreNode.java
new file mode 100644
index 0000000..78a0856
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/LoreNode.java
@@ -0,0 +1,42 @@
+package com.loremind.domain.lorecontext;
+
+import lombok.Builder;
+import lombok.Data;
+import java.time.LocalDateTime;
+
+/**
+ * Entité de domaine représentant un dossier dans l'arborescence d'un Lore.
+ * Un dossier organise des Pages et peut contenir des sous-dossiers.
+ * Structure hiérarchique via parentId (auto-référence).
+ * Entité pure du domaine, sans dépendance technique.
+ *
+ * Note : le nom interne reste "LoreNode" pour des raisons historiques et
+ * techniques (compatibilité BDD, couplage avec le code existant). L'UI expose
+ * le concept sous le terme "dossier".
+ */
+@Data
+@Builder
+public class LoreNode {
+
+ private String id;
+ private String name;
+ /** Clé de l'icône lucide choisie par l'utilisateur (ex: "users", "map-pin"). */
+ private String icon;
+ private String parentId; // Auto-référence pour l'arborescence
+ private String loreId; // Référence vers le Lore parent
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+
+ // Méthode métier pour vérifier si c'est un nœud racine
+ public boolean isRoot() {
+ return parentId == null || parentId.isEmpty();
+ }
+
+ // Méthode métier pour vérifier si c'est un nœud feuille (sans enfants)
+ // Note: La vérification réelle nécessite d'accéder aux enfants,
+ // donc cette méthode est indicative et doit être complétée par le repository
+ public boolean isLeaf() {
+ // Cette logique sera implémentée au niveau du service/repository
+ return false;
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/Page.java b/core/src/main/java/com/loremind/domain/lorecontext/Page.java
new file mode 100644
index 0000000..1cd3039
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/Page.java
@@ -0,0 +1,82 @@
+package com.loremind.domain.lorecontext;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Entité de domaine représentant une page de contenu rattachée à un LoreNode.
+ *
+ * Une page :
+ * - appartient à un Lore (loreId — dénormalisé pour queries rapides)
+ * - est rangée sous un LoreNode (nodeId)
+ * - est générée depuis un Template (templateId) dont elle suit les `fields`
+ * - stocke les valeurs de ses champs dynamiques dans `values` (fieldName → value)
+ * - porte des métadonnées éditoriales : notes privées MJ, tags, liens inter-pages.
+ *
+ * Entité pure du domaine : aucune dépendance technique.
+ */
+@Data
+@Builder
+public class Page {
+
+ private String id;
+ private String loreId;
+ private String nodeId;
+ private String templateId;
+ private String title;
+
+ /** Valeurs des champs dynamiques définis par le Template. */
+ private Map values;
+
+ /** Notes privées du MJ (non exportées vers FoundryVTT). */
+ private String notes;
+
+ /** Étiquettes libres pour regroupement/recherche. */
+ private List tags;
+
+ /** IDs d'autres Pages liées (mêmes Lore ou cross-lore). */
+ private List relatedPageIds;
+
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+
+ // --- Méthodes métier --------------------------------------------------
+
+ /** Met à jour la valeur d'un champ dynamique (création de la map si absente). */
+ public void setFieldValue(String fieldName, String value) {
+ if (values == null) {
+ values = new HashMap<>();
+ }
+ values.put(fieldName, value);
+ this.updatedAt = LocalDateTime.now();
+ }
+
+ public String getFieldValue(String fieldName) {
+ return values == null ? null : values.get(fieldName);
+ }
+
+ public void addTag(String tag) {
+ if (tag == null || tag.isBlank()) return;
+ if (tags == null) tags = new ArrayList<>();
+ if (!tags.contains(tag)) {
+ tags.add(tag);
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+
+ public void removeTag(String tag) {
+ if (tags != null && tags.remove(tag)) {
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+
+ public boolean hasTemplate() {
+ return templateId != null && !templateId.isBlank();
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/Template.java b/core/src/main/java/com/loremind/domain/lorecontext/Template.java
new file mode 100644
index 0000000..95c7bd5
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/Template.java
@@ -0,0 +1,61 @@
+package com.loremind.domain.lorecontext;
+
+import lombok.Builder;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entité de domaine représentant un Template pour la génération de Pages.
+ *
+ * Un Template :
+ * - appartient à un Lore (loreId)
+ * - définit le noeud par défaut où seront rangées les Pages créées (defaultNodeId)
+ * - porte une liste ordonnée de noms de champs dynamiques (fields)
+ * qui seront instanciés sur chaque Page produite depuis ce gabarit.
+ *
+ * Entité pure du domaine : aucune dépendance technique (Spring, JPA, etc.).
+ */
+@Data
+@Builder
+public class Template {
+
+ private String id;
+ private String loreId; // Rattachement au Lore propriétaire
+ private String name;
+ private String description;
+ private String defaultNodeId; // Noeud cible des Pages générées
+ private List fields; // Noms des champs dynamiques (ordonnés)
+ private LocalDateTime createdAt;
+ private LocalDateTime updatedAt;
+
+ // --- Méthodes métier ---------------------------------------------------
+
+ /** Nombre de champs dynamiques définis (affiché dans le sidebar "X champs"). */
+ public int fieldCount() {
+ return fields == null ? 0 : fields.size();
+ }
+
+ /** Ajoute un champ à la fin de la liste (ignore les doublons et les blancs). */
+ public void addField(String fieldName) {
+ if (fieldName == null || fieldName.isBlank()) {
+ return;
+ }
+ if (fields == null) {
+ fields = new ArrayList<>();
+ }
+ if (!fields.contains(fieldName)) {
+ fields.add(fieldName);
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+
+ /** Retire un champ s'il existe. */
+ public void removeField(String fieldName) {
+ if (fields != null && fields.remove(fieldName)) {
+ this.updatedAt = LocalDateTime.now();
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/ports/LoreNodeRepository.java b/core/src/main/java/com/loremind/domain/lorecontext/ports/LoreNodeRepository.java
new file mode 100644
index 0000000..9cf966f
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/ports/LoreNodeRepository.java
@@ -0,0 +1,30 @@
+package com.loremind.domain.lorecontext.ports;
+
+import com.loremind.domain.lorecontext.LoreNode;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des LoreNodes.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ */
+public interface LoreNodeRepository {
+
+ LoreNode save(LoreNode loreNode);
+
+ Optional findById(String id);
+
+ List findByLoreId(String loreId);
+
+ List findByParentId(String parentId);
+
+ List findAll();
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+
+ long countByLoreId(String loreId);
+
+ List searchByName(String query);
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/ports/LoreRepository.java b/core/src/main/java/com/loremind/domain/lorecontext/ports/LoreRepository.java
new file mode 100644
index 0000000..140d534
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/ports/LoreRepository.java
@@ -0,0 +1,25 @@
+package com.loremind.domain.lorecontext.ports;
+
+import com.loremind.domain.lorecontext.Lore;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des Lores.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ * C'est un Port de sortie (Output Port) selon l'Architecture Hexagonale.
+ */
+public interface LoreRepository {
+
+ Lore save(Lore lore);
+
+ Optional findById(String id);
+
+ List findAll();
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+
+ List searchByName(String query);
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/ports/PageRepository.java b/core/src/main/java/com/loremind/domain/lorecontext/ports/PageRepository.java
new file mode 100644
index 0000000..663e6f9
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/ports/PageRepository.java
@@ -0,0 +1,32 @@
+package com.loremind.domain.lorecontext.ports;
+
+import com.loremind.domain.lorecontext.Page;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des Pages.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ */
+public interface PageRepository {
+
+ Page save(Page page);
+
+ Optional findById(String id);
+
+ List findByLoreId(String loreId);
+
+ List findByNodeId(String nodeId);
+
+ List findByTemplateId(String templateId);
+
+ List findAll();
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+
+ long countByLoreId(String loreId);
+
+ List searchByTitle(String query);
+}
diff --git a/core/src/main/java/com/loremind/domain/lorecontext/ports/TemplateRepository.java b/core/src/main/java/com/loremind/domain/lorecontext/ports/TemplateRepository.java
new file mode 100644
index 0000000..9305ccd
--- /dev/null
+++ b/core/src/main/java/com/loremind/domain/lorecontext/ports/TemplateRepository.java
@@ -0,0 +1,27 @@
+package com.loremind.domain.lorecontext.ports;
+
+import com.loremind.domain.lorecontext.Template;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Port de sortie pour la persistance des Templates.
+ * Interface définie dans le domaine, implémentée par l'infrastructure.
+ */
+public interface TemplateRepository {
+
+ Template save(Template template);
+
+ Optional findById(String id);
+
+ List findAll();
+
+ /** Tous les templates rattachés à un Lore donné (pour le panneau sidebar). */
+ List findByLoreId(String loreId);
+
+ void deleteById(String id);
+
+ boolean existsById(String id);
+
+ List searchByName(String query);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/converter/MapJsonConverter.java b/core/src/main/java/com/loremind/infrastructure/persistence/converter/MapJsonConverter.java
new file mode 100644
index 0000000..a3c47fe
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/converter/MapJsonConverter.java
@@ -0,0 +1,44 @@
+package com.loremind.infrastructure.persistence.converter;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+import java.util.Map;
+
+/**
+ * Converter JPA pour convertir Map en String (JSON).
+ * Compatible avec PostgreSQL (JSONB peut stocker du JSON dans TEXT).
+ * Utilisé pour le champ structure de Template, mais peut servir pour tout champ JSON.
+ * C'est un converter générique réutilisable.
+ */
+@Converter(autoApply = false)
+public class MapJsonConverter implements AttributeConverter, String> {
+
+ private static final ObjectMapper objectMapper = new ObjectMapper();
+
+ @Override
+ public String convertToDatabaseColumn(Map attribute) {
+ if (attribute == null) {
+ return null;
+ }
+ try {
+ return objectMapper.writeValueAsString(attribute);
+ } catch (JsonProcessingException e) {
+ throw new IllegalArgumentException("Erreur lors de la conversion Map vers JSON String", e);
+ }
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public Map convertToEntityAttribute(String dbData) {
+ if (dbData == null) {
+ return null;
+ }
+ try {
+ return objectMapper.readValue(dbData, Map.class);
+ } catch (JsonProcessingException e) {
+ throw new IllegalArgumentException("Erreur lors de la conversion JSON String vers Map", e);
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringListJsonConverter.java b/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringListJsonConverter.java
new file mode 100644
index 0000000..a50d83e
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringListJsonConverter.java
@@ -0,0 +1,46 @@
+package com.loremind.infrastructure.persistence.converter;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Convertit une List du domaine en chaîne JSON stockée en base, et
+ * inversement. Utilisé pour les listes simples (ex: Template.fields).
+ *
+ * Ceci est un adaptateur technique d'infrastructure : il permet au domaine de
+ * rester pur (juste une List) pendant que JPA parle JSON à PostgreSQL.
+ */
+@Converter
+public class StringListJsonConverter implements AttributeConverter, String> {
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ @Override
+ public String convertToDatabaseColumn(List attribute) {
+ if (attribute == null || attribute.isEmpty()) {
+ return "[]";
+ }
+ try {
+ return MAPPER.writeValueAsString(attribute);
+ } catch (Exception e) {
+ throw new IllegalStateException("Erreur sérialisation List → JSON", e);
+ }
+ }
+
+ @Override
+ public List convertToEntityAttribute(String dbData) {
+ if (dbData == null || dbData.isBlank()) {
+ return Collections.emptyList();
+ }
+ try {
+ return MAPPER.readValue(dbData, new TypeReference>() {});
+ } catch (Exception e) {
+ throw new IllegalStateException("Erreur désérialisation JSON → List", e);
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringMapJsonConverter.java b/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringMapJsonConverter.java
new file mode 100644
index 0000000..e36aa43
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/converter/StringMapJsonConverter.java
@@ -0,0 +1,44 @@
+package com.loremind.infrastructure.persistence.converter;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.AttributeConverter;
+import jakarta.persistence.Converter;
+
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * Convertit une Map du domaine en chaîne JSON et inversement.
+ * Utilisé pour les maps clé-valeur simples (ex: Page.values — stocke les valeurs
+ * des champs dynamiques définis par le Template).
+ */
+@Converter
+public class StringMapJsonConverter implements AttributeConverter, String> {
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ @Override
+ public String convertToDatabaseColumn(Map attribute) {
+ if (attribute == null || attribute.isEmpty()) {
+ return "{}";
+ }
+ try {
+ return MAPPER.writeValueAsString(attribute);
+ } catch (Exception e) {
+ throw new IllegalStateException("Erreur sérialisation Map → JSON", e);
+ }
+ }
+
+ @Override
+ public Map convertToEntityAttribute(String dbData) {
+ if (dbData == null || dbData.isBlank()) {
+ return Collections.emptyMap();
+ }
+ try {
+ return MAPPER.readValue(dbData, new TypeReference>() {});
+ } catch (Exception e) {
+ throw new IllegalStateException("Erreur désérialisation JSON → Map", e);
+ }
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/ArcJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/ArcJpaEntity.java
new file mode 100644
index 0000000..b491e1d
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/ArcJpaEntity.java
@@ -0,0 +1,81 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entité JPA pour la persistance des Arcs en base de données PostgreSQL.
+ */
+@Entity
+@Table(name = "arcs")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArcJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false)
+ private String name;
+
+ @Column(columnDefinition = "TEXT")
+ private String description;
+
+ @Column(name = "campaign_id", nullable = false)
+ private Long campaignId;
+
+ @Column(name = "\"order\"", nullable = false)
+ private int order;
+
+ // Champs narratifs enrichis — ajoutés automatiquement par Hibernate DDL (ddl-auto=update)
+ @Column(columnDefinition = "TEXT")
+ private String themes;
+
+ @Column(columnDefinition = "TEXT")
+ private String stakes;
+
+ @Column(name = "gm_notes", columnDefinition = "TEXT")
+ private String gmNotes;
+
+ @Column(columnDefinition = "TEXT")
+ private String rewards;
+
+ @Column(columnDefinition = "TEXT")
+ private String resolution;
+
+ /**
+ * IDs des pages du Lore liées à cet arc, stockés en JSON dans une colonne TEXT.
+ * Pas de FK cross-context : respect des Bounded Contexts.
+ */
+ @Column(name = "related_page_ids", columnDefinition = "TEXT")
+ @Convert(converter = StringListJsonConverter.class)
+ @Builder.Default
+ private List relatedPageIds = new ArrayList<>();
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/CampaignJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/CampaignJpaEntity.java
new file mode 100644
index 0000000..b856901
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/CampaignJpaEntity.java
@@ -0,0 +1,58 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+
+/**
+ * Entité JPA pour la persistance des Campaigns en base de données PostgreSQL.
+ */
+@Entity
+@Table(name = "campaigns")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CampaignJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false)
+ private String name;
+
+ @Column(columnDefinition = "TEXT")
+ private String description;
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @Column(name = "arcs_count", nullable = false)
+ private int arcsCount;
+
+ /**
+ * ID du Lore associé (nullable).
+ * Pas de @ManyToOne / pas de FK : c'est une weak reference inter-contexte.
+ * Le Campaign Context et le Lore Context doivent pouvoir évoluer indépendamment.
+ */
+ @Column(name = "lore_id")
+ private String loreId;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/ChapterJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/ChapterJpaEntity.java
new file mode 100644
index 0000000..f7f2e04
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/ChapterJpaEntity.java
@@ -0,0 +1,71 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entité JPA pour la persistance des Chapters en base de données PostgreSQL.
+ */
+@Entity
+@Table(name = "chapters")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class ChapterJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false)
+ private String name;
+
+ @Column(columnDefinition = "TEXT")
+ private String description;
+
+ @Column(name = "arc_id", nullable = false)
+ private Long arcId;
+
+ @Column(name = "\"order\"", nullable = false)
+ private int order;
+
+ // Champs narratifs enrichis — ajoutés automatiquement par Hibernate DDL (ddl-auto=update)
+ @Column(name = "gm_notes", columnDefinition = "TEXT")
+ private String gmNotes;
+
+ @Column(name = "player_objectives", columnDefinition = "TEXT")
+ private String playerObjectives;
+
+ @Column(name = "narrative_stakes", columnDefinition = "TEXT")
+ private String narrativeStakes;
+
+ @Column(name = "related_page_ids", columnDefinition = "TEXT")
+ @Convert(converter = StringListJsonConverter.class)
+ @Builder.Default
+ private List relatedPageIds = new ArrayList<>();
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/LoreJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/LoreJpaEntity.java
new file mode 100644
index 0000000..33827f1
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/LoreJpaEntity.java
@@ -0,0 +1,54 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+
+/**
+ * Entité JPA pour la persistance des Lores en base de données PostgreSQL.
+ * Cette classe contient des annotations JPA, donc elle est dans infrastructure, pas dans le domaine.
+ */
+@Entity
+@Table(name = "lores")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class LoreJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false)
+ private String name;
+
+ @Column(columnDefinition = "TEXT")
+ private String description;
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @Column(name = "node_count", nullable = false)
+ private int nodeCount;
+
+ @Column(name = "page_count", nullable = false)
+ private int pageCount;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/LoreNodeJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/LoreNodeJpaEntity.java
new file mode 100644
index 0000000..b35e901
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/LoreNodeJpaEntity.java
@@ -0,0 +1,55 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+
+/**
+ * Entité JPA pour la persistance des LoreNodes en base de données PostgreSQL.
+ * Structure hiérarchique via parentId (auto-référence).
+ */
+@Entity
+@Table(name = "lore_nodes")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class LoreNodeJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false)
+ private String name;
+
+ /** Clé de l'icône lucide-angular (ex: "users", "map-pin"). Nullable : un dossier peut ne pas avoir d'icône. */
+ @Column(length = 64)
+ private String icon;
+
+ @Column(name = "parent_id")
+ private Long parentId; // Auto-référence pour l'arborescence
+
+ @Column(name = "lore_id", nullable = false)
+ private Long loreId;
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/PageJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/PageJpaEntity.java
new file mode 100644
index 0000000..56616fe
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/PageJpaEntity.java
@@ -0,0 +1,76 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
+import com.loremind.infrastructure.persistence.converter.StringMapJsonConverter;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Entité JPA pour la persistance des Pages en PostgreSQL.
+ * - lore_id dénormalisé (accès rapide aux pages d'un lore sans passer par nodes).
+ * - values / tags / related_page_ids stockés en JSON (TEXT via converters).
+ * - Note : colonne `values_json` car `values` est un mot-clé SQL réservé.
+ */
+@Entity
+@Table(name = "pages")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class PageJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(name = "lore_id", nullable = false)
+ private Long loreId;
+
+ @Column(name = "node_id", nullable = false)
+ private Long nodeId;
+
+ @Column(name = "template_id")
+ private Long templateId;
+
+ @Column(nullable = false)
+ private String title;
+
+ @Column(name = "values_json", columnDefinition = "TEXT")
+ @Convert(converter = StringMapJsonConverter.class)
+ private Map values;
+
+ @Column(columnDefinition = "TEXT")
+ private String notes;
+
+ @Column(name = "tags", columnDefinition = "TEXT")
+ @Convert(converter = StringListJsonConverter.class)
+ private List tags;
+
+ @Column(name = "related_page_ids", columnDefinition = "TEXT")
+ @Convert(converter = StringListJsonConverter.class)
+ private List relatedPageIds;
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/SceneJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/SceneJpaEntity.java
new file mode 100644
index 0000000..79ffea7
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/SceneJpaEntity.java
@@ -0,0 +1,92 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Entité JPA pour la persistance des Scenes en base de données PostgreSQL.
+ */
+@Entity
+@Table(name = "scenes")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class SceneJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(nullable = false)
+ private String name;
+
+ @Column(columnDefinition = "TEXT")
+ private String description;
+
+ @Column(name = "chapter_id", nullable = false)
+ private Long chapterId;
+
+ @Column(name = "\"order\"", nullable = false)
+ private int order;
+
+ // Champs narratifs enrichis — ajoutés automatiquement par Hibernate (ddl-auto=update)
+
+ // Contexte et ambiance
+ @Column(columnDefinition = "TEXT")
+ private String location;
+
+ @Column(columnDefinition = "TEXT")
+ private String timing;
+
+ @Column(columnDefinition = "TEXT")
+ private String atmosphere;
+
+ // Narration
+ @Column(name = "player_narration", columnDefinition = "TEXT")
+ private String playerNarration;
+
+ // Secrets MJ
+ @Column(name = "gm_secret_notes", columnDefinition = "TEXT")
+ private String gmSecretNotes;
+
+ // Choix et conséquences
+ @Column(name = "choices_consequences", columnDefinition = "TEXT")
+ private String choicesConsequences;
+
+ // Combat
+ @Column(name = "combat_difficulty", columnDefinition = "TEXT")
+ private String combatDifficulty;
+
+ @Column(columnDefinition = "TEXT")
+ private String enemies;
+
+ @Column(name = "related_page_ids", columnDefinition = "TEXT")
+ @Convert(converter = StringListJsonConverter.class)
+ @Builder.Default
+ private List relatedPageIds = new ArrayList<>();
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/entity/TemplateJpaEntity.java b/core/src/main/java/com/loremind/infrastructure/persistence/entity/TemplateJpaEntity.java
new file mode 100644
index 0000000..3508617
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/entity/TemplateJpaEntity.java
@@ -0,0 +1,63 @@
+package com.loremind.infrastructure.persistence.entity;
+
+import com.loremind.infrastructure.persistence.converter.StringListJsonConverter;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * Entité JPA pour la persistance des Templates en PostgreSQL.
+ * - loreId et defaultNodeId : colonnes typées (FK logiques, pas de @ManyToOne
+ * pour respecter l'isolation des Bounded Contexts).
+ * - fields : stocké en JSON (TEXT) via StringListJsonConverter.
+ */
+@Entity
+@Table(name = "templates")
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class TemplateJpaEntity {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.IDENTITY)
+ private Long id;
+
+ @Column(name = "lore_id", nullable = false)
+ private Long loreId;
+
+ @Column(nullable = false)
+ private String name;
+
+ @Column(columnDefinition = "TEXT")
+ private String description;
+
+ @Column(name = "default_node_id")
+ private Long defaultNodeId;
+
+ @Column(name = "fields", columnDefinition = "TEXT")
+ @Convert(converter = StringListJsonConverter.class)
+ private List fields;
+
+ @Column(name = "created_at", nullable = false, updatable = false)
+ private LocalDateTime createdAt;
+
+ @Column(name = "updated_at", nullable = false)
+ private LocalDateTime updatedAt;
+
+ @PrePersist
+ protected void onCreate() {
+ createdAt = LocalDateTime.now();
+ updatedAt = LocalDateTime.now();
+ }
+
+ @PreUpdate
+ protected void onUpdate() {
+ updatedAt = LocalDateTime.now();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ArcJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ArcJpaRepository.java
new file mode 100644
index 0000000..210d269
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ArcJpaRepository.java
@@ -0,0 +1,16 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.ArcJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour ArcJpaEntity.
+ */
+@Repository
+public interface ArcJpaRepository extends JpaRepository {
+
+ List findByCampaignId(Long campaignId);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/CampaignJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/CampaignJpaRepository.java
new file mode 100644
index 0000000..0957e87
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/CampaignJpaRepository.java
@@ -0,0 +1,19 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.CampaignJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour CampaignJpaEntity.
+ */
+@Repository
+public interface CampaignJpaRepository extends JpaRepository {
+
+ @Query("SELECT c FROM CampaignJpaEntity c WHERE LOWER(c.name) LIKE LOWER(CONCAT('%', :query, '%'))")
+ List findByNameContainingIgnoreCase(@Param("query") String query);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ChapterJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ChapterJpaRepository.java
new file mode 100644
index 0000000..da5a07e
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/ChapterJpaRepository.java
@@ -0,0 +1,16 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.ChapterJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour ChapterJpaEntity.
+ */
+@Repository
+public interface ChapterJpaRepository extends JpaRepository {
+
+ List findByArcId(Long arcId);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/LoreJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/LoreJpaRepository.java
new file mode 100644
index 0000000..324d872
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/LoreJpaRepository.java
@@ -0,0 +1,17 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.LoreJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour LoreJpaEntity.
+ * Utilisé par l'adaptateur PostgresLoreRepository.
+ */
+@Repository
+public interface LoreJpaRepository extends JpaRepository {
+
+ List findByNameContainingIgnoreCase(String query);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/LoreNodeJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/LoreNodeJpaRepository.java
new file mode 100644
index 0000000..e9cfe4c
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/LoreNodeJpaRepository.java
@@ -0,0 +1,22 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.LoreNodeJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour LoreNodeJpaEntity.
+ */
+@Repository
+public interface LoreNodeJpaRepository extends JpaRepository {
+
+ List findByLoreId(Long loreId);
+
+ List findByParentId(Long parentId);
+
+ long countByLoreId(Long loreId);
+
+ List findByNameContainingIgnoreCase(String query);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/PageJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/PageJpaRepository.java
new file mode 100644
index 0000000..75a752d
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/PageJpaRepository.java
@@ -0,0 +1,24 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.PageJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour PageJpaEntity.
+ */
+@Repository
+public interface PageJpaRepository extends JpaRepository {
+
+ List findByLoreId(Long loreId);
+
+ List findByNodeId(Long nodeId);
+
+ List findByTemplateId(Long templateId);
+
+ long countByLoreId(Long loreId);
+
+ List findByTitleContainingIgnoreCase(String query);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/SceneJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/SceneJpaRepository.java
new file mode 100644
index 0000000..a6d1b3c
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/SceneJpaRepository.java
@@ -0,0 +1,16 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.SceneJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour SceneJpaEntity.
+ */
+@Repository
+public interface SceneJpaRepository extends JpaRepository {
+
+ List findByChapterId(Long chapterId);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/jpa/TemplateJpaRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/TemplateJpaRepository.java
new file mode 100644
index 0000000..b16212e
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/jpa/TemplateJpaRepository.java
@@ -0,0 +1,18 @@
+package com.loremind.infrastructure.persistence.jpa;
+
+import com.loremind.infrastructure.persistence.entity.TemplateJpaEntity;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * Repository Spring Data JPA pour TemplateJpaEntity.
+ */
+@Repository
+public interface TemplateJpaRepository extends JpaRepository {
+
+ List findByLoreId(Long loreId);
+
+ List findByNameContainingIgnoreCase(String query);
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresArcRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresArcRepository.java
new file mode 100644
index 0000000..10a8c8f
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresArcRepository.java
@@ -0,0 +1,108 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.campaigncontext.Arc;
+import com.loremind.domain.campaigncontext.ports.ArcRepository;
+import com.loremind.infrastructure.persistence.entity.ArcJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.ArcJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port ArcRepository.
+ */
+@Repository
+public class PostgresArcRepository implements ArcRepository {
+
+ private final ArcJpaRepository jpaRepository;
+
+ public PostgresArcRepository(ArcJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public Arc save(Arc arc) {
+ ArcJpaEntity jpaEntity = toJpaEntity(arc);
+ ArcJpaEntity saved = jpaRepository.save(jpaEntity);
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.findById(longId)
+ .map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findByCampaignId(String campaignId) {
+ Long longCampaignId = Long.parseLong(campaignId);
+ return jpaRepository.findByCampaignId(longCampaignId).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ Long longId = Long.parseLong(id);
+ jpaRepository.deleteById(longId);
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.existsById(longId);
+ }
+
+ private Arc toDomainEntity(ArcJpaEntity jpaEntity) {
+ return Arc.builder()
+ .id(jpaEntity.getId().toString())
+ .name(jpaEntity.getName())
+ .description(jpaEntity.getDescription())
+ .campaignId(jpaEntity.getCampaignId().toString())
+ .order(jpaEntity.getOrder())
+ .themes(jpaEntity.getThemes())
+ .stakes(jpaEntity.getStakes())
+ .gmNotes(jpaEntity.getGmNotes())
+ .rewards(jpaEntity.getRewards())
+ .resolution(jpaEntity.getResolution())
+ // Defensive copy : jamais de null en domaine pour simplifier les appelants.
+ .relatedPageIds(jpaEntity.getRelatedPageIds() != null
+ ? new ArrayList<>(jpaEntity.getRelatedPageIds())
+ : new ArrayList<>())
+ .createdAt(jpaEntity.getCreatedAt())
+ .updatedAt(jpaEntity.getUpdatedAt())
+ .build();
+ }
+
+ private ArcJpaEntity toJpaEntity(Arc arc) {
+ Long id = arc.getId() != null ? Long.parseLong(arc.getId()) : null;
+ return ArcJpaEntity.builder()
+ .id(id)
+ .name(arc.getName())
+ .description(arc.getDescription())
+ .campaignId(Long.parseLong(arc.getCampaignId()))
+ .order(arc.getOrder())
+ .themes(arc.getThemes())
+ .stakes(arc.getStakes())
+ .gmNotes(arc.getGmNotes())
+ .rewards(arc.getRewards())
+ .resolution(arc.getResolution())
+ .relatedPageIds(arc.getRelatedPageIds() != null
+ ? new ArrayList<>(arc.getRelatedPageIds())
+ : new ArrayList<>())
+ .createdAt(arc.getCreatedAt())
+ .updatedAt(arc.getUpdatedAt())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresCampaignRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresCampaignRepository.java
new file mode 100644
index 0000000..86aa974
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresCampaignRepository.java
@@ -0,0 +1,89 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.campaigncontext.Campaign;
+import com.loremind.domain.campaigncontext.ports.CampaignRepository;
+import com.loremind.infrastructure.persistence.entity.CampaignJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.CampaignJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port CampaignRepository.
+ */
+@Repository
+public class PostgresCampaignRepository implements CampaignRepository {
+
+ private final CampaignJpaRepository jpaRepository;
+
+ public PostgresCampaignRepository(CampaignJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public Campaign save(Campaign campaign) {
+ CampaignJpaEntity jpaEntity = toJpaEntity(campaign);
+ CampaignJpaEntity saved = jpaRepository.save(jpaEntity);
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.findById(longId)
+ .map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ Long longId = Long.parseLong(id);
+ jpaRepository.deleteById(longId);
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.existsById(longId);
+ }
+
+ @Override
+ public List searchByName(String query) {
+ return jpaRepository.findByNameContainingIgnoreCase(query).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ private Campaign toDomainEntity(CampaignJpaEntity jpaEntity) {
+ return Campaign.builder()
+ .id(jpaEntity.getId().toString())
+ .name(jpaEntity.getName())
+ .description(jpaEntity.getDescription())
+ .createdAt(jpaEntity.getCreatedAt())
+ .updatedAt(jpaEntity.getUpdatedAt())
+ .arcsCount(jpaEntity.getArcsCount())
+ .loreId(jpaEntity.getLoreId())
+ .build();
+ }
+
+ private CampaignJpaEntity toJpaEntity(Campaign campaign) {
+ Long id = campaign.getId() != null ? Long.parseLong(campaign.getId()) : null;
+ return CampaignJpaEntity.builder()
+ .id(id)
+ .name(campaign.getName())
+ .description(campaign.getDescription())
+ .createdAt(campaign.getCreatedAt())
+ .updatedAt(campaign.getUpdatedAt())
+ .arcsCount(campaign.getArcsCount())
+ .loreId(campaign.getLoreId())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresChapterRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresChapterRepository.java
new file mode 100644
index 0000000..4583753
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresChapterRepository.java
@@ -0,0 +1,103 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.domain.campaigncontext.ports.ChapterRepository;
+import com.loremind.infrastructure.persistence.entity.ChapterJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.ChapterJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port ChapterRepository.
+ */
+@Repository
+public class PostgresChapterRepository implements ChapterRepository {
+
+ private final ChapterJpaRepository jpaRepository;
+
+ public PostgresChapterRepository(ChapterJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public Chapter save(Chapter chapter) {
+ ChapterJpaEntity jpaEntity = toJpaEntity(chapter);
+ ChapterJpaEntity saved = jpaRepository.save(jpaEntity);
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.findById(longId)
+ .map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findByArcId(String arcId) {
+ Long longArcId = Long.parseLong(arcId);
+ return jpaRepository.findByArcId(longArcId).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ Long longId = Long.parseLong(id);
+ jpaRepository.deleteById(longId);
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.existsById(longId);
+ }
+
+ private Chapter toDomainEntity(ChapterJpaEntity jpaEntity) {
+ return Chapter.builder()
+ .id(jpaEntity.getId().toString())
+ .name(jpaEntity.getName())
+ .description(jpaEntity.getDescription())
+ .arcId(jpaEntity.getArcId().toString())
+ .order(jpaEntity.getOrder())
+ .gmNotes(jpaEntity.getGmNotes())
+ .playerObjectives(jpaEntity.getPlayerObjectives())
+ .narrativeStakes(jpaEntity.getNarrativeStakes())
+ .relatedPageIds(jpaEntity.getRelatedPageIds() != null
+ ? new ArrayList<>(jpaEntity.getRelatedPageIds())
+ : new ArrayList<>())
+ .createdAt(jpaEntity.getCreatedAt())
+ .updatedAt(jpaEntity.getUpdatedAt())
+ .build();
+ }
+
+ private ChapterJpaEntity toJpaEntity(Chapter chapter) {
+ Long id = chapter.getId() != null ? Long.parseLong(chapter.getId()) : null;
+ return ChapterJpaEntity.builder()
+ .id(id)
+ .name(chapter.getName())
+ .description(chapter.getDescription())
+ .arcId(Long.parseLong(chapter.getArcId()))
+ .order(chapter.getOrder())
+ .gmNotes(chapter.getGmNotes())
+ .playerObjectives(chapter.getPlayerObjectives())
+ .narrativeStakes(chapter.getNarrativeStakes())
+ .relatedPageIds(chapter.getRelatedPageIds() != null
+ ? new ArrayList<>(chapter.getRelatedPageIds())
+ : new ArrayList<>())
+ .createdAt(chapter.getCreatedAt())
+ .updatedAt(chapter.getUpdatedAt())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreNodeRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreNodeRepository.java
new file mode 100644
index 0000000..db9b5eb
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreNodeRepository.java
@@ -0,0 +1,118 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.lorecontext.LoreNode;
+import com.loremind.domain.lorecontext.ports.LoreNodeRepository;
+import com.loremind.infrastructure.persistence.entity.LoreNodeJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.LoreNodeJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port LoreNodeRepository.
+ */
+@Repository
+public class PostgresLoreNodeRepository implements LoreNodeRepository {
+
+ private final LoreNodeJpaRepository jpaRepository;
+
+ public PostgresLoreNodeRepository(LoreNodeJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public LoreNode save(LoreNode loreNode) {
+ LoreNodeJpaEntity jpaEntity = toJpaEntity(loreNode);
+ LoreNodeJpaEntity saved = jpaRepository.save(jpaEntity);
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.findById(longId)
+ .map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findByLoreId(String loreId) {
+ Long longLoreId = Long.parseLong(loreId);
+ return jpaRepository.findByLoreId(longLoreId).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findByParentId(String parentId) {
+ if (parentId == null || parentId.isEmpty()) {
+ return jpaRepository.findByParentId(null).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+ Long longParentId = Long.parseLong(parentId);
+ return jpaRepository.findByParentId(longParentId).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ Long longId = Long.parseLong(id);
+ jpaRepository.deleteById(longId);
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.existsById(longId);
+ }
+
+ @Override
+ public long countByLoreId(String loreId) {
+ return jpaRepository.countByLoreId(Long.parseLong(loreId));
+ }
+
+ @Override
+ public List searchByName(String query) {
+ return jpaRepository.findByNameContainingIgnoreCase(query).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ private LoreNode toDomainEntity(LoreNodeJpaEntity jpaEntity) {
+ return LoreNode.builder()
+ .id(jpaEntity.getId().toString())
+ .name(jpaEntity.getName())
+ .icon(jpaEntity.getIcon())
+ .parentId(jpaEntity.getParentId() != null ? jpaEntity.getParentId().toString() : null)
+ .loreId(jpaEntity.getLoreId().toString())
+ .createdAt(jpaEntity.getCreatedAt())
+ .updatedAt(jpaEntity.getUpdatedAt())
+ .build();
+ }
+
+ private LoreNodeJpaEntity toJpaEntity(LoreNode loreNode) {
+ Long id = loreNode.getId() != null ? Long.parseLong(loreNode.getId()) : null;
+ Long parentId = loreNode.getParentId() != null && !loreNode.getParentId().isEmpty()
+ ? Long.parseLong(loreNode.getParentId())
+ : null;
+ return LoreNodeJpaEntity.builder()
+ .id(id)
+ .name(loreNode.getName())
+ .icon(loreNode.getIcon())
+ .parentId(parentId)
+ .loreId(Long.parseLong(loreNode.getLoreId()))
+ .createdAt(loreNode.getCreatedAt())
+ .updatedAt(loreNode.getUpdatedAt())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreRepository.java
new file mode 100644
index 0000000..02b9e9e
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreRepository.java
@@ -0,0 +1,92 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.lorecontext.Lore;
+import com.loremind.domain.lorecontext.ports.LoreRepository;
+import com.loremind.infrastructure.persistence.entity.LoreJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.LoreJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port LoreRepository.
+ * Utilise LoreJpaRepository pour interagir avec PostgreSQL.
+ * Fait la conversion entre Lore (domaine) et LoreJpaEntity (JPA).
+ */
+@Repository
+public class PostgresLoreRepository implements LoreRepository {
+
+ private final LoreJpaRepository jpaRepository;
+
+ public PostgresLoreRepository(LoreJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public Lore save(Lore lore) {
+ LoreJpaEntity jpaEntity = toJpaEntity(lore);
+ LoreJpaEntity saved = jpaRepository.save(jpaEntity);
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.findById(longId)
+ .map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ Long longId = Long.parseLong(id);
+ jpaRepository.deleteById(longId);
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.existsById(longId);
+ }
+
+ @Override
+ public List searchByName(String query) {
+ return jpaRepository.findByNameContainingIgnoreCase(query).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ // Méthodes de conversion
+ private Lore toDomainEntity(LoreJpaEntity jpaEntity) {
+ return Lore.builder()
+ .id(jpaEntity.getId().toString())
+ .name(jpaEntity.getName())
+ .description(jpaEntity.getDescription())
+ .createdAt(jpaEntity.getCreatedAt())
+ .updatedAt(jpaEntity.getUpdatedAt())
+ .nodeCount(jpaEntity.getNodeCount())
+ .pageCount(jpaEntity.getPageCount())
+ .build();
+ }
+
+ private LoreJpaEntity toJpaEntity(Lore lore) {
+ Long id = lore.getId() != null ? Long.parseLong(lore.getId()) : null;
+ return LoreJpaEntity.builder()
+ .id(id)
+ .name(lore.getName())
+ .description(lore.getDescription())
+ .createdAt(lore.getCreatedAt())
+ .updatedAt(lore.getUpdatedAt())
+ .nodeCount(lore.getNodeCount())
+ .pageCount(lore.getPageCount())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresPageRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresPageRepository.java
new file mode 100644
index 0000000..fb2f98e
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresPageRepository.java
@@ -0,0 +1,130 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.lorecontext.Page;
+import com.loremind.domain.lorecontext.ports.PageRepository;
+import com.loremind.infrastructure.persistence.entity.PageJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.PageJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port PageRepository.
+ */
+@Repository
+public class PostgresPageRepository implements PageRepository {
+
+ private final PageJpaRepository jpaRepository;
+
+ public PostgresPageRepository(PageJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public Page save(Page page) {
+ PageJpaEntity jpaEntity = toJpaEntity(page);
+ PageJpaEntity saved = jpaRepository.save(jpaEntity);
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.findById(longId)
+ .map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findByLoreId(String loreId) {
+ return jpaRepository.findByLoreId(Long.parseLong(loreId)).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findByNodeId(String nodeId) {
+ Long longNodeId = Long.parseLong(nodeId);
+ return jpaRepository.findByNodeId(longNodeId).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findByTemplateId(String templateId) {
+ if (templateId == null || templateId.isEmpty()) {
+ return List.of();
+ }
+ Long longTemplateId = Long.parseLong(templateId);
+ return jpaRepository.findByTemplateId(longTemplateId).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ Long longId = Long.parseLong(id);
+ jpaRepository.deleteById(longId);
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.existsById(longId);
+ }
+
+ @Override
+ public long countByLoreId(String loreId) {
+ return jpaRepository.countByLoreId(Long.parseLong(loreId));
+ }
+
+ @Override
+ public List searchByTitle(String query) {
+ return jpaRepository.findByTitleContainingIgnoreCase(query).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ private Page toDomainEntity(PageJpaEntity e) {
+ return Page.builder()
+ .id(e.getId().toString())
+ .loreId(e.getLoreId() != null ? e.getLoreId().toString() : null)
+ .nodeId(e.getNodeId() != null ? e.getNodeId().toString() : null)
+ .templateId(e.getTemplateId() != null ? e.getTemplateId().toString() : null)
+ .title(e.getTitle())
+ .values(e.getValues() != null ? new HashMap<>(e.getValues()) : new HashMap<>())
+ .notes(e.getNotes())
+ .tags(e.getTags() != null ? new ArrayList<>(e.getTags()) : new ArrayList<>())
+ .relatedPageIds(e.getRelatedPageIds() != null ? new ArrayList<>(e.getRelatedPageIds()) : new ArrayList<>())
+ .createdAt(e.getCreatedAt())
+ .updatedAt(e.getUpdatedAt())
+ .build();
+ }
+
+ private PageJpaEntity toJpaEntity(Page p) {
+ return PageJpaEntity.builder()
+ .id(p.getId() != null ? Long.parseLong(p.getId()) : null)
+ .loreId(p.getLoreId() != null ? Long.parseLong(p.getLoreId()) : null)
+ .nodeId(p.getNodeId() != null ? Long.parseLong(p.getNodeId()) : null)
+ .templateId(p.getTemplateId() != null && !p.getTemplateId().isBlank()
+ ? Long.parseLong(p.getTemplateId()) : null)
+ .title(p.getTitle())
+ .values(p.getValues() != null ? new HashMap<>(p.getValues()) : new HashMap<>())
+ .notes(p.getNotes())
+ .tags(p.getTags() != null ? new ArrayList<>(p.getTags()) : new ArrayList<>())
+ .relatedPageIds(p.getRelatedPageIds() != null ? new ArrayList<>(p.getRelatedPageIds()) : new ArrayList<>())
+ .createdAt(p.getCreatedAt())
+ .updatedAt(p.getUpdatedAt())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresSceneRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresSceneRepository.java
new file mode 100644
index 0000000..84bdd19
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresSceneRepository.java
@@ -0,0 +1,113 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.campaigncontext.Scene;
+import com.loremind.domain.campaigncontext.ports.SceneRepository;
+import com.loremind.infrastructure.persistence.entity.SceneJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.SceneJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port SceneRepository.
+ */
+@Repository
+public class PostgresSceneRepository implements SceneRepository {
+
+ private final SceneJpaRepository jpaRepository;
+
+ public PostgresSceneRepository(SceneJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public Scene save(Scene scene) {
+ SceneJpaEntity jpaEntity = toJpaEntity(scene);
+ SceneJpaEntity saved = jpaRepository.save(jpaEntity);
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.findById(longId)
+ .map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findByChapterId(String chapterId) {
+ Long longChapterId = Long.parseLong(chapterId);
+ return jpaRepository.findByChapterId(longChapterId).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ Long longId = Long.parseLong(id);
+ jpaRepository.deleteById(longId);
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ Long longId = Long.parseLong(id);
+ return jpaRepository.existsById(longId);
+ }
+
+ private Scene toDomainEntity(SceneJpaEntity jpaEntity) {
+ return Scene.builder()
+ .id(jpaEntity.getId().toString())
+ .name(jpaEntity.getName())
+ .description(jpaEntity.getDescription())
+ .chapterId(jpaEntity.getChapterId().toString())
+ .order(jpaEntity.getOrder())
+ .location(jpaEntity.getLocation())
+ .timing(jpaEntity.getTiming())
+ .atmosphere(jpaEntity.getAtmosphere())
+ .playerNarration(jpaEntity.getPlayerNarration())
+ .gmSecretNotes(jpaEntity.getGmSecretNotes())
+ .choicesConsequences(jpaEntity.getChoicesConsequences())
+ .combatDifficulty(jpaEntity.getCombatDifficulty())
+ .enemies(jpaEntity.getEnemies())
+ .relatedPageIds(jpaEntity.getRelatedPageIds() != null
+ ? new ArrayList<>(jpaEntity.getRelatedPageIds())
+ : new ArrayList<>())
+ .createdAt(jpaEntity.getCreatedAt())
+ .updatedAt(jpaEntity.getUpdatedAt())
+ .build();
+ }
+
+ private SceneJpaEntity toJpaEntity(Scene scene) {
+ Long id = scene.getId() != null ? Long.parseLong(scene.getId()) : null;
+ return SceneJpaEntity.builder()
+ .id(id)
+ .name(scene.getName())
+ .description(scene.getDescription())
+ .chapterId(Long.parseLong(scene.getChapterId()))
+ .order(scene.getOrder())
+ .location(scene.getLocation())
+ .timing(scene.getTiming())
+ .atmosphere(scene.getAtmosphere())
+ .playerNarration(scene.getPlayerNarration())
+ .gmSecretNotes(scene.getGmSecretNotes())
+ .choicesConsequences(scene.getChoicesConsequences())
+ .combatDifficulty(scene.getCombatDifficulty())
+ .enemies(scene.getEnemies())
+ .relatedPageIds(scene.getRelatedPageIds() != null
+ ? new ArrayList<>(scene.getRelatedPageIds())
+ : new ArrayList<>())
+ .createdAt(scene.getCreatedAt())
+ .updatedAt(scene.getUpdatedAt())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresTemplateRepository.java b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresTemplateRepository.java
new file mode 100644
index 0000000..cc7e838
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/persistence/postgres/PostgresTemplateRepository.java
@@ -0,0 +1,97 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.lorecontext.Template;
+import com.loremind.domain.lorecontext.ports.TemplateRepository;
+import com.loremind.infrastructure.persistence.entity.TemplateJpaEntity;
+import com.loremind.infrastructure.persistence.jpa.TemplateJpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Adaptateur d'infrastructure qui implémente le Port TemplateRepository.
+ * Responsable du mapping bidirectionnel entre l'entité de domaine (Template)
+ * et l'entité JPA (TemplateJpaEntity).
+ */
+@Repository
+public class PostgresTemplateRepository implements TemplateRepository {
+
+ private final TemplateJpaRepository jpaRepository;
+
+ public PostgresTemplateRepository(TemplateJpaRepository jpaRepository) {
+ this.jpaRepository = jpaRepository;
+ }
+
+ @Override
+ public Template save(Template template) {
+ TemplateJpaEntity saved = jpaRepository.save(toJpaEntity(template));
+ return toDomainEntity(saved);
+ }
+
+ @Override
+ public Optional findById(String id) {
+ return jpaRepository.findById(Long.parseLong(id)).map(this::toDomainEntity);
+ }
+
+ @Override
+ public List findAll() {
+ return jpaRepository.findAll().stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List findByLoreId(String loreId) {
+ return jpaRepository.findByLoreId(Long.parseLong(loreId)).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public void deleteById(String id) {
+ jpaRepository.deleteById(Long.parseLong(id));
+ }
+
+ @Override
+ public boolean existsById(String id) {
+ return jpaRepository.existsById(Long.parseLong(id));
+ }
+
+ @Override
+ public List searchByName(String query) {
+ return jpaRepository.findByNameContainingIgnoreCase(query).stream()
+ .map(this::toDomainEntity)
+ .collect(Collectors.toList());
+ }
+
+ // --- Mapping ----------------------------------------------------------
+
+ private Template toDomainEntity(TemplateJpaEntity e) {
+ return Template.builder()
+ .id(e.getId().toString())
+ .loreId(e.getLoreId() != null ? e.getLoreId().toString() : null)
+ .name(e.getName())
+ .description(e.getDescription())
+ .defaultNodeId(e.getDefaultNodeId() != null ? e.getDefaultNodeId().toString() : null)
+ .fields(e.getFields() != null ? new ArrayList<>(e.getFields()) : new ArrayList<>())
+ .createdAt(e.getCreatedAt())
+ .updatedAt(e.getUpdatedAt())
+ .build();
+ }
+
+ private TemplateJpaEntity toJpaEntity(Template t) {
+ return TemplateJpaEntity.builder()
+ .id(t.getId() != null ? Long.parseLong(t.getId()) : null)
+ .loreId(t.getLoreId() != null ? Long.parseLong(t.getLoreId()) : null)
+ .name(t.getName())
+ .description(t.getDescription())
+ .defaultNodeId(t.getDefaultNodeId() != null ? Long.parseLong(t.getDefaultNodeId()) : null)
+ .fields(t.getFields() != null ? new ArrayList<>(t.getFields()) : new ArrayList<>())
+ .createdAt(t.getCreatedAt())
+ .updatedAt(t.getUpdatedAt())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/config/CorsConfig.java b/core/src/main/java/com/loremind/infrastructure/web/config/CorsConfig.java
new file mode 100644
index 0000000..d973cef
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/config/CorsConfig.java
@@ -0,0 +1,29 @@
+package com.loremind.infrastructure.web.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+import org.springframework.web.filter.CorsFilter;
+
+/**
+ * Configuration CORS pour autoriser les requêtes depuis le Frontend Angular.
+ * Adaptateur d'infrastructure qui configure la politique CORS.
+ */
+@Configuration
+public class CorsConfig {
+
+ @Bean
+ public CorsFilter corsFilter() {
+ UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+ CorsConfiguration config = new CorsConfiguration();
+
+ // Autoriser les requêtes depuis localhost:4200 (Angular dev server)
+ config.addAllowedOrigin("http://localhost:4200");
+ config.addAllowedHeader("*");
+ config.addAllowedMethod("*");
+
+ source.registerCorsConfiguration("/**", config);
+ return new CorsFilter(source);
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/ArcController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/ArcController.java
new file mode 100644
index 0000000..25afd9a
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/ArcController.java
@@ -0,0 +1,71 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.campaigncontext.ArcService;
+import com.loremind.domain.campaigncontext.Arc;
+import com.loremind.infrastructure.web.dto.campaigncontext.ArcDTO;
+import com.loremind.infrastructure.web.mapper.ArcMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte Arc.
+ */
+@RestController
+@RequestMapping("/api/arcs")
+public class ArcController {
+
+ private final ArcService arcService;
+ private final ArcMapper arcMapper;
+
+ public ArcController(ArcService arcService, ArcMapper arcMapper) {
+ this.arcService = arcService;
+ this.arcMapper = arcMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createArc(@RequestBody ArcDTO arcDTO) {
+ Arc arc = arcMapper.toDomain(arcDTO);
+ Arc createdArc = arcService.createArc(arc.getName(), arc.getDescription(), arc.getCampaignId(), arc.getOrder());
+ return ResponseEntity.ok(arcMapper.toDTO(createdArc));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getArcById(@PathVariable String id) {
+ return arcService.getArcById(id)
+ .map(arc -> ResponseEntity.ok(arcMapper.toDTO(arc)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ @GetMapping
+ public ResponseEntity> getAllArcs() {
+ List arcs = arcService.getAllArcs();
+ List arcDTOs = arcs.stream()
+ .map(arcMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(arcDTOs);
+ }
+
+ @GetMapping("/campaign/{campaignId}")
+ public ResponseEntity> getArcsByCampaignId(@PathVariable String campaignId) {
+ List arcs = arcService.getArcsByCampaignId(campaignId);
+ List arcDTOs = arcs.stream()
+ .map(arcMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(arcDTOs);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateArc(@PathVariable String id, @RequestBody ArcDTO arcDTO) {
+ Arc updatedArc = arcService.updateArc(id, arcMapper.toDomain(arcDTO));
+ return ResponseEntity.ok(arcMapper.toDTO(updatedArc));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteArc(@PathVariable String id) {
+ arcService.deleteArc(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/CampaignController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/CampaignController.java
new file mode 100644
index 0000000..a36ed46
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/CampaignController.java
@@ -0,0 +1,77 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.campaigncontext.CampaignService;
+import com.loremind.domain.campaigncontext.Campaign;
+import com.loremind.infrastructure.web.dto.campaigncontext.CampaignDTO;
+import com.loremind.infrastructure.web.mapper.CampaignMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte Campaign.
+ * Adaptateur d'infrastructure qui expose l'API REST.
+ * Utilise le Service d'application et le Mapper selon l'Architecture Hexagonale.
+ */
+@RestController
+@RequestMapping("/api/campaigns")
+public class CampaignController {
+
+ private final CampaignService campaignService;
+ private final CampaignMapper campaignMapper;
+
+ public CampaignController(CampaignService campaignService, CampaignMapper campaignMapper) {
+ this.campaignService = campaignService;
+ this.campaignMapper = campaignMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createCampaign(@RequestBody CampaignDTO campaignDTO) {
+ Campaign campaign = campaignMapper.toDomain(campaignDTO);
+ Campaign createdCampaign = campaignService.createCampaign(
+ new CampaignService.CampaignData(campaign.getName(), campaign.getDescription(), campaign.getLoreId())
+ );
+ return ResponseEntity.ok(campaignMapper.toDTO(createdCampaign));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getCampaignById(@PathVariable String id) {
+ return campaignService.getCampaignById(id)
+ .map(campaign -> ResponseEntity.ok(campaignMapper.toDTO(campaign)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ @GetMapping
+ public ResponseEntity> getAllCampaigns() {
+ List campaigns = campaignService.getAllCampaigns();
+ List campaignDTOs = campaigns.stream()
+ .map(campaignMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(campaignDTOs);
+ }
+
+ @GetMapping("/search")
+ public ResponseEntity> searchCampaigns(@RequestParam("q") String query) {
+ List dtos = campaignService.searchCampaigns(query).stream()
+ .map(campaignMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(dtos);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateCampaign(@PathVariable String id, @RequestBody CampaignDTO campaignDTO) {
+ Campaign updatedCampaign = campaignService.updateCampaign(
+ id,
+ new CampaignService.CampaignData(campaignDTO.getName(), campaignDTO.getDescription(), campaignDTO.getLoreId())
+ );
+ return ResponseEntity.ok(campaignMapper.toDTO(updatedCampaign));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteCampaign(@PathVariable String id) {
+ campaignService.deleteCampaign(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/ChapterController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/ChapterController.java
new file mode 100644
index 0000000..65b8558
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/ChapterController.java
@@ -0,0 +1,71 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.campaigncontext.ChapterService;
+import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.infrastructure.web.dto.campaigncontext.ChapterDTO;
+import com.loremind.infrastructure.web.mapper.ChapterMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte Chapter.
+ */
+@RestController
+@RequestMapping("/api/chapters")
+public class ChapterController {
+
+ private final ChapterService chapterService;
+ private final ChapterMapper chapterMapper;
+
+ public ChapterController(ChapterService chapterService, ChapterMapper chapterMapper) {
+ this.chapterService = chapterService;
+ this.chapterMapper = chapterMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createChapter(@RequestBody ChapterDTO chapterDTO) {
+ Chapter chapter = chapterMapper.toDomain(chapterDTO);
+ Chapter createdChapter = chapterService.createChapter(chapter.getName(), chapter.getDescription(), chapter.getArcId(), chapter.getOrder());
+ return ResponseEntity.ok(chapterMapper.toDTO(createdChapter));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getChapterById(@PathVariable String id) {
+ return chapterService.getChapterById(id)
+ .map(chapter -> ResponseEntity.ok(chapterMapper.toDTO(chapter)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ @GetMapping
+ public ResponseEntity> getAllChapters() {
+ List chapters = chapterService.getAllChapters();
+ List chapterDTOs = chapters.stream()
+ .map(chapterMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(chapterDTOs);
+ }
+
+ @GetMapping("/arc/{arcId}")
+ public ResponseEntity> getChaptersByArcId(@PathVariable String arcId) {
+ List chapters = chapterService.getChaptersByArcId(arcId);
+ List chapterDTOs = chapters.stream()
+ .map(chapterMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(chapterDTOs);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateChapter(@PathVariable String id, @RequestBody ChapterDTO chapterDTO) {
+ Chapter updatedChapter = chapterService.updateChapter(id, chapterMapper.toDomain(chapterDTO));
+ return ResponseEntity.ok(chapterMapper.toDTO(updatedChapter));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteChapter(@PathVariable String id) {
+ chapterService.deleteChapter(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/LoreController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/LoreController.java
new file mode 100644
index 0000000..2c6cec2
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/LoreController.java
@@ -0,0 +1,72 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.lorecontext.LoreService;
+import com.loremind.domain.lorecontext.Lore;
+import com.loremind.infrastructure.web.dto.lorecontext.LoreDTO;
+import com.loremind.infrastructure.web.mapper.LoreMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte Lore.
+ * Adaptateur d'infrastructure qui expose l'API REST.
+ * Utilise le Service d'application et le Mapper selon l'Architecture Hexagonale.
+ */
+@RestController
+@RequestMapping("/api/lores")
+public class LoreController {
+
+ private final LoreService loreService;
+ private final LoreMapper loreMapper;
+
+ public LoreController(LoreService loreService, LoreMapper loreMapper) {
+ this.loreService = loreService;
+ this.loreMapper = loreMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createLore(@RequestBody LoreDTO loreDTO) {
+ Lore lore = loreMapper.toDomain(loreDTO);
+ Lore createdLore = loreService.createLore(lore.getName(), lore.getDescription());
+ return ResponseEntity.ok(loreMapper.toDTO(createdLore));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getLoreById(@PathVariable String id) {
+ return loreService.getLoreById(id)
+ .map(lore -> ResponseEntity.ok(loreMapper.toDTO(lore)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ @GetMapping
+ public ResponseEntity> getAllLores() {
+ List lores = loreService.getAllLores();
+ List loreDTOs = lores.stream()
+ .map(loreMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(loreDTOs);
+ }
+
+ @GetMapping("/search")
+ public ResponseEntity> searchLores(@RequestParam("q") String query) {
+ List dtos = loreService.searchLores(query).stream()
+ .map(loreMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(dtos);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateLore(@PathVariable String id, @RequestBody LoreDTO loreDTO) {
+ Lore updatedLore = loreService.updateLore(id, loreDTO.getName(), loreDTO.getDescription());
+ return ResponseEntity.ok(loreMapper.toDTO(updatedLore));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteLore(@PathVariable String id) {
+ loreService.deleteLore(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/LoreNodeController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/LoreNodeController.java
new file mode 100644
index 0000000..33199d4
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/LoreNodeController.java
@@ -0,0 +1,100 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.lorecontext.LoreNodeService;
+import com.loremind.domain.lorecontext.LoreNode;
+import com.loremind.infrastructure.web.dto.lorecontext.LoreNodeDTO;
+import com.loremind.infrastructure.web.mapper.LoreNodeMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte LoreNode.
+ */
+@RestController
+@RequestMapping("/api/lore-nodes")
+public class LoreNodeController {
+
+ private final LoreNodeService loreNodeService;
+ private final LoreNodeMapper loreNodeMapper;
+
+ public LoreNodeController(LoreNodeService loreNodeService, LoreNodeMapper loreNodeMapper) {
+ this.loreNodeService = loreNodeService;
+ this.loreNodeMapper = loreNodeMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createLoreNode(@RequestBody LoreNodeDTO loreNodeDTO) {
+ LoreNode changes = loreNodeMapper.toDomain(loreNodeDTO);
+ LoreNode created = loreNodeService.createLoreNode(changes);
+ return ResponseEntity.ok(loreNodeMapper.toDTO(created));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getLoreNodeById(@PathVariable String id) {
+ return loreNodeService.getLoreNodeById(id)
+ .map(loreNode -> ResponseEntity.ok(loreNodeMapper.toDTO(loreNode)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ /**
+ * GET /api/lore-nodes → tous les dossiers (usage admin/debug)
+ * GET /api/lore-nodes?loreId=X → uniquement les dossiers du Lore X
+ *
+ * Sans ce filtre, le frontend recevait TOUS les dossiers de TOUS les lores,
+ * ce qui polluait l'affichage quand on switche entre deux lores.
+ * Pattern aligné sur TemplateController et PageController.
+ */
+ @GetMapping
+ public ResponseEntity> getLoreNodes(
+ @RequestParam(value = "loreId", required = false) String loreId) {
+ List loreNodes = (loreId != null && !loreId.isBlank())
+ ? loreNodeService.getLoreNodesByLoreId(loreId)
+ : loreNodeService.getAllLoreNodes();
+ List loreNodeDTOs = loreNodes.stream()
+ .map(loreNodeMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(loreNodeDTOs);
+ }
+
+ @GetMapping("/search")
+ public ResponseEntity> searchLoreNodes(@RequestParam("q") String query) {
+ List dtos = loreNodeService.searchLoreNodes(query).stream()
+ .map(loreNodeMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(dtos);
+ }
+
+ @GetMapping("/lore/{loreId}")
+ public ResponseEntity> getLoreNodesByLoreId(@PathVariable String loreId) {
+ List loreNodes = loreNodeService.getLoreNodesByLoreId(loreId);
+ List loreNodeDTOs = loreNodes.stream()
+ .map(loreNodeMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(loreNodeDTOs);
+ }
+
+ @GetMapping("/parent/{parentId}")
+ public ResponseEntity> getLoreNodesByParentId(@PathVariable String parentId) {
+ List loreNodes = loreNodeService.getLoreNodesByParentId(parentId);
+ List loreNodeDTOs = loreNodes.stream()
+ .map(loreNodeMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(loreNodeDTOs);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateLoreNode(@PathVariable String id, @RequestBody LoreNodeDTO loreNodeDTO) {
+ LoreNode changes = loreNodeMapper.toDomain(loreNodeDTO);
+ LoreNode updated = loreNodeService.updateLoreNode(id, changes);
+ return ResponseEntity.ok(loreNodeMapper.toDTO(updated));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteLoreNode(@PathVariable String id) {
+ loreNodeService.deleteLoreNode(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/PageController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/PageController.java
new file mode 100644
index 0000000..1d2b9a8
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/PageController.java
@@ -0,0 +1,89 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.lorecontext.PageService;
+import com.loremind.domain.lorecontext.Page;
+import com.loremind.infrastructure.web.dto.lorecontext.PageDTO;
+import com.loremind.infrastructure.web.mapper.PageMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte Page.
+ * - GET /api/pages?loreId=X → toutes les pages d'un lore
+ * - GET /api/pages?nodeId=Y → toutes les pages d'un noeud
+ * - GET /api/pages/{id} → détail
+ * - POST /api/pages → création (loreId, nodeId, templateId, title)
+ * - PUT /api/pages/{id} → mise à jour complète (title, nodeId, values, notes, tags, relatedPageIds)
+ * - DELETE /api/pages/{id} → suppression
+ */
+@RestController
+@RequestMapping("/api/pages")
+public class PageController {
+
+ private final PageService pageService;
+ private final PageMapper pageMapper;
+
+ public PageController(PageService pageService, PageMapper pageMapper) {
+ this.pageService = pageService;
+ this.pageMapper = pageMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createPage(@RequestBody PageDTO dto) {
+ Page created = pageService.createPage(
+ dto.getLoreId(),
+ dto.getNodeId(),
+ dto.getTemplateId(),
+ dto.getTitle()
+ );
+ return ResponseEntity.ok(pageMapper.toDTO(created));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getPageById(@PathVariable String id) {
+ return pageService.getPageById(id)
+ .map(page -> ResponseEntity.ok(pageMapper.toDTO(page)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ @GetMapping
+ public ResponseEntity> getPages(
+ @RequestParam(value = "loreId", required = false) String loreId,
+ @RequestParam(value = "nodeId", required = false) String nodeId) {
+ List pages;
+ if (loreId != null && !loreId.isBlank()) {
+ pages = pageService.getPagesByLoreId(loreId);
+ } else if (nodeId != null && !nodeId.isBlank()) {
+ pages = pageService.getPagesByNodeId(nodeId);
+ } else {
+ pages = pageService.getAllPages();
+ }
+ List dtos = pages.stream().map(pageMapper::toDTO).collect(Collectors.toList());
+ return ResponseEntity.ok(dtos);
+ }
+
+ @GetMapping("/search")
+ public ResponseEntity> searchPages(@RequestParam("q") String query) {
+ List dtos = pageService.searchPages(query).stream()
+ .map(pageMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(dtos);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updatePage(@PathVariable String id,
+ @RequestBody PageDTO dto) {
+ Page changes = pageMapper.toDomain(dto);
+ Page updated = pageService.updatePage(id, changes);
+ return ResponseEntity.ok(pageMapper.toDTO(updated));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deletePage(@PathVariable String id) {
+ pageService.deletePage(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/SceneController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/SceneController.java
new file mode 100644
index 0000000..e743e83
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/SceneController.java
@@ -0,0 +1,71 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.campaigncontext.SceneService;
+import com.loremind.domain.campaigncontext.Scene;
+import com.loremind.infrastructure.web.dto.campaigncontext.SceneDTO;
+import com.loremind.infrastructure.web.mapper.SceneMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte Scene.
+ */
+@RestController
+@RequestMapping("/api/scenes")
+public class SceneController {
+
+ private final SceneService sceneService;
+ private final SceneMapper sceneMapper;
+
+ public SceneController(SceneService sceneService, SceneMapper sceneMapper) {
+ this.sceneService = sceneService;
+ this.sceneMapper = sceneMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createScene(@RequestBody SceneDTO sceneDTO) {
+ Scene scene = sceneMapper.toDomain(sceneDTO);
+ Scene createdScene = sceneService.createScene(scene.getName(), scene.getDescription(), scene.getChapterId(), scene.getOrder());
+ return ResponseEntity.ok(sceneMapper.toDTO(createdScene));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getSceneById(@PathVariable String id) {
+ return sceneService.getSceneById(id)
+ .map(scene -> ResponseEntity.ok(sceneMapper.toDTO(scene)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ @GetMapping
+ public ResponseEntity> getAllScenes() {
+ List scenes = sceneService.getAllScenes();
+ List sceneDTOs = scenes.stream()
+ .map(sceneMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(sceneDTOs);
+ }
+
+ @GetMapping("/chapter/{chapterId}")
+ public ResponseEntity> getScenesByChapterId(@PathVariable String chapterId) {
+ List scenes = sceneService.getScenesByChapterId(chapterId);
+ List sceneDTOs = scenes.stream()
+ .map(sceneMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(sceneDTOs);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateScene(@PathVariable String id, @RequestBody SceneDTO sceneDTO) {
+ Scene updatedScene = sceneService.updateScene(id, sceneMapper.toDomain(sceneDTO));
+ return ResponseEntity.ok(sceneMapper.toDTO(updatedScene));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteScene(@PathVariable String id) {
+ sceneService.deleteScene(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/controller/TemplateController.java b/core/src/main/java/com/loremind/infrastructure/web/controller/TemplateController.java
new file mode 100644
index 0000000..040fcda
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/controller/TemplateController.java
@@ -0,0 +1,82 @@
+package com.loremind.infrastructure.web.controller;
+
+import com.loremind.application.lorecontext.TemplateService;
+import com.loremind.domain.lorecontext.Template;
+import com.loremind.infrastructure.web.dto.lorecontext.TemplateDTO;
+import com.loremind.infrastructure.web.mapper.TemplateMapper;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * REST Controller pour le contexte Template.
+ * Expose également un endpoint filtré par Lore pour alimenter le panneau
+ * "Templates" du sidebar secondaire.
+ */
+@RestController
+@RequestMapping("/api/templates")
+public class TemplateController {
+
+ private final TemplateService templateService;
+ private final TemplateMapper templateMapper;
+
+ public TemplateController(TemplateService templateService, TemplateMapper templateMapper) {
+ this.templateService = templateService;
+ this.templateMapper = templateMapper;
+ }
+
+ @PostMapping
+ public ResponseEntity createTemplate(@RequestBody TemplateDTO dto) {
+ Template created = templateService.createTemplate(
+ dto.getLoreId(),
+ dto.getName(),
+ dto.getDescription(),
+ dto.getDefaultNodeId(),
+ dto.getFields()
+ );
+ return ResponseEntity.ok(templateMapper.toDTO(created));
+ }
+
+ @GetMapping("/{id}")
+ public ResponseEntity getTemplateById(@PathVariable String id) {
+ return templateService.getTemplateById(id)
+ .map(template -> ResponseEntity.ok(templateMapper.toDTO(template)))
+ .orElse(ResponseEntity.notFound().build());
+ }
+
+ @GetMapping
+ public ResponseEntity> getAllTemplates(
+ @RequestParam(value = "loreId", required = false) String loreId) {
+ List templates = (loreId != null && !loreId.isBlank())
+ ? templateService.getTemplatesByLoreId(loreId)
+ : templateService.getAllTemplates();
+ List dtos = templates.stream()
+ .map(templateMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(dtos);
+ }
+
+ @GetMapping("/search")
+ public ResponseEntity> searchTemplates(@RequestParam("q") String query) {
+ List dtos = templateService.searchTemplates(query).stream()
+ .map(templateMapper::toDTO)
+ .collect(Collectors.toList());
+ return ResponseEntity.ok(dtos);
+ }
+
+ @PutMapping("/{id}")
+ public ResponseEntity updateTemplate(@PathVariable String id,
+ @RequestBody TemplateDTO dto) {
+ Template changes = templateMapper.toDomain(dto);
+ Template updated = templateService.updateTemplate(id, changes);
+ return ResponseEntity.ok(templateMapper.toDTO(updated));
+ }
+
+ @DeleteMapping("/{id}")
+ public ResponseEntity deleteTemplate(@PathVariable String id) {
+ templateService.deleteTemplate(id);
+ return ResponseEntity.noContent().build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ArcDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ArcDTO.java
new file mode 100644
index 0000000..79d5029
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ArcDTO.java
@@ -0,0 +1,29 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.Data;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * DTO pour l'entité Arc.
+ * Objet de transfert de données pour l'API REST.
+ */
+@Data
+public class ArcDTO {
+
+ private String id;
+ private String name;
+ private String description;
+ private String campaignId;
+ private int order;
+
+ // Champs narratifs enrichis
+ private String themes;
+ private String stakes;
+ private String gmNotes;
+ private String rewards;
+ private String resolution;
+
+ /** IDs des pages du Lore liées à cet arc (weak cross-context references). */
+ private List relatedPageIds = new ArrayList<>();
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/CampaignDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/CampaignDTO.java
new file mode 100644
index 0000000..3c6c997
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/CampaignDTO.java
@@ -0,0 +1,18 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.Data;
+
+/**
+ * DTO pour l'entité Campaign.
+ * Objet de transfert de données pour l'API REST.
+ */
+@Data
+public class CampaignDTO {
+
+ private String id;
+ private String name;
+ private String description;
+ private int arcsCount;
+ /** Nullable : campagne sans univers associé. */
+ private String loreId;
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ChapterDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ChapterDTO.java
new file mode 100644
index 0000000..7da9451
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/ChapterDTO.java
@@ -0,0 +1,27 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.Data;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * DTO pour l'entité Chapter.
+ * Objet de transfert de données pour l'API REST.
+ */
+@Data
+public class ChapterDTO {
+
+ private String id;
+ private String name;
+ private String description;
+ private String arcId;
+ private int order;
+
+ // Champs narratifs enrichis
+ private String gmNotes;
+ private String playerObjectives;
+ private String narrativeStakes;
+
+ /** IDs des pages du Lore liées (weak cross-context references). */
+ private List relatedPageIds = new ArrayList<>();
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/SceneDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/SceneDTO.java
new file mode 100644
index 0000000..ac122b2
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/campaigncontext/SceneDTO.java
@@ -0,0 +1,32 @@
+package com.loremind.infrastructure.web.dto.campaigncontext;
+
+import lombok.Data;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * DTO pour l'entité Scene.
+ * Objet de transfert de données pour l'API REST.
+ */
+@Data
+public class SceneDTO {
+
+ private String id;
+ private String name;
+ private String description;
+ private String chapterId;
+ private int order;
+
+ // Champs narratifs enrichis
+ private String location;
+ private String timing;
+ private String atmosphere;
+ private String playerNarration;
+ private String gmSecretNotes;
+ private String choicesConsequences;
+ private String combatDifficulty;
+ private String enemies;
+
+ /** IDs des pages du Lore liées (weak cross-context references). */
+ private List relatedPageIds = new ArrayList<>();
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/LoreDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/LoreDTO.java
new file mode 100644
index 0000000..2faa7c6
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/LoreDTO.java
@@ -0,0 +1,18 @@
+package com.loremind.infrastructure.web.dto.lorecontext;
+
+import lombok.Data;
+
+/**
+ * DTO pour l'entité Lore.
+ * Objet de transfert de données pour l'API REST.
+ * Contient uniquement les champs nécessaires pour le Frontend.
+ */
+@Data
+public class LoreDTO {
+
+ private String id;
+ private String name;
+ private String description;
+ private int nodeCount;
+ private int pageCount;
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/LoreNodeDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/LoreNodeDTO.java
new file mode 100644
index 0000000..18f0faa
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/LoreNodeDTO.java
@@ -0,0 +1,17 @@
+package com.loremind.infrastructure.web.dto.lorecontext;
+
+import lombok.Data;
+
+/**
+ * DTO pour l'entité LoreNode.
+ * Objet de transfert de données pour l'API REST.
+ */
+@Data
+public class LoreNodeDTO {
+
+ private String id;
+ private String name;
+ private String icon;
+ private String parentId;
+ private String loreId;
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/PageDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/PageDTO.java
new file mode 100644
index 0000000..1e53140
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/PageDTO.java
@@ -0,0 +1,24 @@
+package com.loremind.infrastructure.web.dto.lorecontext;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * DTO pour l'entité Page.
+ * Objet de transfert de données pour l'API REST.
+ */
+@Data
+public class PageDTO {
+
+ private String id;
+ private String loreId;
+ private String nodeId;
+ private String templateId;
+ private String title;
+ private Map values;
+ private String notes;
+ private List tags;
+ private List relatedPageIds;
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/TemplateDTO.java b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/TemplateDTO.java
new file mode 100644
index 0000000..9f166f3
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/dto/lorecontext/TemplateDTO.java
@@ -0,0 +1,22 @@
+package com.loremind.infrastructure.web.dto.lorecontext;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * DTO pour l'entité Template.
+ * Objet de transfert de données pour l'API REST.
+ * Expose un compteur fieldCount pour éviter aux clients de recalculer fields.size().
+ */
+@Data
+public class TemplateDTO {
+
+ private String id;
+ private String loreId;
+ private String name;
+ private String description;
+ private String defaultNodeId;
+ private List fields;
+ private int fieldCount;
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/ArcMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/ArcMapper.java
new file mode 100644
index 0000000..e14cc60
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/ArcMapper.java
@@ -0,0 +1,58 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.campaigncontext.Arc;
+import com.loremind.infrastructure.web.dto.campaigncontext.ArcDTO;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+
+/**
+ * Mapper pour convertir entre Arc (entité de domaine) et ArcDTO.
+ */
+@Component
+public class ArcMapper {
+
+ public ArcDTO toDTO(Arc arc) {
+ if (arc == null) {
+ return null;
+ }
+
+ ArcDTO dto = new ArcDTO();
+ dto.setId(arc.getId());
+ dto.setName(arc.getName());
+ dto.setDescription(arc.getDescription());
+ dto.setCampaignId(arc.getCampaignId());
+ dto.setOrder(arc.getOrder());
+ dto.setThemes(arc.getThemes());
+ dto.setStakes(arc.getStakes());
+ dto.setGmNotes(arc.getGmNotes());
+ dto.setRewards(arc.getRewards());
+ dto.setResolution(arc.getResolution());
+ dto.setRelatedPageIds(arc.getRelatedPageIds() != null
+ ? new ArrayList<>(arc.getRelatedPageIds())
+ : new ArrayList<>());
+ return dto;
+ }
+
+ public Arc toDomain(ArcDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+
+ return Arc.builder()
+ .id(dto.getId())
+ .name(dto.getName())
+ .description(dto.getDescription())
+ .campaignId(dto.getCampaignId())
+ .order(dto.getOrder())
+ .themes(dto.getThemes())
+ .stakes(dto.getStakes())
+ .gmNotes(dto.getGmNotes())
+ .rewards(dto.getRewards())
+ .resolution(dto.getResolution())
+ .relatedPageIds(dto.getRelatedPageIds() != null
+ ? new ArrayList<>(dto.getRelatedPageIds())
+ : new ArrayList<>())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/CampaignMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/CampaignMapper.java
new file mode 100644
index 0000000..393a655
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/CampaignMapper.java
@@ -0,0 +1,40 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.campaigncontext.Campaign;
+import com.loremind.infrastructure.web.dto.campaigncontext.CampaignDTO;
+import org.springframework.stereotype.Component;
+
+/**
+ * Mapper pour convertir entre Campaign (entité de domaine) et CampaignDTO.
+ */
+@Component
+public class CampaignMapper {
+
+ public CampaignDTO toDTO(Campaign campaign) {
+ if (campaign == null) {
+ return null;
+ }
+
+ CampaignDTO dto = new CampaignDTO();
+ dto.setId(campaign.getId());
+ dto.setName(campaign.getName());
+ dto.setDescription(campaign.getDescription());
+ dto.setArcsCount(campaign.getArcsCount());
+ dto.setLoreId(campaign.getLoreId());
+ return dto;
+ }
+
+ public Campaign toDomain(CampaignDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+
+ return Campaign.builder()
+ .id(dto.getId())
+ .name(dto.getName())
+ .description(dto.getDescription())
+ .arcsCount(dto.getArcsCount())
+ .loreId(dto.getLoreId())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/ChapterMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/ChapterMapper.java
new file mode 100644
index 0000000..233ffe6
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/ChapterMapper.java
@@ -0,0 +1,54 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.campaigncontext.Chapter;
+import com.loremind.infrastructure.web.dto.campaigncontext.ChapterDTO;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+
+/**
+ * Mapper pour convertir entre Chapter (entité de domaine) et ChapterDTO.
+ */
+@Component
+public class ChapterMapper {
+
+ public ChapterDTO toDTO(Chapter chapter) {
+ if (chapter == null) {
+ return null;
+ }
+
+ ChapterDTO dto = new ChapterDTO();
+ dto.setId(chapter.getId());
+ dto.setName(chapter.getName());
+ dto.setDescription(chapter.getDescription());
+ dto.setArcId(chapter.getArcId());
+ dto.setOrder(chapter.getOrder());
+ dto.setGmNotes(chapter.getGmNotes());
+ dto.setPlayerObjectives(chapter.getPlayerObjectives());
+ dto.setNarrativeStakes(chapter.getNarrativeStakes());
+ dto.setRelatedPageIds(chapter.getRelatedPageIds() != null
+ ? new ArrayList<>(chapter.getRelatedPageIds())
+ : new ArrayList<>());
+ return dto;
+ }
+
+ public Chapter toDomain(ChapterDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+
+ return Chapter.builder()
+ .id(dto.getId())
+ .name(dto.getName())
+ .description(dto.getDescription())
+ .arcId(dto.getArcId())
+ .order(dto.getOrder())
+ .gmNotes(dto.getGmNotes())
+ .playerObjectives(dto.getPlayerObjectives())
+ .narrativeStakes(dto.getNarrativeStakes())
+ .relatedPageIds(dto.getRelatedPageIds() != null
+ ? new ArrayList<>(dto.getRelatedPageIds())
+ : new ArrayList<>())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/LoreMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/LoreMapper.java
new file mode 100644
index 0000000..9a02d44
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/LoreMapper.java
@@ -0,0 +1,41 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.lorecontext.Lore;
+import com.loremind.infrastructure.web.dto.lorecontext.LoreDTO;
+import org.springframework.stereotype.Component;
+
+/**
+ * Mapper pour convertir entre Lore (entité de domaine) et LoreDTO.
+ * Fait partie de la couche Infrastructure de l'Architecture Hexagonale.
+ */
+@Component
+public class LoreMapper {
+
+ public LoreDTO toDTO(Lore lore) {
+ if (lore == null) {
+ return null;
+ }
+
+ LoreDTO dto = new LoreDTO();
+ dto.setId(lore.getId());
+ dto.setName(lore.getName());
+ dto.setDescription(lore.getDescription());
+ dto.setNodeCount(lore.getNodeCount());
+ dto.setPageCount(lore.getPageCount());
+ return dto;
+ }
+
+ public Lore toDomain(LoreDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+
+ return Lore.builder()
+ .id(dto.getId())
+ .name(dto.getName())
+ .description(dto.getDescription())
+ .nodeCount(dto.getNodeCount())
+ .pageCount(dto.getPageCount())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/LoreNodeMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/LoreNodeMapper.java
new file mode 100644
index 0000000..bfece93
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/LoreNodeMapper.java
@@ -0,0 +1,40 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.lorecontext.LoreNode;
+import com.loremind.infrastructure.web.dto.lorecontext.LoreNodeDTO;
+import org.springframework.stereotype.Component;
+
+/**
+ * Mapper pour convertir entre LoreNode (entité de domaine) et LoreNodeDTO.
+ */
+@Component
+public class LoreNodeMapper {
+
+ public LoreNodeDTO toDTO(LoreNode loreNode) {
+ if (loreNode == null) {
+ return null;
+ }
+
+ LoreNodeDTO dto = new LoreNodeDTO();
+ dto.setId(loreNode.getId());
+ dto.setName(loreNode.getName());
+ dto.setIcon(loreNode.getIcon());
+ dto.setParentId(loreNode.getParentId());
+ dto.setLoreId(loreNode.getLoreId());
+ return dto;
+ }
+
+ public LoreNode toDomain(LoreNodeDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+
+ return LoreNode.builder()
+ .id(dto.getId())
+ .name(dto.getName())
+ .icon(dto.getIcon())
+ .parentId(dto.getParentId())
+ .loreId(dto.getLoreId())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/PageMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/PageMapper.java
new file mode 100644
index 0000000..13dfb77
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/PageMapper.java
@@ -0,0 +1,49 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.lorecontext.Page;
+import com.loremind.infrastructure.web.dto.lorecontext.PageDTO;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/**
+ * Mapper pour convertir entre Page (entité de domaine) et PageDTO.
+ */
+@Component
+public class PageMapper {
+
+ public PageDTO toDTO(Page page) {
+ if (page == null) {
+ return null;
+ }
+ PageDTO dto = new PageDTO();
+ dto.setId(page.getId());
+ dto.setLoreId(page.getLoreId());
+ dto.setNodeId(page.getNodeId());
+ dto.setTemplateId(page.getTemplateId());
+ dto.setTitle(page.getTitle());
+ dto.setValues(page.getValues() != null ? new HashMap<>(page.getValues()) : new HashMap<>());
+ dto.setNotes(page.getNotes());
+ dto.setTags(page.getTags() != null ? new ArrayList<>(page.getTags()) : new ArrayList<>());
+ dto.setRelatedPageIds(page.getRelatedPageIds() != null ? new ArrayList<>(page.getRelatedPageIds()) : new ArrayList<>());
+ return dto;
+ }
+
+ public Page toDomain(PageDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+ return Page.builder()
+ .id(dto.getId())
+ .loreId(dto.getLoreId())
+ .nodeId(dto.getNodeId())
+ .templateId(dto.getTemplateId())
+ .title(dto.getTitle())
+ .values(dto.getValues() != null ? new HashMap<>(dto.getValues()) : new HashMap<>())
+ .notes(dto.getNotes())
+ .tags(dto.getTags() != null ? new ArrayList<>(dto.getTags()) : new ArrayList<>())
+ .relatedPageIds(dto.getRelatedPageIds() != null ? new ArrayList<>(dto.getRelatedPageIds()) : new ArrayList<>())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/SceneMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/SceneMapper.java
new file mode 100644
index 0000000..182558d
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/SceneMapper.java
@@ -0,0 +1,64 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.campaigncontext.Scene;
+import com.loremind.infrastructure.web.dto.campaigncontext.SceneDTO;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+
+/**
+ * Mapper pour convertir entre Scene (entité de domaine) et SceneDTO.
+ */
+@Component
+public class SceneMapper {
+
+ public SceneDTO toDTO(Scene scene) {
+ if (scene == null) {
+ return null;
+ }
+
+ SceneDTO dto = new SceneDTO();
+ dto.setId(scene.getId());
+ dto.setName(scene.getName());
+ dto.setDescription(scene.getDescription());
+ dto.setChapterId(scene.getChapterId());
+ dto.setOrder(scene.getOrder());
+ dto.setLocation(scene.getLocation());
+ dto.setTiming(scene.getTiming());
+ dto.setAtmosphere(scene.getAtmosphere());
+ dto.setPlayerNarration(scene.getPlayerNarration());
+ dto.setGmSecretNotes(scene.getGmSecretNotes());
+ dto.setChoicesConsequences(scene.getChoicesConsequences());
+ dto.setCombatDifficulty(scene.getCombatDifficulty());
+ dto.setEnemies(scene.getEnemies());
+ dto.setRelatedPageIds(scene.getRelatedPageIds() != null
+ ? new ArrayList<>(scene.getRelatedPageIds())
+ : new ArrayList<>());
+ return dto;
+ }
+
+ public Scene toDomain(SceneDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+
+ return Scene.builder()
+ .id(dto.getId())
+ .name(dto.getName())
+ .description(dto.getDescription())
+ .chapterId(dto.getChapterId())
+ .order(dto.getOrder())
+ .location(dto.getLocation())
+ .timing(dto.getTiming())
+ .atmosphere(dto.getAtmosphere())
+ .playerNarration(dto.getPlayerNarration())
+ .gmSecretNotes(dto.getGmSecretNotes())
+ .choicesConsequences(dto.getChoicesConsequences())
+ .combatDifficulty(dto.getCombatDifficulty())
+ .enemies(dto.getEnemies())
+ .relatedPageIds(dto.getRelatedPageIds() != null
+ ? new ArrayList<>(dto.getRelatedPageIds())
+ : new ArrayList<>())
+ .build();
+ }
+}
diff --git a/core/src/main/java/com/loremind/infrastructure/web/mapper/TemplateMapper.java b/core/src/main/java/com/loremind/infrastructure/web/mapper/TemplateMapper.java
new file mode 100644
index 0000000..71958a5
--- /dev/null
+++ b/core/src/main/java/com/loremind/infrastructure/web/mapper/TemplateMapper.java
@@ -0,0 +1,47 @@
+package com.loremind.infrastructure.web.mapper;
+
+import com.loremind.domain.lorecontext.Template;
+import com.loremind.infrastructure.web.dto.lorecontext.TemplateDTO;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+
+/**
+ * Mapper pour convertir entre Template (entité de domaine) et TemplateDTO.
+ */
+@Component
+public class TemplateMapper {
+
+ public TemplateDTO toDTO(Template template) {
+ if (template == null) {
+ return null;
+ }
+ TemplateDTO dto = new TemplateDTO();
+ dto.setId(template.getId());
+ dto.setLoreId(template.getLoreId());
+ dto.setName(template.getName());
+ dto.setDescription(template.getDescription());
+ dto.setDefaultNodeId(template.getDefaultNodeId());
+ dto.setFields(template.getFields() != null
+ ? new ArrayList<>(template.getFields())
+ : new ArrayList<>());
+ dto.setFieldCount(template.fieldCount());
+ return dto;
+ }
+
+ public Template toDomain(TemplateDTO dto) {
+ if (dto == null) {
+ return null;
+ }
+ return Template.builder()
+ .id(dto.getId())
+ .loreId(dto.getLoreId())
+ .name(dto.getName())
+ .description(dto.getDescription())
+ .defaultNodeId(dto.getDefaultNodeId())
+ .fields(dto.getFields() != null
+ ? new ArrayList<>(dto.getFields())
+ : new ArrayList<>())
+ .build();
+ }
+}
diff --git a/core/src/main/resources/application.properties b/core/src/main/resources/application.properties
new file mode 100644
index 0000000..251c937
--- /dev/null
+++ b/core/src/main/resources/application.properties
@@ -0,0 +1,20 @@
+# Configuration du serveur
+server.port=8080
+
+# Configuration de la base de données PostgreSQL
+spring.datasource.url=jdbc:postgresql://localhost:5432/loremind
+spring.datasource.username=ietm64
+spring.datasource.password=M&Ipourlavie64
+spring.datasource.driver-class-name=org.postgresql.Driver
+
+# Configuration JPA / Hibernate
+spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
+spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=true
+spring.jpa.properties.hibernate.format_sql=true
+
+# Configuration CORS pour autoriser le Frontend Angular
+spring.web.cors.allowed-origins=http://localhost:4200
+spring.web.cors.allowed-methods=GET,POST,PUT,DELETE,OPTIONS
+spring.web.cors.allowed-headers=*
+spring.web.cors.allow-credentials=true
diff --git a/core/src/test/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreRepositoryTest.java b/core/src/test/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreRepositoryTest.java
new file mode 100644
index 0000000..b18745d
--- /dev/null
+++ b/core/src/test/java/com/loremind/infrastructure/persistence/postgres/PostgresLoreRepositoryTest.java
@@ -0,0 +1,103 @@
+package com.loremind.infrastructure.persistence.postgres;
+
+import com.loremind.domain.lorecontext.Lore;
+import com.loremind.domain.lorecontext.ports.LoreRepository;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test pour vérifier que PostgresLoreRepository fonctionne correctement.
+ * Utilise PostgreSQL (loremind_test) pour les tests d'intégration.
+ */
+@SpringBootTest
+public class PostgresLoreRepositoryTest {
+
+ @Autowired
+ private LoreRepository loreRepository;
+
+ @Test
+ public void testSaveAndFindLore() {
+ // Créer un Lore
+ Lore lore = Lore.builder()
+ .name("Lore Test")
+ .description("Description test")
+ .nodeCount(0)
+ .pageCount(0)
+ .createdAt(LocalDateTime.now())
+ .updatedAt(LocalDateTime.now())
+ .build();
+
+ // Sauvegarder
+ Lore savedLore = loreRepository.save(lore);
+ assertNotNull(savedLore.getId());
+
+ // Récupérer
+ Optional foundLore = loreRepository.findById(savedLore.getId());
+ assertTrue(foundLore.isPresent());
+ assertEquals("Lore Test", foundLore.get().getName());
+
+ // Nettoyer
+ loreRepository.deleteById(savedLore.getId());
+ }
+
+ @Test
+ public void testFindAllLores() {
+ // Créer deux Lores
+ Lore lore1 = Lore.builder()
+ .name("Lore 1")
+ .description("Description 1")
+ .nodeCount(0)
+ .pageCount(0)
+ .createdAt(LocalDateTime.now())
+ .updatedAt(LocalDateTime.now())
+ .build();
+
+ Lore lore2 = Lore.builder()
+ .name("Lore 2")
+ .description("Description 2")
+ .nodeCount(0)
+ .pageCount(0)
+ .createdAt(LocalDateTime.now())
+ .updatedAt(LocalDateTime.now())
+ .build();
+
+ Lore saved1 = loreRepository.save(lore1);
+ Lore saved2 = loreRepository.save(lore2);
+
+ // Récupérer tous
+ List allLores = loreRepository.findAll();
+ assertTrue(allLores.size() >= 2);
+
+ // Nettoyer
+ loreRepository.deleteById(saved1.getId());
+ loreRepository.deleteById(saved2.getId());
+ }
+
+ @Test
+ public void testDeleteLore() {
+ // Créer un Lore
+ Lore lore = Lore.builder()
+ .name("Lore to delete")
+ .description("Description")
+ .nodeCount(0)
+ .pageCount(0)
+ .createdAt(LocalDateTime.now())
+ .updatedAt(LocalDateTime.now())
+ .build();
+
+ Lore savedLore = loreRepository.save(lore);
+
+ // Supprimer
+ loreRepository.deleteById(savedLore.getId());
+
+ // Vérifier qu'il n'existe plus
+ assertFalse(loreRepository.existsById(savedLore.getId()));
+ }
+}
diff --git a/core/src/test/resources/application.properties b/core/src/test/resources/application.properties
new file mode 100644
index 0000000..456ad4e
--- /dev/null
+++ b/core/src/test/resources/application.properties
@@ -0,0 +1,10 @@
+# Configuration de test avec PostgreSQL
+spring.datasource.url=jdbc:postgresql://localhost:5432/loremind_test
+spring.datasource.username=ietm64
+spring.datasource.password=M&Ipourlavie64
+spring.datasource.driver-class-name=org.postgresql.Driver
+
+# Configuration JPA pour les tests
+spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
+spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.show-sql=true
diff --git a/docs/Documentation_projet.docx b/docs/Documentation_projet.docx
new file mode 100644
index 0000000..fee4d34
Binary files /dev/null and b/docs/Documentation_projet.docx differ
diff --git a/docs/loremind-contexte.md b/docs/loremind-contexte.md
new file mode 100644
index 0000000..757c707
--- /dev/null
+++ b/docs/loremind-contexte.md
@@ -0,0 +1,33 @@
+# LoreMind - Document de Contexte et d'Architecture
+
+## 1. Vision du Produit
+LoreMind est une application web d'aide aux Maîtres de Jeu (JDR). Elle permet de centraliser la gestion de l'univers (Lore) et le suivi des campagnes.
+**Fonctionnalité clé :** Intégration d'un moteur IA capable de générer des pages de contenu complètes (PNJ, Villes, Quêtes) à partir de templates prédéfinis.
+**Objectif final :** Permettre l'export structuré de ces données vers FoundryVTT.
+
+## 2. Stack Technologique Globale
+L'application suit une architecture distribuée pour séparer les responsabilités :
+* **Frontend :** Angular (Interface utilisateur, affichage du lore, formulaires de templates).
+* **Backend Core (Métier & Données) :** Java (Spring Boot recommandé). Orchestre l'application, gère la persistance et l'export VTT.
+* **Backend IA (Cognitif) :** Python. Dédié au traitement des LLM et à la génération de contenu selon les gabarits.
+* **Base de Données :** PostgreSQL. Stockage relationnel classique, avec utilisation intensive du type `JSONB` pour stocker les templates flexibles.
+
+## 3. Architecture du Backend Java (Règles strictes)
+Le développement du Backend Core doit IMPÉRATIVEMENT respecter le **Domain-Driven Design (DDD)** et l'**Architecture Hexagonale (Ports et Adaptateurs)**.
+
+### 3.1. Contextes Délimités (Bounded Contexts)
+Le code doit être séparé selon ces domaines autonomes :
+* `LoreContext` : Gestion de l'encyclopédie de l'univers (Lieux, Factions, PNJ).
+* `CampaignContext` : Suivi des sessions, actions des joueurs, chronologie.
+* `GenerationContext` : Gestion des requêtes IA, traitement des templates et communication avec le Backend Python.
+
+### 3.2. Règles d'Architecture Hexagonale
+* **Domaine (Core) :** Contient les entités métier pures et les interfaces (Ports). Il ne doit avoir **aucune** dépendance technique (ni Spring, ni annotations JPA, ni base de données).
+* **Application (Use Cases) :** Orchestre les flux de données (ex: `GenerateNpcUseCase`).
+* **Infrastructure (Adapters) :** Implémente les interfaces du domaine (ex: `PostgresLoreRepository`, `PythonAiClient`, `RestControllers`).
+
+## 4. Directives pour l'IA (Windsurf)
+* Utilise toujours le vocabulaire du domaine (*Ubiquitous Language*) dans le nommage des classes et méthodes (ex: `LoreNode`, `Template`, `Campaign`).
+* Assure-toi que les entités du domaine ne soient jamais anémiques (la logique métier est dans l'entité, pas dans des services externes).
+* Pour la base de données PostgreSQL, utilise la spécification JSONB dès qu'une structure de donnée est liée à un template modulable.
+* Commente uniquement la logique métier complexe, évite les commentaires évidents.
\ No newline at end of file
diff --git a/docs/maquettes/campagne/Accueil partie campagne.png b/docs/maquettes/campagne/Accueil partie campagne.png
new file mode 100644
index 0000000..d618940
Binary files /dev/null and b/docs/maquettes/campagne/Accueil partie campagne.png differ
diff --git a/docs/maquettes/campagne/Assistance IA.png b/docs/maquettes/campagne/Assistance IA.png
new file mode 100644
index 0000000..18e6e94
Binary files /dev/null and b/docs/maquettes/campagne/Assistance IA.png differ
diff --git a/docs/maquettes/campagne/Création d'un nouvel arc.png b/docs/maquettes/campagne/Création d'un nouvel arc.png
new file mode 100644
index 0000000..cb70082
Binary files /dev/null and b/docs/maquettes/campagne/Création d'un nouvel arc.png differ
diff --git a/docs/maquettes/campagne/Création de chapitre.png b/docs/maquettes/campagne/Création de chapitre.png
new file mode 100644
index 0000000..b1c68f6
Binary files /dev/null and b/docs/maquettes/campagne/Création de chapitre.png differ
diff --git a/docs/maquettes/campagne/Création de scène.png b/docs/maquettes/campagne/Création de scène.png
new file mode 100644
index 0000000..1c01909
Binary files /dev/null and b/docs/maquettes/campagne/Création de scène.png differ
diff --git a/docs/maquettes/campagne/Ecran de création de campagne.png b/docs/maquettes/campagne/Ecran de création de campagne.png
new file mode 100644
index 0000000..0df00dd
Binary files /dev/null and b/docs/maquettes/campagne/Ecran de création de campagne.png differ
diff --git a/docs/maquettes/campagne/Modification d'arc.png b/docs/maquettes/campagne/Modification d'arc.png
new file mode 100644
index 0000000..76cfdbb
Binary files /dev/null and b/docs/maquettes/campagne/Modification d'arc.png differ
diff --git a/docs/maquettes/campagne/Modification d'un chapitre.png b/docs/maquettes/campagne/Modification d'un chapitre.png
new file mode 100644
index 0000000..f2d1999
Binary files /dev/null and b/docs/maquettes/campagne/Modification d'un chapitre.png differ
diff --git a/docs/maquettes/campagne/Modification de scène.png b/docs/maquettes/campagne/Modification de scène.png
new file mode 100644
index 0000000..cb16f3f
Binary files /dev/null and b/docs/maquettes/campagne/Modification de scène.png differ
diff --git a/docs/maquettes/campagne/Sauvegarde de la campagne.png b/docs/maquettes/campagne/Sauvegarde de la campagne.png
new file mode 100644
index 0000000..26a39df
Binary files /dev/null and b/docs/maquettes/campagne/Sauvegarde de la campagne.png differ
diff --git a/docs/maquettes/campagne/détail/Modification arc détail 2.png b/docs/maquettes/campagne/détail/Modification arc détail 2.png
new file mode 100644
index 0000000..623002b
Binary files /dev/null and b/docs/maquettes/campagne/détail/Modification arc détail 2.png differ
diff --git a/docs/maquettes/campagne/détail/Modification arc détail 3.png b/docs/maquettes/campagne/détail/Modification arc détail 3.png
new file mode 100644
index 0000000..29f9fb4
Binary files /dev/null and b/docs/maquettes/campagne/détail/Modification arc détail 3.png differ
diff --git a/docs/maquettes/campagne/détail/Modification chapitre détail 2.png b/docs/maquettes/campagne/détail/Modification chapitre détail 2.png
new file mode 100644
index 0000000..9ce3042
Binary files /dev/null and b/docs/maquettes/campagne/détail/Modification chapitre détail 2.png differ
diff --git a/docs/maquettes/campagne/détail/Modification chapitre détail 3.png b/docs/maquettes/campagne/détail/Modification chapitre détail 3.png
new file mode 100644
index 0000000..fd131f9
Binary files /dev/null and b/docs/maquettes/campagne/détail/Modification chapitre détail 3.png differ
diff --git a/docs/maquettes/campagne/détail/Modification de scène détail 2.png b/docs/maquettes/campagne/détail/Modification de scène détail 2.png
new file mode 100644
index 0000000..1676ef9
Binary files /dev/null and b/docs/maquettes/campagne/détail/Modification de scène détail 2.png differ
diff --git a/docs/maquettes/campagne/détail/Modification de scène détail 3.png b/docs/maquettes/campagne/détail/Modification de scène détail 3.png
new file mode 100644
index 0000000..264d0a1
Binary files /dev/null and b/docs/maquettes/campagne/détail/Modification de scène détail 3.png differ
diff --git a/docs/maquettes/campagne/détail/Modification de scène détail 4.png b/docs/maquettes/campagne/détail/Modification de scène détail 4.png
new file mode 100644
index 0000000..9d6868e
Binary files /dev/null and b/docs/maquettes/campagne/détail/Modification de scène détail 4.png differ
diff --git a/docs/maquettes/général/Accueil.png b/docs/maquettes/général/Accueil.png
new file mode 100644
index 0000000..efb83a6
Binary files /dev/null and b/docs/maquettes/général/Accueil.png differ
diff --git a/docs/maquettes/général/Ecran de recherche.png b/docs/maquettes/général/Ecran de recherche.png
new file mode 100644
index 0000000..18d4d89
Binary files /dev/null and b/docs/maquettes/général/Ecran de recherche.png differ
diff --git a/docs/maquettes/lore/Accueil Lore.png b/docs/maquettes/lore/Accueil Lore.png
new file mode 100644
index 0000000..5317c9c
Binary files /dev/null and b/docs/maquettes/lore/Accueil Lore.png differ
diff --git a/docs/maquettes/lore/Assistance IA dans une page.png b/docs/maquettes/lore/Assistance IA dans une page.png
new file mode 100644
index 0000000..123ad6d
Binary files /dev/null and b/docs/maquettes/lore/Assistance IA dans une page.png differ
diff --git a/docs/maquettes/lore/Création d'un Lore.png b/docs/maquettes/lore/Création d'un Lore.png
new file mode 100644
index 0000000..7f9dbf7
Binary files /dev/null and b/docs/maquettes/lore/Création d'un Lore.png differ
diff --git a/docs/maquettes/lore/Création de noeud.png b/docs/maquettes/lore/Création de noeud.png
new file mode 100644
index 0000000..f656b02
Binary files /dev/null and b/docs/maquettes/lore/Création de noeud.png differ
diff --git a/docs/maquettes/lore/Création de template.png b/docs/maquettes/lore/Création de template.png
new file mode 100644
index 0000000..1494ee6
Binary files /dev/null and b/docs/maquettes/lore/Création de template.png differ
diff --git a/docs/maquettes/lore/Modification d'une page.png b/docs/maquettes/lore/Modification d'une page.png
new file mode 100644
index 0000000..c2d339b
Binary files /dev/null and b/docs/maquettes/lore/Modification d'une page.png differ
diff --git a/docs/maquettes/lore/Modification de template.png b/docs/maquettes/lore/Modification de template.png
new file mode 100644
index 0000000..6b757b6
Binary files /dev/null and b/docs/maquettes/lore/Modification de template.png differ
diff --git a/docs/maquettes/lore/création de page.png b/docs/maquettes/lore/création de page.png
new file mode 100644
index 0000000..4d2ce78
Binary files /dev/null and b/docs/maquettes/lore/création de page.png differ
diff --git a/docs/plan.md b/docs/plan.md
new file mode 100644
index 0000000..7799061
--- /dev/null
+++ b/docs/plan.md
@@ -0,0 +1,407 @@
+# Plan de développement LoreMind
+
+## Contexte du projet
+LoreMind est une application d'aide aux Maîtres de Jeu (JDR) permettant de gérer le Lore, les campagnes, et intègre un moteur IA pour générer du contenu structuré à partir de templates. À terme, les données seront exportables vers FoundryVTT.
+
+## Stack technique
+- **Frontend** : Angular
+- **Backend Core (Données & Métier)** : Java (Spring Boot, DDD, Architecture Hexagonale)
+- **Backend AI (Génération & LLM)** : Python (FastAPI, Ollama en local)
+- **Base de données** : PostgreSQL
+
+## Architecture Backend Java
+- Domain-Driven Design (DDD) strict
+- Architecture Hexagonale (Ports et Adaptateurs)
+- Bounded Contexts : LoreContext, CampaignContext, GenerationContext
+- Cœur du domaine sans dépendances techniques (ni framework, ni base de données)
+
+## État actuel du projet
+
+### 🆕 Projet initialisé (14 avril 2026)
+- [x] Création des dossiers structurels (core/, web/, brain/, docs/)
+- [x] Documentation de contexte et règles (.windsurfrules, loremind-contexte.md)
+
+### 🚀 Backend Java - Phase 1 (16 avril 2026)
+- [x] Initialisation du projet Spring Boot (pom.xml)
+- [x] Configuration de la base de données PostgreSQL
+- [x] Création des entités de domaine :
+ - LoreContext : Lore, LoreNode, Page, Template
+ - CampaignContext : Campaign, Arc, Chapter, Scene
+- [x] Création des Ports (Repositories interfaces) pour TOUS les contexts
+- [x] Création des Adaptateurs d'infrastructure :
+ - JPA Entities (LoreJpaEntity, LoreNodeJpaEntity, etc.)
+ - JPA Repositories (LoreJpaRepository, etc.)
+ - Postgres Repositories (PostgresLoreRepository, etc.)
+- [x] Création des Services d'application PARTIELS :
+ - LoreService ✅
+ - CampaignService ✅
+- [x] Création des Services d'application restants :
+ - LoreNodeService ✅
+ - PageService ✅
+ - TemplateService ✅
+ - ArcService ✅
+ - ChapterService ✅
+ - SceneService ✅
+- [x] Création des DTOs et Mappers :
+ - LoreContext DTOs ✅
+ - CampaignContext DTOs ✅
+ - Mappers pour toutes les entités ✅
+- [x] Création des REST Controllers :
+ - LoreController, CampaignController ✅
+ - LoreNodeController, PageController, TemplateController ✅
+ - ArcController, ChapterController, SceneController ✅
+- [x] Configuration CORS ✅
+- [ ] Création du GenerationContext (entités, ports, adaptateurs, services)
+
+### ⏳ À faire
+
+#### Phase 2 : Frontend Angular (Priorité haute)
+- [x] Initialisation du projet Angular ✅
+- [x] Création du layout de base (Sidebar + Main Content) ✅
+- [x] Création du composant Sidebar ✅ (redesign complet : logo, palette violette, OUTILS, version)
+- [x] Configuration routing Angular ✅
+- [x] Styles globaux dark theme ✅
+- [x] Installation lucide-angular (icônes SVG) ✅
+- [x] Page Lore (Vos Univers) — grille de cartes, carte "Nouveau Lore" ✅
+- [x] Page Campagnes — grille de cartes, carte "Nouvelle Campagne" ✅
+- [x] Modal création de Lore (LoreCreateComponent) ✅
+- [x] Branchement LoreService.createLore() ✅
+- [x] Composant SecondarySidebar (réutilisable Lore + Campagne) ✅
+- [x] LayoutService (contrôle affichage secondary sidebar) ✅
+- [x] Page détail Lore (/lore/:id) avec arborescence noeuds ✅
+- [x] Page détail Campagne (/campaigns/:id) avec arborescence arcs/chapitres ✅
+- [x] Formulaire création Campagne (modal) ✅
+- [x] Sidebar globale contextuelle (liste lores/campagnes + retour) ✅
+- [x] Secondary sidebar avec toggle pli/dépli ✅
+- [x] Écran création de noeud (Lore) ✅
+- [x] Refonte secondary sidebar : actions contextuelles (Lore: + Noeud / + Page, Campagne: + Nouvel arc). Bouton "Sauvegarder" retiré (persistance immédiate via REST). ✅
+- [x] Écran création/modification de page (Lore) ✅ — Phase 5A livrée : domaine Page enrichi (`loreId`, `values: Map`, `notes`, `tags`, `relatedPageIds`), écrans `page-create` (titre + grille de templates + noeud pré-rempli depuis `template.defaultNodeId`) et `page-edit` basique (champs dynamiques du template rendus en textarea + notes privées). Pages affichées dans l'arbre sous leur noeud + action "+ Nouvelle page" par noeud.
+- [x] Écran création/modification de template (Lore) ✅ (domaine enrichi `loreId` + `defaultNodeId` + `List fields`, panneau sidebar "Templates" fidèle à la maquette)
+- [x] Écran création d'arc (Campagne) ✅ (champ `illustration` reporté — à ajouter quand l'écran détail d'un arc sera implémenté)
+- [x] Écran création de chapitre (Campagne) ✅ (chargement chapitres existants + action "+ Nouveau chapitre" inline dans l'arbre)
+- [x] Écran création de scène (Campagne) ✅
+- [x] Refactor : helper `campaign-tree.helper.ts` (chargement arbre + construction TreeItem[]) + rendu récursif 3 niveaux dans SecondarySidebar ✅
+- [x] Écrans détail/modification (Campagne) : arc-edit, chapter-edit, scene-edit avec Sauvegarder + Supprimer ✅
+- [x] SecondarySidebar : séparation chevron/label pour permettre expand + navigation sur un même item ✅
+- [x] **Enrichissement domaine narratif Arc/Chapter/Scene** (sous-tâches 1-3 ✅, sous-tâche 4 cross-context Lore↔Campaign restante)
+
+### Enrichissement du domaine Template (Lore) ✅ (18 avril 2026)
+Maquettes : `docs/maquettes/lore/Création de template.png` et `Modification de template.png`.
+
+**Changements backend Java (Option i : champs typés explicites, DDD-friendly) :**
+- `Template.java` : ajout `loreId`, `defaultNodeId`, `List fields` ; suppression `Map structure` ; méthodes métier `fieldCount`, `addField`, `removeField`.
+- `TemplateRepository.java` (port) : ajout `findByLoreId(String loreId)`.
+- `TemplateJpaEntity.java` : colonnes typées `lore_id` (NOT NULL), `default_node_id`, `fields` (TEXT via converter JSON).
+- Nouveau converter `StringListJsonConverter` : `List` ↔ JSON pour la persistance PostgreSQL.
+- `PostgresTemplateRepository.java` : mapping bidirectionnel enrichi + implémentation `findByLoreId`.
+- `TemplateJpaRepository.java` : méthode dérivée `findByLoreId(Long)`.
+- `TemplateDTO.java` + `TemplateMapper.java` : alignement sur le nouveau domaine (expose `fieldCount` calculé côté serveur).
+- `TemplateService.java` : signatures refactorées ; `updateTemplate` en Parameter Object pattern ; `loreId` volontairement immuable (pas de migration cross-Lore via simple update).
+- `TemplateController.java` : `POST /api/templates`, `GET /api/templates?loreId=X`, `GET /{id}`, `PUT /{id}`, `DELETE /{id}`. Retrait du `PATCH /{id}/structure` obsolète.
+
+**Changements frontend Angular :**
+- `template.model.ts`, `template.service.ts` : modèle TS + service HTTP complet.
+- `layout.service.ts` : nouveaux types `BottomPanel`, `BottomPanelItem` ; `SecondarySidebarConfig.bottomPanel?` ajouté. `footerLabel` déprécié (gardé optionnel pour compat des callers campagne).
+- `SecondarySidebarComponent` : rendu du `bottomPanel` avec toggle ouvert/fermé, items cliquables + meta (ex: `"8 champs"`).
+- Nouveau helper `@app/lore/lore-sidebar.helper.ts` : charge lore + all lores + nodes + templates en parallèle et construit la config sidebar complète (panneau Templates inclus). Utilisé par `lore-detail` et `lore-node-create` (→ résout la dette "duplications de pattern côté Lore").
+- `TemplateCreateComponent` et `TemplateEditComponent` : écrans fidèles aux maquettes (colonne gauche = identité, colonne droite = liste dynamique ajout/suppression de champs).
+- Routes ajoutées : `/lore/:loreId/templates/create` et `/lore/:loreId/templates/:templateId`.
+
+### Enrichissement du domaine Page (Lore) — Phase 5A ✅ (18 avril 2026)
+Maquettes : `docs/maquettes/lore/création de page.png` et `Modification d'une page.png`.
+
+**Changements backend Java (structure alignée sur les maquettes) :**
+- `Page.java` : suppression `content: String` (trop vague) ; ajout `loreId`, `values: Map` (valeurs des champs dynamiques du template, clé = `fieldName`), `notes` (privé MJ), `tags: List`, `relatedPageIds: List`. Méthodes métier `setFieldValue`, `getFieldValue`, `addTag`, `removeTag`.
+- `PageRepository.java` : ajout `findByLoreId(String loreId)`.
+- `PageJpaEntity.java` : colonne `lore_id` NOT NULL, `values_json` (colonne renommée car `values` est un mot-clé SQL), `notes`, `tags`, `related_page_ids` — tous stockés en JSON (TEXT) via converters.
+- Nouveau converter `StringMapJsonConverter` : `Map` ↔ JSON (distinct du `MapJsonConverter` générique `Map` dont Page n'a pas besoin).
+- `PostgresPageRepository.java` + `PageJpaRepository.java` : mapping et méthode dérivée `findByLoreId`.
+- `PageDTO.java` + `PageMapper.java` : alignement complet.
+- `PageService.java` : `createPage(loreId, nodeId, templateId, title)` minimaliste ; `updatePage(id, changes)` Parameter Object (applique title/nodeId/values/notes/tags/relatedPageIds). `loreId` et `templateId` immuables après création.
+- `PageController.java` : `POST /api/pages`, `GET /api/pages?loreId=X` ou `?nodeId=Y`, `GET /{id}`, `PUT /{id}`, `DELETE /{id}`. Suppression de `PATCH /{id}/template` et de `GET /node/{nodeId}` (unifié en query param).
+
+**Changements frontend Angular :**
+- `page.model.ts`, `page.service.ts` : modèle TS + service HTTP.
+- `lore-sidebar.helper.ts` enrichi : charge aussi les pages ; les pages apparaissent dans l'arbre **sous leur noeud** (TreeItem `children`) ; chaque noeud a un item action "+ Nouvelle page" pointant vers `/lore/:loreId/nodes/:nodeId/pages/create` ; bouton "+ Page" du header de sidebar pointe vers `/lore/:loreId/pages/create` (choix libre du template).
+- `PageCreateComponent` : fidèle à la maquette — titre + grille de cartes Template sélectionnables + select Noeud de destination (pré-rempli depuis `template.defaultNodeId` si l'URL n'impose pas déjà un nodeId). Redirige vers `page-edit` après création.
+- `PageEditComponent` basique — titre, noeud (déplaçable), **un textarea par `field` du template** (valeurs stockées dans `values`), notes privées. Bouton "Assistant IA" stub (sera branché en Phase 3 Python).
+- Routes ajoutées : `/lore/:loreId/pages/create`, `/lore/:loreId/nodes/:nodeId/pages/create`, `/lore/:loreId/pages/:pageId`.
+
+### Renommage "dossier" + icônes + hiérarchie ✅ (18 avril 2026)
+Triple corrections suite au retour utilisateur :
+
+**Renommage UI "noeud" → "dossier"** (nom interne `LoreNode` conservé côté Java pour limiter l'impact BDD et code) :
+- Textes visibles mis à jour dans : `lore-node-create.*`, `lore-detail.*`, `lore.component.*`, `page-create.*`, `page-edit.*`, `template-create.*`, `template-edit.*`, bouton sidebar `+ Dossier`.
+
+**Bug corrigé — icônes de dossier invisibles :**
+- Côté backend : l'icône envoyée par l'UI était silencieusement ignorée (`icon` absent de `LoreNode.java`, `LoreNodeDTO.java`, du mapping JPA). Ajouté partout : domaine + JPA entity (colonne `icon`) + DTO + mapper + repository + service (Parameter Object pour `createLoreNode`/`updateLoreNode`).
+- Côté frontend : nouveau registre partagé `@app/lore/lore-icons.ts` (`LORE_ICON_OPTIONS` + `resolveIcon(key)`). Refactor de `lore-node-create` pour utiliser ce registre. Sidebar rend l'icône via `TreeItem.iconKey` (nouveau champ) + méthode `iconFor()`.
+
+**Dossiers imbriqués :**
+- Le backend supportait déjà `parentId` — seul le frontend ne l'exposait pas. Ajout du champ `parentId` à `LoreNode`/`LoreNodeCreate` TS + formulaire `lore-node-create` (select "Dossier parent"). Nouvelle route `/lore/:loreId/folders/:parentId/create` pour pré-remplir depuis la sidebar.
+- Helper `lore-sidebar.helper.ts` refactoré : construction récursive de l'arbre (fonction `buildFolderItem`). Chaque dossier affiche ses sous-dossiers + ses pages + actions `+ Nouveau dossier` et `+ Nouvelle page` inline.
+
+### Édition et suppression de dossier ✅ (18 avril 2026)
+Complète la CRUD manquante pour les `LoreNode` (dossiers).
+
+**Frontend Angular :**
+- `LoreService` enrichi : `getLoreNodeById`, `updateLoreNode`, `deleteLoreNode`. URL des lore-nodes factorisée dans `nodesUrl`.
+- Nouveau `LoreNodeEditComponent` (`lore-node-edit/`) — formulaire avec nom, icône (grille), dossier parent (select). Header avec boutons Annuler / Supprimer / Sauvegarder.
+- Helper `lore-sidebar.helper.ts` : ajout de la fonction utilitaire `collectDescendantIds(rootId, allNodes)` qui calcule de manière itérative l'ensemble des descendants d'un dossier. Utilisée pour **empêcher les cycles** : le select "Dossier parent" de l'édition exclut le dossier courant et tous ses descendants.
+- Chaque dossier dans la sidebar a maintenant une `route` pointant vers son écran d'édition (clic sur le label → édition, clic sur le chevron → expand/collapse).
+- Route ajoutée : `/lore/:loreId/folders/:folderId/edit`.
+
+**Règle de suppression (safe) :**
+- La suppression est **refusée si le dossier contient des sous-dossiers ou des pages** (message explicite "Videz-le d'abord : X sous-dossier(s) et Y page(s)").
+- Raison : protéger les notes MJ contre un clic accidentel. Pas de cascade silencieuse.
+- La vérification se fait côté frontend à partir des données déjà chargées dans la sidebar (pas d'appel HTTP supplémentaire). Le backend accepte le DELETE sans check, mais le frontend ne l'émet jamais si le dossier n'est pas vide.
+
+### Pages — Phases à venir
+
+#### Phase 5B : édition complète ✅ (18 avril 2026)
+- [x] **Tags (chips)** — nouveau composant réutilisable `app-chips-input` (`@app/shared/chips-input/`). UX : Entrée ou virgule pour ajouter, Backspace sur input vide retire le dernier chip, doublons silencieusement ignorés, trim automatique. Binding deux-sens via `[value]` / `(valueChange)`.
+- [x] **Liens vers d'autres pages** — nouveau composant `app-lore-link-picker` (`@app/shared/lore-link-picker/`). Input de recherche avec dropdown de suggestions filtrées (max 8), chips cliquables pour chaque page liée (clic → navigation, X → retrait). Exclut la page courante via `excludePageId`.
+- [x] **Intégration dans `page-edit`** : sections "Tags" et "Pages liées" ajoutées entre les champs dynamiques et les notes privées. `allPages: Page[]` récupéré depuis la sidebar pour alimenter le picker.
+- [x] Le composant `app-lore-link-picker` est **conçu pour être réutilisé** en Phase cross-context Campagne↔Lore (Arc/Chapter/Scene pourront lier des Pages du Lore via ce même picker).
+
+#### Phase 5C : affichage et navigation fine
+- [x] Compteur de pages sur chaque dossier dans le sidebar (ex: `PNJ · 3`) ✅ (19 avril 2026).
+- [x] Correction compteurs home "Vos univers" (nodeCount/pageCount calculés à la volée via `countByLoreId` au lieu d'être stockés en BDD et jamais MAJ) ✅ (19 avril 2026).
+- [x] Breadcrumb `Lore > Dossier > Page` dans `page-edit` ✅ (19 avril 2026) — composant réutilisable `app-breadcrumb` prêt pour Arc/Chapter/Scene.
+- [ ] Raccourci clavier `Ctrl+S` pour sauvegarder.
+
+#### Phase 5D : intégration IA (dépend de la Phase 3 Python)
+- [ ] Branchement du bouton "Assistant IA" de `page-edit` sur l'endpoint Python Ollama.
+- [ ] Affichage streaming des suggestions par champ.
+
+### Enrichissement du domaine narratif (Campagne)
+Les maquettes (`docs/maquettes/campagne/détail/*.png`) révèlent que chaque entité narrative doit porter bien plus que `name + description`. Voici le détail des champs manquants qui doivent être ajoutés côté Java (domain + JPA + DTO + mapper) et côté Angular (model + forms).
+
+**Approche retenue :**
+- Colonnes TEXT dédiées (pas de JSONB) car chaque champ a un sens métier précis et sera utilisé par l'Assistant IA (Phase 3) comme prompt structuré.
+- Les **liens vers le Lore** (PNJ, lieux, objets) = IDs stockés en JSONB ou table de liaison, **pas** de relation JPA cross-context (principe DDD : Bounded Contexts isolés).
+
+#### Sous-tâche 1 : Arc (5 champs texte) ✅
+- [x] `themes` — Thèmes principaux ✅
+- [x] `stakes` — Enjeux globaux ✅
+- [x] `gmNotes` — Notes et planification du MJ (privé, non exporté FoundryVTT) ✅
+- [x] `rewards` — Récompenses et progression ✅
+- [x] `resolution` — Dénouement prévu ✅
+- Impact : `Arc.java` (domain), `ArcJpaEntity.java` (JPA + colonnes TEXT auto via `ddl-auto=update`), `ArcDTO.java`, `ArcMapper.java`, `PostgresArcRepository.java`, `ArcService.updateArc()` refactoré en Parameter Object pattern, `ArcController.updateArc()`, `campaign.model.ts`, `arc-edit.component.*` (formulaire enrichi, arc-create reste volontairement minimal comme la maquette).
+
+#### Sous-tâche 2 : Chapter (3 champs texte) ✅
+- [x] `gmNotes` — Notes du Maître de Jeu (privé) ✅
+- [x] `playerObjectives` — Objectifs des joueurs ✅
+- [x] `narrativeStakes` — Enjeux narratifs ✅
+- Impact : `Chapter.java`, `ChapterJpaEntity.java`, `ChapterDTO.java`, `ChapterMapper.java`, `PostgresChapterRepository.java`, `ChapterService.updateChapter()` (Parameter Object), `ChapterController.updateChapter()`, `campaign.model.ts`, `chapter-edit.component.*`.
+
+#### Sous-tâche 3 : Scene (8 champs texte répartis en sections) ✅
+Sections de la maquette (chaque section est un bloc d'UI expandable) :
+- [x] **Contexte et ambiance** : `location` (court), `timing` (court), `atmosphere` (long) ✅
+- [x] **Narration pour les joueurs** : `playerNarration` (long) ✅
+- [x] **Notes et secrets du MJ** (privé, variant "private" rouge) : `gmSecretNotes` (long) ✅
+- [x] **Choix et conséquences** : `choicesConsequences` (long) ✅
+- [x] **Combat ou rencontre** : `combatDifficulty` (court), `enemies` (long) ✅
+- Impact : `Scene.java`, `SceneJpaEntity.java`, `SceneDTO.java`, `SceneMapper.java`, `PostgresSceneRepository.java`, `SceneService.updateScene()` (Parameter Object), `SceneController.updateScene()`, `campaign.model.ts`, `scene-edit.component.*` (11 champs totaux, 5 sections expandables).
+- **Nouveau composant partagé** : `@app/shared/expandable-section/` — réutilisable (propriétés : `title`, `icon` emoji, `initiallyOpen`, `variant: 'default' | 'private'`).
+
+#### Sous-tâche 4 : Liens cross-context Lore ↔ Campaign
+Tous des `List` d'IDs de LoreNode :
+- [ ] Arc : `antagonistNpcIds`, `allyNpcIds`
+- [ ] Chapter : `involvedNpcIds`, `visitedLocationIds`
+- [ ] Scene : `presentNpcIds`, `importantObjectIds`
+- [ ] Composant Angular réutilisable : `app-lore-link-picker` (autocomplete + liste de chips)
+- [ ] Endpoint `GET /api/lore-nodes?ids=a,b,c` (résolution multi-IDs) côté Java
+
+#### Phase 3 : Backend Python (Priorité basse - PLUS TARD)
+- [ ] Initialisation de la structure
+- [ ] Configuration Ollama en local
+- [ ] Adaptateur OllamaProvider
+- [ ] Routes API pour la génération
+
+## Structure des dossiers
+
+```
+LoreMind/
+├── core/ # Backend Java
+│ ├── src/main/java/com/loremind/
+│ │ ├── domain/ # Entités de domaine (DDD)
+│ │ │ ├── lorecontext/
+│ │ │ ├── campaigncontext/
+│ │ │ └── generationcontext/
+│ │ ├── application/ # Use Cases
+│ │ └── infrastructure/ # Adaptateurs (JPA, REST)
+│ └── pom.xml
+├── web/ # Frontend Angular
+│ ├── src/app/
+│ │ ├── shared/ # Composants partagés (Sidebar)
+│ │ ├── campaigns/ # Module Campaigns
+│ │ ├── lore/ # Module Lore
+│ │ └── services/ # Services HTTP
+│ └── package.json
+├── brain/ # Backend Python (IA)
+│ ├── app/
+│ │ ├── core/
+│ │ ├── domain/
+│ │ ├── infrastructure/
+│ │ └── api/
+│ └── requirements.txt
+└── docs/ # Documentation
+ ├── academy/ # Documents pédagogiques
+ ├── loremind-contexte.md # Contexte du projet
+ └── plan.md # Ce fichier
+```
+
+## Configuration prévue
+
+### Base de données PostgreSQL
+- URL : jdbc:postgresql://localhost:5432/loremind
+- Username : ietm64
+- Password : M&Ipourlavie64
+
+### Serveurs
+- Backend Java : http://localhost:8080
+- Frontend Angular : http://localhost:4200
+- Backend Python : À définir
+
+## Notes importantes
+- Le Backend Java suit strictement l'Architecture Hexagonale
+- Le Frontend Angular utilise des services HTTP pour communiquer avec le Backend
+- L'IA sera configurée avec Ollama en local (pas d'API OpenAI pour le moment)
+- Les templates PostgreSQL utiliseront le type JSONB pour la flexibilité
+
+## Points à surveiller / Dette technique connue
+Ces points sont à garder en tête pour de futures refactorisations. Pas bloquant aujourd'hui — à traiter quand le besoin se manifestera.
+
+- **Champ `illustration` manquant sur Arc/Chapter/Scene (front + back)** — les maquettes prévoient une URL d'illustration. Reporté jusqu'à l'implémentation des écrans de détail (affichage) correspondants. Impact : domaine Java + JPA + DTO + migration Postgres + champ Angular.
+- **Chargement de l'arbre campagne via N+1 requêtes HTTP** — `campaign-tree.helper.ts` fait `1 arcs + N chapters + M scenes` appels HTTP en forkJoin. Correct pour des campagnes de taille modeste. À remplacer par un endpoint agrégé `GET /api/campaigns/:id/tree` quand les volumes l'exigeront (>20 chapitres par ex).
+- **Calcul de `order` naïf** — actuellement `order = existingCount + 1`. Ne gère pas les réordonnancements ni les suppressions (risque de collisions). À reprendre avec un pattern de fractional indexing ou recalcul côté backend.
+- ~~**Duplications de pattern côté Lore**~~ ✅ Résolu le 18 avril 2026 via `lore-sidebar.helper.ts` — utilisé par `lore-detail`, `lore-node-create`, `template-create`, `template-edit`. L'écran de création de page à venir suivra le même pattern.
+- ~~**Harmonisation du style bouton primaire**~~ ✅ Résolu le 18 avril 2026 sur les 6 composants pattern A (arc/chapter/scene × create/edit). Partials créés : `web/src/styles/_buttons.scss` et `_forms.scss`. 572 → 120 lignes (-79%). Reste la **unification pattern A / pattern B** (voir entrée dédiée ci-dessous).
+- **Deux design systems cohabitent** — Pattern A (`#1f2937` / radius 8px / padding 0.75rem, utilisé par arc/chapter/scene/campaign/lore-create) vs Pattern B (`#1a1a2e` / radius 6px / padding 0.7rem, utilisé par template/page/lore-node). C'est un vrai choix de design à faire, pas juste de la dette. Option : garder A pour les écrans "campagne simples" et B pour les écrans "Lore premium". Option alternative : unifier sur un seul pattern.
+- **Fusion create + edit** — les composants `*-create` et `*-edit` partagent ~80% du code (form, layout, soumission). À fusionner en un seul composant par entité avec un flag `mode: 'create' | 'edit'` OU router-data. Pas urgent : YAGNI tant que les 2 écrans restent simples.
+- ~~**Breadcrumb**~~ ✅ Résolu le 19 avril 2026. Composant réutilisable `app-breadcrumb` créé dans `web/src/app/shared/breadcrumb/`. Intégré dans `page-edit`. Reste à intégrer sur `arc-edit`, `chapter-edit`, `scene-edit` si nécessaire (le composant est prêt).
+- **Modale de confirmation personnalisée** — la suppression utilise `confirm()` natif. À remplacer par une modale Angular cohérente avec la charte graphique.
+- **Gestion des migrations DB** — actuellement `spring.jpa.hibernate.ddl-auto=update` (auto-alter). Acceptable en dev, **inutilisable en prod** (perte de données possible). À remplacer par Flyway ou Liquibase avant la mise en prod (chaque changement de schéma devra être versionné en fichier SQL).
+
+## Dernière mise à jour
+19 avril 2026 - **Phase 5C en cours : compteurs + breadcrumb livrés**.
+
+**Breadcrumb (fil d'Ariane) dans `page-edit`** :
+ - Nouveau composant réutilisable `app-breadcrumb` dans [web/src/app/shared/breadcrumb/](../web/src/app/shared/breadcrumb/). Interface `BreadcrumbItem { label, route? }` — item sans `route` = position courante (non-cliquable, style différencié).
+ - Séparateur visuel `›` géré en CSS via `::before` (pas de DOM supplémentaire).
+ - Intégré dans `page-edit` au-dessus du header. Chemin construit dynamiquement par un getter `breadcrumbItems` qui remonte la hiérarchie de dossiers via `parentId` depuis les `nodes` déjà chargés pour la sidebar — zéro appel HTTP supplémentaire.
+ - Le getter recalcule à chaque render (Angular change detection) : peu coûteux (dizaines de nœuds max), reste réactif si le `nodeId` change via le select "Dossier".
+ - Composant prêt pour réutilisation sur `arc-edit`, `chapter-edit`, `scene-edit` (dette technique correspondante marquée résolue).
+ - 5 fichiers touchés (3 nouveaux + page-edit TS/HTML).
+
+19 avril 2026 - **Phase 5C démarrée : compteurs de pages**.
+
+**Compteurs de pages par dossier (sidebar)** :
+ - Nouveau champ `meta?: string` sur `TreeItem` ([layout.service.ts](../web/src/app/services/layout.service.ts)) pour afficher un badge aligné à droite.
+ - `buildFolderItem` dans [lore-sidebar.helper.ts](../web/src/app/lore/lore-sidebar.helper.ts) renseigne `meta = nodePages.length` (count direct, `undefined` si 0 — ne pas polluer visuellement).
+ - Rendu dans [secondary-sidebar.component.html](../web/src/app/shared/secondary-sidebar/secondary-sidebar.component.html) via `` + style SCSS `margin-left: auto` cohérent avec `.panel-item-meta` existant (DRY).
+ - 4 fichiers touchés, ~9 lignes ajoutées.
+
+**Bug fix — compteurs home "Vos univers" affichaient 0** :
+ - Cause : les champs `Lore.nodeCount` / `pageCount` étaient stockés en BDD mais les méthodes métier `incrementNodeCount()` / `incrementPageCount()` n'étaient **jamais appelées** par `LoreNodeService` ou `PageService`. Les compteurs restaient à 0 depuis la création.
+ - Correction : bascule vers un calcul à la volée (Option B — source of truth = tables nodes/pages).
+ - Ports enrichis : `countByLoreId(String loreId)` ajouté sur `LoreNodeRepository` et `PageRepository`.
+ - JPA : `long countByLoreId(Long loreId)` en Spring Data query derivation (pas de `@Query` à écrire).
+ - Adaptateurs Postgres : impl propagée avec conversion `String → Long`.
+ - `LoreService` injecte les 2 ports supplémentaires et enrichit via une méthode privée `withCounts(Lore)` appliquée dans `getAllLores()` et `getLoreById()`. Anciennes colonnes `node_count`/`page_count` laissées en BDD (ignorées, à nettoyer plus tard).
+ - N+1 assumé (1 find + 2 COUNT par Lore). Négligeable à petite échelle.
+ - 7 fichiers touchés (2 ports, 2 JPA, 2 adaptateurs, 1 service).
+
+18 avril 2026 (fin de soirée, après B2) - **Cross-context Campagne ↔ Lore complet sur Arc + Chapter + Scene**.
+
+**B2 — `relatedPageIds` sur Arc / Chapter / Scene** :
+ - Backend (18 fichiers touchés, 3 entités × 6 couches) :
+ - Domaine : `List relatedPageIds` ajouté avec `@Builder.Default` (jamais null) + méthodes métier `linkPage(id)` / `unlinkPage(id)` idempotentes et réutilisables.
+ - Persistance JPA : nouvelle colonne `related_page_ids` en TEXT avec le converter existant `StringListJsonConverter` (pattern déjà utilisé pour Page + Template).
+ - Repositories Postgres : propagation dans les deux sens (`toDomainEntity` / `toJpaEntity`) avec defensive copy (`new ArrayList<>(src)`) pour garantir qu'un changement côté domaine ne modifie pas accidentellement l'entité JPA.
+ - DTO + Mapper : idem, propagation + defensive copy. Initialisation `new ArrayList<>()` pour que Jackson sérialise toujours un tableau JSON (jamais `null`).
+ - Services : `updateArc/Chapter/Scene` déjà en Parameter Object (full entity) → une seule ligne ajoutée par service (`entity.setRelatedPageIds(updated.getRelatedPageIds())`).
+ - Frontend (7 fichiers touchés) :
+ - Modèles `Arc`/`Chapter`/`Scene` + `*Create` : champ `relatedPageIds?: string[]` ajouté.
+ - `arc-edit`, `chapter-edit`, `scene-edit` : injection `PageService`, chargement conditionnel des pages du Lore via `switchMap` (si `campaign.loreId` est défini), binding bidirectionnel avec `app-lore-link-picker`. Le picker est caché avec un message explicatif si la campagne n'a pas de Lore associé.
+ - `scene-edit` : le picker est dans une `app-expandable-section` avec l'icône 🔗 pour rester cohérent avec les 5 autres sections de la scène.
+ - Principe DDD réaffirmé : **aucune** classe du Lore Context importée dans le Campaign Context. Seuls des IDs (`String`) voyagent. Le `LoreLinkPickerComponent` est le SEUL point où les deux contextes se rejoignent, et c'est côté UI — pas côté domaine.
+ - Le `app-lore-link-picker` que j'avais introduit pour `page-edit` (Phase 5B) est désormais **réutilisé à l'identique** dans 3 nouveaux écrans → pari design payant, la composantisation a tenu ses promesses.
+
+18 avril 2026 (soir, après dette technique) - **Extraction SCSS + mise en valeur bouton retour sidebar**.
+
+**Extraction SCSS partagés** :
+ - Nouveaux partials `web/src/styles/_buttons.scss` (`.btn-primary`, `.btn-secondary`, `.btn-danger` + modificateurs `.btn-sm` et `.btn-icon`) et `_forms.scss` (`.field`, `.field-hint`, `.field-row`, `.page-header`, `.form-actions`). Importés via `@use` dans `styles.scss`.
+ - 6 composants pattern A nettoyés : `arc-create/edit`, `chapter-create/edit`, `scene-create/edit`. Réduction de **572 → 120 lignes** (-79%, 452 lignes économisées). Seuls les overrides contextuels subsistent (ex: `.btn-danger { margin-left: auto }` pour pousser Supprimer à droite).
+ - Composants pattern B (template, page, lore-node) volontairement **non modifiés** — ils utilisent un design différent (`#1a1a2e` / radius 6px). Ajouté comme nouvelle entrée dans la dette "Deux design systems cohabitent".
+ - ⚠️ Piège Angular ViewEncapsulation rencontré : les sélecteurs CSS locaux ont une spécificité plus élevée que les globaux (ajout d'un attribut `[_ngcontent-xxx]`). Il fallait donc **réellement supprimer** les blocs dupliqués pour que les globaux s'appliquent — sinon ils étaient silencieusement ignorés.
+
+**Bouton retour sidebar (Tous les lores / Toutes les campagnes)** :
+ - Avant : simple libellé gris sans bordure, confondu avec les items de contexte.
+ - Après : vrai bouton bordé avec icône `ArrowLeft` Lucide, centré, séparateur visuel au-dessus via `::before`, hover marqué (bordure violet, texte blanc, flèche qui glisse à gauche en micro-interaction).
+ - Principe UX appliqué : "affordance visuelle" — un bouton doit *avoir l'air cliquable* avant même qu'on le survole.
+
+18 avril 2026 (soir, après B1) - **Weak reference Campaign ↔ Lore + 4 corrections de bugs**.
+
+**B1 — Lien optionnel Campaign ↔ Lore (cross-context weak reference)** :
+ - Backend : `Campaign.loreId` ajouté (nullable) avec méthodes métier `linkToLore` / `unlinkFromLore` / `isLinkedToLore`. Pas de `@ManyToOne`, pas de FK — c'est volontaire, les Bounded Contexts (Lore, Campaign) doivent rester indépendants. Normalisation `""` → `null` côté service. `CampaignService` refacto en Parameter Object (`CampaignData`).
+ - Frontend : select "Univers associé" (optionnel, "— Aucun univers —") dans la modal de création de campagne. Badge cliquable `🌐 ` dans `campaign-detail` qui navigue vers le Lore. Cas dégradé "Univers introuvable" (rouge italique) si le Lore a été supprimé entre-temps.
+
+**4 bugs corrigés suite retour utilisateur** :
+ 1. **Pollution cross-lore** (🔴 critique) — `GET /api/lore-nodes?loreId=X` ignorait le query param (pas d'annotation `@RequestParam`), renvoyait TOUS les dossiers de TOUS les lores. Les dossiers d'un Lore apparaissaient dans les autres. Pattern aligné sur `TemplateController` / `PageController`.
+ 2. **Grille "Dossiers" plate** dans `lore-detail` — les sous-dossiers apparaissaient au même niveau que leurs parents dans la grille principale. Fix : `rootNodes = nodes.filter(n => !n.parentId)`. Les sous-dossiers restent accessibles via l'arbre de la sidebar.
+ 3. **Switch entre Lores/Campaigns ne rechargeait pas** — même bug que le page-edit précédent : `route.snapshot.paramMap.get('id')` lu une seule fois dans `ngOnInit`, alors qu'Angular réutilise le composant. Fix : subscription à `route.paramMap` avec comparaison à l'id courant, appliqué à `lore-detail` ET `campaign-detail` (préventif).
+ 4. **Pas de bouton Modifier/Supprimer sur Lore et Campaign** — nouveau mode édition inline dans le header des deux écrans détail. Rename + description (+ select Lore associé pour Campaign) + sauvegarde/annulation. Suppression protégée : refus si Lore contient encore des dossiers, ou si Campagne contient encore des arcs (message explicite avec le nombre). Pattern cohérent avec `lore-node-edit`.
+
+**Encore en attente (B2, ~24 fichiers)** : `relatedPageIds: List