Aller au contenu

Cycle de vie d'un compte

Cette page explique pourquoi l'état d'un compte Kirexo produit les effets qu'il produit, au-delà de la seule connexion. Les routes, méthodes et messages exacts sont dans la référence de la gestion des comptes ; les gestes d'administration, dans le guide Gérer les comptes utilisateurs.

Le cycle en un schéma

Un compte naît d'une invitation acceptée, vit entre deux états, Actif et Désactivé, peut être mis de côté à l'état Supprimé, et n'est détruit qu'au terme d'un geste distinct. Chaque flèche est un geste d'administrateur ; entre parenthèses, la variante de bouton qui le porte à l'écran.

stateDiagram-v2
    direction LR
    state "Désactivé" as Desactive
    state "Supprimé" as Supprime
    state "Effacé" as Efface
    [*] --> Invitation : Inviter (btn-primary, écran Invitations)
    Invitation --> Invitation : Renvoyer (btn-secondary, délai 5 min)
    Invitation --> [*] : Supprimer l'invitation (btn-danger, suppression réelle)
    Invitation --> Actif : Lien cliqué + prénom + mot de passe
    Actif --> Desactive : Désactiver (btn-danger + justification)
    Desactive --> Actif : Réactiver (btn-secondary)
    Actif --> Supprime : Supprimer (btn-danger, ressaisie e-mail)
    Desactive --> Supprime : Supprimer (btn-danger, ressaisie e-mail)
    Supprime --> Desactive : Réintégrer (btn-secondary, jamais Actif)
    Supprime --> Efface : Supprimer définitivement (bo-btn-purge, depuis l'encart)
    Efface --> [*]
    note right of Actif
        Seul état avec présence publique
        et connexion possible (isActive)
    end note
    note right of Supprime
        Listé dans l'encart replié
        (details natif, sans JS)
    end note

Trois propriétés se lisent directement sur le schéma, et le reste de la page les justifie :

  • aucune flèche ne mène de Supprimé à Actif : la réintégration passe toujours par Désactivé ;
  • aucune flèche ne mène d'Actif ou de Désactivé à Effacé : la destruction exige d'être passé par Supprimé ;
  • le seul état qui donne accès et présence publique est Actif.

Les variantes de boutons ne sont pas décoratives. Seuls les gestes qui ouvrent quelque chose (inviter) sont primaires ; les gestes de retrait sont en btn-danger, et l'effacement a sa propre variante pleine, bo-btn-purge, pour ne jamais ressembler à une suppression logique.

L'invitation n'est pas un compte

L'invitation vit dans sa propre table (src/Entity/Invitation.php), avec sa propre liste. Aucun User n'existe avant que l'invité ait cliqué le lien et choisi son prénom et son mot de passe.

L'autre option, créer tout de suite un compte « en attente » et lui laisser définir son mot de passe plus tard, paraît plus simple : une seule table, une seule liste. Elle aurait pourtant contaminé tout le modèle.

  • Un compte sans mot de passe. User::$password aurait dû devenir nullable, et chaque lecture du mot de passe, du formulaire de connexion au cookie « Se souvenir de moi », aurait dû prévoir le cas.
  • Un quatrième état. Un compte « invité » n'est ni actif, ni désactivé, ni supprimé. Chaque surface qui raisonne sur isActive() aurait dû apprendre à le distinguer.
  • L'admin qui remplit à la place de la personne. Un compte existe avec un prénom : quelqu'un doit le saisir. En le laissant à l'invité, l'administration ne touche jamais aux informations personnelles d'autrui, conformément à la règle « l'admin gère des comptes, pas leurs données ».

Garder l'invitation à part a une contrepartie assumée : une invitation n'a pas les gestes d'un compte. On ne la désactive pas, on la supprime, réellement, puisqu'il n'y a rien à conserver. On ne la réintègre pas non plus : on en émet une autre. Et une invitation d'administrateur ne compte pas comme un administrateur, puisqu'aucun compte n'existe derrière un lien que personne n'a encore cliqué.

Le lien lui-même est borné : 72 heures, en dur, et un renvoi au plus toutes les 5 minutes. Une durée fixe évite un réglage que personne ne saurait choisir ; le délai de renvoi évite qu'un double clic ou un administrateur impatient n'envoie une rafale d'e-mails, dont un seul lien fonctionnerait.

Un seul prédicat pour dire « ce compte existe pour le monde »

Un compte porte deux dates facultatives : disabledAt (désactivation) et deletedAt (suppression logique). Plutôt que de laisser chaque écran interpréter ces deux colonnes, le code n'en tire qu'une seule question : User::isActive() (src/Entity/User.php), vraie si et seulement si les deux dates sont nulles.

Ce choix a une conséquence directe : tout ce qui dépend de l'état d'un compte ne distingue pas pourquoi il est inactif. Désactivé ou supprimé, le compte est simplement « non actif », et c'est cette seule information qui gouverne la connexion (voir Couper l'accès d'un compte) comme la présence publique décrite ci-dessous.

La suppression définitive, elle, ne pose pas de date : elle efface la ligne. Elle fait l'objet de la dernière partie, Effacer pour de bon.

Effacement public

La règle

Rien de ce qui appartient à un compte non actif n'est visible publiquement. Ses sites web répondent 404, ses articles disparaissent du fil d'accueil de la plateforme. La réactivation rétablit exactement l'état antérieur : rien n'a été supprimé, seule la visibilité a été coupée.

La règle est volontairement large. Une désactivation est une mesure de modération : si elle laissait en ligne le site de la personne, elle ne couperait que la moitié de ce qui compte. À l'inverse, supprimer le contenu rendrait la mesure irréversible, ce qu'elle ne doit pas être.

flowchart LR
    subgraph Public
      A["Fil d'accueil (app_home)"] --> R1["findPublishedForPublic()<br/>auteurs actifs seulement"]
      W["Site du plugin Web<br/>(toutes les routes)"] --> G["Gate : SitePublicAccessChecker<br/>propriétaire actif ?"]
      G --> F["PublishedWebArticleFinder<br/>auteur actif (défense en profondeur)"]
    end
    subgraph Admin
      D["Dashboard de modération"] --> R2["findPublishedForModeration()<br/>sans filtre"]
    end

Un gate unique plutôt qu'un filtre global

L'idée la plus immédiate serait un SQLFilter Doctrine : un filtre global, ajouté à toutes les requêtes, qui écarterait les lignes appartenant à un compte non actif. Il a été écarté pour trois raisons.

  • L'hydratation casse. Les associations vers l'auteur sont non nullables. Si le filtre masque l'auteur alors que l'article est chargé, Doctrine ne trouve pas l'entité liée et lève une EntityNotFoundException au moment où le code la lit.
  • Le filtre est incomplet. Il s'applique aux requêtes, pas à l'identity map : une entité déjà chargée dans la requête en cours reste accessible, filtrée ou non.
  • Il aveugle tout le monde. Un filtre global s'applique aussi à l'espace d'administration, qui doit précisément continuer à voir ce qu'il vient de retirer du public (voir plus bas).

Kirexo s'appuie donc sur le point de passage obligé qui existait déjà : la résolution du domaine d'un site. Toute requête sur un domaine de site traverse HostResolutionSubscriber, qui interroge SitePublicAccessCheckerInterface avant de rendre quoi que ce soit (voir Multi-tenant : résolution d'un domaine vers un site). Ce gate vérifiait déjà que le plugin Web était activé pour le propriétaire ; il vérifie désormais d'abord que ce propriétaire est actif.

Un seul contrôle suffit alors pour toutes les surfaces du site : accueil, articles, pages spéciales, feuille de style, sonde de santé. Les routes publiques du bundle ne répondent que si le gate a posé l'attribut _kirexo_public_site ; en cas de refus, aucune ne correspond, et aucun cache n'est même lu.

Le cas des pages spéciales illustre l'intérêt de cette position. Une page spéciale n'a pas d'auteur : elle appartient à un site, qui appartient à un utilisateur (voir Pages spéciales du plugin web). La filtrer en SQL imposerait au plugin une jointure de ses tables vers la table "user" du cœur, c'est-à-dire un couplage de schéma que l'architecture en plugins cherche à éviter. Le gate, lui, raisonne sur le site entier : les pages spéciales sont couvertes sans qu'on y touche.

Le contrat garde son nom, isPluginEnabledForOwner(), alors que sa sémantique s'élargit. Changer la signature d'une interface de Kirexo\Plugin\Contracts casserait tout plugin tiers qui l'implémente ou l'appelle ; le nom est un peu en retrait de ce qu'il fait, mais la référence du contrat le documente.

Un 404 qui ne dit rien

Le refus prend la forme d'un 404, identique à celui d'un domaine inconnu ou d'un plugin non activé. Un visiteur ne peut pas en déduire qu'un compte a été désactivé. C'est la même logique que pour la connexion, où un compte désactivé reçoit le message d'identifiants invalides : l'état d'un compte ne regarde que son titulaire et l'administration.

Défense en profondeur dans les requêtes du plugin

Le gate coupe déjà le site entier. Les trois requêtes SQL natives qui lisent les articles d'un site (PublishedWebArticleFinder : page d'articles, comptage, article unitaire) exigent pourtant, elles aussi, un auteur actif, par une jointure sur "user" qui reprend disabled_at IS NULL AND deleted_at IS NULL.

Ce filtre ne sert à rien aujourd'hui, et c'est voulu. Il protège contre un appelant futur qui lirait ces articles hors du parcours de résolution de domaine : un flux, une API, une tâche de fond. Sans lui, la règle ne tiendrait que par l'ordre d'exécution d'un abonné kernel.request, ce qui est une garantie fragile pour une règle de modération.

Ce filtre réplique en SQL le prédicat User::isActive(). C'est une exception assumée au principe d'une seule autorité : une requête SQL ne peut pas appeler une méthode PHP. La réplique est confinée à une constante unique dans le fichier, et au fil d'accueil côté cœur. À noter : "user" doit y être écrit entre guillemets, car user seul désigne en PostgreSQL l'utilisateur de base de données courant.

La modération n'est pas aveuglée

L'ancienne méthode findPublished() du dépôt d'articles a été retirée et remplacée par deux méthodes au nom explicite :

  • findPublishedForPublic(), qui écarte les auteurs non actifs, pour le fil d'accueil ;
  • findPublishedForModeration(), sans filtre, pour le tableau de bord de l'administration.

Un filtre unique appliqué partout aurait eu un effet pervers : un administrateur qui désactive un compte verrait aussitôt ses articles disparaître de son propre poste de modération, et ne pourrait plus constater ce qu'il vient de retirer du public. La séparation en deux méthodes garde les deux besoins visibles.

Le retrait de l'ancienne méthode, plutôt que son maintien à côté des deux nouvelles, force chaque appelant à choisir sa surface. Un appel oublié vise une méthode qui n'existe plus : l'analyse statique (PHPStan) le signale, au lieu de laisser un écran public hériter silencieusement de la variante non filtrée.

Pourquoi l'invalidation du cache vit dans le plugin

Le rendu public d'un site est mis en cache par tag de site (voir Rendu public d'un site). Le cache n'est pas la barrière : le gate refuse la requête avant toute lecture. L'invalider à la désactivation évite toutefois de conserver, pendant la coupure, des copies rendues d'un contenu qui n'est plus public ; l'invalider à la réactivation garantit que le site repart d'un rendu recalculé.

