discovery-media-player 0.1.36 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Self-hosted document viewer: per-recipient tracked links, reading analytics, live presentation. The core knows nothing about the application hosting it — everything it borrows arrives through an injected context.",
   "keywords": [
     "pdf-viewer",

package/server/handler.js

@@ -2577,7 +2577,22 @@ async function handler(req, res) {
           try {
             if (!body.slug || !visitor || !visitor.email) return;
             await PLAYER.db.request("xp_visitor_unlocks", { method: "POST", headers: { Prefer: "return=minimal" }, body: [{ doc_slug: String(body.slug), email: visitor.email, name: visitor.name || null, method }] });
-          } catch { /* best-effort */ }
+          } catch (e) {
+      // ⚠️ TROUVÉ EN VÉRIFIANT LE TARBALL DE 0.1.37, PAS PAR LA GARDE QUI VENAIT DE NAÎTRE.
+      //
+      // Celle-ci filtrait sur une LISTE DE NOMS de fonctions d'écriture. `recordUnlock` écrit
+      // directement par `PLAYER.db.request`, donc elle ne l'a pas vu — exactement le défaut que
+      // l'audit reprochait à la garde des prototypes, reproduit dans une garde écrite le même jour
+      // pour éviter ce genre de chose.
+      //
+      // La garde vise désormais la FORME (toute écriture en base rattrapée en silence), pas des
+      // noms. Une liste ne voit que ce qu'on y a mis ; une forme voit aussi le prochain.
+      try {
+        if (await PLAYER.limits.allow("unlock:echec", 1, 3600)) {
+          PLAYER.errors.capture(new Error(`déverrouillage visiteur non journalisé : ${e && e.message ? e.message : "cause inconnue"}`), { route: "visitor-unlock" });
+        }
+      } catch { /* un journal ne doit jamais empêcher une lecture */ }
+    }
         };
         if (body.action === "visitor-google") {
           const r = await V.verifyGoogle(body.credential);
@@ -3139,7 +3154,29 @@ async function handler(req, res) {
             userName: jeton ? (jeton.name || body.name) : body.name,
             numPages: body.numPages, maxPage: body.maxPage, totalSeconds: body.totalSeconds, pagesTime: body.pagesTime,
           }, { ip: ip0, ua: ua0 });
-        } catch { /* best-effort */ }
+        } catch (e) {
+          // ⚠️ CE `catch` A COÛTÉ UNE JOURNÉE À UN HÔTE, ET IL ÉTAIT À TROIS LIGNES DU COMMENTAIRE
+          // QUI DIT DE NE PAS FAIRE ÇA.
+          //
+          // La ligne écrite portait `ua` et `ip` ; la table des sessions internes ne les a pas.
+          // PostgREST refusait, ce `catch` avalait le refus, et la route répondait `{"ok":true}`.
+          // Ni le second hôte ni nous n'avions une seule ligne mesurée — notre table de production
+          // en comptait ZÉRO — et rien, nulle part, ne le disait.
+          //
+          // « best-effort » est une intention juste : une mesure ne doit jamais empêcher de lire un
+          // document. Mais best-effort ne veut pas dire MUET. Ce qu'on rattrape ici, c'est le droit
+          // de continuer — pas le droit de ne rien dire.
+          //
+          // ⚠️ La leçon dépasse ce bloc : une règle écrite dans un commentaire ne protège pas le
+          // code qui la suit. C'est pourquoi elle est aussi devenue un test —
+          // server/__tests__/ecritureMuette.test.js refuse tout `catch` vide autour d'une écriture
+          // de mesure.
+          try {
+            if (await PLAYER.limits.allow("intsess:echec", 1, 3600)) {
+              PLAYER.errors.capture(new Error(`écriture de session interne refusée : ${e && e.message ? e.message : "cause inconnue"} — la mesure ne s'enregistre pas`), { route: "internal-session" });
+            }
+          } catch { /* un journal ne doit jamais empêcher une lecture */ }
+        }
         res.statusCode = 200; res.setHeader("Content-Type", "application/json"); res.end('{"ok":true}');
         return;
       }
