@mostajs/wagon-engine 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 **Auteur** : Dr Hamid MADANI <drmdh@msn.com>
 Format : Keep a Changelog ; versions : SemVer.
 
+## [0.8.0] — 2026-10-29
+
+### Ajouté — les membres d'un compte (demandé par CaisseTrax : écart E-08 de SPEC-ECRANS-CAISSETRAX)
+- `ctx.utilisateur` (la personne de la session, sans empreinte) et `ctx.role` (son rôle dans le compte) ; `null`
+  sans session et pour une clé d'API.
+- `ctx.membres` (session seulement) : `lister()` (courriel, nom, rôle, statut `actif` | `invite` | `suspendu`),
+  `inviter({ courriel, nom, role })` → membre du MÊME compte + lien d'activation (`config.invitationJours`, défaut 7),
+  `reinviter(id)`, `changerRole(id, role)`, `retirer(id)`. Le lien part par courriel s'il y a un transport et est
+  TOUJOURS rendu à la charge (un commerce n'a pas toujours de courriel). La charge décide qui peut s'en servir.
+- `charge.vues.connexion({ lang, action, erreur, oubli })` et `charge.vues.reinitialiser({ lang, jeton, utilisateur, erreur,
+  expire, minimum })` : la greffe rend ces deux pages ENTIÈRES (l'écran de SA maquette), erreurs comprises ; le porteur
+  d'un jeton d'invitation est lu sans le consommer (« Bienvenue …, vous êtes invité comme … »).
+- `config.apresConnexion` : la page d'arrivée après connexion ou activation (défaut `/compte`).
+
+### Corrigé
+- Les jetons de réinitialisation vivaient en mémoire : un redémarrage perdait les liens en cours. Ils sont rangés en
+  base (table `wagon_jetons`, empreinte seule).
+- `/connexion/reinitialiser` est servie dès que la connexion est par mot de passe, même sans courriel : le lien d'une
+  invitation remis de la main à la main doit fonctionner. La DEMANDE (`/connexion/oubli`) exige toujours un courriel.
+
+Essais T-WAG-30 à 35 (test-scripts/unit/membres.test.mjs) ; 52/52 ; sabotage vérifié (jetons remis en mémoire →
+T-WAG-32 tombe).
+
 ## [0.7.0] — 2026-10-29
 
 ### Ajouté

package/llms.txt

@@ -4,7 +4,7 @@
 > PayPal), espace client, administration, pages légales, robots/sitemap, sauvegarde, fr/en/ar. Une GREFFE n'apporte que
 > wagon.config.mjs, charge/, legal/ et son .env. N2 (pack). Extrait du gabarit mosta-wagon 0.11.0 le 26/10/2026.
 
-- Version: 0.6.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
+- Version: 0.8.0 · Licence: AGPL-3.0-or-later · Auteur: Dr Hamid MADANI <drmdh@msn.com>
 - Chemin: mostajs/mosta-platform-stack/mosta-wagon-engine · gabarit d'une greffe : Entreprise/mosta-wagon
 
 ## ⚙️ D'EMBLÉE : LE .env ET LA CASCADE @mostajs/config
@@ -49,6 +49,7 @@ démarrage) · exporterCompte(id), effacerCompte(id) (RGPD) · sitemap() · sauv
 { '/page': { microphone: 'self' }, '/dossier/*': … }, garde-http ≥ 0.2).
 ctx : chemin, methode, lang, t, ui, page({ titre, contenu }), envoyer, json, rediriger, formulaire, corpsJson({ strict }),
 compte, consommer(cle), refuser(v), palier({ compte? }), plafond(cle, n, { compte? }), courriel({ to, subject, text, html? }) → bool, admin.