Ce travail ne peut pas être fait par le cœur. Le cache du plugin Web se manipule par site (SiteCacheInterface::invalidateSite(Site)), et le cœur ne connaît pas l'entité Site : c'est une donnée du plugin. Le cœur se contente donc d'annoncer le changement par deux événements, UserAccessRevoked et UserAccessRestored, qui ne portent que l'identifiant du compte. Le plugin Web s'y abonne et invalide chacun de ses sites. Un futur plugin qui tient lui aussi une copie publique (flux, fédération) pourra s'y abonner de la même manière, sans modification du cœur. C'est le principe décrit dans Architecture des plugins de diffusion.

Pourquoi des événements synchrones, dans la transaction

Ces deux événements ne passent pas par Messenger : ils sont dispatchés de façon synchrone, à l'intérieur de la transaction qui écrit l'état du compte, juste après le flush. Deux propriétés en découlent.

  • Les abonnés voient l'état déjà écrit, sur la même connexion.
  • Un abonné qui échoue fait échouer toute l'opération : l'état du compte et la note de modération sont annulés, et l'administrateur voit l'erreur. Il n'existe pas d'état intermédiaire où le compte serait désactivé mais un plugin n'aurait pas réagi.

L'e-mail de justification, lui, part après le commit. Si un abonné échoue, l'exception interrompt l'opération avant cet envoi : le titulaire ne reçoit jamais l'annonce d'une désactivation qui n'a pas eu lieu.

