Files
photobooth-qr/supabase/functions/admin-gallery/index.ts
T
KevinLecouandClaude Opus 5.5 6a507e0bc5 fix: galerie sans retéléchargement, ZIP par parties, suppression de photo, miniatures, liens admin et slugs non devinables
- Galerie fête : ne remplace plus l'URL signée d'une image déjà affichée (egress ~10 Go/h par écran)
- ZIP découpé en parties (300 photos / 100 Mo), liens directs sans blob en mémoire
- Suppression d'une photo par l'admin (original + miniature), POST authentifié par admin_token
- Miniatures 480 px générées côté client, ZIP et téléchargement gardent l'original
- Token admin dans le fragment (#token=), nginx sans access_log sur /admin/, logs Docker bornés
- Slug avec suffixe aléatoire de 6 hex pour les nouveaux événements

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 19:07:01 +02:00

557 lines
22 KiB
TypeScript

// Edge Function `admin-gallery`
//
// Contrat (fixé par le chef de projet, à ne pas renommer) :
// GET {SUPABASE_URL}/functions/v1/admin-gallery?slug=<slug>&token=<admin_token>
// -> JSON galerie (+ zip_parts : nombre de parties du ZIP)
// GET ...&action=zip&part=<1..zip_parts> -> ZIP d'une partie (flux)
// POST ...&action=delete&photo_id=<uuid> -> supprime une photo (B1)
//
// ⚠️ Déploiement : verify_jwt = false requis. Les parties du ZIP sont des
// liens directs (<a href>) que le navigateur télécharge en flux, sans header
// Authorization possible. La clé publishable n'apportait aucune sécurité
// (publique) : l'accès repose sur admin_token, vérifié ci-dessous.
//
// Tourne avec la service_role key (cf. _shared/supabase-admin.ts).
//
// Changement d'architecture (2026-09-16) : les tables photobooth.events /
// photobooth.photos ne sont PLUS accessibles, même en service_role, via une
// requête `.from(...)` classique — le schéma `photobooth` n'est jamais
// exposé via PostgREST (cf.
// supabase/migrations/20260916090000_create_photobooth_schema.sql). Tout
// passe désormais par des RPC `public.get_event_for_admin` /
// `public.get_event_photos`, réservées à service_role côté SQL (grants).
//
// Pas d'auth Supabase (pas de compte admin en V1, cf. docs/decisions.md) :
// la sécurité repose entièrement sur `admin_token`, comparé ici (jamais en
// SQL) en temps constant.
//
// ⚠️ Ne pas déployer depuis cet agent (pas de `deploy_edge_function`) :
// fichier fourni pour relecture humaine avant déploiement (Kévin applique
// lui-même via son accès MCP Supabase direct).
//
// Dépendance : "jsr:@zip-js/zip-js" pour la génération de ZIP en flux
// (cf. plus bas, section `action=zip`). Non testée en exécution dans cet
// environnement (pas d'accès réseau/deploy) — à valider avec
// `supabase functions serve` avant premier déploiement réel.
import { getSupabaseAdmin, getStorageBucket, thumbPathOf } from "../_shared/supabase-admin.ts";
import { corsHeaders, handleCorsPreflight } from "../_shared/cors.ts";
import { timingSafeEqual } from "../_shared/timing-safe.ts";
import { TextReader, Uint8ArrayReader, ZipWriter } from "jsr:@zip-js/zip-js";
// URL signées affichées dans la galerie admin : courte durée, c'est pour un
// affichage/téléchargement immédiat dans le navigateur de l'admin, pas pour
// un lien à partager (cf. consigne de tâche).
const GALLERY_SIGNED_URL_TTL_SECONDS = 10 * 60; // 10 minutes
// URLs signées utilisées en interne par la fonction pour lire les fichiers
// et les empaqueter dans le ZIP : pas renvoyées au client, la durée n'a donc
// pas besoin d'être aussi courte, mais doit couvrir le temps de génération
// du ZIP en cas de gros volume.
const ZIP_INTERNAL_SIGNED_URL_TTL_SECONDS = 30 * 60; // 30 minutes
// Découpage du ZIP en parties (audit B3). Limite Supabase (doc "Edge
// Functions > Limits", lue le 2026-10-15) : 150 s de durée max par worker en
// plan Free (400 s en payant), 256 Mo de RAM, 2 s de CPU. Une partie doit
// donc être téléchargée en entier en < 150 s par le client : 100 Mo
// demandent ~5,5 Mbit/s soutenus. Plafond en nombre aussi (1 requête
// Storage par photo). Plan payant : on peut monter à ~250 Mo.
const MAX_ZIP_PART_BYTES = 100 * 1024 * 1024;
const MAX_ZIP_PART_PHOTOS = 300;
const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
function jsonResponse(status: number, body: unknown): Response {
return new Response(JSON.stringify(body), {
status,
headers: { ...corsHeaders(), "Content-Type": "application/json" },
});
}
// Réponse générique utilisée à la fois pour "event inconnu" et "token
// invalide" : MÊME statut HTTP (404) et MÊME corps dans les deux cas.
//
// ⚠️ Écart assumé par rapport à la consigne initiale du 2026-09-15 ("404 si
// absent, 403 si mismatch, même forme de réponse que le 404") : si les deux
// cas renvoient des STATUTS HTTP différents (404 vs 403), un attaquant peut
// malgré tout distinguer "slug inconnu" de "slug connu mais token invalide"
// rien qu'en lisant le code HTTP, même si le corps JSON est identique — ce
// qui va à l'encontre de l'objectif explicitement énoncé. Pour respecter
// l'objectif de sécurité plutôt que la lettre de la consigne, les deux cas
// renvoient ici exactement la même réponse (statut ET corps). Toujours à
// confirmer avec le chef de projet / Kévin — non retranché depuis le
// rapport du 2026-09-15.
function notFoundOrForbidden(): Response {
return jsonResponse(404, { error: "not_found" });
}
function sanitizeFilenamePart(input: string | null | undefined, fallback: string): string {
// NFKD décompose les caractères accentués en (lettre de base + marque
// diacritique combinante) ; le filtre `[^\w \-]` qui suit élimine ensuite
// ces marques (elles ne font pas partie de `\w`), on récupère donc la
// lettre de base sans accent, sans avoir besoin d'une plage unicode
// explicite dédiée.
const cleaned = (input ?? "")
.normalize("NFKD")
.replace(/[^\w \-]+/g, "")
.trim()
.slice(0, 40);
const withDashes = cleaned.replace(/\s+/g, "-");
return withDashes.length > 0 ? withDashes : fallback;
}
function extensionFromPath(path: string): string {
const match = /\.([a-zA-Z0-9]+)$/.exec(path);
return match ? match[1].toLowerCase() : "jpg";
}
type PhotoRow = {
id: string;
nom_invite: string | null;
message: string | null;
uploaded_at: string;
url_storage: string;
size_bytes: number;
};
// Découpage glouton dans l'ordre stable (uploaded_at, id) : renvoie l'index
// de début de chaque partie. Un ajout de photo ne change que la dernière
// partie ; une suppression décale les parties suivantes (le front le dit).
function zipPartStarts(photos: PhotoRow[]): number[] {
const starts: number[] = [];
let bytes = 0;
let count = 0;
for (let i = 0; i < photos.length; i++) {
const size = Number(photos[i].size_bytes) || 0;
if (
starts.length === 0 ||
count >= MAX_ZIP_PART_PHOTOS ||
(count > 0 && bytes + size > MAX_ZIP_PART_BYTES)
) {
starts.push(i);
bytes = 0;
count = 0;
}
bytes += size;
count++;
}
return starts;
}
type AdminEventRow = {
id: string;
nom: string;
statut: string;
date_evenement: string;
expire_at: string;
admin_token: string;
};
function buildZipEntryName(photo: PhotoRow, index: number, ext: string): string {
if (photo.nom_invite && photo.nom_invite.trim().length > 0) {
const safeName = sanitizeFilenamePart(photo.nom_invite, "invite");
return `${safeName}-${photo.id}.${ext}`;
}
return `photo-${index + 1}.${ext}`;
}
Deno.serve(async (req) => {
const preflight = handleCorsPreflight(req);
if (preflight) return preflight;
const url = new URL(req.url);
const slug = url.searchParams.get("slug");
const token = url.searchParams.get("token");
const action = url.searchParams.get("action");
// Suppression = POST uniquement (jamais un GET qu'un préchargement ou un
// robot pourrait déclencher) ; tout le reste = GET.
const expectedMethod = action === "delete" ? "POST" : "GET";
if (req.method !== expectedMethod) {
return jsonResponse(405, { error: "method_not_allowed" });
}
if (!slug || !token) {
return jsonResponse(400, { error: "missing_parameters" });
}
const supabaseAdmin = getSupabaseAdmin();
const bucket = getStorageBucket();
// 1. Charge l'event par slug via la RPC public.get_event_for_admin
// (service_role uniquement, renvoie admin_token en clair — jamais via une
// requête `.from("photobooth.events" | "events")`, cette table n'est pas
// exposée par PostgREST).
const { data: event, error: eventError } = await supabaseAdmin
.rpc("get_event_for_admin", { p_slug: slug })
.maybeSingle();
if (eventError) {
console.error("[admin-gallery] get_event_for_admin failed", eventError);
return jsonResponse(500, { error: "internal_error" });
}
if (!event) {
return notFoundOrForbidden();
}
const typedEvent = event as AdminEventRow;
// 2. Comparaison du token en temps constant (cf. _shared/timing-safe.ts).
// C'est la fonction SQL get_event_for_admin qui renvoie admin_token, mais
// c'est bien ICI, côté Deno, que la comparaison a lieu — jamais en SQL.
const tokenMatches = await timingSafeEqual(token, typedEvent.admin_token);
if (!tokenMatches) {
return notFoundOrForbidden();
}
// Pas de rate limiting / anti brute-force sur `token` (décision assumée,
// cf. rapport de tâche du 2026-09-15) : admin_token fait 256 bits
// d'entropie, un brute-force en ligne est impraticable en pratique.
if (action === "zip") {
// `slug` (paramètre déjà validé plus haut) sert de base au nom du
// fichier ZIP téléchargé : get_event_for_admin ne renvoie PAS le slug
// (signature fixée côté SQL, cf.
// 20260916090400_create_public_functions.sql), on réutilise donc
// directement celui de la query string plutôt que de modifier la RPC
// pour ça.
return await handleZipExport(
supabaseAdmin,
bucket,
typedEvent,
slug,
url.searchParams.get("part")
);
}
if (action === "delete") {
return await handleDeletePhoto(
supabaseAdmin,
bucket,
typedEvent,
url.searchParams.get("photo_id")
);
}
return await handleJsonGallery(supabaseAdmin, typedEvent);
});
async function fetchEventPhotos(
// deno-lint-ignore no-explicit-any
supabaseAdmin: any,
eventId: string
): Promise<PhotoRow[]> {
// public.get_event_photos_admin (service_role uniquement) : photos triées
// par uploaded_at ASC puis id, avec la taille du fichier, cf.
// 20261015120000_admin_delete_photo_and_zip_sizes.sql.
const { data, error } = await supabaseAdmin.rpc("get_event_photos_admin", {
p_event_id: eventId,
p_bucket: getStorageBucket(),
});
if (error) {
throw error;
}
return (data ?? []) as PhotoRow[];
}
async function handleJsonGallery(
// deno-lint-ignore no-explicit-any
supabaseAdmin: any,
event: AdminEventRow
): Promise<Response> {
let photosAsc: PhotoRow[];
try {
photosAsc = await fetchEventPhotos(supabaseAdmin, event.id);
} catch (err) {
console.error("[admin-gallery] get_event_photos failed", err);
return jsonResponse(500, { error: "internal_error" });
}
// Galerie admin : plus récent en premier. get_event_photos renvoie déjà
// un tableau trié ASC (chronologique) ; on l'inverse ici plutôt que
// d'ajouter un paramètre d'ordre à la RPC (le volume par événement reste
// modeste, quelques milliers au plus, donc un `.reverse()` en mémoire est
// largement suffisant).
const photosDesc = [...photosAsc].reverse();
// Une seule requête batch pour toutes les URLs signées (createSignedUrls),
// plutôt qu'un appel par photo : moins de requêtes réseau, cohérent avec
// le principe d'écoconception du projet (CLAUDE.md).
const signedUrlBypath = new Map<string, string>();
const thumbUrlByPath = new Map<string, string>();
if (photosDesc.length > 0) {
const paths = photosDesc.map((p) => p.url_storage);
const bucket = getStorageBucket();
const { data: signedUrls, error: signError } = await supabaseAdmin.storage
.from(bucket)
// Originaux + miniatures en une seule requête. Miniature absente
// (photo d'avant les miniatures, échec côté invité) : entrée en erreur,
// thumb_url null, le front affiche l'original.
.createSignedUrls([...paths, ...paths.map(thumbPathOf)], GALLERY_SIGNED_URL_TTL_SECONDS);
if (signError) {
console.error("[admin-gallery] createSignedUrls failed", signError);
return jsonResponse(500, { error: "internal_error" });
}
for (let i = 0; i < paths.length; i++) {
const thumbUrl = signedUrls?.[paths.length + i]?.signedUrl;
if (thumbUrl) thumbUrlByPath.set(paths[i], thumbUrl);
const entry = signedUrls?.[i];
if (entry?.signedUrl) {
signedUrlBypath.set(paths[i], entry.signedUrl);
} else if (entry?.error) {
// Une photo dont l'URL n'a pas pu être signée (ex. fichier absent du
// Storage alors que la ligne existe encore côté DB) ne doit pas
// faire échouer toute la galerie : on la renvoie avec
// signed_url: null, au front de gérer l'affichage.
console.warn(
`[admin-gallery] signed url failed for ${paths[i]}`,
entry.error
);
}
}
}
return jsonResponse(200, {
event: {
nom: event.nom,
date_evenement: event.date_evenement,
statut: event.statut,
photo_count: photosDesc.length,
},
zip_parts: zipPartStarts(photosAsc).length,
photos: photosDesc.map((p) => ({
id: p.id,
nom_invite: p.nom_invite,
message: p.message,
uploaded_at: p.uploaded_at,
signed_url: signedUrlBypath.get(p.url_storage) ?? null,
thumb_url: thumbUrlByPath.get(p.url_storage) ?? null,
expires_in: GALLERY_SIGNED_URL_TTL_SECONDS,
})),
});
}
async function handleZipExport(
// deno-lint-ignore no-explicit-any
supabaseAdmin: any,
bucket: string,
event: AdminEventRow,
slug: string,
partParam: string | null
): Promise<Response> {
let allPhotos: PhotoRow[];
try {
allPhotos = await fetchEventPhotos(supabaseAdmin, event.id);
} catch (err) {
console.error("[admin-gallery] zip: get_event_photos_admin failed", err);
return textResponse(500, "Le service est momentanément indisponible. Réessaie dans quelques instants.");
}
if (allPhotos.length === 0) {
return textResponse(404, "Il n'y a aucune photo à télécharger pour cet événement.");
}
const starts = zipPartStarts(allPhotos);
const part = partParam === null ? 1 : Number(partParam);
if (!Number.isInteger(part) || part < 1 || part > starts.length) {
return textResponse(
404,
`Cette partie du ZIP n'existe plus (l'export compte ${starts.length} partie(s)). Retourne sur la galerie et clique sur "Actualiser".`
);
}
const offset = starts[part - 1];
const photos = allPhotos.slice(offset, starts[part] ?? allPhotos.length);
const paths = photos.map((p) => p.url_storage);
const { data: signedUrls, error: signError } = await supabaseAdmin.storage
.from(bucket)
.createSignedUrls(paths, ZIP_INTERNAL_SIGNED_URL_TTL_SECONDS);
if (signError) {
console.error("[admin-gallery] zip: createSignedUrls failed", signError);
return textResponse(500, "Le service est momentanément indisponible. Réessaie dans quelques instants.");
}
// Construction du ZIP en FLUX (pas de Blob/Uint8Array accumulé en mémoire
// pour l'ensemble des photos) : on écrit dans un TransformStream, et on
// renvoie sa moitié "readable" comme corps de la Response immédiatement,
// pendant que la moitié "writable" continue de recevoir les fichiers
// (lus un par un depuis Storage, cf. fetchPhotoBytes). `level: 0`
// (STORE, pas de compression) : les photos sont déjà des JPEG compressés
// côté client (cf. src/e/upload.js), les recompresser dans le ZIP
// coûterait du CPU pour un gain quasi nul.
let streamController!: TransformStreamDefaultController<Uint8Array>;
const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>({
start(controller) {
streamController = controller;
},
});
const zipWriter = new ZipWriter(writable);
const usedNames = new Set<string>();
// Fire-and-forget assumé : on ne peut pas `await` la fin du ZIP avant de
// `return new Response(readable, ...)`, sinon on perdrait l'intérêt du
// streaming. La fonction Edge reste vivante tant que la réponse en
// streaming n'est pas entièrement consommée par le client.
// Photo illisible (Storage en erreur, fichier disparu) : on la saute et on
// la liste dans PHOTOS-MANQUANTES.txt à la fin du ZIP. Une fois le 200
// envoyé, on ne peut plus signaler d'erreur HTTP, et faire échouer le flux
// ne coupe pas la connexion (testé en local : téléchargement suspendu
// jusqu'au kill du worker à 150 s). Chaque photo est lue en entier
// (<= 6 Mo, cf. src/e/upload.js) AVANT d'être ajoutée : un échec de
// lecture ne peut donc pas laisser une entrée à moitié écrite.
const missing: string[] = [];
(async () => {
try {
for (let i = 0; i < photos.length; i++) {
const photo = photos[i];
const signed = signedUrls?.[i];
const bytes = signed?.signedUrl ? await fetchPhotoBytes(signed.signedUrl) : null;
if (!bytes) {
console.warn(`[admin-gallery] zip: missing ${photo.url_storage}`);
missing.push(`${photo.nom_invite ?? "invité anonyme"}, ${photo.uploaded_at} (id ${photo.id})`);
continue;
}
const ext = extensionFromPath(photo.url_storage);
// Index global (offset + i) : noms uniques d'une partie à l'autre.
let entryName = buildZipEntryName(photo, offset + i, ext);
// Garantit l'unicité même en cas de collision improbable.
let suffix = 1;
while (usedNames.has(entryName)) {
entryName = `${buildZipEntryName(photo, offset + i, ext).replace(`.${ext}`, "")}-${suffix}.${ext}`;
suffix++;
}
usedNames.add(entryName);
await zipWriter.add(entryName, new Uint8ArrayReader(bytes), {
level: 0,
});
}
if (missing.length > 0) {
await zipWriter.add(
"PHOTOS-MANQUANTES.txt",
new TextReader(
`${missing.length} photo(s) n'ont pas pu être ajoutées à cette partie.\n` +
`Retélécharge cette partie depuis la galerie admin.\n\n${missing.join("\n")}\n`
)
);
}
await zipWriter.close();
} catch (err) {
// Écriture du ZIP elle-même en échec (client parti, le plus souvent) :
// pas de close() qui livrerait un ZIP tronqué d'apparence complète.
console.error("[admin-gallery] zip: stream build failed", err);
streamController.error(err);
}
})();
const baseName = sanitizeFilenamePart(slug || event.nom, "export");
const zipFilename =
starts.length === 1 ? `${baseName}.zip` : `${baseName}-partie-${part}-sur-${starts.length}.zip`;
return new Response(readable, {
status: 200,
headers: {
...corsHeaders(),
"Content-Type": "application/zip",
"Content-Disposition": `attachment; filename="${zipFilename}"`,
},
});
}
// Lit une photo en entier, 1 nouvel essai si Storage échoue. null = échec
// (journalisé), à l'appelant de la déclarer manquante.
async function fetchPhotoBytes(signedUrl: string): Promise<Uint8Array | null> {
for (let attempt = 1; attempt <= 2; attempt++) {
try {
const res = await fetch(signedUrl);
if (res.ok) return new Uint8Array(await res.arrayBuffer());
console.warn(`[admin-gallery] zip: storage HTTP ${res.status} (essai ${attempt})`);
await res.body?.cancel();
} catch (err) {
console.warn(`[admin-gallery] zip: storage fetch failed (essai ${attempt})`, err);
}
}
return null;
}
// Réponses d'erreur du ZIP en texte lisible : la partie est ouverte par un
// lien direct (pas un fetch), c'est donc ce texte que l'organisateur voit.
function textResponse(status: number, message: string): Response {
return new Response(message, {
status,
headers: { ...corsHeaders(), "Content-Type": "text/plain; charset=utf-8" },
});
}
// B1 : suppression d'une photo (original + miniature). Ordre : fichiers
// Storage PUIS ligne DB.
// - Storage échoue -> rien n'a bougé, 500, l'admin réessaie.
// - Ligne échoue après le fichier -> photo listée mais sans image (vignette
// cassée, absente du ZIP) ; réessayer termine le travail (remove() d'un
// fichier déjà absent ne renvoie pas d'erreur). L'ordre inverse laisserait
// un fichier invisible mais toujours présent : pire pour le droit à
// l'effacement, et seul le cas à éviter absolument ici.
async function handleDeletePhoto(
// deno-lint-ignore no-explicit-any
supabaseAdmin: any,
bucket: string,
event: AdminEventRow,
photoId: string | null
): Promise<Response> {
if (!photoId || !UUID_RE.test(photoId)) {
return jsonResponse(400, { error: "invalid_photo_id" });
}
let photos: PhotoRow[];
try {
photos = await fetchEventPhotos(supabaseAdmin, event.id);
} catch (err) {
console.error("[admin-gallery] delete: get_event_photos_admin failed", err);
return jsonResponse(500, { error: "internal_error" });
}
// Appartenance à l'event du token : une photo d'un autre event est
// indiscernable d'une photo inexistante.
const photo = photos.find((p) => p.id === photoId.toLowerCase());
if (!photo) {
return jsonResponse(404, { error: "photo_not_found" });
}
const { error: removeError } = await supabaseAdmin.storage
.from(bucket)
.remove([photo.url_storage, thumbPathOf(photo.url_storage)]);
if (removeError) {
console.error("[admin-gallery] delete: storage remove failed", removeError);
return jsonResponse(500, { error: "storage_delete_failed" });
}
const { data: deleted, error: deleteError } = await supabaseAdmin.rpc(
"delete_event_photo",
{ p_event_id: event.id, p_photo_id: photo.id }
);
if (deleteError) {
console.error("[admin-gallery] delete: delete_event_photo failed", deleteError);
return jsonResponse(500, { error: "db_delete_failed" });
}
if (deleted !== true) {
// Supprimée entre-temps (double clic, autre onglet) : le résultat voulu
// est atteint, mais on le signale tel quel.
return jsonResponse(404, { error: "photo_not_found" });
}
const remaining = photos.filter((p) => p.id !== photo.id);
return jsonResponse(200, {
deleted: true,
photo_count: remaining.length,
zip_parts: zipPartStarts(remaining).length,
});
}