From 9fe1f8bea2440bb01d26188a82d31a5e44162093 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 20 Feb 2026 07:16:20 +0000 Subject: [PATCH] =?UTF-8?q?fix:=20=C3=A9liminer=20d=C3=A9finitivement=20le?= =?UTF-8?q?s=20bugs=20d'affichage=20des=20images=20priv=C3=A9es?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cause racine : les Signed URLs Supabase étaient générées au moment du rendu ISR et embarquées dans le HTML mis en cache. Si Vercel servait le HTML avant régénération ou si la signed URL expirait, l'image était cassée et necessitait plusieurs rechargements. Solution — proxy /api/img/[key] : - app/api/img/[key]/route.ts : nouvelle route publique force-dynamic qui génère une Signed URL fraîche à chaque requête image (TTL 1h), avec Cache-Control 55 min côté navigateur/CDN ; fallback sur l'image Unsplash par défaut si createSignedUrl échoue ; 302 direct pour les URLs externes - lib/site-images.ts : getSiteImages() ne génère plus jamais de Signed URL — les chemins storage: retournent /api/img/ (URL permanente), les URLs externes sont retournées telles quelles Résultat : le HTML statique/ISR ne contient plus jamais de signed URL éphémère → zéro image cassée, zéro rechargement nécessaire. https://claude.ai/code/session_01PzA98VhLMmsHpzs7gnLHGs --- app/api/img/[key]/route.ts | 81 ++++++++++++++++++++++++++++++++++++++ lib/site-images.ts | 57 +++++++++------------------ 2 files changed, 99 insertions(+), 39 deletions(-) create mode 100644 app/api/img/[key]/route.ts diff --git a/app/api/img/[key]/route.ts b/app/api/img/[key]/route.ts new file mode 100644 index 0000000..4e942d0 --- /dev/null +++ b/app/api/img/[key]/route.ts @@ -0,0 +1,81 @@ +import { NextRequest, NextResponse } from "next/server"; +import { createAdminClient } from "@/lib/supabase/server"; +import { DEFAULT_IMAGES } from "@/lib/site-images"; + +export const dynamic = "force-dynamic"; + +const BUCKET = "private-gallery"; +// Signed URL valide 1h côté Supabase +const SIGNED_URL_TTL = 3600; +// Le navigateur/CDN met en cache la redirection 55 min +// (légèrement inférieur au TTL pour éviter tout risque d'expiration) +const REDIRECT_CACHE_TTL = 3300; + +export async function GET( + _req: NextRequest, + { params }: { params: Promise<{ key: string }> } +) { + const { key } = await params; + + // Valider la clé (alphanumérique + underscores uniquement) + if (!/^[a-z0-9_]+$/.test(key)) { + return new NextResponse(null, { status: 400 }); + } + + const adminClient = createAdminClient(); + + // Valeur par défaut + let rawUrl: string = DEFAULT_IMAGES[key]?.url ?? ""; + + // Valeur en BDD (prioritaire) + try { + const { data } = await adminClient + .from("site_images") + .select("url") + .eq("key", key) + .single(); + if (data?.url) rawUrl = data.url; + } catch { + // Aucune ligne trouvée ou table absente → on garde le default + } + + // Aucune image configurée (clé inconnue ou default vide) + if (!rawUrl) { + return new NextResponse(null, { status: 404 }); + } + + // ── URL externe (Unsplash, etc.) ────────────────────────────────────────── + if (!rawUrl.startsWith("storage:")) { + return NextResponse.redirect(rawUrl, { + status: 302, + headers: { + "Cache-Control": "public, max-age=86400, s-maxage=86400", + }, + }); + } + + // ── Chemin bucket privé → générer une Signed URL fraîche ───────────────── + const filePath = rawUrl.slice("storage:".length); + const { data, error } = await adminClient.storage + .from(BUCKET) + .createSignedUrl(filePath, SIGNED_URL_TTL); + + if (error || !data?.signedUrl) { + // Fallback sur l'image par défaut Unsplash si la génération échoue + const fallback = DEFAULT_IMAGES[key]?.url; + if (fallback) { + return NextResponse.redirect(fallback, { + status: 302, + headers: { "Cache-Control": "public, max-age=60, s-maxage=60" }, + }); + } + return new NextResponse(null, { status: 503 }); + } + + return NextResponse.redirect(data.signedUrl, { + status: 302, + headers: { + "Cache-Control": `public, max-age=${REDIRECT_CACHE_TTL}, s-maxage=${REDIRECT_CACHE_TTL}, stale-while-revalidate=60`, + }, + }); +} diff --git a/lib/site-images.ts b/lib/site-images.ts index b6d9496..9feb756 100644 --- a/lib/site-images.ts +++ b/lib/site-images.ts @@ -136,42 +136,19 @@ export const DEFAULT_IMAGES: Record = { }, }; -const STORAGE_PREFIX = "storage:"; -const BUCKET = "private-gallery"; -// Durée de validité des Signed URLs : 1 heure -const SIGNED_URL_TTL = 3600; - -/** - * Résout une valeur stockée en BDD vers une URL publique. - * Si la valeur commence par "storage:", génère une Signed URL temporaire (60 min) - * depuis le bucket privé Supabase. - * Sinon, retourne la valeur telle quelle (URL externe). - */ -async function resolveUrl(raw: string): Promise { - if (!raw.startsWith(STORAGE_PREFIX)) return raw; - - const filePath = raw.slice(STORAGE_PREFIX.length); // ex: "hero_portrait/image.jpg" - const supabase = createAdminClient(); - const { data, error } = await supabase.storage - .from(BUCKET) - .createSignedUrl(filePath, SIGNED_URL_TTL); - - if (error || !data?.signedUrl) { - // En cas d'erreur, on renvoie l'URL brute (le placeholder s'affichera) - return raw; - } - return data.signedUrl; -} - /** * Récupère toutes les images du site depuis Supabase. - * Les valeurs "storage:..." sont converties en Signed URLs à la volée. - * Fallback sur les valeurs par défaut si la table n'existe pas. + * + * - URL externe (https://...) → retournée telle quelle + * - Chemin privé (storage:...) → retourné comme /api/img/ + * Le proxy génère une Signed URL fraîche à chaque requête du navigateur + * (cache navigateur/CDN 55 min) — aucune signed URL n'est jamais embarquée + * dans le HTML statique, ce qui élimine tout risque d'expiration. */ export async function getSiteImages(): Promise> { const result: Record = {}; - // Mettre les defaults d'abord + // Initialiser avec les defaults for (const [key, val] of Object.entries(DEFAULT_IMAGES)) { result[key] = val.url; } @@ -182,17 +159,19 @@ export async function getSiteImages(): Promise> { const rows = (data ?? []) as unknown as Pick[]; if (!error) { - // Résoudre toutes les URLs en parallèle (signed URLs pour les paths storage:) - await Promise.all( - rows.map(async (row) => { - if (row.url) { - result[row.key] = await resolveUrl(row.url); - } - }) - ); + for (const row of rows) { + if (!row.url) continue; + if (row.url.startsWith("storage:")) { + // Proxy URL → la signed URL est générée à la demande côté navigateur + result[row.key] = `/api/img/${row.key}`; + } else { + // URL externe directe + result[row.key] = row.url; + } + } } } catch { - // Table n'existe pas encore, on utilise les defaults + // Table absente → on conserve les defaults } return result;