Le compromis est connu : une invalidation de cache n'est pas transactionnelle. Si un abonné invalide son cache puis qu'un autre échoue, le rollback n'y revient pas. Le cache a été vidé pour rien, ce qui est sans conséquence : il se reconstruit à la requête suivante. L'inverse, un cache périmé servi pendant la coupure, est impossible puisque le gate passe avant.

Ce qui reste visible quelques minutes

La feuille de style publique d'un site (/site.css) est servie avec Cache-Control: public, max-age=300. Un navigateur ou un proxy qui l'a déjà reçue peut la resservir jusqu'à 5 minutes après la désactivation. Ce résiduel a été accepté : il s'agit de CSS, pas de contenu, et toute requête qui atteint le serveur reçoit le 404.

Supprimer sans détruire

Une date plutôt qu'un DELETE

Supprimer un compte, dans Kirexo, c'est poser une date dans deletedAt. Aucune ligne ne disparaît : le compte, ses carnets, ses articles, ses sites et ses motifs de modération restent en base. Ce choix répond à trois besoins.

  • Pouvoir revenir en arrière. Une suppression est un geste lourd, et c'est précisément le genre de geste que l'on regrette : mauvais compte, décision prise trop vite, titulaire qui conteste. Une suppression réelle rendrait l'erreur définitive. Une date s'efface.
  • Garder la trace. Le motif d'une suppression, et ceux des désactivations qui l'ont précédée, restent rattachés au compte. Détruire le compte détruirait aussi l'historique qui explique la décision.
  • Ne pas trancher le sort des données rattachées. Un DELETE sur la table "user" devrait décider du sort de tout ce qui y est rattaché, jusque dans les tables des plugins. C'est un travail à part entière, avec ses propres risques : il relève de la suppression définitive, geste distinct et ultérieur.

