discovery-media-player 0.1.2 → 0.1.4

package/README.md

@@ -87,6 +87,9 @@ forking it. A fix lands once and reaches every instance on its next deploy.
 - **Node / Express / Next.js** — same handler, mounted on a route
 - **Standalone** — `npm start`, or the Docker image
 
+It reads `req.query` when the platform provides it (serverless, Express) and falls back to parsing
+`req.url` when it does not — so a bare `http.createServer` works too, without a shim.
+
 See [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the boundary, and
 [`docs/API.md`](docs/API.md) for the surface an integrator implements.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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/__tests__/audienceEtat.test.js

@@ -0,0 +1,90 @@
+// @vitest-environment jsdom
+//
+// L'AUDIENCE DOIT VRAIMENT ÊTRE BRANCHÉE SUR L'ÉTAT DU PRÉSENTATEUR.
+//
+// ⚠️ Ce test existe à cause d'une panne en production. `appliquerEtat` était défini dans un bloc
+// de script, et l'abonnement à la diffusion écrit dans le SUIVANT — autre portée. La référence
+// n'existait pas, la ReferenceError partait dans un try/catch muet, et l'audience n'avait aucun
+// écouteur d'état. Invisible pendant tout le temps où une seconde voie (lecture de table) portait
+// la page ; « les pages ne tournent plus » le jour où on l'a retirée pour fermer une fuite.
+//
+// La leçon : deux voies qui font la même chose ne se valident pas l'une l'autre. Tant que la
+// seconde existait, aucun test ne pouvait dire laquelle marchait. On exécute donc la page.
+
+// ⚠️ AVANT de requérir le gestionnaire : il déstructure ses dépendances au chargement, donc une
+// substitution plus tardive n'aurait aucun effet — il partirait chercher la vraie base.
+const PRESENTATION_ID = require.resolve("../presentations.js");
+const vraiesPresentations = require("../presentations.js");
+const PRESENTATION = {
+  slug: "Ab3-_xYz9012", doc_title: "Démo", file_name: "demo.pdf",
+  file_url: "https://exemple.supabase.co/storage/v1/object/public/resources/demo.pdf",
+  current_page: 1, active: true, updated_at: "2026-08-13T00:00:00.000Z",
+};
+require.cache[PRESENTATION_ID] = {
+  id: PRESENTATION_ID, filename: PRESENTATION_ID, loaded: true,
+  exports: { ...vraiesPresentations, getPresentation: async () => ({ ...PRESENTATION }), listMessages: async () => [] },
+};
+
+const player = require("../handler.js");
+
+function contexteMinimal() {
+  return {
+    plugins: {}, has: () => false,
+    storage: { isAllowedUrl: () => true, async fetchFile() { return null; }, async put() {} },
+    db: { async request() { return []; }, async selectAll() { return []; } },
+    mail: { async send() {} },
+    identity: { async verifyToken() { return null; }, roleOf: () => "", isAdmin: () => false, async canManageShares() { return false; } },
+    limits: { async allow() { return true; } },
+    branding: { async logo() { return ""; }, name: "", poweredBy: "", loaderName: "", async forKey() { return null; }, title: (b) => b },
+    errors: { async capture() {} },
+    legal: { sourceUrl: "", legalUrl: "", privacyUrl: "", trackingNotice: "" },
+    config: { supabaseUrl: "https://exemple.supabase.co", supabasePublishableKey: "cle", mapsKey: "", extraFrameAncestors: [] },
+  };
+}
+
+async function pageAudience() {
+  player.init(contexteMinimal());
+  const res = {
+    statusCode: 0, headers: {}, body: "",
+    setHeader(k, v) { this.headers[k.toLowerCase()] = v; },
+    end(b) { this.body = String(b == null ? "" : b); },
+  };
+  await player.handler({ method: "GET", headers: {}, socket: {}, query: { present: PRESENTATION.slug } }, res);
+  return res.body;
+}
+
+describe("page audience", () => {
+  it("expose vraiment le gestionnaire que la couche live doit brancher", async () => {
+    const html = await pageAudience();
+
+    // ⚠️ On EXÉCUTE la page. Le test statique ne pouvait pas voir le défaut : le code fautif
+    // contenait bien l'appel à onState — il référençait simplement un nom absent de cette
+    // portée-là. Seule l'exécution distingue « écrit » de « branché ».
+    window.supabase = { createClient: () => ({ channel: () => { const c = { on: () => c, subscribe: () => c }; return c; } }) };
+    for (const m of html.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/g)) {
+      // `window.eval` et pas `new Function` : les scripts déclarent des `var` au niveau global,
+      // qu'une portée de fonction rendrait invisibles au bloc suivant — c'est exactement le
+      // genre de nuance de portée qui a produit le bug.
+      try { window.eval(m[1]); } catch { /* les scripts qui dépendent de pdf.js ne nous intéressent pas */ }
+    }
+
+    expect(typeof window.__presAppliquerEtat,
+      "le gestionnaire d'état n'est pas exposé : la couche live, définie dans un autre bloc, ne peut pas le brancher")
+      .toBe("function");
+  });
+
+  it("branche ce gestionnaire-là, et pas un nom hors de portée", async () => {
+    const html = await pageAudience();
+    expect(html).toContain("Live.onState(window.__presAppliquerEtat)");
+  });
+
+  // Il ne doit plus rester une seule voie qui exige une table lisible publiquement.
+  it("n'ouvre aucun abonnement à une table", async () => {
+    expect(await pageAudience()).not.toContain("postgres_changes");
+  });
+
+  // Un câblage raté doit se dire. C'est le silence, pas le bug, qui a coûté la journée.
+  it("crie si la couche live manque, au lieu d'avaler l'erreur", async () => {
+    expect(await pageAudience()).toContain("console.error('[present]");
+  });
+});

