@mostajs/recette 0.2.1 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 
+## 0.4.0 — 2026-10-23
+
+### Corrigé
+
+- **Le feu s'allumait sans certificat.** `campagnes.avancer` menait de « validation » à « figee »,
+  « certifiee » puis « exploitation » à qui cliquait trois fois — constaté le 23/10/2026 sur
+  REC-2026-0001, sans un point, ni dossier, ni certificat. Avancer à la main s'arrête désormais à
+  « validation » ; les trois étapes suivantes ne s'atteignent que par leur acte (`dossiers.figer`,
+  `certificats.recevoir`, `autoriserExploitation`). **T-REC-16**.
+- Une campagne arrivée en « exploitation » **sans certificat** peut être abandonnée : elle n'a jamais
+  été autorisée. Avec certificat, elle ne s'abandonne toujours pas. **T-REC-17**.
+
+### Ajouté
+
+- **`campagnes.reculer(id, { by, motif })`** — revenir d'une étape (validation → recette →
+  verification → candidate) tant que le dossier n'est pas figé ; l'historique garde le retour et son
+  motif. **T-REC-17**.
+- **`rapportEtape(campagneId, { declaration: 'partiel' | 'urgent', sceller, note })`** — le rapport
+  d'étape SIGNÉ (`mostajs-recette-rapport/1`) : relevés qui font foi, avec l'exigence, l'action,
+  l'attendu, la remarque et l'heure ; anomalies ; compteurs. Il ne fige rien et ne demande aucun PV :
+  il sert à CORRIGER pendant que la recette continue. `declaration: 'fini'` accompagne le dossier
+  final. `pieces` décrit les pièces jointes et captures d'écran (cible, nom, type, taille, SHA-256)
+  sous la signature ; leur contenu voyage à côté. **T-REC-18**.
+
+> **Rupture** : `campagnes.avancer(id, 'figee' | 'certifiee' | 'exploitation')` lève désormais une
+> erreur. Un appelant qui s'en servait doit passer par l'acte correspondant.
+
+## 0.3.0 — 2026-10-23
+
+### Corrigé
+
+- **Une ligne, une issue : le DERNIER relevé fait foi.** Le formulaire enregistre à chaque
+  changement, comme un questionnaire ; un testeur qui hésitait entre `ko` et `ok`, ou qui écrivait
+  sa remarque en plusieurs fois, laissait plusieurs relevés pour la même ligne, et tous étaient
+  comptés. Une hésitation devenait un `ko` de plus au dossier, une remarque tapée en trois fois
+  trois `ok` — et le verdict proposé au certificateur s'en trouvait faussé. Les compteurs du
+  dossier et de `etat()` ne retiennent plus que le dernier relevé de chaque (feuillet, ligne).
+  **T-REC-15** le verrouille.
+
+### Ajouté
+
+- `releves.derniersDuFeuillet(feuilletId)` — le relevé qui fait foi pour chaque ligne, issue et
+  remarque comprises : ce qu'un formulaire réaffiche.
+- Le dossier figé porte `relevesRemplaces` : combien de relevés ont été remplacés. L'historique
+  reste en base, rien n'est effacé.
+
+> Le **contenu** d'un dossier figé change de forme (`releves` ne garde que les relevés qui font
+> foi) : son empreinte n'est pas comparable à celle d'un dossier figé en 0.2.x. Les dossiers déjà
+> figés ne sont pas touchés.
+
 ## 0.2.1 — 2026-09-10
 
 Correction née d'une panne **en production**, invisible depuis les essais.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostajs/recette",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Validation & recette applicative : trame `mostajs-devtest/1` reçue signée du certificateur, points enrichis POUR LE CLIENT (l'import n'écrase jamais l'enrichissement), feuillets composés à l'image du manifeste PDF (ok/ko/er), anomalies déclarées puis qualifiées, dossier figé et EXPORTÉ SIGNÉ — aucun appel réseau —, certificat reçu et vérifié, feu d'exploitation DÉRIVÉ du certificat. Powers ValiTrax (valitrax.mostajs.dev).",
   "author": "Dr Hamid MADANI <drmdh@msn.com>",
   "license": "AGPL-3.0-or-later",

package/src/recette.js

