@mostajs/wagon-engine 0.0.0-stage → 0.1.1

package/src/demarrer.mjs

@@ -0,0 +1,68 @@
+/**
+ * @mostajs/wagon-engine — le démarrage d'une greffe : tout ce que faisaient les server.mjs copiés.
+ * @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+ *
+ * Lit le .env de la greffe (@mostajs/config), monte le courriel, les moyens de paiement actifs et la base, puis
+ * écoute. Un moyen de paiement est ACTIF quand ses clés sont dans le .env (et, pour une banque prépayée, quand
+ * wagon.config.mjs la propose) ; `PAIEMENT_<MOYEN>=off` le coupe sans toucher à ses clés (comme RestoTrax).
+ * L'utilisateur choisit parmi les moyens actifs sur l'écran de paiement du wagon.
+ */
+import { createServer } from 'node:http';
+import { appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadEnv, getEnv } from '@mostajs/config';
+import { creerWagon } from './wagon.mjs';
+
+const coupe = (moyen) => getEnv(`PAIEMENT_${moyen.toUpperCase()}`, '') === 'off';
+
+/** Les courriels : SMTP (avec DKIM si la clé est publiée), ou un fichier pour les essais. */
+async function transport() {
+  const fichier = getEnv('WAGON_COURRIEL_FICHIER', '');
+  if (fichier) return { envoyer: async (m) => appendFileSync(fichier, `${JSON.stringify(m)}\n`, { mode: 0o600 }) };
+  const host = getEnv('WAGON_EMAIL_SERVER_HOST', '');
+  if (!host) return null;
+  const { createSmtpLiteDriver } = await import('@mostajs/mailer');
+  const pilote = createSmtpLiteDriver({ host, port: Number(getEnv('WAGON_EMAIL_SERVER_PORT', '587')), user: getEnv('WAGON_EMAIL_SERVER_USER', ''), pass: getEnv('WAGON_EMAIL_SERVER_PASSWORD', '') });
+  const de = getEnv('WAGON_EMAIL_FROM', getEnv('WAGON_EMAIL_SERVER_USER', ''));
+  return { envoyer: (m) => pilote.send({ from: de, ...m }) };
+}
+
+/**
+ * Les banques PRÉPAYÉES prêtes : leurs clés sont dans le .env (@mostajs/payment les y relit pour vérifier chaque
+ * webhook). Une banque sans clé n'est pas proposée : elle échouerait au moment de payer.
+ */
+const PRETES = {
+  chargily: () => getEnv('CHARGILY_SECRET_KEY', '') || getEnv('CHARGILY_API_KEY', ''),
+  paypal: () => getEnv('PAYPAL_CLIENT_ID', '') && getEnv('PAYPAL_SECRET', '') && getEnv('PAYPAL_WEBHOOK_ID', ''),
+  // 0.10 du gabarit — le terminal aussi : SATIM l'exige à l'ouverture du paiement.
+  satim: () => getEnv('SATIM_MERCHANT_ID', '') && getEnv('SATIM_PASSWORD', '') && getEnv('SATIM_TERMINAL_ID', ''),
+};
+
+/**
+ * @param {{ config: object, charge: object, racine?: string, journal?: Pick<Console, 'log'|'warn'|'error'> }} o
+ * @returns {Promise<{ wagon: object, serveur: import('node:http').Server, moyens: string[], fermer(): Promise<void> }>}
+ */
+export async function demarrer({ config, charge, racine = process.cwd(), journal = console }) {
+  loadEnv({ path: join(racine, '.env') });
+  const cle = coupe('stripe') ? '' : (getEnv('WAGON_STRIPE_RESTRICTED_KEY', '') || getEnv('WAGON_STRIPE_SECRET_KEY', ''));
+  const banques = Object.fromEntries(Object.entries(config.paiement?.prepaye ?? {}).filter(([b]) => PRETES[b]?.() && !coupe(b)));
+  const wagon = await creerWagon({
+    config, charge, racine, journal,
+    sgbd: { dialect: getEnv('WAGON_DB_DIALECT', 'sqlite'), uri: getEnv('WAGON_SGBD', join(racine, 'data', 'wagon.db')) },
+    baseUrl: getEnv('WAGON_BASE_URL', 'http://localhost:4800'),
+    stripe: cle ? new (await import('stripe')).default(cle) : null,
+    webhookSecret: getEnv('WAGON_STRIPE_WEBHOOK_SECRET', ''),
+    transport: await transport(),
+    paiement: { banques },
+  });
+  await wagon.catalogue();
+  const moyens = [...(cle ? ['stripe'] : []), ...Object.keys(banques)];
+  const serveur = createServer(wagon.handler);
+  const port = Number(getEnv('PORT', '4800'));
+  await new Promise((ok) => serveur.listen(port, getEnv('HOST', '127.0.0.1'), ok));
+  journal.log(`✅ ${config.marque.nom} → http://127.0.0.1:${serveur.address().port} · paiement : ${moyens.join(', ') || 'aucun'}`);
+  return {
+    wagon, serveur, moyens,
+    async fermer() { serveur.closeAllConnections?.(); await new Promise((ok) => serveur.close(() => ok())); await wagon.fermer(); },
+  };
+}