package/server/__tests__/plateforme.test.js

@@ -0,0 +1,82 @@
+// LE GESTIONNAIRE NE DOIT DÉPENDRE D'AUCUNE PLATEFORME.
+//
+// Le README promet « Vercel, Next.js, Express, ou le serveur HTTP de Node — le même gestionnaire ».
+// C'était vrai à une convention près, jamais écrite : il lisait `req.query`, que les plateformes
+// serverless et Express remplissent, mais qu'un serveur HTTP nu laisse indéfini.
+//
+// ⚠️ ET LE SYMPTÔME ÉTAIT LE PIRE POSSIBLE. Sans paramètres, la requête cherchait un partage nommé
+// « rien » et rendait « Ce lien n'est plus valide ou a été révoqué ». Un intégrateur voyait un
+// REFUS là où il lui manquait un branchement — l'inversion exacte qu'on passe notre temps à
+// corriger. Signalé par un hôte qui montait le player sur http.createServer : chez lui, ça aurait
+// marché en production par chance, pas par construction.
+
+const player = require("../handler.js");
+
+function contexteMinimal() {
+  return {
+    plugins: {}, has: () => false,
+    storage: { isAllowedUrl: () => false, async fetchFile() { return null; }, async put() {} },
+    db: { async request() { return []; }, async selectAll() { return []; } },
+    mail: { async send() {} },
+    identity: { async verifyToken() { return null; }, roleOf: () => "", isAdmin: () => false, async canManageShares() { return false; } },
+    limits: { async allow() { return true; } },
+    branding: { async logo() { return ""; }, name: "", poweredBy: "", loaderName: "", async forKey() { return null; }, title: (b) => b },
+    errors: { async capture() {} },
+    legal: { sourceUrl: "", legalUrl: "", privacyUrl: "", trackingNotice: "" },
+    config: { supabaseUrl: "", supabasePublishableKey: "", mapsKey: "", extraFrameAncestors: [] },
+  };
+}
+
+async function appel(req) {
+  player.init(contexteMinimal());
+  const res = {
+    statusCode: 0, headers: {}, body: "",
+    setHeader(k, v) { this.headers[k.toLowerCase()] = v; },
+    end(b) { this.body = String(b == null ? "" : b); },
+  };
+  await player.handler({ method: "GET", headers: {}, socket: {}, ...req }, res);
+  return res;
+}
+
+describe("d'où viennent les paramètres", () => {
+  // La convention serverless : la plateforme a déjà analysé l'URL.
+  it("utilise req.query quand la plateforme le fournit", async () => {
+    const res = await appel({ query: { contract: "1" } });
+    expect(res.statusCode).toBe(200);
+    expect(JSON.parse(res.body).contract).toBe(1);
+  });
+
+  // ⚠️ Le cas qui produisait « lien révoqué ». Un serveur HTTP nu ne remplit pas req.query.
+  it("les retrouve dans req.url quand elle ne le fournit pas", async () => {
+    const res = await appel({ url: "/api/doc?contract=1" });
+    expect(res.statusCode).toBe(200);
+    expect(JSON.parse(res.body).contract).toBe(1);
+  });
+
+  it("ne se laisse pas troubler par une URL absurde", async () => {
+    const res = await appel({ url: "pas une url du tout" });
+    expect(res.statusCode).toBe(400);
+  });
+});
+
+describe("quand rien n'est demandé", () => {
+  // ⚠️ LE POINT. Ni slug, ni présentation, ni aperçu : il n'y a rien à afficher, et ce n'est PAS
+  // un refus. Rendre la page de révocation envoyait l'intégrateur chercher un lien mort.
+  it("le dit, au lieu d'afficher « lien révoqué »", async () => {
+    const res = await appel({ query: {} });
+    expect(res.statusCode).toBe(400);
+    expect(res.body).toContain("Aucun document demandé");
+    expect(res.body).not.toContain("révoqué");
+  });
+
+  it("oriente vers la cause réelle : les paramètres de requête", async () => {
+    expect((await appel({ query: {} })).body).toMatch(/paramètres de requête/);
+  });
+
+  // Un slug inconnu, LUI, est bien un refus : la distinction doit rester nette dans les deux sens.
+  it("un slug inconnu reste un refus, pas une erreur de branchement", async () => {
+    const res = await appel({ query: { slug: "Inconnu-1234" } });
+    expect(res.statusCode).toBe(404);
+    expect(res.body).toContain("révoqué");
+  });
+});