+  0.8 : ctx.utilisateur, ctx.role ; ctx.membres = { lister(), inviter({ courriel, nom, role }) → { utilisateurId, courriel, role, lien, expiresAt, courrielParti }, reinviter(id), changerRole(id, role), retirer(id) } (session seulement ; la charge garde l'accès) ; config.apresConnexion, config.invitationJours ; jetons en base (wagon_jetons) ; /connexion/reinitialiser servie sans courriel ; charge.vues.connexion(…) / charge.vues.reinitialiser({ jeton, utilisateur, erreur, expire }) → page entière.
   0.7 : ctx.paiement (null sans banque prépayée active) = { moyens: [{ moyen, devise }], ouvrir({ moyen, montant (unités MINEURES), description, reference, metadata, merci: '/chemin', annule: '/chemin' }) → { ok, url, commande } | { ok: false, raison } } — paiement PONCTUEL de la charge (une place de cours…). La banque confirme à /api/paiement/charge/<moyen> (webhook, signature) ou renvoie l'acheteur à /api/paiement/charge-retour/<moyen> (SATIM) ; le wagon appelle alors charge.paiementRegle({ reference, statut: paid|failed|refunded|…, commande, montant (mineures), devise, moyen, metadata }), à écrire IDEMPOTENT (une banque rejoue). merci/annule : chemins locaux seulement.
   0.4 : /inscription?suite=/chemin et /connexion?suite=/chemin — retour à une page LOCALE après inscription (si ni clé ni paiement à montrer ; sinon bouton « Continuer ») ou connexion par mot de passe ; //hôte et adresses absolues ignorés.
   0.3 : ctx.page({ disposition: 'vitrine'|'application'|'console'|'nu'|<fournie>, application: { retour, titre, avatar, onglets, langues }, console: { menu, contexte, utilisateur } }) (wagon-ui 0.10) ; config.jetons { rayon, police, policeTitres, ombre, fond } ; config.marque.logo / logoClair (SVG en ligne ou chemin /…).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostajs/wagon-engine",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Le wagon d'un SaaS, une fois pour toutes : comptes, connexion, paliers, quotas, paiement (Stripe, Chargily, SATIM), espace client, administration, pages légales, fr/en/ar. Une greffe n'apporte que wagon.config.mjs, charge/, legal/ et son .env ; la suite de conformité publiée juge la greffe.",
   "keywords": [
     "mostajs",

package/src/wagon.mjs

@@ -19,6 +19,7 @@
  * faux ; l'administration est invisible (404) à qui n'est pas administrateur.
  */
 import { readFileSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { openIsolatedDialect } from '@mostajs/data-plug';
 import { creerWagonUi, esc } from '@mostajs/wagon-ui';
@@ -143,12 +144,21 @@ const AdminSchema = {
   fields: { courriel: { type: 'string', required: true }, confirmeLe: { type: 'date' }, par: { type: 'string' } },
   relations: {}, indexes: [{ fields: { courriel: 'asc' }, unique: true }],
 };
+/**
+ * 0.8 — les JETONS à usage unique (réinitialisation, invitation), RANGÉS EN BASE : jusqu'à la 0.7 ils vivaient en
+ * mémoire, et un redémarrage perdait le lien qu'un invité n'avait pas encore ouvert. Seule l'empreinte est rangée.
+ */
+const JetonSchema = {
+  name: 'WagonJeton', collection: 'wagon_jetons', timestamps: false,
+  fields: { cle: { type: 'string', required: true }, user: { type: 'string', required: true }, expiresAt: { type: 'number', required: true } },
+  relations: {}, indexes: [{ fields: { cle: 'asc' }, unique: true }],
+};
 export const schemasWagon = () => {
   const vus = new Set();
   // `Payment` (@mostajs/payment) : une ligne par session de banque, que le webhook retrouve pour clore la vente.
   // Déclarée même sans banque prépayée — incident RestoTrax du 19/08/2026 : « no such table: payments » APRÈS
   // que le client eut engagé son paiement.
-  return [...schemasComptes(), ...billingSchemas(), PaymentSchema, SessionSchema, CredentialSchema, AdminSchema].filter((s) => (vus.has(s.name) ? false : vus.add(s.name)));
+  return [...schemasComptes(), ...billingSchemas(), PaymentSchema, SessionSchema, CredentialSchema, AdminSchema, JetonSchema].filter((s) => (vus.has(s.name) ? false : vus.add(s.name)));
 };
 
 const lireCorps = (req, max = 1_000_000) => new Promise((ok, ko) => {
@@ -218,13 +228,21 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
   const purgerSessions = () => sessions.purger?.().catch((e) => journal.warn(`wagon : purge des sessions : ${e?.message ?? e}`));
   purgerSessions(); setInterval(purgerSessions, 6 * 3600 * 1000).unref?.();
   const freinInscription = memoryLimiter({ limits: { byIp: config.freinInscription ?? { capacity: 10, refillPerSec: 1 / 60 } } });
-  const motsDePasse = createPasswordAuth({
-    credentials: {
-      get: async (u) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); return r ? { hash: r.hash, updatedAt: r.updatedAt } : null; },
-      set: async (u, rec) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); if (r) await d.update(S.WagonCredential, String(r.id), rec); else await d.create(S.WagonCredential, { user: String(u), ...rec }); },
-    },
-    findUser: async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; },
-  });
+  const identifiants = {
+    get: async (u) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); return r ? { hash: r.hash, updatedAt: r.updatedAt } : null; },
+    set: async (u, rec) => { const r = await d.findOne(S.WagonCredential, { user: String(u) }); if (r) await d.update(S.WagonCredential, String(r.id), rec); else await d.create(S.WagonCredential, { user: String(u), ...rec }); },
+  };
+  const trouverUtilisateur = async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; };
+  // 0.8 — les jetons en base (voir JetonSchema), partagés par la réinitialisation et l'invitation.
+  const jetons = {
+    get: async (cle) => { const r = await d.findOne(S.WagonJeton, { cle }); return r ? { userId: String(r.user), expiresAt: Number(r.expiresAt) } : null; },
+    put: async (cle, e) => { await d.create(S.WagonJeton, { cle, user: String(e.userId), expiresAt: Number(e.expiresAt) }); },
+    delete: async (cle) => { for (const r of await d.find(S.WagonJeton, { cle })) await d.delete(S.WagonJeton, String(r.id)); },
+  };
+  const motsDePasse = createPasswordAuth({ credentials: identifiants, findUser: trouverUtilisateur, resetTokens: jetons });
+  // L'invitation : même magasin, durée plus longue (un invité n'ouvre pas son courriel dans la demi-heure).
+  const invitations = createPasswordAuth({ credentials: identifiants, findUser: trouverUtilisateur, resetTokens: jetons, limiter: false,
+    resetTtlMs: (config.invitationJours ?? 7) * 86400000 });
   const codes = createEmailCodeAuth({ findUser: async (l) => { const u = await d.findOne(S.User, { email: l }); return u ? { id: String(u.id) } : null; } });
   const vente = stripe ? createStripeSale({
     billing: facturation, stripe, webhookSecret, metadataKeys: META,
@@ -494,6 +512,53 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     });
   }
 