Pour le reste du système, un compte supprimé est simplement non actif, comme un compte désactivé. Toutes les protections décrites plus haut s'appliquent sans une ligne de plus : connexion refusée, sessions coupées, sites en 404, articles retirés du fil d'accueil. C'est le bénéfice du prédicat unique isActive().

La suppression ne touche pas disabledAt. Un compte désactivé puis supprimé garde sa date de désactivation. Les deux informations sont indépendantes, et c'est ce qui permet à la réintégration de restituer l'état antérieur (voir plus bas).

L'adresse e-mail d'un compte supprimé reste occupée. Elle ne peut pas être réinvitée : sinon, une nouvelle personne recevrait un compte neuf sous une identité qui en désigne déjà un autre, que l'on peut encore réintégrer. Seul l'effacement définitif la libère, parce qu'il n'y a alors plus rien à réintégrer.

Où vivent les comptes supprimés

Un compte supprimé n'a plus sa place dans la liste de travail de l'administration : il n'est ni actif ni à réactiver. Il ne doit pas non plus devenir introuvable, sans quoi personne ne pourrait le réintégrer. Il vit donc dans un encart séparé, replié par défaut, sous la liste principale. L'encart est un <details> natif : il se déplie sans JavaScript, comme les filtres de la liste sont de simples liens.

Un avertissement chiffré, confirmé par l'adresse

La désactivation se confirme d'un clic ; la suppression demande de retaper l'adresse du compte. L'écart est voulu. Désactiver est un geste de modération courant, qui se défait par une réactivation. Supprimer sort le compte de la liste de travail et le rapproche de l'effacement définitif. Retaper l'adresse oblige à lire l'identité du compte visé, et un clic machinal ne suffit plus. Le même raisonnement écarte le confirm() JavaScript : une boîte de dialogue s'accepte par réflexe, et elle disparaît sans JavaScript.

L'écran d'avertissement chiffre ce que le compte possède : carnets, articles et articles publiés, présence publique, rôles. Il ne montre que des nombres. L'administration gère des comptes, jamais leur contenu : lister les titres d'articles pour éclairer la décision aurait rompu cette règle pour la commodité d'un seul écran.

La présence publique, déclarée par les plugins