package/server/handler.js

@@ -397,8 +397,8 @@ var Live=(function(){
     try{sb=window.supabase.createClient(LIVECFG.supaUrl,LIVECFG.supaKey,{realtime:{params:{eventsPerSecond:10}}});
       ch=sb.channel('plive-'+slug,{config:{presence:{key:(me.email||me.name||'x')+':'+MYID}}});
       ch.on('presence',{event:'sync'},function(){renderPres(ch.presenceState());});
-      ch.on('postgres_changes',{event:'INSERT',schema:'public',table:'doc_presentation_messages',filter:'slug=eq.'+slug},function(p){if(p&&p.new&&addMsg(p.new))notifyMsg(p.new);});
-      ch.on('postgres_changes',{event:'UPDATE',schema:'public',table:'doc_presentation_messages',filter:'slug=eq.'+slug},function(p){if(p&&p.new)updateMsg(p.new);});
+      // Plus d'abonnement à la table des messages : elle n'est plus publiée ni lisible
+      // publiquement. Tout passe par la diffusion, et l'historique par la route de chat.
       ch.on('broadcast',{event:'msg'},function(p){if(p&&p.payload&&addMsg(p.payload))notifyMsg(p.payload);});
       ch.on('broadcast',{event:'msg-upd'},function(p){if(p&&p.payload)updateMsg(p.payload);});
       ch.on('broadcast',{event:'typing'},function(p){onTyping(p&&p.payload);});
@@ -2016,6 +2016,12 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
     // diffusion temps réel. La règle d'ordre (terminée > carte > changement de doc > page) et la
     // re-validation du contenu vivent dans le module, pas ici.
     var _etatVu='';
+    // ⚠️ EXPOSÉ HORS DE CETTE FERMETURE, ET C'EST INDISPENSABLE. La couche Live est définie dans
+    // le bloc de script SUIVANT : y appeler onState avec ce nom-ci référence une fonction qui
+    // n'existe pas dans cette portée-là. L'exception partait dans un try/catch muet, donc
+    // l'audience n'avait aucun écouteur de diffusion — invisible tant que la lecture de table
+    // portait encore la page, puis « les pages ne tournent plus » le jour où on l'a retirée.
+    window.__presAppliquerEtat = appliquerEtat;
     function appliquerEtat(row){
       if(!row) return;
       // La table et la diffusion portent la même vérité : sans cette garde, chaque changement de
@@ -2042,16 +2048,13 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
     document.addEventListener('visibilitychange',function(){ if(document.visibilityState==='visible') relireEtat(); });
     window.addEventListener('online', relireEtat);
 
-    // Realtime : suivre la page courante + la fin de session (UPDATE de notre ligne).
-    try{
-      if(window.supabase && CFG.supaUrl && CFG.supaKey){
-        var sb=window.supabase.createClient(CFG.supaUrl, CFG.supaKey, {realtime:{params:{eventsPerSecond:5}}});
-        sb.channel('present-'+CFG.slug)
-          .on('postgres_changes',{event:'UPDATE',schema:'public',table:'doc_presentations',filter:'slug=eq.'+CFG.slug},function(payload){
-            appliquerEtat(payload && payload.new);
-          }).subscribe();
-      }
-    }catch(e){}
+    // ⚠️ PLUS D'ABONNEMENT À LA TABLE ICI. Il exigeait une lecture publique de
+    // de la table des présentations — donc, avec la clé publiable, TOUTES les présentations de
+    // l'instance. L'état arrive par diffusion du présentateur, et la relecture d'état ci-dessus
+    // rattrape les arrivées tardives et les retours d'onglet en interrogeant le serveur.
+    //
+    // Le laisser en place n'était pas neutre : il ouvrait un abonnement qui ne recevra jamais
+    // rien, ce qui donne l'impression que le suivi est branché alors qu'il ne l'est pas.
     // Si on rejoint alors que le présentateur est DÉJÀ sur une carte / Street View → l'afficher dès que Map3DD est prêt.
     if(CFG.content && (CFG.content.kind==='map'||CFG.content.kind==='streetview')){ var _mi=setInterval(function(){ if(window.Map3DD){ clearInterval(_mi); if(CFG.content.kind==='streetview')Map3DD.enterSV(CFG.content,false); else Map3DD.enter(CFG.content,false); } },100); setTimeout(function(){ clearInterval(_mi); },8000); }
   })();
@@ -2067,7 +2070,16 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
     // L'état arrive maintenant par DEUX voies : la table (historique) et la diffusion du
     // présentateur (nouvelle). Les deux passent par le même filtre, qui ignore un état déjà
     // appliqué — recevoir deux fois la même chose ne doit pas re-rendre la page.
-    try{ if(window.Live) Live.onState(appliquerEtat); }catch(e){}
+    // Par la référence exposée plus haut : le nom local n'existe pas dans cette portée-ci.
+    try{
+      if(!window.Live || !window.__presAppliquerEtat) throw new Error('couche live absente');
+      Live.onState(window.__presAppliquerEtat);
+    }catch(e){
+      // PLUS DE SILENCE ICI. Ce try/catch a avalé une ReferenceError : l'audience n'avait aucun
+      // ecouteur d'etat, ce qui ne se voyait pas tant qu'une seconde voie portait la page. Un
+      // cablage rate doit se dire, meme si la page continue de vivre.
+      console.error('[present] suivi de l etat non branche :', e && e.message);
+    }
     // « Reprendre la main » : si le membre connecté (même origine) devient propriétaire de CETTE présentation
     // (après un transfert), on affiche un bouton pour ouvrir la visionneuse en pilotage — sinon on ne peut pas
     // piloter depuis la page audience.
@@ -2101,9 +2113,34 @@ async function readJsonBody(req) {
   });
 }
 