+  /**
+   * 0.8 — les MEMBRES du compte d'une session : la charge décide QUI peut s'en servir (le wagon ne connaît pas ses
+   * rôles). Inviter crée un membre du MÊME compte, au mot de passe impossible, et rend un lien d'activation (sept
+   * jours, `config.invitationJours`) : envoyé par courriel s'il y a un transport, toujours rendu à la charge, pour
+   * qu'elle le montre (un commerce n'a pas toujours de courriel).
+   */
+  const membresDe = (compteSession) => {
+    const cid = String(compteSession.id);
+    const lienDe = (token) => `${origine}/connexion/reinitialiser?t=${encodeURIComponent(token)}`;
+    const envoyerInvitation = async (courriel, nom, lien) => {
+      if (!transport) return false;
+      try {
+        await transport.envoyer({ to: courriel, subject: `${config.marque.nom} — invitation`,
+          text: [config.marque.nom, '', `${nom ? `${nom}, v` : 'V'}ous êtes invité(e). Choisissez votre mot de passe :`, lien, '', `Ce lien vaut ${config.invitationJours ?? 7} jours.`, ''].join('\n') });
+        return true;
+      } catch (e) { journal.warn(`wagon : invitation non partie : ${e?.message ?? e}`); return false; }
+    };
+    return {
+      async lister() {
+        const out = [];
+        for (const m of await comptes.membres.lister(cid)) {
+          const u = await d.findById(S.User, m.utilisateurId).catch(() => null);
+          out.push({ ...m, nom: u?.firstName ?? null, statut: u?.status !== 'active' ? 'suspendu' : (await motsDePasse.hasPassword(m.utilisateurId)) ? 'actif' : 'invite' });
+        }
+        return out;
+      },
+      async inviter({ courriel, nom = null, role = 'membre' } = {}) {
+        const r = await comptes.membres.ajouter(cid, courriel, String(role || 'membre'));
+        const n = String(nom ?? '').trim();
+        if (n) await d.update(S.User, r.utilisateurId, { firstName: n });
+        const { token, expiresAt } = await invitations.issueToken(r.utilisateurId);
+        const lien = lienDe(token);
+        return { ...r, nom: n || null, lien, expiresAt: new Date(expiresAt).toISOString(), courrielParti: await envoyerInvitation(r.courriel, n, lien) };
+      },
+      async reinviter(utilisateurId) {
+        const m = (await comptes.membres.lister(cid)).find((x) => x.utilisateurId === String(utilisateurId));
+        if (!m) throw Object.assign(new Error('Cet utilisateur n’est pas membre de ce compte.'), { code: 'NON_MEMBRE' });
+        const u = await d.findById(S.User, m.utilisateurId).catch(() => null);
+        const { token, expiresAt } = await invitations.issueToken(m.utilisateurId);
+        const lien = lienDe(token);
+        return { ...m, lien, expiresAt: new Date(expiresAt).toISOString(), courrielParti: await envoyerInvitation(m.courriel, u?.firstName, lien) };
+      },
+      changerRole: (utilisateurId, role) => comptes.membres.changerRole(cid, String(utilisateurId), String(role)),
+      retirer: (utilisateurId) => comptes.membres.retirer(cid, String(utilisateurId)),
+    };
+  };
+
   async function handler(req, res) {
     const url = new URL(req.url, 'http://wagon.local');
     const chemin = url.pathname;
@@ -693,7 +758,10 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       try { await transport.envoyer(m); return true; } catch (e) { journal.warn(`wagon : courriel de la charge non parti : ${e?.message ?? e}`); return false; }
     };
     const ctx = { chemin, methode, lang, t, ui, page, envoyer, json, rediriger, formulaire, corpsJson, compte, consommer, refuser, palier, plafond, courriel, admin: estAdmin && !compteCle,
-      paiement: paiementCharge };   // 0.7 — null sans banque prépayée active
+      paiement: paiementCharge,   // 0.7 — null sans banque prépayée active
+      // 0.8 — la PERSONNE de la session (sans empreinte) et son rôle dans le compte ; les membres du compte.
+      utilisateur: compteCle ? null : (qui?.utilisateur ?? null), role: compteCle ? null : (qui?.role ?? null),
+      membres: qui && !compteCle ? membresDe(qui.compte) : null };
     if (charge.routes && (await charge.routes(req, res, ctx))) return true;
     if (chemin.startsWith('/api/')) return json(404, { ok: false, error: 'introuvable' });
 