Avant de supprimer, l'administrateur doit savoir ce qui cessera d'être servi : quels domaines vont répondre 404, par exemple. Le cœur ne peut pas le savoir seul. Les domaines sont une donnée du plugin Web, et un futur plugin de fédération aurait ses propres identifiants publics.

Plutôt que d'apprendre au cœur à lire les tables de chaque plugin, Kirexo définit une capability optionnelle, PublicPresenceInventoryInterface : un plugin qui donne une présence publique à un compte l'implémente et renvoie des libellés, des chaînes affichées telles quelles. Le cœur interroge le registre des plugins et agrège les réponses, sans citer aucune classe de plugin. C'est le même mécanisme que pour les entrées de menu (voir Architecture des plugins de diffusion). Le terme volontairement vague de « libellé » laisse chaque plugin décrire sa présence dans ses propres mots : un nom de domaine pour l'un, un handle pour l'autre.

Le plugin Web renvoie tous les domaines rattachés aux sites du compte, quel que soit leur état et même si le plugin n'est pas activé pour lui. La question posée n'est pas « qu'est-ce qui est servi à cet instant ? », mais « qu'est-ce qui est configuré au nom de ce compte ? ». Une réponse fondée sur l'état du moment serait vraie une seconde et trompeuse la suivante, dès qu'une activation change.

Un événement même pour un compte déjà désactivé

Une suppression émet UserAccessRevoked, y compris quand le compte était déjà désactivé et que sa présence publique avait déjà disparu. Le cas pourrait sembler superflu. Il simplifie pourtant le contrat : « toute suppression effective émet l'événement », sans exception à connaître. Côté abonné, l'effet est idempotent. Le plugin Web invalide un cache déjà vide, ce qui ne coûte presque rien.

Réintégrer, c'est revenir désactivé

Deux gestes pour remettre en ligne

Réintégrer un compte le sort de l'encart des supprimés, mais ne le remet pas en ligne : il revient désactivé. Pour qu'il redevienne actif, l'administrateur doit ensuite le réactiver.

L'alternative, une réintégration qui rendrait le compte actif d'un seul clic, aurait deux défauts :

  • Une porte ouverte par inadvertance. Un clic sur « Réintégrer » remettrait en ligne les sites du compte et rouvrirait sa connexion. Un geste pensé comme une correction d'erreur deviendrait une remise en service complète.
  • Un historique effacé. Un compte désactivé puis supprimé retrouverait l'état actif, alors que personne n'a jamais décidé de lever sa désactivation.

L'invariant est porté par l'entité elle-même : User::restore() remet deletedAt à null et pose disabledAt s'il était vide. Une date de désactivation antérieure est conservée. Aucun code ne peut réintégrer un compte en le laissant actif, puisque la seule méthode qui efface deletedAt pose aussi disabledAt.

C'est pour la même raison que la réintégration n'a pas d'écran d'avertissement : elle ne rend rien public et reste réversible par une nouvelle suppression.

Pourquoi la réintégration n'émet aucun événement

UserAccessRevoked et UserAccessRestored annoncent aux plugins un changement de présence publique. Or une réintégration n'en produit pas. Le compte était non actif avant, il l'est encore après ; ses sites répondaient 404, ils répondent toujours 404. Émettre UserAccessRestored annoncerait un retour qui n'a pas lieu. Un plugin qui y réagirait en republiant quoi que ce soit agirait à tort.

L'événement de retour vient au bon moment : lors de la réactivation, quand le compte redevient réellement actif.

Pour la même raison, la réintégration ne vérifie pas l'invariant « au moins un administrateur actif ». Elle ne retire aucun administrateur actif, et n'en ajoute même pas. Elle ne demande pas non plus de justification et n'envoie aucun e-mail : le titulaire n'a toujours pas accès à son compte, et il n'y a donc rien à lui annoncer.

Effacer pour de bon

Deux gestes plutôt qu'un

La suppression logique garde tout pour pouvoir revenir en arrière. Mais un compte que l'on ne réintégrera jamais ne peut pas rester indéfiniment en base : son titulaire peut demander l'effacement de ses données, et son adresse reste bloquée tant que la ligne existe. Il faut donc un moyen de détruire réellement.

