feat: v1

backend/internal/handlers/auth_handlers.go

@@ -0,0 +1,257 @@
+package handlers
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+
+	"pdfeditor/internal/auth"
+)
+
+// userResponse représente un utilisateur tel qu'exposé par l'API.
+type userResponse struct {
+	ID        string    `json:"id"`
+	Email     string    `json:"email"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// credentials est le corps des requêtes register/login.
+type credentials struct {
+	Email    string `json:"email"`
+	Password string `json:"password"`
+}
+
+// tokenPair regroupe un couple access/refresh token.
+type tokenPair struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+}
+
+// authResponse est la réponse de register/login.
+type authResponse struct {
+	User         userResponse `json:"user"`
+	AccessToken  string       `json:"access_token"`
+	RefreshToken string       `json:"refresh_token"`
+}
+
+// validateCredentials applique des règles minimales de validation.
+func validateCredentials(c credentials) (string, bool) {
+	email := strings.TrimSpace(strings.ToLower(c.Email))
+	if email == "" || !strings.Contains(email, "@") || len(email) > 254 {
+		return "", false
+	}
+	if len(c.Password) < 8 || len(c.Password) > 128 {
+		return "", false
+	}
+	return email, true
+}
+
+// Register crée un nouvel utilisateur et renvoie un couple de tokens.
+func (a *API) Register(w http.ResponseWriter, r *http.Request) {
+	var creds credentials
+	if !decodeJSON(w, r, &creds) {
+		return
+	}
+	email, ok := validateCredentials(creds)
+	if !ok {
+		writeError(w, http.StatusBadRequest, "email invalide ou mot de passe trop court (8 caractères minimum)")
+		return
+	}
+
+	hash, err := auth.HashPassword(creds.Password)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur interne")
+		return
+	}
+
+	ctx := r.Context()
+	var user userResponse
+	err = a.DB.QueryRow(ctx,
+		`INSERT INTO users (email, password_hash) VALUES ($1, $2)
+		 RETURNING id, email, created_at`,
+		email, hash,
+	).Scan(&user.ID, &user.Email, &user.CreatedAt)
+	if err != nil {
+		// Violation de contrainte d'unicité (email déjà pris).
+		if strings.Contains(err.Error(), "users_email_key") || strings.Contains(err.Error(), "duplicate key") {
+			writeError(w, http.StatusConflict, "cet email est déjà utilisé")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "erreur lors de la création du compte")
+		return
+	}
+
+	pair, err := a.issueTokens(ctx, user.ID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur lors de la génération des tokens")
+		return
+	}
+
+	writeJSON(w, http.StatusCreated, authResponse{User: user, AccessToken: pair.AccessToken, RefreshToken: pair.RefreshToken})
+}
+
+// Login authentifie un utilisateur et renvoie un couple de tokens.
+func (a *API) Login(w http.ResponseWriter, r *http.Request) {
+	var creds credentials
+	if !decodeJSON(w, r, &creds) {
+		return
+	}
+	email := strings.TrimSpace(strings.ToLower(creds.Email))
+	if email == "" || creds.Password == "" {
+		writeError(w, http.StatusBadRequest, "email et mot de passe requis")
+		return
+	}
+
+	ctx := r.Context()
+	var user userResponse
+	var passwordHash string
+	err := a.DB.QueryRow(ctx,
+		`SELECT id, email, created_at, password_hash FROM users WHERE email = $1`,
+		email,
+	).Scan(&user.ID, &user.Email, &user.CreatedAt, &passwordHash)
+	if err != nil {
+		// On ne distingue pas "email inconnu" de "mauvais mot de passe" (anti-énumération).
+		writeError(w, http.StatusUnauthorized, "identifiants invalides")
+		return
+	}
+
+	if !auth.CheckPassword(passwordHash, creds.Password) {
+		writeError(w, http.StatusUnauthorized, "identifiants invalides")
+		return
+	}
+
+	pair, err := a.issueTokens(ctx, user.ID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur lors de la génération des tokens")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, authResponse{User: user, AccessToken: pair.AccessToken, RefreshToken: pair.RefreshToken})
+}
+
+// refreshRequest est le corps de la requête de rafraîchissement.
+type refreshRequest struct {
+	RefreshToken string `json:"refresh_token"`
+}
+
+// Refresh échange un refresh token valide contre un nouveau couple de tokens.
+// L'ancien refresh token est révoqué (rotation).
+func (a *API) Refresh(w http.ResponseWriter, r *http.Request) {
+	var req refreshRequest
+	if !decodeJSON(w, r, &req) {
+		return
+	}
+	if req.RefreshToken == "" {
+		writeError(w, http.StatusBadRequest, "refresh_token requis")
+		return
+	}
+
+	ctx := r.Context()
+	hash := auth.HashToken(req.RefreshToken)
+
+	var tokenID, userID string
+	var expiresAt time.Time
+	var revoked bool
+	err := a.DB.QueryRow(ctx,
+		`SELECT id, user_id, expires_at, revoked FROM refresh_tokens WHERE token_hash = $1`,
+		hash,
+	).Scan(&tokenID, &userID, &expiresAt, &revoked)
+	if err != nil {
+		writeError(w, http.StatusUnauthorized, "refresh token invalide")
+		return
+	}
+	if revoked || time.Now().After(expiresAt) {
+		writeError(w, http.StatusUnauthorized, "refresh token expiré ou révoqué")
+		return
+	}
+
+	// Rotation : on révoque l'ancien token avant d'en émettre un nouveau.
+	if _, err := a.DB.Exec(ctx, `UPDATE refresh_tokens SET revoked = TRUE WHERE id = $1`, tokenID); err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur interne")
+		return
+	}
+
+	pair, err := a.issueTokens(ctx, userID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur lors de la génération des tokens")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, pair)
+}
+
+// Logout révoque le refresh token fourni. Auth requise.
+func (a *API) Logout(w http.ResponseWriter, r *http.Request) {
+	var req refreshRequest
+	// Le refresh token peut être fourni dans le corps ; s'il est absent, on
+	// révoque malgré tout tous les tokens de l'utilisateur courant.
+	_ = decodeJSON(w, r, &req)
+	userID := userIDFromContext(r.Context())
+
+	ctx := r.Context()
+	if req.RefreshToken != "" {
+		hash := auth.HashToken(req.RefreshToken)
+		_, err := a.DB.Exec(ctx,
+			`UPDATE refresh_tokens SET revoked = TRUE WHERE token_hash = $1 AND user_id = $2`,
+			hash, userID)
+		if err != nil {
+			writeError(w, http.StatusInternalServerError, "erreur interne")
+			return
+		}
+	} else {
+		// Pas de token précisé : on révoque toutes les sessions de l'utilisateur.
+		if _, err := a.DB.Exec(ctx,
+			`UPDATE refresh_tokens SET revoked = TRUE WHERE user_id = $1 AND revoked = FALSE`,
+			userID); err != nil {
+			writeError(w, http.StatusInternalServerError, "erreur interne")
+			return
+		}
+	}
+
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// Me renvoie le profil de l'utilisateur authentifié.
+func (a *API) Me(w http.ResponseWriter, r *http.Request) {
+	userID := userIDFromContext(r.Context())
+	var user userResponse
+	err := a.DB.QueryRow(r.Context(),
+		`SELECT id, email, created_at FROM users WHERE id = $1`, userID,
+	).Scan(&user.ID, &user.Email, &user.CreatedAt)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			writeError(w, http.StatusNotFound, "utilisateur introuvable")
+			return
+		}
+		writeError(w, http.StatusInternalServerError, "erreur interne")
+		return
+	}
+	writeJSON(w, http.StatusOK, user)
+}
+
+// issueTokens génère un access token et un refresh token, persiste ce dernier
+// (hashé) en base, et retourne le couple.
+func (a *API) issueTokens(ctx context.Context, userID string) (tokenPair, error) {
+	accessToken, err := a.Auth.GenerateAccessToken(userID)
+	if err != nil {
+		return tokenPair{}, err
+	}
+
+	refreshToken, refreshHash, expiresAt, err := a.Auth.GenerateRefreshToken()
+	if err != nil {
+		return tokenPair{}, err
+	}
+
+	_, err = a.DB.Exec(ctx,
+		`INSERT INTO refresh_tokens (user_id, token_hash, expires_at) VALUES ($1, $2, $3)`,
+		userID, refreshHash, expiresAt)
+	if err != nil {
+		return tokenPair{}, err
+	}
+
+	return tokenPair{AccessToken: accessToken, RefreshToken: refreshToken}, nil
+}

backend/internal/handlers/document_handlers.go

@@ -0,0 +1,307 @@
+package handlers
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/jackc/pgx/v5"
+)
+
+// pdfMagic est l'en-tête attendu en début de fichier PDF.
+var pdfMagic = []byte("%PDF-")
+
+// documentResponse représente les métadonnées d'un document exposées par l'API.
+type documentResponse struct {
+	ID        string    `json:"id"`
+	Name      string    `json:"name"`
+	Size      int64     `json:"size"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+// ListDocuments renvoie la liste des documents de l'utilisateur courant.
+func (a *API) ListDocuments(w http.ResponseWriter, r *http.Request) {
+	userID := userIDFromContext(r.Context())
+
+	rows, err := a.DB.Query(r.Context(),
+		`SELECT id, name, size, created_at, updated_at FROM documents
+		 WHERE user_id = $1 ORDER BY updated_at DESC`, userID)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur lors de la récupération des documents")
+		return
+	}
+	defer rows.Close()
+
+	docs := make([]documentResponse, 0)
+	for rows.Next() {
+		var d documentResponse
+		if err := rows.Scan(&d.ID, &d.Name, &d.Size, &d.CreatedAt, &d.UpdatedAt); err != nil {
+			writeError(w, http.StatusInternalServerError, "erreur de lecture")
+			return
+		}
+		docs = append(docs, d)
+	}
+	if rows.Err() != nil {
+		writeError(w, http.StatusInternalServerError, "erreur de lecture")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, map[string][]documentResponse{"documents": docs})
+}
+
+// CreateDocument enregistre un nouveau PDF uploadé en multipart/form-data.
+func (a *API) CreateDocument(w http.ResponseWriter, r *http.Request) {
+	userID := userIDFromContext(r.Context())
+
+	file, header, name, ok := a.readUpload(w, r, true)
+	if !ok {
+		return
+	}
+	defer file.Close()
+
+	if name == "" {
+		name = header.Filename
+	}
+	if name == "" {
+		name = "document.pdf"
+	}
+
+	// On lit l'en-tête pour vérifier le type, puis on reconstitue le flux complet.
+	reader, ok := validatePDF(w, file)
+	if !ok {
+		return
+	}
+
+	fileID, size, err := a.Storage.Save(reader)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur lors de l'enregistrement du fichier")
+		return
+	}
+
+	var d documentResponse
+	err = a.DB.QueryRow(r.Context(),
+		`INSERT INTO documents (user_id, name, file_path, size)
+		 VALUES ($1, $2, $3, $4)
+		 RETURNING id, name, size, created_at, updated_at`,
+		userID, name, fileID, size,
+	).Scan(&d.ID, &d.Name, &d.Size, &d.CreatedAt, &d.UpdatedAt)
+	if err != nil {
+		_ = a.Storage.Delete(fileID)
+		writeError(w, http.StatusInternalServerError, "erreur lors de l'enregistrement")
+		return
+	}
+
+	writeJSON(w, http.StatusCreated, d)
+}
+
+// GetDocument renvoie les métadonnées d'un document.
+func (a *API) GetDocument(w http.ResponseWriter, r *http.Request) {
+	userID := userIDFromContext(r.Context())
+	id := chi.URLParam(r, "id")
+
+	var d documentResponse
+	err := a.DB.QueryRow(r.Context(),
+		`SELECT id, name, size, created_at, updated_at FROM documents
+		 WHERE id = $1 AND user_id = $2`, id, userID,
+	).Scan(&d.ID, &d.Name, &d.Size, &d.CreatedAt, &d.UpdatedAt)
+	if err != nil {
+		a.handleDocNotFound(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, d)
+}
+
+// GetDocumentFile renvoie le binaire PDF d'un document.
+func (a *API) GetDocumentFile(w http.ResponseWriter, r *http.Request) {
+	userID := userIDFromContext(r.Context())
+	id := chi.URLParam(r, "id")
+
+	var name, filePath string
+	err := a.DB.QueryRow(r.Context(),
+		`SELECT name, file_path FROM documents WHERE id = $1 AND user_id = $2`, id, userID,
+	).Scan(&name, &filePath)
+	if err != nil {
+		a.handleDocNotFound(w, err)
+		return
+	}
+
+	f, err := a.Storage.Open(filePath)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "fichier introuvable sur le disque")
+		return
+	}
+	defer f.Close()
+
+	w.Header().Set("Content-Type", "application/pdf")
+	w.Header().Set("Content-Disposition", "inline; filename=\""+sanitizeFilename(name)+"\"")
+	w.WriteHeader(http.StatusOK)
+	_, _ = io.Copy(w, f)
+}
+
+// UpdateDocument met à jour le binaire et/ou le nom d'un document.
+func (a *API) UpdateDocument(w http.ResponseWriter, r *http.Request) {
+	userID := userIDFromContext(r.Context())
+	id := chi.URLParam(r, "id")
+
+	// On vérifie d'abord que le document appartient à l'utilisateur.
+	var filePath string
+	err := a.DB.QueryRow(r.Context(),
+		`SELECT file_path FROM documents WHERE id = $1 AND user_id = $2`, id, userID,
+	).Scan(&filePath)
+	if err != nil {
+		a.handleDocNotFound(w, err)
+		return
+	}
+
+	file, _, name, ok := a.readUpload(w, r, false)
+	if !ok {
+		return
+	}
+
+	hasFile := file != nil
+	if hasFile {
+		defer file.Close()
+	}
+
+	// Au moins un des deux champs doit être fourni.
+	if !hasFile && name == "" {
+		writeError(w, http.StatusBadRequest, "fournir un nouveau fichier et/ou un nouveau nom")
+		return
+	}
+
+	if hasFile {
+		reader, valid := validatePDF(w, file)
+		if !valid {
+			return
+		}
+		size, werr := a.Storage.Overwrite(filePath, reader)
+		if werr != nil {
+			writeError(w, http.StatusInternalServerError, "erreur lors de l'écriture du fichier")
+			return
+		}
+		if name != "" {
+			_, err = a.DB.Exec(r.Context(),
+				`UPDATE documents SET size = $1, name = $2, updated_at = now() WHERE id = $3`,
+				size, name, id)
+		} else {
+			_, err = a.DB.Exec(r.Context(),
+				`UPDATE documents SET size = $1, updated_at = now() WHERE id = $2`,
+				size, id)
+		}
+	} else {
+		_, err = a.DB.Exec(r.Context(),
+			`UPDATE documents SET name = $1, updated_at = now() WHERE id = $2`,
+			name, id)
+	}
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur lors de la mise à jour")
+		return
+	}
+
+	var d documentResponse
+	err = a.DB.QueryRow(r.Context(),
+		`SELECT id, name, size, created_at, updated_at FROM documents WHERE id = $1`, id,
+	).Scan(&d.ID, &d.Name, &d.Size, &d.CreatedAt, &d.UpdatedAt)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "erreur interne")
+		return
+	}
+	writeJSON(w, http.StatusOK, d)
+}
+
+// DeleteDocument supprime un document (base + fichier).
+func (a *API) DeleteDocument(w http.ResponseWriter, r *http.Request) {
+	userID := userIDFromContext(r.Context())
+	id := chi.URLParam(r, "id")
+
+	var filePath string
+	err := a.DB.QueryRow(r.Context(),
+		`DELETE FROM documents WHERE id = $1 AND user_id = $2 RETURNING file_path`,
+		id, userID,
+	).Scan(&filePath)
+	if err != nil {
+		a.handleDocNotFound(w, err)
+		return
+	}
+
+	// Suppression best-effort du fichier disque (l'entrée en base est déjà supprimée).
+	_ = a.Storage.Delete(filePath)
+	w.WriteHeader(http.StatusNoContent)
+}
+
+// handleDocNotFound traduit une erreur de requête en 404 ou 500.
+func (a *API) handleDocNotFound(w http.ResponseWriter, err error) {
+	if errors.Is(err, pgx.ErrNoRows) {
+		writeError(w, http.StatusNotFound, "document introuvable")
+		return
+	}
+	writeError(w, http.StatusInternalServerError, "erreur interne")
+}
+
+// readUpload parse un formulaire multipart et retourne le fichier (peut être nil
+// si fileRequired est false) ainsi que le champ "name".
+// En cas d'erreur, il écrit la réponse et retourne ok=false.
+func (a *API) readUpload(w http.ResponseWriter, r *http.Request, fileRequired bool) (multipart.File, *multipart.FileHeader, string, bool) {
+	// Limite la taille du corps lu pour éviter l'épuisement mémoire/disque.
+	r.Body = http.MaxBytesReader(w, r.Body, maxUploadSize+(1<<20))
+
+	if err := r.ParseMultipartForm(maxUploadSize); err != nil {
+		writeError(w, http.StatusBadRequest, "formulaire multipart invalide ou fichier trop volumineux (max 50 Mo)")
+		return nil, nil, "", false
+	}
+
+	name := strings.TrimSpace(r.FormValue("name"))
+
+	file, header, err := r.FormFile("file")
+	if err != nil {
+		if fileRequired {
+			writeError(w, http.StatusBadRequest, "le champ 'file' est obligatoire")
+			return nil, nil, "", false
+		}
+		// Pas de fichier mais ce n'est pas requis (cas PUT nom seul).
+		return nil, nil, name, true
+	}
+
+	if header.Size > maxUploadSize {
+		file.Close()
+		writeError(w, http.StatusBadRequest, "fichier trop volumineux (max 50 Mo)")
+		return nil, nil, "", false
+	}
+
+	return file, header, name, true
+}
+
+// validatePDF vérifie l'en-tête %PDF- et retourne un lecteur reconstitué
+// (en-tête + reste du flux). En cas d'échec, écrit la réponse et retourne ok=false.
+func validatePDF(w http.ResponseWriter, file multipart.File) (io.Reader, bool) {
+	head := make([]byte, len(pdfMagic))
+	n, err := io.ReadFull(file, head)
+	if err != nil && err != io.ErrUnexpectedEOF {
+		writeError(w, http.StatusBadRequest, "fichier illisible")
+		return nil, false
+	}
+	if n < len(pdfMagic) || !bytes.Equal(head[:n], pdfMagic) {
+		writeError(w, http.StatusBadRequest, "le fichier n'est pas un PDF valide")
+		return nil, false
+	}
+	// On recolle l'en-tête déjà lu au reste du flux.
+	return io.MultiReader(bytes.NewReader(head[:n]), file), true
+}
+
+// sanitizeFilename retire les caractères problématiques d'un nom de fichier
+// destiné à l'en-tête Content-Disposition.
+func sanitizeFilename(name string) string {
+	name = strings.ReplaceAll(name, "\"", "")
+	name = strings.ReplaceAll(name, "\n", "")
+	name = strings.ReplaceAll(name, "\r", "")
+	if name == "" {
+		return "document.pdf"
+	}
+	return name
+}