@@ -729,6 +797,10 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     // 0.5 — « mot de passe oublié » n'existe que si un courriel peut partir : un accusé de réception d'un message que
     // personne n'enverra serait pire qu'une page absente (auth-plug T-KIT-5).
     const oubliPossible = methodeConnexion === 'motdepasse' && !!transport;
+    // 0.8 — la page qui consomme un jeton est servie dès que l'on se connecte par mot de passe : le lien d'une
+    // INVITATION remis de la main à la main (sans courriel) doit fonctionner. Seule la DEMANDE (/connexion/oubli)
+    // exige un courriel possible.
+    const reinitPossible = methodeConnexion === 'motdepasse';
     if (chemin === '/inscription') {
       const tous = await paliersEnBase();
       const palierDe = (slug) => tous.find((p) => p.slug === slug && p.active !== false) ?? tous.find((p) => p.slug === (config.planGratuit ?? 'gratuit'));
@@ -775,11 +847,18 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
     if (chemin === '/connexion') {
       const suite = suiteSure(url.searchParams.get('suite'));
       const action = avecSuite('/connexion', suite);
-      if (methode === 'GET') return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, methode: methodeConnexion, action }) + (oubliPossible ? `<p class="hint"><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` : '') }));
+      // 0.8 — `charge.vues.connexion({ lang, action, erreur, oubli })` rend la page ENTIÈRE à la place de wagon-ui
+      // (champs « courriel » et « motdepasse », POST vers `action`) : l'écran de la maquette de la greffe.
+      const vueConnexion = methodeConnexion === 'motdepasse' && typeof charge.vues?.connexion === 'function' ? charge.vues.connexion : null;
+      if (methode === 'GET') {
+        if (vueConnexion) return envoyer(200, await vueConnexion({ lang, action, erreur: null, oubli: oubliPossible ? '/connexion/oubli' : null }));
+        return envoyer(200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, methode: methodeConnexion, action }) + (oubliPossible ? `<p class="hint"><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` : '') }));
+      }
       const f = await formulaire();
       if (methodeConnexion === 'motdepasse') {
         const r = await motsDePasse.login(String(f.courriel ?? ''), String(f.motdepasse ?? ''), { ip: ipClient(req) });
-        if (r.ok) return ouvrirSession(r.userId, suite ?? '/compte');
+        if (r.ok) return ouvrirSession(r.userId, suite ?? config.apresConnexion ?? '/compte');
+        if (vueConnexion) return envoyer(r.reason === 'throttled' ? 429 : 200, await vueConnexion({ lang, action, erreur: t('espace.identifiantsFaux'), oubli: oubliPossible ? '/connexion/oubli' : null }));
         return envoyer(r.reason === 'throttled' ? 429 : 200, page({ titre: t('espace.seConnecter'), contenu: ui.connexion({ lang, erreur: t('espace.identifiantsFaux'), action }) }));
       }
       const courriel = String(f.courriel ?? '').trim().toLowerCase();