Kirexo en fait un second geste, distinct du premier, et non une option de la suppression logique. Un compte ne s'efface définitivement que s'il est déjà supprimé, et le bouton n'existe que dans l'encart des comptes supprimés. Le chemin vers la destruction passe donc toujours par un état intermédiaire réversible, où le compte a déjà disparu du public et de la liste de travail, mais peut encore revenir. Une destruction en un clic depuis la liste principale aurait rendu irréparable l'erreur que la suppression logique cherche à rendre réparable.

La règle « seul un compte supprimé s'efface » est vérifiée deux fois : par le Voter, qui décide de l'affichage du bouton et de l'accès à l'écran, puis par le service, après une relecture verrouillée du compte. La seconde vérification couvre ce que la première ne voit pas : une réintégration faite par un autre administrateur entre l'affichage de l'écran et sa soumission.

L'écran d'effacement reprend la confirmation par ressaisie de l'adresse, mais il est distinct de celui de la suppression logique, et son avertissement dit autre chose : tout sera détruit, les URL deviennent définitivement 404, l'adresse redevient libre. Deux gestes aux conséquences opposées ne doivent pas se ressembler au point qu'on les confonde.

Le geste ne demande ni justification ni e-mail au titulaire. Une justification s'enregistre dans une note de modération, rattachée au compte, qui serait détruite avec lui dans la même transaction. Le titulaire, lui, a déjà pu être prévenu au moment de la suppression logique : c'est là que se prend la décision qui le concerne.

Les plugins détruisent eux-mêmes leurs données

Effacer un compte, c'est aussi effacer ce que les plugins tiennent en son nom. Le cœur ne connaît pas leurs tables : il ne sait pas qu'un site du plugin Web a des domaines et des pages spéciales, ni qu'un thème personnel se rattache à un compte. Les clés étrangères vers "user" ne suffisent pas non plus. Un plugin peut rattacher une donnée à un compte par une simple colonne d'identifiant, sans contrainte : c'est le cas des thèmes, qui resteraient orphelins.

Le cœur émet donc un événement, UserPurged, qui ne porte que l'identifiant du compte. Chaque plugin s'y abonne et supprime ce qui lui appartient. Le principe est le même que pour l'invalidation de cache, décrit plus haut : le cœur annonce, le plugin agit sur ses propres données, et un futur plugin s'y branche sans toucher au cœur.

L'abonné agit sans condition d'activation. Un plugin désactivé pour un compte masque ses données sans les supprimer (voir Activation asymétrique des plugins). Si l'abonné ne réagissait qu'aux comptes pour lesquels le plugin est actif, un compte ayant coupé son plugin Web garderait ses sites en base après son effacement.

Pourquoi synchrone, dans la transaction

L'événement est dispatché de façon synchrone, à l'intérieur de la transaction qui supprime le compte, avant le DELETE. Les abonnés programment leurs suppressions sans les écrire, et un seul flush envoie tout à la base : leurs suppressions, puis celle du compte, que la base prolonge par ses cascades.

Il en découle la propriété recherchée : tout ou rien. Si un plugin échoue, ou si la base refuse une suppression, le rollback annule tout, côté cœur comme côté plugins. Il n'existe pas d'état où le compte aurait disparu mais où un site continuerait d'exister, sans propriétaire, derrière un domaine encore enregistré.

L'alternative asynchrone, un message Messenger traité après coup par chaque plugin, aurait inversé ce risque. Le compte serait effacé tout de suite, et ses données de plugin plus tard, ou jamais si le worker échouait. Un échec n'aurait alors plus personne à qui se rapporter : le compte n'existerait plus pour être réessayé, et l'administrateur aurait vu un succès.

Un échec ici est un incident, pas un refus métier. Il est journalisé au niveau error, sous un nom distinct (account.purge_failed) de celui des refus (account.refused). L'administrateur voit un message clair : rien n'a été supprimé, il peut réessayer une fois la cause réglée.

Une empreinte plutôt qu'une adresse dans le journal

Après l'effacement, le journal d'audit est la seule trace qui subsiste. Il doit permettre de répondre plus tard à une question comme « ce compte a-t-il bien été effacé, et par qui ? ». Mais il ne doit pas conserver ce que l'effacement vient de retirer : garder l'adresse en clair dans un journal reviendrait à ne l'effacer qu'à moitié.