package/src/index.js

@@ -0,0 +1,7 @@
+// @mostajs/wagon-engine — le wagon d'un SaaS, une fois pour toutes.
+// Author: Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+// La suite de conformité, qui juge une greffe, est publiée à part : '@mostajs/wagon-engine/conformite'.
+export { creerWagon, schemasWagon } from './wagon.mjs';
+export { demarrer } from './demarrer.mjs';
+export { sauvegarder } from './sauvegarde.mjs';
+export { suivrePalette } from './palette.mjs';

package/src/palette.mjs

@@ -0,0 +1,41 @@
+/**
+ * mosta-wagon — LA MARQUE SE GÈRE DANS PALETTE STUDIO (palette.amia.fr), comme pour qatrax.dev et mdseal.
+ * @author Dr Hamid MADANI <drmdh@msn.com> · AGPL-3.0-or-later
+ *
+ * Repris de qatrax-cra (src/vitrine/palette.mjs, 02/10/2026) pour que toute greffe en profite. Côté SERVEUR :
+ * le thème (`/theme.css?site=<projet>`, un `:root{…}` de jetons) est relu toutes les `ttlMs` et posé dans
+ * chaque page par @mostajs/wagon-ui (option `theme`) — aucun script à autoriser dans la CSP, et un changement
+ * fait dans Palette Studio se voit sans redéploiement.
+ *
+ * ⚠️ Palette Studio ne refuse pas un projet inconnu : il rend le thème d'un AUTRE (constaté sur mdseal). On
+ * vérifie donc d'abord que le projet existe ; sinon, la greffe garde les couleurs de wagon.config.mjs.
+ */
+export function suivrePalette({ source, projet, ttlMs = 60000, journal = console } = {}) {
+  let css = '';
+  let lu = 0;
+  let enCours = null;
+  let averti = false;
+  async function rafraichir() {
+    lu = Date.now();
+    try {
+      const liste = await (await fetch(`${source}/api/projects`, { signal: AbortSignal.timeout(5000) })).json();
+      if (!Array.isArray(liste?.projects) || !liste.projects.includes(projet)) {
+        if (!averti) { journal.warn(`[palette] projet « ${projet} » absent de ${source} : couleurs de wagon.config.mjs gardées`); averti = true; }
+        css = '';
+        return;
+      }
+      averti = false;
+      const r = await fetch(`${source}/theme.css?site=${encodeURIComponent(projet)}`, { signal: AbortSignal.timeout(5000) });
+      const t = r.ok ? (await r.text()).trim() : '';
+      if (/^:root\s*\{[^{}<]*\}$/.test(t)) css = t; // sinon : on garde le dernier thème sain
+    } catch { /* source muette : on garde le dernier thème connu */ }
+  }
+  return {
+    rafraichir,
+    /** Le thème courant ; relance une lecture en arrière-plan quand il a vieilli. Ne bloque jamais une page. */
+    css() {
+      if (Date.now() - lu > ttlMs && !enCours) enCours = rafraichir().finally(() => { enCours = null; });
+      return css;
+    },
+  };
+}

package/src/sauvegarde.mjs

