OpenMind v1 : cartes mentales libres, local-first et dockerisees

Premiere version fonctionnelle, demarrable avec `docker compose up -d --build`
sur http://localhost:8080.

Architecture
- Frontend React 18 / TypeScript strict / Vite / Tailwind, canvas @xyflow/react,
  etat Zustand, persistance IndexedDB via Dexie, auto-layout dagre.
- Backend FastAPI / SQLAlchemy 2 / Pydantic v2 / SQLite, qui sert aussi les
  fichiers statiques du frontend compile.
- Image Docker multi-stage, un seul service, bind mount ./data pour SQLite.

Local-first
Les cartes restent dans le navigateur. Le serveur ne recoit une carte que sur
demande explicite de partage.

Partage
Deux secrets distincts : share_token public en lecture seule dans l'URL, et
management_token conserve uniquement cote client, transmis en en-tete pour les
modifications et stocke hashe en base.

Fonctionnalites
Tableau de bord, editeur complet (undo/redo, copier/coller, raccourcis,
branches repliables, recherche), 9 themes, 4 dispositions automatiques,
panneau de proprietes, import/export .mmap, export PNG/SVG/PDF, impression,
page publique en lecture seule, PWA.

Qualite
25 tests pytest et 43 tests vitest au vert, ruff et ESLint sans erreur,
TypeScript strict sans erreur.

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

backend/app/services/errors.py

@@ -0,0 +1,34 @@
+"""Erreurs metier du domaine partage.
+
+Elles sont converties en reponses HTTP propres par les handlers de `app.main` :
+aucune trace technique n'est exposee au client.
+"""
+
+from __future__ import annotations
+
+
+class ShareError(Exception):
+    """Erreur metier generique."""
+
+    status_code = 400
+    message = "Requete invalide."
+
+    def __init__(self, message: str | None = None) -> None:
+        super().__init__(message or self.message)
+        if message:
+            self.message = message
+
+
+class ShareNotFoundError(ShareError):
+    status_code = 404
+    message = "Ce partage n'existe pas ou a ete supprime."
+
+
+class ShareForbiddenError(ShareError):
+    status_code = 403
+    message = "Jeton de gestion invalide."
+
+
+class SharePayloadTooLargeError(ShareError):
+    status_code = 413
+    message = "La carte depasse la taille maximale autorisee."

backend/app/services/shares.py

