Files
photobooth-qr/supabase/functions/public-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

185 lines
7.2 KiB
TypeScript

// Edge Function `public-gallery`
//
// Contrat : GET {SUPABASE_URL}/functions/v1/public-gallery?slug=<slug>
//
// Tourne avec la service_role key (cf. _shared/supabase-admin.ts), MAIS
// sans aucune vérification de token — c'est le point central de cette
// fonction, à la différence de `admin-gallery`. L'accès est intentionnellement
// ouvert à quiconque connaît le `slug` : même modèle de confiance que
// l'upload invité (le slug circule via QR code, ce n'est pas un secret).
//
// Origine : revirement produit du 2026-09-18 (cf. docs/decisions.md) — les
// invités peuvent désormais voir toutes les photos d'un événement, pas
// seulement envoyer la leur. Ça inverse la règle "lecture des photos jamais
// publique" du cahier des charges initial / docs/modele-donnees.md : ce
// revirement est acté comme décision explicite du 2026-09-18, pas tranché
// par cet agent.
//
// Sécurité : on résout le slug via `public.get_public_event` (PAS
// `get_event_for_admin`, qui expose admin_token) — cette fonction ne
// renvoie que {id, nom, statut, date_evenement, expire_at,
// max_photos_per_guest}, jamais admin_token / client_nom / facture_montant.
// Les photos elles-mêmes viennent de `public.get_event_photos`
// (service_role uniquement), qui ne renvoie que {id, url_storage,
// nom_invite, message, uploaded_at} — jamais l'email/téléphone d'un invité
// (ces colonnes n'existent d'ailleurs pas dans photobooth.photos, cf.
// docs/modele-donnees.md).
//
// `get_public_event` renvoie l'événement même si son statut n'est pas
// `actif` (expiré/archivé) — comportement hérité, inchangé ici. Cette
// fonction renvoie donc telles quelles les photos d'un événement expiré si
// elles existent encore en base (la purge Storage/DB à J+7 est un job
// séparé, cf. expire-events) : pas de filtre `statut = 'actif'` ajouté ici,
// le front peut décider d'afficher un message adapté à partir de
// `event.statut`, cohérent avec le comportement déjà choisi pour
// `get_public_event` côté page d'upload.
import { getSupabaseAdmin, getStorageBucket, thumbPathOf } from "../_shared/supabase-admin.ts";
import { corsHeaders, handleCorsPreflight } from "../_shared/cors.ts";
// URLs signées affichées dans la galerie invité : courte durée, c'est pour
// un affichage immédiat dans le navigateur de l'invité, pas pour un lien à
// partager. Même valeur que `admin-gallery` (cf. GALLERY_SIGNED_URL_TTL_SECONDS
// dans supabase/functions/admin-gallery/index.ts).
const GALLERY_SIGNED_URL_TTL_SECONDS = 10 * 60; // 10 minutes
type PhotoRow = {
id: string;
nom_invite: string | null;
message: string | null;
uploaded_at: string;
url_storage: string;
};
type PublicEventRow = {
id: string;
nom: string;
statut: string;
date_evenement: string;
expire_at: string;
max_photos_per_guest: number | null;
};
function jsonResponse(status: number, body: unknown): Response {
return new Response(JSON.stringify(body), {
status,
headers: { ...corsHeaders(), "Content-Type": "application/json" },
});
}
// 404 générique : même statut/corps que le "slug inconnu" de admin-gallery,
// pour ne pas distinguer un slug qui n'existe pas d'un autre cas d'erreur
// silencieuse côté appelant.
function notFound(): Response {
return jsonResponse(404, { error: "not_found" });
}
Deno.serve(async (req) => {
const preflight = handleCorsPreflight(req);
if (preflight) return preflight;
if (req.method !== "GET") {
return jsonResponse(405, { error: "method_not_allowed" });
}
const url = new URL(req.url);
const slug = url.searchParams.get("slug");
if (!slug) {
return jsonResponse(400, { error: "missing_parameters" });
}
const supabaseAdmin = getSupabaseAdmin();
// 1. Résout l'event par slug via public.get_public_event (anon-safe,
// n'expose jamais admin_token/client_nom/facture_montant) — pas
// get_event_for_admin, réservée à admin-gallery.
const { data: event, error: eventError } = await supabaseAdmin
.rpc("get_public_event", { p_slug: slug })
.maybeSingle();
if (eventError) {
console.error("[public-gallery] get_public_event failed", eventError);
return jsonResponse(500, { error: "internal_error" });
}
if (!event) {
return notFound();
}
const typedEvent = event as PublicEventRow;
// 2. Photos de l'event, triées chronologiquement (get_event_photos renvoie
// déjà uploaded_at ASC) — pas de tri inversé ici contrairement à
// admin-gallery : une galerie invité affiche naturellement l'ordre
// d'arrivée des photos, pas de raison produit de l'inverser pour l'instant.
let photos: PhotoRow[];
try {
const { data, error } = await supabaseAdmin.rpc("get_event_photos", {
p_event_id: typedEvent.id,
});
if (error) throw error;
photos = (data ?? []) as PhotoRow[];
} catch (err) {
console.error("[public-gallery] get_event_photos failed", err);
return jsonResponse(500, { error: "internal_error" });
}
// Event sans photo : état normal (pas d'upload pour l'instant), pas une
// erreur — 200 avec photos: [], contrairement à admin-gallery?action=zip
// qui renvoie 404/no_photos (là, l'absence de photo empêche l'action
// demandée "générer un ZIP" ; ici il n'y a pas d'action, juste un état
// d'affichage à rendre).
const signedUrlByPath = new Map<string, string>();
const thumbUrlByPath = new Map<string, string>();
if (photos.length > 0) {
const paths = photos.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("[public-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(
`[public-gallery] signed url failed for ${paths[i]}`,
entry.error
);
}
}
}
return jsonResponse(200, {
event: {
nom: typedEvent.nom,
date_evenement: typedEvent.date_evenement,
statut: typedEvent.statut,
photo_count: photos.length,
},
photos: photos.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,
})),
});
});