+/**
+ * Paramètres de la requête, quelle que soit la plateforme.
+ *
+ * Le gestionnaire lit `req.query` — la convention des plateformes serverless (Vercel, Next.js) et
+ * d'Express. Un serveur HTTP nu ne la remplit pas : `req.query` est alors `undefined`, et TOUT
+ * paramètre disparaît.
+ *
+ * ⚠️ CE QUE ÇA DONNAIT, ET POURQUOI C'ÉTAIT LE PIRE DES SYMPTÔMES. Sans paramètres, la requête
+ * partait chercher un partage nommé « rien », n'en trouvait pas, et affichait « Ce lien n'est plus
+ * valide ou a été révoqué ». Un intégrateur voyait donc un REFUS là où il n'avait simplement pas
+ * branché la plateforme. C'est exactement l'inversion qu'on passe notre temps à corriger : une
+ * erreur de câblage ne doit jamais ressembler à une décision.
+ *
+ * Signalé par un hôte qui montait le player sur `http.createServer` : chez lui ça aurait marché en
+ * production (Vercel remplit `req.query`) — par chance, pas par construction.
+ */
+function parametres(req) {
+  if (req.query && typeof req.query === "object") return req.query;
+  try {
+    return Object.fromEntries(new URL(req.url || "/", "http://interne").searchParams);
+  } catch {
+    return {};
+  }
+}
+
 async function handler(req, res) {
   try {
-    const q = req.query || {};
+    const q = parametres(req);
     const slug = String(q.slug || "").trim();
 
     if (req.method === "POST") {
@@ -2484,6 +2521,17 @@ async function handler(req, res) {
       return;
     }
 
+    // AUCUN DOCUMENT DEMANDÉ. Ni slug, ni présentation, ni aperçu, ni carte d'identité — il n'y a
+    // rien à afficher, et ce n'est pas un refus. Le dire franchement évite qu'un intégrateur
+    // cherche un lien révoqué là où il lui manque un paramètre.
+    if (req.method === "GET" && !slug && !q.present && !q.preview && !q.contract) {
+      res.statusCode = 400;
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      res.end("Aucun document demandé. Attendu : ?slug=… , ?present=… , ?preview=1 ou ?contract=1.\n" +
+              "Si vous intégrez le player, vérifiez que la plateforme fournit les paramètres de requête.");
+      return;
+    }
+
     // ── CARTE D'IDENTITÉ (`?contract=1`) ─────────────────────────────────────────────────────
     // La règle 4 du contrat demande à l'hôte d'épingler la version qu'il vise et de le VÉRIFIER.
     // Sans point d'interrogation, cette règle était une intention : un hôte ne pouvait pas écrire