Le journal enregistre donc une empreinte HMAC de l'adresse, calculée avec le secret de l'application. Un simple hachage ne suffirait pas : une adresse e-mail se devine, et il suffirait de hacher une liste d'adresses candidates pour retrouver celle d'une entrée. Avec un HMAC, ce calcul exige le secret. Un administrateur qui le détient peut recalculer l'empreinte d'une adresse donnée et vérifier qu'elle figure au journal ; un lecteur du journal seul ne peut rien en tirer.

Le compromis : si le secret de l'application change, les anciennes empreintes ne peuvent plus être recalculées. Les entrées restent datées et gardent les identifiants du compte et de l'administrateur, mais on ne peut plus les rapprocher d'une adresse.

Pour la même raison, un plugin ne met jamais de donnée personnelle dans ses exceptions : en cas d'échec, l'exception complète est écrite au journal.

Ce que l'effacement épargne

Tout ce qui appartient au compte disparaît. Ce que le compte a fait à d'autres reste : les motifs de modération qu'il a rédigés en tant qu'administrateur, les invitations qu'il a émises, les comptes qu'il a invités. Ces données appartiennent à leurs sujets, pas à lui. Seul le lien vers leur auteur est coupé : il devient vide, et l'interface affiche « — ».

L'effacement ne vérifie pas non plus l'invariant « au moins un administrateur actif ». Un compte supprimé est déjà non actif : l'effacer ne retire aucun administrateur actif.

Toujours au moins un administrateur actif

Pourquoi un invariant plutôt qu'une précaution d'interface

Une instance sans administrateur actif n'a plus personne pour inviter, réactiver ou réintégrer. La seule issue redevient l'accès shell. Kirexo garantit donc qu'il reste toujours au moins un compte actif portant ROLE_ADMIN.

La demande d'origine tenait en deux règles : un administrateur ne peut ni se désactiver, ni se supprimer. Elles ne suffisent pas. Deux administrateurs qui se désactivent l'un l'autre respectent chacun la règle, et vident pourtant l'instance. D'où la troisième : personne ne peut retirer le dernier administrateur actif, même un autre administrateur.

Deux étages, pas un

Le Voter UserManagementVoter refuse l'auto-désactivation et l'auto-suppression. C'est lui qui pilote l'affichage : sur sa propre ligne, l'administrateur voit les actions, inopérantes, avec leur raison. Masquer ces boutons aurait été plus simple, mais un bouton absent n'explique rien, alors qu'un bouton inopérant dit pourquoi.

Le Voter ne compte pourtant pas les administrateurs. Ce décompte appartient au service AccountStateManager, qui revérifie avant toute écriture. Une règle portée par la seule couche web protège les routes connues ; une règle portée par le service protège aussi une commande, une fixture, ou un point d'entrée qui n'existe pas encore.

Le verrou

Le décompte seul ne suffit pas non plus. Deux administrateurs, derniers actifs, qui se désactivent au même instant lisent chacun « deux administrateurs actifs », passent le contrôle, puis écrivent. Le résultat est exactement celui que l'invariant interdit.

Le service sérialise donc le décompte et l'écriture : il verrouille les lignes des administrateurs actifs (SELECT … FOR UPDATE) dans la transaction qui écrit l'état. La seconde opération attend la fin de la première, relit un jeu réduit, et refuse. Le prix est un verrou bref sur quelques lignes, pour un geste rare : négligeable face au risque couvert.

Les gestes qui ne peuvent pas retirer un administrateur actif ne prennent pas ce verrou : la réactivation en ajoute un, la réintégration rend un compte désactivé, l'effacement porte sur un compte déjà supprimé.

Amorcer le premier administrateur

L'invariant suppose qu'un administrateur existe déjà. Sur une instance neuve, il n'y en a aucun, et l'inscription publique est fermée : personne ne peut inviter personne.

La commande app:user:create comble ce trou. Elle n'est pas le chemin courant de création des comptes, mais l'amorçage : elle crée le premier administrateur depuis un accès shell, après quoi tous les comptes suivants passent par l'invitation, où l'invité choisit lui-même son mot de passe. Elle partage avec les invitations le même vocabulaire de rôles, l'enum AccountRole (user, admin, both), pour qu'un rôle signifie la même chose quel que soit le chemin de création. Mode d'emploi : Créer un compte utilisateur en ligne de commande.

Voir aussi