Phase 2 : mind map bilaterale, relations, templates et Markdown

Format .mmap v4 : `node.side` (cote d'une branche de niveau 1) et
`MindMap.relations` (relations secondaires). Migration v3 -> v4 sans perte, les
cartes v1/v2/v3 restent ouvrables telles quelles.

Une relation est une connexion purement visuelle : elle ne touche jamais
parentId, order, les enfants, le repli ni l'auto-layout. `withEdges()` continue
de deriver les liens de parentId et se contente de retirer les relations dont
une extremite a disparu.

Mind map bilaterale : repartition gloutonne et deterministe des branches selon
la taille des sous-arbres, heritage du cote par sous-arbre, deux passes dagre
recalees sur la racine. Choisir une disposition ne deplace plus la carte : seul
Reorganiser applique.

Ajoute aussi une galerie de huit modeles locaux, l'import Markdown (fichier ou
texte, nouvelle carte ou sous-arbre) reutilisant l'analyseur d'outline existant,
et l'export Markdown de la hierarchie.

Corrige un bug de rendu : React Flow ne remesure pas les poignees quand elles
changent de cote, ce qui faisait disparaitre les liens concernes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/schemas/map.py

@@ -31,6 +31,29 @@ class MapEdgeIn(BaseModel):
     target: str = Field(min_length=1, max_length=128)
 
 
