discovery-media-player 0.1.70 → 0.1.71

package/context/standalone.js

@@ -269,6 +269,18 @@ function createStandaloneContext(env = process.env) {
       }),
       // Écriture de fichier : hors périmètre d'une instance autonome (elle sert, elle ne range pas).
       async put() { throw new Error("storage.put n'est pas disponible sans câblage d'hôte"); },
+      // Optionnelle (rétention) : efface un objet du bucket — faux si l'API Storage est absente.
+      async remove(bucket, chemin) {
+        const base = sansBarreFinale(env.SUPABASE_URL);
+        const cle = String(env.SUPABASE_SERVICE_ROLE_KEY || "");
+        if (!base || !cle || !bucket || !chemin) return false;
+        try {
+          const r = await fetch(`${base}/storage/v1/object/${bucket}/${chemin}`, {
+            method: "DELETE", headers: { apikey: cle, Authorization: `Bearer ${cle}` },
+          });
+          return r.ok;
+        } catch { return false; }
+      },
 
       /**
        * URL d'envoi signée, pour une pièce jointe de chat. **Capacité de l'HÔTE**, pas du cœur.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.70",
+  "version": "0.1.71",
   "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

@@ -29,6 +29,7 @@ function init(ctx) {
   PLAYER = ctx;
   // Le domaine reçoit le même contexte : une seule construction pour tout le player.
   require("./shares").init(ctx);
+  require("./retention").init(ctx);
   require("./presentations").init(ctx);
   require("./brands").init(ctx);
   // ⚠️ Réinitialisé avec le contexte : les réponses de la sonde valent pour UNE base. Un hôte qui
@@ -3535,8 +3536,23 @@ async function handler(req, res) {
       // ⚠️ QUI a le droit de diffuser un document est en revanche une règle de l'HÔTE, pas du
       // player : elle passe par le contexte (`identity.canManageShares`). Le player se contente de
       // vérifier le jeton. Sans réponse de l'hôte : refus.
+      // ── RÉTENTION (docs/RETENTION.md) ────────────────────────────────────────────────────────
+      // Déclenchement explicite : hôte de confiance ou admin. Renvoie les comptes DÉCLARÉS —
+      // le recensement indépendant (SQL nu) est l'autre moitié du contrat, pas cette route.
+      if (body.action === "retention.run") {
+        const jd = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
+        try {
+          const hote = !!(PLAYER.identity.isTrustedHostCall && PLAYER.identity.isTrustedHostCall(req.headers));
+          let admin = false;
+          if (!hote) { const u = await PLAYER.identity.verifyToken(req.headers.authorization); admin = !!(u && PLAYER.identity.isAdmin(u)); }
+          if (!hote && !admin) return jd(403, { ok: false, error: "retention.run : hôte de confiance ou admin requis" });
+          return jd(200, await require("./retention").purgerRetention(Date.now()));
+        } catch (e) { try { PLAYER.errors.capture(e, { route: "retention" }); } catch { /* jamais bloquant */ } return jd(500, { ok: false }); }
+      }
       if (String(body.action || "").startsWith("docshare.")) {
         const jd = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
+        // Balayage de rétention opportuniste — au plus un par 24 h, jamais bloquant.
+        try { require("./retention").tick(); } catch { /* jamais bloquant */ }
         try {
           // ── L'HÔTE PARLE EN SON NOM PROPRE ────────────────────────────────────────────────
           //

package/server/retention.js

@@ -0,0 +1,92 @@
+// LA PURGE DÉCLARE, LE RECENSEMENT LA CONTREDIT.
+//
+// Ce module est UNE des deux moitiés du contrat de rétention (docs/RETENTION.md) : il efface ce
+// qui a dépassé sa fenêtre et DÉCLARE ses comptes, table par table. L'autre moitié —
+// `supabase/recensement-retention.sql` — recompte en SQL nu ce qui reste dans le périmètre
+// revendiqué, sans partager une ligne, une fonction ni un filtre avec ce fichier : deux textes
+// qui ne peuvent pas être faux de la même manière. La forge les confronte sur une base réelle.
+//
+// ⚠️ Le compte déclaré vient des LIGNES RENDUES par le DELETE (`Prefer: return=representation`,
+// select réduit à une colonne), jamais d'un comptage préalable : ce qui est déclaré est ce qui a
+// été fait, pas ce qui était prévu.
+//
+// ⚠️ L'absence ne se prouve pas ici : ce module peut seulement dire ce qu'il a effacé. La
+// question « son périmètre couvre-t-il ce qui existe ? » appartient à la garde de forge qui
+// confronte les colonnes du schéma vivant à docs/RETENTION.md.
+
+let PLAYER = null;
+const init = (ctx) => { PLAYER = ctx; };
+const enc = encodeURIComponent;
+
+// Fenêtres par défaut de docs/RETENTION.md — l'hôte ajuste via `config.retention`.
+const FENETRES = { journauxMois: 13, presentationsMois: 12, liensRevoquesMois: 13 };
+const fenetres = () => ({ ...FENETRES, ...((PLAYER.config && PLAYER.config.retention) || {}) });
+
+// Borne calendaire : N mois avant `now`, en ISO — les fenêtres de RETENTION.md parlent en mois.
+function borne(now, mois) { const d = new Date(now); d.setMonth(d.getMonth() - mois); return d.toISOString(); }
+
+async function effacer(chemin) {
+  const lignes = await PLAYER.db.request(chemin, { method: "DELETE", headers: { Prefer: "return=representation" } });
+  return Array.isArray(lignes) ? lignes.length : 0;
+}
+
+// Chemin du bucket depuis l'URL publique d'une pièce jointe — nul si l'URL vient d'ailleurs.
+function cheminPieceJointe(url) {
+  const m = /\/present-attachments\/(.+)$/.exec(String(url || ""));
+  return m ? m[1].split("?")[0] : null;
+}
+
+async function purgerRetention(now) {
+  const f = fenetres();
+  const efface = {};
+  const bJournaux = borne(now, f.journauxMois);
+
+  efface.commercial_doc_views = await effacer(`commercial_doc_views?at=lt.${enc(bJournaux)}&select=id`);
+  efface.commercial_doc_sessions = await effacer(`commercial_doc_sessions?last_at=lt.${enc(bJournaux)}&select=session_id`);
+  efface.commercial_doc_internal_sessions = await effacer(`commercial_doc_internal_sessions?last_at=lt.${enc(bJournaux)}&select=session_id`);
+  efface.doc_bot_sessions = await effacer(`doc_bot_sessions?last_at=lt.${enc(bJournaux)}&select=id`);
+  efface.player_rate_limits = await effacer(`player_rate_limits?expires_at=lt.${enc(new Date(now).toISOString())}&select=key`);
+
+  // Liens révoqués : seulement là où la révocation est DATÉE (0013) — sans la colonne, la purge
+  // resterait muette plutôt que d'inventer une borne depuis l'âge du lien.
+  const dateDispo = await require("./schema").attendue("revocationDatee");
+  efface.commercial_doc_shares = dateDispo
+    ? await effacer(`commercial_doc_shares?revoked=eq.true&revoked_at=lt.${enc(borne(now, f.liensRevoquesMois))}&select=slug`)
+    : 0;
+
+  // Présentations mortes : la ligne, ses messages, ses présences — et les fichiers du bucket si
+  // l'hôte fournit storage.remove (capacité OPTIONNELLE : sans elle, la limite est écrite dans
+  // RETENTION.md plutôt que simulée ici).
+  const bPres = borne(now, f.presentationsMois);
+  const mortes = await PLAYER.db.request(`doc_presentations?active=eq.false&updated_at=lt.${enc(bPres)}&select=slug`);
+  efface.doc_presentations = 0; efface.doc_presentation_messages = 0;
+  efface.doc_presentation_attendees = 0; efface.pieces_jointes = 0;
+  const retirer = PLAYER.storage && typeof PLAYER.storage.remove === "function" ? PLAYER.storage.remove.bind(PLAYER.storage) : null;
+  for (const p of (Array.isArray(mortes) ? mortes : [])) {
+    const slug = p && p.slug; if (!slug) continue;
+    if (retirer) {
+      const jointes = await PLAYER.db.request(`doc_presentation_messages?slug=eq.${enc(slug)}&attachment=not.is.null&select=attachment`);
+      for (const j of (Array.isArray(jointes) ? jointes : [])) {
+        const chemin = cheminPieceJointe(j && j.attachment);
+        if (!chemin) continue;
+        try { if (await retirer("present-attachments", chemin)) efface.pieces_jointes += 1; } catch { /* le fichier survit, la ligne part quand même — limite dite */ }
+      }
+    }
+    efface.doc_presentation_messages += await effacer(`doc_presentation_messages?slug=eq.${enc(slug)}&select=id`);
+    efface.doc_presentation_attendees += await effacer(`doc_presentation_attendees?slug=eq.${enc(slug)}&select=attendee_key`);
+    efface.doc_presentations += await effacer(`doc_presentations?slug=eq.${enc(slug)}&select=slug`);
+  }
+  return { ok: true, efface };
+}
+
+// Balayage opportuniste : au plus UN par fenêtre de 24 h (le verrou est le compteur de débit
+// partagé — même mécanique que les limites, donc multi-processus sans coordination). Jamais
+// bloquant : la route qui l'héberge répond sans l'attendre, l'échec se capture.
+function tick() {
+  Promise.resolve()
+    .then(() => PLAYER.limits.allow("retention:sweep", 1, 86400))
+    .then((permis) => { if (permis) return purgerRetention(Date.now()); })
+    .catch((e) => { try { PLAYER.errors.capture(e, { route: "retention", benin: true }); } catch { /* jamais bloquant */ } });
+}
+
+module.exports = { init, purgerRetention, tick, cheminPieceJointe };

package/server/schema.js

@@ -47,6 +47,11 @@ const ATTENDUES = {
     migration: "supabase/migrations/0011-liens-uniques.sql",
     fonction: "empêcher deux demandes simultanées de créer deux liens système pour le même usage",
   },
+  revocationDatee: {
+    table: "commercial_doc_shares", colonne: "revoked_at",
+    migration: "supabase/migrations/0013-revocation-datee.sql",
+    fonction: "dater la révocation pour borner la rétention des liens révoqués",
+  },
   reactionsOrdonnees: {
     table: "doc_presentation_messages", colonne: "reactions_seq",
     migration: "supabase/migrations/0006-reactions-ordonnees.sql",

package/server/shares.js

@@ -345,7 +345,9 @@ async function sendReshareEmail({ parent, childSlug, origin, toEmail, toName })
 }
 
 async function revokeShare(slug) {
-  await PLAYER.db.request(`commercial_doc_shares?slug=eq.${enc(String(slug || ""))}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { revoked: true } });
+  // La date borne la rétention (RETENTION.md) — écrite seulement là où la colonne existe (0013).
+  const dateDispo = await require("./schema").attendue("revocationDatee");
+  await PLAYER.db.request(`commercial_doc_shares?slug=eq.${enc(String(slug || ""))}`, { method: "PATCH", headers: { Prefer: "return=minimal" }, body: { revoked: true, ...(dateDispo ? { revoked_at: new Date().toISOString() } : {}) } });
 }
 
 // Soft wall : (dé)verrouille l'accès d'un lien /doc — require_auth=true → connexion visiteur exigée.

package/supabase/init.sql

@@ -39,6 +39,7 @@ create table if not exists public.commercial_doc_shares (
   created_by      text,
   created_at      timestamptz not null default now(),
   revoked         boolean not null default false,
+  revoked_at      timestamptz,               -- date de l'acte : borne la rétention (RETENTION.md)
   parent_slug     text,                      -- re-partage : le lien d'où celui-ci est issu
   bot_enabled     boolean not null default false,
   bot_script      text,
@@ -423,6 +424,9 @@ alter table public.doc_presentation_messages
   add column if not exists client_key text;
 alter table public.commercial_doc_shares
   add column if not exists idem_key text;
+alter table public.commercial_doc_shares
+  add column if not exists revoked_at timestamptz;
+update public.commercial_doc_shares set revoked_at = now() where revoked = true and revoked_at is null;
 -- Une base née d'un init.sql d'avant la 0008 porte un NOT NULL qui rend la clôture impossible.
 alter table public.doc_presentations
   alter column control_hash drop not null;

package/supabase/migrations/0013-revocation-datee.sql

@@ -0,0 +1,21 @@
+-- LA RÉVOCATION N'AVAIT PAS DE DATE — « 13 MOIS APRÈS RÉVOCATION » ÉTAIT INCALCULABLE.
+--
+-- docs/RETENTION.md promet la purge des liens révoqués 13 mois après leur révocation ; or le
+-- schéma ne portait que `revoked boolean` et `created_at`. Sans date, la politique serait restée
+-- une phrase — ou aurait pris l'âge du lien comme borne, purgeant un lien révoqué d'hier parce
+-- qu'il est né il y a deux ans. La colonne date l'acte ; le backfill démarre l'horloge des
+-- révoqués existants À MAINTENANT (leur date réelle est perdue — compter large plutôt qu'inventer).
+--
+-- Sans lui : rien ne casse — la purge des liens révoqués reste simplement inactive (sonde de
+-- schéma négative), les autres purges tournent.
+alter table public.commercial_doc_shares
+  add column if not exists revoked_at timestamptz;
+
+comment on column public.commercial_doc_shares.revoked_at is
+  'Date de révocation du lien — borne la rétention (purge N mois après, cf. docs/RETENTION.md). '
+  'Nulle tant que le lien vit. Les révoqués d''avant cette colonne ont reçu la date de la '
+  'migration : leur horloge démarre là.';
+
+update public.commercial_doc_shares
+  set revoked_at = now()
+  where revoked = true and revoked_at is null;

package/supabase/recensement-retention.sql

@@ -0,0 +1,54 @@
+-- LE RECENSEMENT INDÉPENDANT — L'AUTRE MOITIÉ DU CONTRAT DE RÉTENTION.
+--
+-- Ce fichier recompte, en SQL nu, ce qui RESTE dans le périmètre que docs/RETENTION.md revendique.
+-- Il ne partage RIEN avec `server/retention.js` : ni fonction, ni filtre, ni transport — deux
+-- textes écrits séparément, qui ne peuvent pas être faux de la même manière (l'erreur partagée
+-- rend un compte juste ; l'indépendance est la propriété, pas un style). Les fenêtres (13/12/13
+-- mois) sont le CONTRAT commun : elles viennent du document, pas du code.
+--
+-- Usage : psql -f supabase/recensement-retention.sql — chaque ligne rend « table|restantes ».
+-- Après une purge, tout doit être à zéro ; un reste est un mensonge de la purge OU un trou de
+-- son périmètre. La forge l'exécute à chaque course, après le banc base.
+select 'commercial_doc_views' as perimetre, count(*) as restantes
+  from public.commercial_doc_views
+  where at < now() - interval '13 months'
+union all
+select 'commercial_doc_sessions', count(*)
+  from public.commercial_doc_sessions
+  where last_at < now() - interval '13 months'
+union all
+select 'commercial_doc_internal_sessions', count(*)
+  from public.commercial_doc_internal_sessions
+  where last_at < now() - interval '13 months'
+union all
+select 'doc_bot_sessions', count(*)
+  from public.doc_bot_sessions
+  where last_at < now() - interval '13 months'
+union all
+select 'player_rate_limits', count(*)
+  from public.player_rate_limits
+  where expires_at < now()
+union all
+select 'commercial_doc_shares_revoques', count(*)
+  from public.commercial_doc_shares
+  where revoked and revoked_at < now() - interval '13 months'
+union all
+select 'doc_presentations_mortes', count(*)
+  from public.doc_presentations
+  where not active and updated_at < now() - interval '12 months'
+union all
+-- Messages et présences : orphelins d'une présentation morte-ancienne OU d'aucune présentation —
+-- formulé par NOT EXISTS, pas par la liste de slugs que la purge a construite.
+select 'doc_presentation_messages_orphelins', count(*)
+  from public.doc_presentation_messages m
+  where not exists (
+    select 1 from public.doc_presentations p
+    where p.slug = m.slug
+      and (p.active or p.updated_at >= now() - interval '12 months'))
+union all
+select 'doc_presentation_attendees_orphelins', count(*)
+  from public.doc_presentation_attendees a
+  where not exists (
+    select 1 from public.doc_presentations p
+    where p.slug = a.slug
+      and (p.active or p.updated_at >= now() - interval '12 months'));