@@ -826,15 +905,36 @@ export async function creerWagon({ config, charge, sgbd, baseUrl, stripe = null,
       }
       return true;
     }
-    if (oubliPossible && chemin === '/connexion/reinitialiser') {
+    if (reinitPossible && chemin === '/connexion/reinitialiser') {
       const formulaireReinit = (tk, erreur = '') => `<h1>${esc(TC.reinit)}</h1>${erreur ? `<p class="msg">${esc(erreur)}</p>` : ''}<form method="post" action="/connexion/reinitialiser"><input type="hidden" name="t" value="${esc(tk)}"><p><label>${esc(TC.nouveau)} <input type="password" name="nouveau" required autocomplete="new-password"></label></p><p><label>${esc(TC.confirmer)} <input type="password" name="confirmer" required autocomplete="new-password"></label></p><button class="bouton">${esc(TC.enregistrer)}</button></form>`;
-      if (methode === 'GET') return envoyer(200, page({ titre: TC.reinit, contenu: formulaireReinit(url.searchParams.get('t') ?? '') }));
+      // 0.8 — `charge.vues.reinitialiser({ lang, jeton, utilisateur, erreur, expire })` rend la page ENTIÈRE (champs
+      // « t », « nouveau », « confirmer ») : une invitation s'y présente (« Bienvenue …, vous êtes invité comme … »).
+      // `utilisateur` (id, courriel, prenom) est lu sur le jeton SANS le consommer ; null si le lien ne vaut plus.
+      const vueReinit = typeof charge.vues?.reinitialiser === 'function' ? charge.vues.reinitialiser : null;
+      const porteurDe = async (tk) => {
+        const e = tk ? await jetons.get(createHash('sha256').update(String(tk)).digest('base64url')) : null;
+        if (!e || e.expiresAt < Date.now()) return null;
+        const u = await d.findById(S.User, e.userId).catch(() => null);
+        return u ? { id: String(u.id), courriel: u.email, prenom: u.firstName ?? null } : null;
+      };
+      const vueR = async (code, tk, erreur) => {
+        const u = await porteurDe(tk);
+        return envoyer(code, await vueReinit({ lang, jeton: tk, utilisateur: u, erreur, expire: !u, minimum: motsDePasse.policy.minLength }));
+      };
+      if (methode === 'GET') {
+        if (vueReinit) return vueR(200, url.searchParams.get('t') ?? '', null);
+        return envoyer(200, page({ titre: TC.reinit, contenu: formulaireReinit(url.searchParams.get('t') ?? '') }));
+      }
       const f = await formulaire();
-      if (String(f.nouveau ?? '') !== String(f.confirmer ?? '')) return envoyer(400, page({ titre: TC.reinit, contenu: formulaireReinit(String(f.t ?? ''), TC.differents) }));
+      if (String(f.nouveau ?? '') !== String(f.confirmer ?? '')) {
+        if (vueReinit) return vueR(400, String(f.t ?? ''), TC.differents);
+        return envoyer(400, page({ titre: TC.reinit, contenu: formulaireReinit(String(f.t ?? ''), TC.differents) }));
+      }
       const r = await motsDePasse.consumeReset(String(f.t ?? ''), String(f.nouveau ?? ''));
+      if (!r.ok && vueReinit) return vueR(400, String(f.t ?? ''), r.reason === 'policy' ? t('espace.faible', { motifs: (r.issues ?? []).join(', ') }) : TC.lienMort);
       if (!r.ok) return envoyer(400, page({ titre: TC.reinit, contenu: r.reason === 'policy' ? formulaireReinit(String(f.t ?? ''), t('espace.faible', { motifs: (r.issues ?? []).join(', ') })) : `<h1>${esc(TC.reinit)}</h1><p class="msg">${esc(TC.lienMort)}</p><p><a href="/connexion/oubli">${esc(TC.oublie)}</a></p>` }));
       await sessions.fermerToutes(String(r.userId));
-      return ouvrirSession(r.userId);
+      return ouvrirSession(r.userId, config.apresConnexion ?? '/compte');
     }
 
     // L'espace du client.