+class MapRelationIn(BaseModel):
+    """Relation secondaire (format v4).
+
+    Purement visuelle : le backend ne l'interprete pas, il verifie seulement
+    qu'elle est bien formee. Une relation qui boucle sur elle-meme est refusee,
+    comme cote frontend : les deux validations disent la meme chose.
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+    id: str = Field(min_length=1, max_length=128)
+    # Les noms suivent le document JSON du frontend, d'ou le camelCase.
+    sourceId: str = Field(min_length=1, max_length=128)
+    targetId: str = Field(min_length=1, max_length=128)
+    label: str | None = Field(default=None, max_length=120)
+
+    @model_validator(mode="after")
+    def _check_endpoints(self) -> MapRelationIn:
+        if self.sourceId == self.targetId:
+            raise ValueError("Une relation doit relier deux noeuds differents.")
+        return self
+
+
 class MapDocumentIn(BaseModel):
     """Document carte complet, tel que produit par le frontend."""
 
@@ -41,6 +64,7 @@ class MapDocumentIn(BaseModel):
     name: str = Field(default="", max_length=255)
     nodes: list[MapNodeIn] = Field(default_factory=list)
     edges: list[MapEdgeIn] = Field(default_factory=list)
+    relations: list[MapRelationIn] = Field(default_factory=list)
     viewport: dict[str, Any] = Field(default_factory=dict)
     settings: dict[str, Any] = Field(default_factory=dict)
 
@@ -59,4 +83,8 @@ class MapDocumentIn(BaseModel):
         max_edges = get_settings().max_nodes * 4
         if len(self.edges) > max_edges:
             raise ValueError(f"La carte depasse la limite de {max_edges} liens.")
+
+        max_relations = get_settings().max_nodes * 2
+        if len(self.relations) > max_relations:
+            raise ValueError(f"La carte depasse la limite de {max_relations} relations.")
         return self

backend/tests/test_relation_payload.py

@@ -0,0 +1,149 @@
+"""Le backend doit accepter le format v4 : cotes de branche et relations."""
+
+from __future__ import annotations
+
+from fastapi.testclient import TestClient
+
+from tests.conftest import build_map
+
+
+def build_v4_map() -> dict:
+    payload = build_map(node_count=1, name="Infrastructure")
+    payload["version"] = 4
+    payload["nodes"] = [
+        {
+            "id": "root",
+            "type": "root",
+            "text": "Infrastructure",
+            "position": {"x": 0, "y": 0},
+            "parentId": None,
+            "order": 0,
+        },
+        {
+            "id": "reseau",
+            "type": "standard",
+            "text": "Reseau",
+            "position": {"x": 240, "y": 0},
+            "parentId": "root",
+            "order": 0,
+            "side": "right",
+        },
+        {
+            "id": "firewall",
+            "type": "standard",
+            "text": "Firewall",
+            "position": {"x": 460, "y": 0},
+            "parentId": "reseau",
+            "order": 0,
+        },
+        {
+            "id": "services",
+            "type": "standard",
+            "text": "Services",
+            "position": {"x": -240, "y": 0},
+            "parentId": "root",
+            "order": 1,
+            "side": "left",
+        },
+        {
+            "id": "web",
+            "type": "standard",
+            "text": "Web",
+            "position": {"x": -460, "y": 0},
+            "parentId": "services",
+            "order": 0,
+        },
+    ]
+    payload["edges"] = [
+        {"id": "e-root-reseau", "source": "root", "target": "reseau"},
+        {"id": "e-reseau-firewall", "source": "reseau", "target": "firewall"},
+        {"id": "e-root-services", "source": "root", "target": "services"},
+        {"id": "e-services-web", "source": "services", "target": "web"},
+    ]
+    payload["relations"] = [
+        {
+            "id": "r-1",
+            "sourceId": "firewall",
+            "targetId": "web",
+            "label": "protege",
+            "style": "bezier",
+            "color": "#a855f7",
+            "width": 2,
+            "dashed": True,
+            "markerEnd": "arrow",
+        }
+    ]
+    payload["settings"]["layout"] = "mindmap-both"
+    return payload
+
+
+def test_share_accepts_v4_map(client: TestClient) -> None:
+    response = client.post("/api/shares", json={"title": "v4", "map": build_v4_map()})
+    assert response.status_code == 201, response.text
+
+
+def test_sides_and_relations_are_returned_unchanged(client: TestClient) -> None:
+    created = client.post("/api/shares", json={"title": "v4", "map": build_v4_map()})
+    token = created.json()["share_token"]
+
+    public = client.get("/api/shares/" + token).json()
+    assert public["map_version"] == 4
+    assert public["map"]["settings"]["layout"] == "mindmap-both"
+
+    sides = {node["id"]: node.get("side") for node in public["map"]["nodes"]}
+    assert sides["reseau"] == "right"
+    assert sides["services"] == "left"
+    # Le cote n'est porte que par les branches de niveau 1.
+    assert sides["firewall"] is None
+
+    relations = public["map"]["relations"]
+    assert len(relations) == 1
+    assert relations[0]["sourceId"] == "firewall"
+    assert relations[0]["targetId"] == "web"
+    assert relations[0]["label"] == "protege"
+    assert relations[0]["dashed"] is True
+
+
+def test_relation_does_not_alter_hierarchy(client: TestClient) -> None:
+    """Une relation ne doit jamais devenir un lien parent / enfant."""
+    created = client.post("/api/shares", json={"title": "v4", "map": build_v4_map()})
+    public = client.get("/api/shares/" + created.json()["share_token"]).json()
+
+    parents = {node["id"]: node.get("parentId") for node in public["map"]["nodes"]}
+    assert parents["firewall"] == "reseau"
+    assert parents["web"] == "services"
+
+    edge_pairs = {(edge["source"], edge["target"]) for edge in public["map"]["edges"]}
+    assert ("firewall", "web") not in edge_pairs
+
+
+def test_self_relation_is_rejected(client: TestClient) -> None:
+    payload = build_v4_map()
+    payload["relations"][0]["targetId"] = payload["relations"][0]["sourceId"]
+
+    response = client.post("/api/shares", json={"title": "x", "map": payload})
+    assert response.status_code == 422
+
+
+def test_relation_without_endpoints_is_rejected(client: TestClient) -> None:
+    payload = build_v4_map()
+    del payload["relations"][0]["targetId"]
+
+    response = client.post("/api/shares", json={"title": "x", "map": payload})
+    assert response.status_code == 422
+
+
+def test_map_without_relations_is_still_accepted(client: TestClient) -> None:
+    payload = build_v4_map()
+    del payload["relations"]
+
+    response = client.post("/api/shares", json={"title": "x", "map": payload})
+    assert response.status_code == 201, response.text
+
+
+def test_older_versions_are_still_accepted(client: TestClient) -> None:
+    for version in (1, 2, 3):
+        payload = build_map()
+        payload["version"] = version
+        response = client.post("/api/shares", json={"title": f"v{version}", "map": payload})
+        assert response.status_code == 201, response.text