backend/internal/handlers/handlers.go

@@ -0,0 +1,51 @@
+// Package handlers contient les handlers HTTP et le routeur de l'API.
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"pdfeditor/internal/auth"
+	"pdfeditor/internal/storage"
+)
+
+// maxUploadSize est la taille maximale autorisée pour un upload de PDF (50 Mo).
+const maxUploadSize = 50 << 20
+
+// API regroupe les dépendances partagées par les handlers.
+type API struct {
+	DB      *pgxpool.Pool
+	Auth    *auth.Manager
+	Storage *storage.Store
+}
+
+// New crée une instance d'API.
+func New(db *pgxpool.Pool, authMgr *auth.Manager, store *storage.Store) *API {
+	return &API{DB: db, Auth: authMgr, Storage: store}
+}
+
+// writeJSON sérialise v en JSON avec le code de statut donné.
+func writeJSON(w http.ResponseWriter, status int, v interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	if v != nil {
+		_ = json.NewEncoder(w).Encode(v)
+	}
+}
+
+// writeError renvoie une erreur au format { "error": "..." }.
+func writeError(w http.ResponseWriter, status int, message string) {
+	writeJSON(w, status, map[string]string{"error": message})
+}
+
+// decodeJSON décode le corps JSON de la requête dans v.
+// Retourne false (et écrit une 400) en cas d'échec.
+func decodeJSON(w http.ResponseWriter, r *http.Request, v interface{}) bool {
+	if err := json.NewDecoder(r.Body).Decode(v); err != nil {
+		writeError(w, http.StatusBadRequest, "corps de requête JSON invalide")
+		return false
+	}
+	return true
+}