@@ -0,0 +1,131 @@
+"""Logique metier du partage de cartes."""
+
+from __future__ import annotations
+
+import json
+import logging
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.config import get_settings
+from app.models.share import SharedMap, utcnow
+from app.schemas.map import MapDocumentIn
+from app.services.errors import (
+    ShareForbiddenError,
+    ShareNotFoundError,
+    SharePayloadTooLargeError,
+)
+from app.services.tokens import (
+    generate_management_token,
+    generate_share_token,
+    hash_token,
+    verify_token,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def serialize_map(document: MapDocumentIn) -> str:
+    """Serialise le document carte en JSON compact et deterministe."""
+    return json.dumps(
+        document.model_dump(mode="json"),
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+
+
+def _guard_payload_size(payload: str) -> None:
+    settings = get_settings()
+    size = len(payload.encode("utf-8"))
+    if size > settings.max_map_size_bytes:
+        raise SharePayloadTooLargeError(
+            f"La carte fait {size / (1024 * 1024):.1f} Mo, "
+            f"la limite est de {settings.max_map_size_mb} Mo."
+        )
+
+
+def _get_by_token(session: Session, share_token: str) -> SharedMap:
+    stmt = select(SharedMap).where(SharedMap.share_token == share_token)
+    share = session.execute(stmt).scalar_one_or_none()
+    if share is None:
+        raise ShareNotFoundError()
+    return share
+
+
+def create_share(session: Session, *, title: str, document: MapDocumentIn) -> tuple[SharedMap, str]:
+    """Cree un partage et retourne (entite, management_token en clair).
+
+    Le management token en clair n'est renvoye qu'ici, une seule fois.
+    """
+    payload = serialize_map(document)
+    _guard_payload_size(payload)
+
+    management_token = generate_management_token()
+    share = SharedMap(
+        share_token=generate_share_token(),
+        management_token_hash=hash_token(management_token),
+        title=(title or document.name or "Carte sans titre")[: get_settings().max_title_length],
+        map_version=document.version,
+        map_data=payload,
+    )
+    session.add(share)
+    session.commit()
+    session.refresh(share)
+
+    logger.info("Partage cree share_token=%s nodes=%s", share.share_token, len(document.nodes))
+    return share, management_token
+
+
+def get_share(session: Session, share_token: str) -> SharedMap:
+    return _get_by_token(session, share_token)
+
+
+def load_map_data(share: SharedMap) -> dict:
+    """Deserialise le snapshot stocke. Ne fait qu'un json.loads : aucun code execute."""
+    try:
+        data = json.loads(share.map_data)
+    except json.JSONDecodeError:  # pragma: no cover - donnee corrompue
+        logger.exception("Snapshot illisible pour share_token=%s", share.share_token)
+        raise ShareNotFoundError("Le contenu de ce partage est illisible.") from None
+    if not isinstance(data, dict):  # pragma: no cover - donnee corrompue
+        raise ShareNotFoundError("Le contenu de ce partage est illisible.")
+    return data
+
+
+def update_share(
+    session: Session,
+    share_token: str,
+    *,
+    management_token: str,
+    title: str,
+    document: MapDocumentIn,
+) -> SharedMap:
+    share = _get_by_token(session, share_token)
+    if not verify_token(management_token, share.management_token_hash):
+        logger.warning("Tentative de mise a jour refusee share_token=%s", share_token)
+        raise ShareForbiddenError()
+
+    payload = serialize_map(document)
+    _guard_payload_size(payload)
+
+    share.title = (title or document.name or share.title)[: get_settings().max_title_length]
+    share.map_version = document.version
+    share.map_data = payload
+    share.updated_at = utcnow()
+    session.commit()
+    session.refresh(share)
+
+    logger.info("Partage mis a jour share_token=%s", share_token)
+    return share
+
+
+def delete_share(session: Session, share_token: str, *, management_token: str) -> None:
+    share = _get_by_token(session, share_token)
+    if not verify_token(management_token, share.management_token_hash):
+        logger.warning("Tentative de suppression refusee share_token=%s", share_token)
+        raise ShareForbiddenError()
+
+    session.delete(share)
+    session.commit()
+    logger.info("Partage supprime share_token=%s", share_token)

backend/app/services/tokens.py

@@ -0,0 +1,45 @@
+"""Generation et verification des jetons de partage.
+
+Deux secrets distincts sont produits a la creation d'un partage :
+
+* ``share_token``      : identifiant public, present dans /s/<token>, lecture seule.
+* ``management_token`` : secret de gestion (PUT/DELETE), jamais dans une URL,
+                         stocke uniquement dans l'IndexedDB du proprietaire.
+
+Seul le hash SHA-256 du management token est conserve en base.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import secrets
+
+# 12 octets -> 16 caracteres url-safe, ~96 bits d'entropie : non enumerable.
+SHARE_TOKEN_BYTES = 12
+# 32 octets -> ~256 bits d'entropie pour le secret de gestion.
+MANAGEMENT_TOKEN_BYTES = 32
+
+
+def generate_share_token() -> str:
+    return secrets.token_urlsafe(SHARE_TOKEN_BYTES)
+
+
+def generate_management_token() -> str:
+    return secrets.token_urlsafe(MANAGEMENT_TOKEN_BYTES)
+
+
+def hash_token(token: str) -> str:
+    """Hash du secret de gestion.
+
+    Le token est deja un secret aleatoire de haute entropie : un SHA-256 simple
+    suffit (pas de risque de force brute par dictionnaire, contrairement a un
+    mot de passe choisi par un humain).
+    """
+    return hashlib.sha256(token.encode("utf-8")).hexdigest()
+
+
+def verify_token(token: str, expected_hash: str) -> bool:
+    """Comparaison a temps constant."""
+    if not token or not expected_hash:
+        return False
+    return secrets.compare_digest(hash_token(token), expected_hash)