@@ -62,7 +62,11 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
     if (vers === 'abandonnee') {
       // On abandonne de partout, sauf une fois l'exploitation autorisée : à ce moment le logiciel
       // est en production, et « abandonner la recette » ne veut plus rien dire.
-      if (campagne.state === 'exploitation') throw new Error("l'exploitation est autorisée : la campagne ne s'abandonne plus");
+      // 0.4.0 — SAUF si elle y est arrivée SANS certificat : avant cette version, `campagnes.avancer` menait de
+      // « validation » à « exploitation » par trois clics (constaté le 23/10/2026, REC-2026-0001, 0 point). Une telle
+      // campagne n'a jamais été autorisée ; la garder irrécupérable serait garder l'erreur.
+      if (campagne.state === 'exploitation' && (await certificats.of(campagne.id))) throw new Error("l'exploitation est autorisée : la campagne ne s'abandonne plus");
+      if (campagne.state === 'abandonnee') throw new Error('la campagne est déjà abandonnée');
     } else {
       const de = rang(campagne.state), a = rang(vers);
       if (a < 0) throw new Error(`étape inconnue : ${vers}`);
@@ -96,7 +100,37 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
     },
     get: getCampagne,
     list: (filtre = () => true) => repo.campagnes.find(filtre),
-    avancer: async (id, vers, opts) => avancer(await getCampagne(id), vers, opts),
+    /**
+     * AVANCER À LA MAIN — seulement les étapes de TRAVAIL : verification, recette, validation (et l'abandon).
+     *
+     * 0.4.0 : « figee », « certifiee » et « exploitation » ne se franchissent QUE par leur acte — figer le dossier,
+     * recevoir le certificat, autoriser l'exploitation. Avant, ce verbe public les accordait à qui cliquait trois fois,
+     * et le feu « dérivé du certificat » s'allumait sans certificat.
+     */
+    avancer: async (id, vers, opts) => {
+      const ACTE = { figee: '« figer le dossier »', certifiee: '« recevoir le certificat »', exploitation: '« autoriser l’exploitation » (avec un certificat qui la permet)' };
+      if (ACTE[vers]) throw new Error(`« ${vers} » ne s'atteint pas en avançant : il faut ${ACTE[vers]}`);
+      return avancer(await getCampagne(id), vers, opts);
+    },
+    /**
+     * REVENIR D'UNE ÉTAPE (0.4.0) — tant que le dossier n'est pas figé : validation → recette → verification → candidate.
+     * Une recette relancée parce qu'une correction est arrivée n'est pas une faute ; l'historique garde le retour et son motif.
+     */
+    async reculer(id, { by = null, motif = '' } = {}) {
+      const c = await getCampagne(id);
+      const de = rang(c.state);
+      if (!['verification', 'recette', 'validation'].includes(c.state)) {
+        throw new Error(`on ne revient pas en arrière depuis « ${c.state} »${rang(c.state) >= rang('figee') ? ' : le dossier est figé, ouvrez une nouvelle campagne' : ''}`);
+      }
+      const vers = PARCOURS[de - 1];
+      const at = clock();
+      const out = await repo.campagnes.update(c.id, {
+        state: vers,
+        stateHistory: [...(c.stateHistory || []), { from: c.state, to: vers, at, by, reason: `retour : ${motif || 'sans motif'}` }],
+      });
+      await trace('recette.campagne.reculer', by, { campagneId: c.id, from: c.state, to: vers, motif });
+      return out;
+    },
   };
 
   /** Les champs que l'import a le droit d'écrire. Tout le reste appartient à ValiTrax. */
@@ -261,6 +295,29 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
     },
   };
 