backend/internal/handlers/middleware.go

@@ -0,0 +1,42 @@
+package handlers
+
+import (
+	"context"
+	"net/http"
+	"strings"
+)
+
+// ctxKey est un type privé pour les clefs de contexte (évite les collisions).
+type ctxKey string
+
+// userIDKey est la clef de contexte sous laquelle on stocke l'ID utilisateur authentifié.
+const userIDKey ctxKey = "userID"
+
+// RequireAuth est un middleware qui valide l'access token Bearer et injecte
+// l'ID utilisateur dans le contexte de la requête.
+func (a *API) RequireAuth(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		header := r.Header.Get("Authorization")
+		const prefix = "Bearer "
+		if !strings.HasPrefix(header, prefix) {
+			writeError(w, http.StatusUnauthorized, "en-tête Authorization manquant ou invalide")
+			return
+		}
+		tokenString := strings.TrimSpace(strings.TrimPrefix(header, prefix))
+
+		claims, err := a.Auth.ParseAccessToken(tokenString)
+		if err != nil {
+			writeError(w, http.StatusUnauthorized, "token invalide ou expiré")
+			return
+		}
+
+		ctx := context.WithValue(r.Context(), userIDKey, claims.UserID)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+// userIDFromContext récupère l'ID utilisateur stocké par RequireAuth.
+func userIDFromContext(ctx context.Context) string {
+	id, _ := ctx.Value(userIDKey).(string)
+	return id
+}

backend/internal/handlers/router.go

@@ -0,0 +1,64 @@
+package handlers
+
+import (
+	"net/http"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/cors"
+)
+
+// Router construit le routeur HTTP complet de l'API.
+// corsOrigin est l'origine autorisée pour les requêtes cross-origin.
+func (a *API) Router(corsOrigin string) http.Handler {
+	r := chi.NewRouter()
+
+	r.Use(middleware.RealIP)
+	r.Use(middleware.Logger)
+	r.Use(middleware.Recoverer)
+
+	// Configuration CORS pour l'origine du frontend.
+	allowedOrigins := []string{"*"}
+	if corsOrigin != "" {
+		allowedOrigins = []string{corsOrigin}
+	}
+	r.Use(cors.Handler(cors.Options{
+		AllowedOrigins:   allowedOrigins,
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type"},
+		ExposedHeaders:   []string{"Content-Disposition"},
+		AllowCredentials: true,
+		MaxAge:           300,
+	}))
+
+	r.Route("/api", func(r chi.Router) {
+		r.Get("/health", a.Health)
+
+		// Authentification (routes publiques).
+		r.Post("/auth/register", a.Register)
+		r.Post("/auth/login", a.Login)
+		r.Post("/auth/refresh", a.Refresh)
+
+		// Routes protégées.
+		r.Group(func(r chi.Router) {
+			r.Use(a.RequireAuth)
+
+			r.Post("/auth/logout", a.Logout)
+			r.Get("/me", a.Me)
+
+			r.Get("/documents", a.ListDocuments)
+			r.Post("/documents", a.CreateDocument)
+			r.Get("/documents/{id}", a.GetDocument)
+			r.Get("/documents/{id}/file", a.GetDocumentFile)
+			r.Put("/documents/{id}", a.UpdateDocument)
+			r.Delete("/documents/{id}", a.DeleteDocument)
+		})
+	})
+
+	return r
+}
+
+// Health répond au healthcheck.
+func (a *API) Health(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}