@@ -0,0 +1,76 @@
+/**
+ * mosta-wagon 0.6 — LA SAUVEGARDE HORS SERVEUR (audit du 09/10/2026 : rien ne sauvegardait data/).
+ *
+ * Reprise de mdseal et qatrax.dev (scripts/sauvegarde-distante.mjs) : tout le travail est fait par `@mostajs/backup`
+ * (archive, empreintes, scellement X25519, test de restauration, rétention) et `@mostajs/blob-store` (dépôt).
+ * Ce module n'ajoute que la GÉNÉRALISATION au wagon : plusieurs cibles (la base des comptes, la base de la charge),
+ * les fichiers d'une cible (les photos d'une agence), et la copie cohérente d'une base sqlite EN SERVICE.
+ *
+ * Règles reprises, et non négociables (DEVRULES-SAAS-APP §5.3 à §5.5) :
+ *   - ce qui sort du serveur sort SCELLÉ : sans destinataire, refus AVANT toute copie ;
+ *   - l'archive se restaure sur une base jetable AVANT le dépôt ; sinon, rien n'est déposé ;
+ *   - la rétention ne purge qu'après un dépôt réussi.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ */
+import { mkdtempSync, readdirSync, readFileSync, rmSync, statSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative, sep } from 'node:path';
+import { createBackup, storeBackup, testRestore, pruneBackups } from '@mostajs/backup';
+
+/** Les fichiers d'un dossier, chemins relatifs (séparateur « / »). */
+function fichiersDe(dossier) {
+  const sortie = [];
+  const parcourir = (d) => {
+    for (const nom of readdirSync(d)) {
+      const p = join(d, nom);
+      if (statSync(p).isDirectory()) parcourir(p);
+      else sortie.push({ path: relative(dossier, p).split(sep).join('/'), content: readFileSync(p) });
+    }
+  };
+  if (dossier && existsSync(dossier)) parcourir(dossier);
+  return sortie;
+}
+
+/**
+ * Une copie COHÉRENTE d'une base sqlite en service : `VACUUM INTO` prend un instantané transactionnel (lire le fichier
+ * pendant une écriture peut rendre une base tronquée que rien ne signale — constaté sur qatrax le 29/09/2026).
+ */
+async function copieSqlite(uri, cible) {
+  const Database = (await import('better-sqlite3')).default;
+  const db = new Database(uri, { readonly: true, fileMustExist: true });
+  try { db.exec(`VACUUM INTO '${cible.replaceAll("'", "''")}'`); } finally { db.close(); }
+  return cible;
+}
+
+/**
+ * Sauvegarde chaque cible : copie cohérente (sqlite), archive scellée (+ fichiers), restauration éprouvée, dépôt, rétention.
+ * @param {object} o
+ * @param {{ site: string, source: { dialect: string, uri: string, schemas: object[] }, fichiers?: string }[]} o.cibles
+ * @param {object} o.driver   un pilote @mostajs/blob-store (disque d'un autre serveur, S3…)
+ * @param {string} o.seau
+ * @param {Uint8Array[]} o.recipients  clés PUBLIQUES X25519 : l'hébergeur conserve sans pouvoir ouvrir
+ * @param {number} [o.garder]  combien d'archives garder par cible (défaut 30)
+ * @returns {Promise<{ site, total, fichiers, verifie, contenu, scellee, chemin }[]>}
+ */
+export async function sauvegarder({ cibles, driver, seau, recipients, garder = 30, journal = console, createdBy = 'mosta-wagon/scripts/sauvegarde.mjs' }) {
+  if (!recipients?.length) throw new Error('aucun destinataire de scellement : une sauvegarde hors serveur ne part que scellée (rien n’a été copié)');
+  const rapports = [];
+  for (const c of cibles) {
+    const atelier = mkdtempSync(join(tmpdir(), 'wagon-sauv-'));
+    try {
+      const source = c.source.dialect === 'sqlite' ? { ...c.source, uri: await copieSqlite(c.source.uri, join(atelier, 'copie.db')) } : c.source;
+      const fichiers = fichiersDe(c.fichiers);
+      const archive = await createBackup({ source, siteId: c.site, createdBy, recipients, extras: fichiers.length ? { files: fichiers } : undefined });
+      const total = Object.values(archive.counts).reduce((s, n) => s + n, 0);
+      const rendu = await testRestore(archive.plainBuffer, { schemas: c.source.schemas });
+      if (!rendu.verifie) throw new Error(`${c.site} : l’archive ne se restaure pas — RIEN n’a été déposé (${(rendu.ecarts ?? []).join(' · ')})`);
+      const ref = await storeBackup(driver, seau, archive);
+      await pruneBackups(driver, seau, c.site, { keepLast: garder });
+      journal.log?.(`✓ ${c.site} : ${total} enregistrement(s), ${fichiers.length} fichier(s), restauration éprouvée${rendu.contenu === 'verifie' ? ' (contenu identique)' : ''}, déposée en ${ref.bucket}/${ref.path}${archive.sealed ? ', scellée' : ''}`);
+      rapports.push({ site: c.site, total, fichiers: fichiers.length, verifie: true, contenu: rendu.contenu, scellee: !!archive.sealed, chemin: ref.path });
+    } finally {
+      rmSync(atelier, { recursive: true, force: true });
+    }
+  }
+  return rapports;
+}