@@ -3149,7 +3186,19 @@ async function handler(req, res) {
           // 'session' = résumé riche (temps par page, appareil) → upsert ; open/page/heartbeat → journal léger (funnel/overview).
           if (body.event === "session") await upsertSession(share, { sessionId: body.sessionId, numPages: body.numPages, maxPage: body.maxPage, totalSeconds: body.totalSeconds, pagesTime: body.pagesTime }, { ip: ip0, ua: ua0 });
           else await logView(share, { event: body.event, page: body.page, maxPage: body.maxPage, seconds: body.seconds, sessionId: body.sessionId, ua: ua0 });
-        } catch { /* best-effort */ }
+        } catch (e) {
+          // ⚠️ LE MÊME `catch` MUET, SUR LE CHEMIN EXTERNE. Trouvé par la garde écrite pour
+          // l'interne : une fois la règle devenue un test, elle a désigné son jumeau.
+          //
+          // Celui-ci n'a rien cassé jusqu'ici — la table des sessions externes a bien les colonnes
+          // qu'on lui envoie. Mais il aurait avalé le prochain écart de la même façon, et personne
+          // n'aurait rien vu : c'est ce qui rend la classe dangereuse, pas l'instance.
+          try {
+            if (await PLAYER.limits.allow("sess:echec", 1, 3600)) {
+              PLAYER.errors.capture(new Error(`écriture de mesure refusée : ${e && e.message ? e.message : "cause inconnue"} — la lecture n'est pas comptée`), { route: "track" });
+            }
+          } catch { /* un journal ne doit jamais empêcher une lecture */ }
+        }
       }
       res.statusCode = 200; res.setHeader("Content-Type", "application/json"); res.end('{"ok":true}');
       return;

package/server/shares.js

@@ -344,7 +344,11 @@ async function setShareAuth(slug, requireAuth) {
 // signalé au point d'entrée plutôt qu'ici.
 const BORNES = { pages: 10_000, secondes: 24 * 3600, entreesPagesTime: 2_000 };
 
-async function upsertInternalSession(p, { ip, ua }) {
+// ⚠️ `ip` N'EST PLUS LU, ET LA SIGNATURE LE DIT. L'appelant continue de le passer — il ne sait pas
+// ce que chaque table conserve, et ce n'est pas à lui de le savoir. Mais le garder en paramètre
+// nommé laisserait croire qu'il sert : c'est comme ça qu'une donnée revient dans une ligne où elle
+// n'a rien à faire. Une lecture interne, c'est un collègue ; on ne conserve pas son adresse.
+async function upsertInternalSession(p, { ip: _ip, ua }) {
   const num = (v) => (Number.isFinite(+v) ? Math.trunc(+v) : null);
   const borne = (v, max) => { const n = num(v); return n == null ? null : Math.max(0, Math.min(n, max)); };
   const sessionId = String(p.sessionId || "").slice(0, 64);
@@ -390,7 +394,24 @@ async function upsertInternalSession(p, { ip, ua }) {
       }
       return out;
     })(),
-    ua: String(ua || "").slice(0, 300), ip: String(ip || "").slice(0, 60), device, os, browser, last_at: new Date().toISOString(),
+    // ⚠️ NI `ua` NI `ip` ICI, ET C'EST LE CORRECTIF — PAS UNE COLONNE À AJOUTER.
+    //
+    // Ces deux champs partaient vers une table qui ne les a pas. PostgREST refusait l'insertion
+    // (« column "ua" ... does not exist »), le `catch` de l'appelant avalait le refus, et la route
+    // répondait `{"ok":true}`. Le suivi interne n'a donc JAMAIS rien écrit — ni chez le second
+    // hôte, ni chez nous : notre table de production comptait zéro ligne.
+    //
+    // ⚠️ Le schéma avait raison, c'est le code qui mentait. Une lecture INTERNE, c'est un collègue :
+    // `device`, `os` et `browser` — dérivés — suffisent, et on ne conserve pas l'agent complet ni
+    // l'adresse de ses propres équipes. La table des sessions EXTERNES les porte, elle, parce que
+    // ce n'est ni la même population ni la même promesse.
+    //
+    // Corriger en AJOUTANT les colonnes aurait fait l'inverse : mettre le schéma au niveau du code
+    // au lieu du code au niveau de l'intention. Ce qu'on garde sur ses propres équipes ne se décide
+    // pas par un message d'erreur PostgREST.
+    //
+    // Trouvé par le second hôte, vérifié en rejouant l'insertion.
+    device, os, browser, last_at: new Date().toISOString(),
   };
   await PLAYER.db.request("commercial_doc_internal_sessions?on_conflict=session_id", { method: "POST", headers: { Prefer: "resolution=merge-duplicates,return=minimal" }, body: [row] });
 }