@mostajs/recette 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 
+## 0.2.1 — 2026-09-10
+
+Correction née d'une panne **en production**, invisible depuis les essais.
+
+### Corrigé
+
+- **Le contenu du dossier revenait en CHAÎNE** de plusieurs dialectes SQL (sqljs le premier) là
+  où un dépôt en mémoire rend l'objet. L'enveloppe exportée transportait donc une chaîne, le
+  destinataire recalculait l'empreinte sur autre chose, et **refusait tout dossier** — avec un
+  message parlant de falsification. Le moteur normalise désormais à la lecture : `dossiers.of()`
+  et l'export rendent toujours un objet.
+- **`dossiers.exporter()` vérifie l'empreinte avant de signer.** Un document dont l'empreinte ne
+  recouvre plus le contenu relu est refusé ici, en nommant la cause, plutôt que d'aller se faire
+  rejeter chez le destinataire qui, lui, n'aura que « signature ou empreinte invalide » à offrir.
+
+### Ajouté aux essais
+
+- **T-REC-14** monte un dépôt qui imite sqljs — écriture d'objet, lecture de texte. C'est le cas
+  qui manquait : quatorze essais verts et rien ne fonctionnait en ligne.
+
+## 0.2.0 — 2026-09-10
+
+Le sceau savait fermer un pli ; il ne savait pas l'ouvrir. C'est ce qui manquait pour que QaTrax
+puisse recevoir ce que ValiTrax lui scelle — la moitié retour de la chaîne.
+
+### Ajouté
+
+- **`sceau.ouvrir(scelle)`**, rendu quand `destinataire.privee` est fourni. Pendant exact de
+  `sceller`, et pour la même raison logé ici : le format ne s'écrit qu'à un seul endroit. Ouvrir
+  n'authentifie pas — c'est la signature retrouvée à l'intérieur qui dit l'origine. **Ouvrir
+  d'abord, vérifier ensuite.**
+- **`verification: { publique }`**, alias neutre de `certificateur: { publique }`. La contrepartie
+  est *le certificateur* vue de ValiTrax et *l'émetteur* vue de QaTrax : même verbe, vantage
+  inverse. L'ancien nom reste servi, aucune application n'est à modifier.
+
+### Compatibilité
+
+Aucune rupture. Une instance qui ne fournit pas `destinataire.privee` n'obtient pas `ouvrir` — la
+règle inchangée du module : **un verbe n'existe que si sa clé existe**, pour que le manque se
+découvre à la mise en service et non le jour de la remise.
+
 ## 0.1.0 — 2026-09-10
 
 Première version. Le moteur de la recette applicative, extrait du besoin de **déléguer la recette

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostajs/recette",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "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

@@ -31,6 +31,17 @@ const rang = (e) => PARCOURS.indexOf(e);
 const need = (v, msg) => { if (v === undefined || v === null || v === '') throw new Error(msg); return v; };
 const asDate = (d) => (d ? new Date(d) : null);
 
