// Edge Function `admin-gallery` // // Contrat (fixé par le chef de projet, à ne pas renommer) : // GET {SUPABASE_URL}/functions/v1/admin-gallery?slug=&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= -> supprime une photo (B1) // // ⚠️ Déploiement : verify_jwt = false requis. Les parties du ZIP sont des // liens directs () 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 { // 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 { 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(); const thumbUrlByPath = new Map(); 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 { 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; const { readable, writable } = new TransformStream({ start(controller) { streamController = controller; }, }); const zipWriter = new ZipWriter(writable); const usedNames = new Set(); // 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 { 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 { 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, }); }