+  /**
+   * UNE LIGNE, UNE ISSUE : le DERNIER relevé de chaque (feuillet, ligne) fait foi.
+   *
+   * Un relevé ne s'efface pas, il se remplace : le formulaire enregistre à chaque changement, comme
+   * un questionnaire, et le testeur qui hésite entre `ko` et `ok`, ou qui écrit sa remarque en
+   * plusieurs fois, laisse plusieurs relevés pour la même ligne. Les compter tous faisait d'une
+   * hésitation un `ko` de plus au dossier, et d'une remarque tapée en trois fois trois `ok` :
+   * le verdict proposé au certificateur s'en trouvait faussé. L'historique reste en base ; le
+   * dossier dit combien de relevés ont été remplacés.
+   */
+  const instant = (r) => +new Date(r.createdAt || r.at || 0);
+  function derniers(rs) {
+    const parLigne = new Map();
+    rs.forEach((r, i) => {
+      const cle = `${r.feuilletId}\u0000${r.ref}`;
+      const avant = parLigne.get(cle);
+      // À instant égal, l'ordre de lecture départage : le plus tard lu est le plus récent.
+      if (!avant || instant(r) >= instant(avant.r)) parLigne.set(cle, { r, i });
+    });
+    return [...parLigne.values()].sort((a, b) => a.i - b.i).map((x) => x.r);
+  }
+  const compter = (rs) => ({ ok: rs.filter((r) => r.issue === 'ok').length, ko: rs.filter((r) => r.issue === 'ko').length, er: rs.filter((r) => r.issue === 'er').length });
+
   const releves = {
     /**
      * Consigner une observation.
@@ -285,6 +342,8 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
     },
     of: (campagneId) => repo.releves.find((r) => r.campagneId === campagneId),
     duFeuillet: (feuilletId) => repo.releves.find((r) => r.feuilletId === feuilletId),
+    /** Le relevé QUI FAIT FOI pour chaque ligne d'un feuillet : le dernier consigné (voir `derniers`). */
+    derniersDuFeuillet: async (feuilletId) => derniers(await repo.releves.find((r) => r.feuilletId === feuilletId)),
   };
 
   const anomalies = {
@@ -368,14 +427,16 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
       if (obstacles.length && !force) throw new Error(`figement refusé — ${obstacles.join(' · ')}`);
 
       const fs = await feuillets.of(campagneId);
-      const rs = await releves.of(campagneId);
+      const tous = await releves.of(campagneId);
+      const rs = derniers(tous);
       const as = await anomalies.of(campagneId);
       const contenu = {
         campagne: { no: c.no, releaseRef: c.releaseRef, projet: c.projet, perimetre: c.perimetre, instanceUrl: c.instanceUrl },
         feuillets: fs.map((f) => ({ role: f.role, langue: f.langue, state: f.state, planVersion: f.planVersion })),
         releves: rs.map((r) => ({ ref: r.ref, issue: r.issue, at: r.at, source: r.source, confiance: r.confiance, texte: r.texte })),
         anomalies: as.map((a) => ({ titre: a.titre, graviteProposee: a.graviteProposee, graviteQualifiee: a.graviteQualifiee, state: a.state, bugRef: a.bugRef, motifEcart: a.motifEcart })),
-        compteurs: { ok: rs.filter((r) => r.issue === 'ok').length, ko: rs.filter((r) => r.issue === 'ko').length, er: rs.filter((r) => r.issue === 'er').length },
+        compteurs: compter(rs),
+        relevesRemplaces: tous.length - rs.length,
         obstaclesAuFigement: obstacles,   // consignés même en `force` : un dossier dit ce qu'il vaut
       };
       const empreinte = createHash('sha256').update(JSON.stringify(contenu)).digest('hex');
@@ -499,16 +560,67 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
   async function etat(campagneId) {
     const c = await getCampagne(campagneId);
     const fs = await feuillets.of(campagneId);
-    const rs = await releves.of(campagneId);
+    const rs = derniers(await releves.of(campagneId));
     const as = await anomalies.of(campagneId);
     return {
       campagne: { no: c.no, state: c.state, releaseRef: c.releaseRef },
       feuillets: { remis: fs.length, rendus: fs.filter((f) => f.state !== 'remis').length },
-      releves: { ok: rs.filter((r) => r.issue === 'ok').length, ko: rs.filter((r) => r.issue === 'ko').length, er: rs.filter((r) => r.issue === 'er').length },
+      releves: compter(rs),
       anomalies: { declarees: as.filter((a) => a.state === 'declaree').length, bloquantes: as.filter((a) => a.graviteQualifiee === 'bloquante').length, total: as.length },
       obstacles: await obstaclesAuDepot(campagneId),
     };
   }
 
-  return { campagnes, trame, points, feuillets, releves, anomalies, dossiers, certificats, autoriserExploitation, etat, PARCOURS };
+  /**
+   * LE RAPPORT D'ÉTAPE (0.4.0) — ce que le client déclare EN COURS de recette : « partiellement fini », ou « l'urgent est
+   * fini ». Il part vers QaTrax SIGNÉ (et scellé si son destinataire est configuré), comme le dossier ; mais il ne fige rien
+   * et ne demande aucun PV : il sert à CORRIGER — chaque `ko`, chaque `er`, chaque anomalie y devient un défaut à traiter
+   * pendant que la recette continue. Le dossier final, lui, reste l'affaire de `dossiers.figer` puis `exporter`.
+   */
+  // « fini » accompagne le dossier final : le dossier porte le PV, le rapport porte de quoi corriger (et les pièces).
+  const DECLARATIONS = ['partiel', 'urgent', 'fini'];
+  /**
+   * @param {Array} [pieces]  les pièces jointes DÉCRITES — `{ cible: '<réf>' | 'anomalie:<n>', nom, type, taille, sha256 }`.
+   *   Leur CONTENU voyage à côté de l'enveloppe ; la signature couvre leurs empreintes : une pièce échangée en chemin
+   *   ne correspond plus.
+   */
+  async function rapportEtape(campagneId, { declaration, by = null, sceller = false, note = '', pieces = [] } = {}) {
+    const c = await getCampagne(campagneId);
+    if (!DECLARATIONS.includes(declaration)) throw new Error(`déclaration inconnue : ${declaration} (attendu : ${DECLARATIONS.join(' ou ')})`);
+    if (!['verification', 'recette', 'validation'].includes(c.state)) throw new Error(`un rapport d'étape s'envoie pendant la recette (la campagne est « ${c.state} »)`);
+    const sceau = ports.sceau;
+    if (!sceau?.signer) throw new Error("aucun sceau configuré : un rapport non signé ne prouve rien, il est refusé");
+    const fs = await feuillets.of(campagneId);
+    const rs = derniers(await releves.of(campagneId));
+    const as = await anomalies.of(campagneId);
+    const ps = await points.of(campagneId);
+    const parRef = new Map(ps.map((p) => [p.ref, p]));
+    const enveloppe = {
+      type: 'mostajs-recette-rapport/1',
+      emisLe: clock().toISOString(),
+      declaration, note: String(note || ''),
+      campagne: { no: c.no, releaseRef: c.releaseRef, projet: c.projet, instanceUrl: c.instanceUrl, state: c.state },
+      feuillets: fs.map((f) => ({ role: f.role, destinataire: f.destinataire || '', state: f.state })),
+      // Chaque relevé porte de quoi le CORRIGER : l'exigence, ce que le testeur devait faire et voir, sa remarque, l'heure.
+      releves: rs.map((r) => {
+        const p = parRef.get(r.ref);
+        return { ref: r.ref, issue: r.issue, at: r.at, texte: r.texte || '', specRef: p?.specRef || null,
+          action: p?.libelle || p?.titreTrame || '', attendu: p?.attendu || (p?.etapesTrame || []).map((e) => e.expected).filter(Boolean).join(' · ') };
+      }),
+      anomalies: as.map((a) => ({ titre: a.titre, description: a.description || '', graviteProposee: a.graviteProposee, graviteQualifiee: a.graviteQualifiee, state: a.state, declareePar: a.declareePar })),
+      compteurs: { ...compter(rs), retenus: ps.filter((p) => p.retenu).length },
+      pieces: (pieces || []).map((x) => ({ cible: String(x.cible || ''), nom: String(x.nom || ''), type: String(x.type || ''), taille: Number(x.taille) || 0, sha256: String(x.sha256 || '') })),
+    };
+    for (const x of enveloppe.pieces) if (!/^[0-9a-f]{64}$/.test(x.sha256)) throw new Error(`pièce « ${x.nom} » : empreinte SHA-256 absente ou invalide`);
+    const signature = await sceau.signer(JSON.stringify(enveloppe));
+    let corps = { enveloppe, signature };
+    if (sceller) {
+      if (!sceau.sceller) throw new Error("scellement demandé mais aucun destinataire configuré (clé publique du certificateur)");
+      corps = { type: 'mostajs-recette-scelle/1', scelle: await sceau.sceller(JSON.stringify(corps)) };
+    }
+    await trace('recette.rapport.etape', by, { campagneId, declaration });
+    return corps;
+  }
+
+  return { campagnes, trame, points, feuillets, releves, anomalies, dossiers, certificats, autoriserExploitation, rapportEtape, etat, PARCOURS };
 }