+/**
+ * Le CONTENU d'un dossier, quel que soit ce que le stockage a bien voulu en faire.
+ *
+ * Un champ `json` revient en OBJET d'un dépôt en mémoire, et en CHAÎNE de plusieurs dialectes
+ * SQL — sqljs le premier. Sans cette normalisation, l'enveloppe exportée transportait une
+ * chaîne là où le destinataire attend un objet, et l'empreinte recalculée à l'arrivée ne
+ * pouvait plus correspondre : tout dossier était refusé, pour une raison invisible depuis les
+ * essais, qui n'utilisent que des dépôts en mémoire.
+ */
+const contenuDe = (d) => (typeof d?.contenu === 'string' ? JSON.parse(d.contenu) : d?.contenu);
+
 export function createRecette({ repositories, ports = {}, clock = () => new Date(), numeroteur } = {}) {
   const repo = need(repositories, 'repositories requis');
   for (const c of ['campagnes', 'points', 'feuillets', 'releves', 'anomalies', 'dossiers', 'certificats']) {
@@ -392,12 +403,21 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
       const sceau = ports.sceau;
       if (!sceau?.signer) throw new Error("aucun sceau configuré : un export non signé ne prouve rien, il est refusé");
 
+      // ON VÉRIFIE AVANT DE SIGNER. Exporter un document dont l'empreinte ne recouvre plus le
+      // contenu, c'est fabriquer un refus chez le destinataire — et un refus qu'il mettra sur le
+      // compte d'une falsification. Mieux vaut refuser ici, en nommant la cause.
+      const contenu = contenuDe(d);
+      const verif = createHash('sha256').update(JSON.stringify(contenu)).digest('hex');
+      if (verif !== d.empreinte) {
+        throw new Error(`empreinte du dossier ${d.no} incohérente avec son contenu relu (${verif.slice(0, 12)}… ≠ ${String(d.empreinte).slice(0, 12)}…) : le stockage n'a pas rendu ce qui lui a été confié`);
+      }
+
       const enveloppe = {
         type: 'mostajs-recette-dossier/1',
         emisLe: clock().toISOString(),
         campagne: { no: c.no, releaseRef: c.releaseRef },
         dossier: { no: d.no, empreinte: d.empreinte, figeLe: d.figeLe },
-        contenu: d.contenu,
+        contenu,
       };
       const charge = JSON.stringify(enveloppe);
       const signature = await sceau.signer(charge);
@@ -416,7 +436,12 @@ export function createRecette({ repositories, ports = {}, clock = () => new Date
       const d = need(await dossiers.of(campagneId), 'aucun dossier pour cette campagne');
       return repo.dossiers.update(d.id, { depotRef: need(depotRef, 'depotRef requis') });
     },
-    of: async (campagneId) => (await repo.dossiers.find((x) => x.campagneId === campagneId))[0] || null,
+    of: async (campagneId) => {
+      const d = (await repo.dossiers.find((x) => x.campagneId === campagneId))[0] || null;
+      // On rend TOUJOURS un objet : l'appelant n'a pas à connaître le dialecte SQL sous-jacent
+      // pour relire le contenu du dossier qu'il vient de figer.
+      return d ? { ...d, contenu: contenuDe(d) } : null;
+    },
   };
 
   const certificats = {

package/src/sceau.js

@@ -20,7 +20,7 @@
 // La formule « signé avec la clé publique fournie par le certificateur » décrit en réalité le
 // SCELLEMENT : cette clé sert à fermer le pli à son intention, pas à prouver notre identité.
 // C'est `destinataire.publique` ci-dessous. Notre identité, elle, vient de `signature.privee`.
-import { sign, verifySignature, seal, generateSigningKeyPair, generateRecipientKeyPair } from '@mostajs/crypto-box';
+import { sign, verifySignature, seal, open, generateSigningKeyPair, generateRecipientKeyPair } from '@mostajs/crypto-box';
 
 const ALG_SIGNATURE = 'Ed25519';
 
@@ -43,10 +43,16 @@ function octets(k, quoi) {
  *
  * @param {object}  opt
  * @param {object}  [opt.signature]     `{ privee, nom }` — NOTRE identité (Ed25519). Sans elle, pas d'export.
- * @param {object}  [opt.destinataire]  `{ publique }` — le certificateur (X25519). Sans elle, pas de scellement.
- * @param {object}  [opt.certificateur] `{ publique }` — le certificateur (Ed25519). Sans elle, aucun PV vérifiable.
+ * @param {object}  [opt.destinataire]  `{ publique, privee }` — X25519. La PUBLIQUE du destinataire
+ *                                      permet de SCELLER pour lui ; notre PRIVÉE permet d'OUVRIR
+ *                                      ce qui nous a été scellé. Les deux vantages du même pli.
+ * @param {object}  [opt.certificateur] `{ publique }` — Ed25519 de la contrepartie. Sans elle,
+ *                                      aucun document reçu n'est vérifiable. Alias neutre :
+ *                                      `verification`, car la contrepartie est le certificateur
+ *                                      vu de ValiTrax, et l'émetteur vu de QaTrax — même verbe,
+ *                                      vantage inverse.
  */
-export function creerSceau({ signature, destinataire, certificateur } = {}) {
+export function creerSceau({ signature, destinataire, certificateur, verification } = {}) {
   const port = {};
 
   if (signature?.privee) {
@@ -67,8 +73,17 @@ export function creerSceau({ signature, destinataire, certificateur } = {}) {
     port.sceller = async (charge) => Buffer.from(seal([pub], charge)).toString('base64');
   }
 
-  if (certificateur?.publique) {
-    const pub = octets(certificateur.publique, 'certificateur.publique');
+  if (destinataire?.privee) {
+    const priv = octets(destinataire.privee, 'destinataire.privee');
+    // OUVRIR est le pendant exact de SCELLER, et il vit ici pour la même raison : le format ne
+    // s'écrit qu'à un seul endroit. Le pli ouvert n'est PAS authentifié pour autant — c'est la
+    // signature qu'il contient qui dira d'où il vient. Ouvrir d'abord, vérifier ensuite.
+    port.ouvrir = async (scelle) => open(priv, Buffer.from(String(scelle), 'base64')).toString('utf8');
+  }
+
+  const contrepartie = certificateur?.publique ? certificateur : verification;
+  if (contrepartie?.publique) {
+    const pub = octets(contrepartie.publique, 'clé publique de la contrepartie');
     port.verifier = async (charge, sig) => {
       // Un algorithme inattendu n'est pas une signature invalide : c'est un document qu'on ne
       // sait pas lire. On refuse dans les deux cas, mais on ne prétend pas avoir vérifié.