@agence-zef/astro 0.5.0 → 0.6.0-pilot.1

package/components/Image.astro

@@ -17,11 +17,13 @@ interface Props {
 	 * priorité (`fetchpriority="high"`). Une seule par page.
 	 */
 	priority?: boolean;
+	/** Qualité de compression (1 à 100, défaut 75 : à l'œil identique, deux à trois fois plus léger). */
+	quality?: number;
 	/** Largeur affichée (`(min-width: 48rem) 33vw, 100vw`) : active le `srcset`. */
 	sizes?: string;
 }
 
-const { media, class: className, priority = false, sizes } = Astro.props;
+const { media, class: className, priority = false, sizes, quality = 75 } = Astro.props;
 const loading = priority ? "eager" : (Astro.props.loading ?? "lazy");
 const fetchpriority = priority ? "high" : undefined;
 // Proportions réservées même si le CSS du site force `width: auto` (pas de décalage au chargement).
@@ -53,6 +55,7 @@ const widths =
 				decoding={priority ? "sync" : "async"}
 				sizes={sizes}
 				widths={widths}
+				quality={quality}
 				class={className}
 				style={style}
 			/>

package/components/routes/cache.ts

@@ -0,0 +1,10 @@
+/*
+ * Rendu à la demande (`rendering: "cached"`) : règles de cache des pages du CMS. Le CDN garde
+ * une page un an ; une publication l'invalide par le tag `zef` (le CDN sert l'ancienne version
+ * le temps d'en rendre une nouvelle, `swr`).
+ */
+
+/** Tag posé sur toutes les réponses du site rendues depuis le CMS. */
+export const CACHE_TAG = "zef";
+
+export const PAGE_CACHE = { maxAge: 60 * 60 * 24 * 365, swr: 60 * 60 * 24 * 7 };

package/components/routes/llms.ts

@@ -1,15 +1,16 @@
 import config from "virtual:zef/config";
 import { getClient, llmsTxt, siteOrigin, zefSiteIndex } from "@agence-zef/astro";
 import type { APIRoute } from "astro";
+import { CACHE_TAG, PAGE_CACHE } from "./cache";
 
 /*
  * `llms.txt` injecté par `@agence-zef/astro` (§ 5.13, format llmstxt.org) : le site présenté aux
  * assistants IA, avec ses pages et ses collections et leur description.
  */
 
-export const prerender = true;
-
-export const GET: APIRoute = async ({ site: astroSite }) => {
+export const GET: APIRoute = async ({ site: astroSite, cache }) => {
+	// Rendu à la demande (`rendering: "cached"`) : gardé en cache, invalidé par une publication.
+	if (cache.enabled) cache.set({ ...PAGE_CACHE, tags: [CACHE_TAG] });
 	const site = await getClient().site();
 	const collections = (config.collections ?? [])
 		.filter((c) => c.page)

package/components/routes/page-cached.astro

@@ -0,0 +1,68 @@
+---
+import Layout from "virtual:zef/layout";
+/**
+ * Rendu à la demande (`defineConfig({ rendering: "cached" })`) : chaque page du CMS ou élément
+ * de collection est rendu à la première visite puis gardé en cache par le CDN (route caching
+ * d'Astro), avec le tag `zef`. Une publication invalide ce tag (`/__zef/revalidate`) : les pages
+ * sont rafraîchies à la visite suivante, sans build. Contenu réservé : jamais en cache.
+ * Adresse inconnue : redirection du CMS (C-17) si elle existe, sinon 404.
+ */
+import { getClient, type RouteProps, zefRouteProps } from "@agence-zef/astro";
+import { visitorOf } from "@agence-zef/astro/accounts";
+import ReservedNotice from "../ReservedNotice.astro";
+import ZefSections from "../ZefSections.astro";
+import { CACHE_TAG, PAGE_CACHE } from "./cache";
+
+const path = decodeURI(Astro.url.pathname);
+let props: RouteProps | null;
+try {
+	props = await zefRouteProps(path, visitorOf(Astro));
+} catch {
+	// CMS injoignable : 503 sans cache, le CDN continue de servir la version qu'il a.
+	if (Astro.cache.enabled) Astro.cache.set(false);
+	return new Response("Service momentanément indisponible.", { status: 503 });
+}
+
+if (!props) {
+	const redirect = (
+		await getClient()
+			.redirects()
+			.catch(() => [])
+	).find((r) => r.from === path || r.from === path.replace(/\/$/, ""));
+	if (Astro.cache.enabled) Astro.cache.set({ maxAge: 60, tags: [CACHE_TAG] });
+	if (redirect) return Astro.redirect(redirect.to, redirect.status === 302 ? 302 : 301);
+	return new Response(null, { status: 404 });
+}
+
+const doc = props.kind === "page" ? props.page : props.item;
+const reserved = doc.access?.reserved === true;
+// Le contenu réservé dépend du visiteur : jamais en cache.
+if (Astro.cache.enabled) Astro.cache.set(reserved ? false : { ...PAGE_CACHE, tags: [CACHE_TAG] });
+
+// Site en développement (§ 5.11) : aucune page n'est indexable.
+const seo =
+	props.site.indexable === false || reserved ? { ...props.seo, noindex: true } : props.seo;
+---
+
+<Layout
+	site={props.site}
+	locale={props.locale}
+	title={props.title}
+	seo={seo}
+	alternates={props.alternates}
+	url={props.url}
+	breadcrumbs={props.breadcrumbs}
+	item={props.kind === "item" ? props.item : undefined}
+	header={props.header}
+	footer={props.footer}
+>
+	{
+		reserved && !doc.access?.granted ? (
+			<ReservedNotice title={props.title} products={doc.access?.products ?? []} />
+		) : props.kind === "page" ? (
+			<ZefSections sections={props.page.sections} />
+		) : (
+			<ZefSections sections={props.item.sections ?? []} item={props.item} />
+		)
+	}
+</Layout>

package/components/routes/revalidate.ts

@@ -0,0 +1,33 @@
+import { createClient } from "@agence-zef/sdk";
+import type { APIRoute } from "astro";
+import { CACHE_TAG } from "./cache";
+
+/*
+ * Invalidation du cache après une publication (`rendering: "cached"`) : le CMS appelle
+ * `POST /__zef/revalidate` avec un jeton d'aperçu de ce site (`Authorization: Bearer …`). Le site
+ * vérifie le jeton auprès de son CMS (`ZEF_URL` désigne le client : un jeton accepté là est
+ * forcément le sien), puis invalide le tag `zef` : toutes les pages sont rafraîchies à leur
+ * prochaine visite.
+ */
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request, cache }) => {
+	const token = request.headers.get("authorization")?.replace(/^Bearer\s+/i, "");
+	const url = process.env.ZEF_URL;
+	if (!token || !url) return json(401, { ok: false, error: "Jeton manquant." });
+	const valid = await createClient({ url, apiKey: token })
+		.site()
+		.then(() => true)
+		.catch(() => false);
+	if (!valid) return json(403, { ok: false, error: "Jeton refusé." });
+	if (!cache.enabled) return json(200, { ok: true, invalidated: false });
+	await cache.invalidate({ tags: [CACHE_TAG] });
+	return json(200, { ok: true, invalidated: true });
+};
+
+const json = (status: number, body: unknown) =>
+	new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json", "cache-control": "no-store" },
+	});

package/components/routes/robots.ts

@@ -1,5 +1,6 @@
 import { getClient, robotsTxt, siteOrigin } from "@agence-zef/astro";
 import type { APIRoute } from "astro";
+import { CACHE_TAG, PAGE_CACHE } from "./cache";
 
 /*
  * `robots.txt` injecté par `@agence-zef/astro` (§ 5.11, § 5.13) : tout est bloqué tant que le site
@@ -7,9 +8,9 @@ import type { APIRoute } from "astro";
  * sitemap est déclaré. Construit avec le site : la mise en ligne relance un build.
  */
 
-export const prerender = true;
-
-export const GET: APIRoute = async ({ site: astroSite }) => {
+export const GET: APIRoute = async ({ site: astroSite, cache }) => {
+	// Rendu à la demande (`rendering: "cached"`) : gardé en cache, invalidé par une publication.
+	if (cache.enabled) cache.set({ ...PAGE_CACHE, tags: [CACHE_TAG] });
 	const site = await getClient().site();
 	const body = robotsTxt(site, siteOrigin(site, astroSite?.origin));
 	return new Response(body, { headers: { "Content-Type": "text/plain; charset=utf-8" } });

package/components/routes/sitemap.ts

@@ -1,15 +1,16 @@
 import config from "virtual:zef/config";
 import { getClient, sitemapXml, siteOrigin, zefSiteIndex } from "@agence-zef/astro";
 import type { APIRoute } from "astro";
+import { CACHE_TAG, PAGE_CACHE } from "./cache";
 
 /*
  * `sitemap.xml` injecté par `@agence-zef/astro` (§ 5.13) : pages et éléments publiés et
  * indexables, chaque langue liée par `xhtml:link`, date de dernière publication.
  */
 
-export const prerender = true;
-
-export const GET: APIRoute = async ({ site: astroSite }) => {
+export const GET: APIRoute = async ({ site: astroSite, cache }) => {
+	// Rendu à la demande (`rendering: "cached"`) : gardé en cache, invalidé par une publication.
+	if (cache.enabled) cache.set({ ...PAGE_CACHE, tags: [CACHE_TAG] });
 	const site = await getClient().site();
 	const body = sitemapXml(await zefSiteIndex(config), siteOrigin(site, astroSite?.origin));
 	return new Response(body, { headers: { "Content-Type": "application/xml; charset=utf-8" } });

package/dist/helpers.d.ts

@@ -56,6 +56,12 @@ export declare function zefLayoutProps(opts: {
     locale?: string;
     noindex?: boolean;
 }): Promise<LayoutProps>;
+/**
+ * Rendu à la demande (`rendering: "cached"`) : les props du gabarit pour une adresse, page ou
+ * élément de collection, sans parcourir tout le site. `null` si rien n'est publié à cette
+ * adresse ; une erreur du CMS remonte (la page en cache reste servie).
+ */
+export declare function zefRouteProps(path: string, visitor?: Parameters<ZefClient["document"]>[1]): Promise<RouteProps | null>;
 /**
  * Toutes les routes du site : pages publiées, puis éléments des collections avec page. Calculé
  * une fois par build : la route des pages, le sitemap et `llms.txt` partagent le résultat.

package/dist/helpers.js

@@ -43,6 +43,85 @@ export async function zefLayoutProps(opts) {
     };
 }
 const toParam = (url) => url.replace(/^\/+|\/+$/g, "") || undefined;
+/** Arborescence des pages : fil d'Ariane d'une page, accueil de chaque langue. */
+function pageTree(entries, site) {
+    const byId = new Map(entries.map((e) => [e.id, e]));
+    const homeOf = (locale) => entries.find((e) => e.urls[locale] === "/" || e.urls[locale] === `/${locale}`);
+    /** Accueil, puis les pages parentes, puis la page elle-même. */
+    const trail = (id, locale) => {
+        const out = [];
+        for (let e = byId.get(id); e; e = e.parentId ? byId.get(e.parentId) : undefined) {
+            const url = e.urls[locale];
+            if (url)
+                out.unshift({ title: e.titles[locale] || e.titles[site.defaultLocale] || "", url });
+        }
+        const home = homeOf(locale);
+        if (home && out[0]?.url !== home.urls[locale]) {
+            out.unshift({ title: home.titles[locale] || site.name, url: home.urls[locale] });
+        }
+        return out;
+    };
+    return { trail, homeOf };
+}
+/**
+ * Rendu à la demande (`rendering: "cached"`) : les props du gabarit pour une adresse, page ou
+ * élément de collection, sans parcourir tout le site. `null` si rien n'est publié à cette
+ * adresse ; une erreur du CMS remonte (la page en cache reste servie).
+ */
+export async function zefRouteProps(path, visitor) {
+    const api = getClient();
+    const [found, site, entries] = await Promise.all([
+        api.document(path, visitor).catch((error) => {
+            if (error.status === 404)
+                return null;
+            throw error;
+        }),
+        api.site(),
+        api.pages(),
+    ]);
+    if (!found)
+        return null;
+    const { trail, homeOf } = pageTree(entries, site);
+    if (found.kind === "page") {
+        const { page } = found;
+        const layout = await api.layout({ locale: page.locale });
+        const entry = entries.find((e) => e.id === page.id);
+        return {
+            kind: "page",
+            page,
+            site,
+            locale: page.locale,
+            title: page.seo.title ?? page.title,
+            seo: page.seo,
+            alternates: page.alternates,
+            url: page.url,
+            breadcrumbs: entry ? trail(entry.id, page.locale) : [],
+            header: layout.header,
+            footer: layout.footer,
+        };
+    }
+    const { item, collection, titleField } = found;
+    const locale = Object.entries(item.alternates ?? {}).find(([, url]) => url === item.url)?.[0] ??
+        site.defaultLocale;
+    const layout = await api.layout({ locale });
+    const title = String(item[titleField] ?? "");
+    const listingPath = item.url?.replace(/\/[^/]+\/?$/, "") ?? "";
+    const listing = entries.find((e) => e.urls[locale] === listingPath) ?? homeOf(locale);
+    return {
+        kind: "item",
+        collection,
+        item,
+        site,
+        locale,
+        title: item.seo?.title ?? title,
+        seo: item.seo,
+        alternates: item.alternates ?? {},
+        url: item.url ?? path,
+        breadcrumbs: [...(listing ? trail(listing.id, locale) : []), { title, url: item.url ?? path }],
+        header: layout.header,
+        footer: layout.footer,
+    };
+}
 let staticPaths;
 /**
  * Toutes les routes du site : pages publiées, puis éléments des collections avec page. Calculé
@@ -61,22 +140,7 @@ async function buildStaticPaths(config) {
     const paths = [];
     const layouts = new Map(await Promise.all(site.locales.map(async (l) => [l, await api.layout({ locale: l })])));
     const entries = await api.pages();
-    const byId = new Map(entries.map((e) => [e.id, e]));
-    const homeOf = (locale) => entries.find((e) => e.urls[locale] === "/" || e.urls[locale] === `/${locale}`);
-    /** Accueil, puis les pages parentes, puis la page elle-même. */
-    const trail = (id, locale) => {
-        const out = [];
-        for (let e = byId.get(id); e; e = e.parentId ? byId.get(e.parentId) : undefined) {
-            const url = e.urls[locale];
-            if (url)
-                out.unshift({ title: e.titles[locale] || e.titles[site.defaultLocale] || "", url });
-        }
-        const home = homeOf(locale);
-        if (home && out[0]?.url !== home.urls[locale]) {
-            out.unshift({ title: home.titles[locale] || site.name, url: home.urls[locale] });
-        }
-        return out;
-    };
+    const { trail, homeOf } = pageTree(entries, site);
     for (const entry of entries) {
         for (const [locale, url] of Object.entries(entry.urls)) {
             const page = await api.page(url);
@@ -111,12 +175,7 @@ async function buildStaticPaths(config) {
             for (const item of list.items) {
                 if (!item.url || item.access?.reserved)
                     continue;
-                const alternates = {};
-                for (const other of byLocale) {
-                    const url = other.list.items.find((i) => i.id === item.id)?.url;
-                    if (url)
-                        alternates[other.locale] = url;
-                }
+                const alternates = { ...item.alternates };
                 // Fil d'Ariane : accueil, page de la liste si elle existe (`/vins`), puis l'élément.
                 const listing = entries.find((e) => e.urls[locale] === def.page.path || e.urls[locale] === `/${locale}${def.page.path}`) ?? homeOf(locale);
                 const title = String(item[def.titleField] ?? "");

package/dist/index.js

@@ -8,6 +8,20 @@ export * from "./helpers.js";
 export * from "./seo.js";
 export * from "./shop.js";
 const MEDIA_URL = "https://medias.agence-zef.fr";
+/** `rendering` de `zef.config.ts` (lu comme la CLI, avec jiti) ; `static` en cas de doute. */
+async function readRendering(file) {
+    if (!existsSync(file))
+        return "static";
+    try {
+        const { createJiti } = await import("jiti");
+        const jiti = createJiti(import.meta.url, { moduleCache: false, fsCache: false });
+        const config = await jiti.import(file, { default: true });
+        return config?.rendering === "cached" ? "cached" : "static";
+    }
+    catch {
+        return "static";
+    }
+}
 /** Domaines autorisés pour l'optimisation des images distantes (`image.remotePatterns`). */
 function mediaPatterns(urls) {
     return urls.flatMap((raw) => {
@@ -93,27 +107,55 @@ export default function zef(options = {}) {
                 addWatchFile(join(root, ".env"));
                 const layout = join(root, options.layout ?? "src/layouts/Page.astro");
                 const configFile = join(root, "zef.config.ts");
+                // Rendu des pages (`defineConfig({ rendering })`) : construites au build (`static`), ou
+                // rendues à la demande et gardées en cache par le CDN, invalidé par une publication
+                // (`cached`, demande un adaptateur).
+                const rendering = await readRendering(configFile);
+                const cached = rendering === "cached" && Boolean(config.adapter || command === "dev");
+                if (rendering === "cached" && !cached) {
+                    logger.warn("rendering « cached » sans adaptateur : pages construites au build");
+                }
+                if (cached && !config.cache?.provider) {
+                    // Cache du CDN de l'hébergeur : Vercel (tags, invalidation), sinon en mémoire.
+                    const vercelProvider = config.adapter?.name === "@astrojs/vercel";
+                    updateConfig({
+                        cache: {
+                            provider: vercelProvider
+                                ? { name: "vercel", entrypoint: "@astrojs/vercel/cache/provider" }
+                                : { name: "memory", entrypoint: "astro/cache/memory" },
+                        },
+                    });
+                }
                 injectRoute({
                     pattern: "/[...path]",
-                    entrypoint: "@agence-zef/astro/routes/page.astro",
-                    prerender: true,
+                    entrypoint: cached
+                        ? "@agence-zef/astro/routes/page-cached.astro"
+                        : "@agence-zef/astro/routes/page.astro",
+                    prerender: !cached,
                 });
                 injectRoute({
                     pattern: "/robots.txt",
                     entrypoint: "@agence-zef/astro/routes/robots.ts",
-                    prerender: true,
+                    prerender: !cached,
                 });
                 // Référencement prêt à l'emploi (§ 5.13) : sitemap et présentation pour les IA.
                 injectRoute({
                     pattern: "/sitemap.xml",
                     entrypoint: "@agence-zef/astro/routes/sitemap.ts",
-                    prerender: true,
+                    prerender: !cached,
                 });
                 injectRoute({
                     pattern: "/llms.txt",
                     entrypoint: "@agence-zef/astro/routes/llms.ts",
-                    prerender: true,
+                    prerender: !cached,
                 });
+                if (cached) {
+                    injectRoute({
+                        pattern: "/__zef/revalidate",
+                        entrypoint: "@agence-zef/astro/routes/revalidate.ts",
+                        prerender: false,
+                    });
+                }
                 // Aperçu de l'éditeur : rendu à la demande, donc avec un adaptateur (Vercel) ou en dev.
                 if (command === "dev" || config.adapter) {
                     injectRoute({
@@ -137,7 +179,7 @@ export default function zef(options = {}) {
                 }
                 // Contenu réservé (lot 14e5c) : les adresses que la route statique n'a pas générées
                 // (pages et éléments réservés) sont rendues à la demande, avec la session du compte.
-                if (options.shop && (command === "dev" || config.adapter)) {
+                if (options.shop && !cached && (command === "dev" || config.adapter)) {
                     injectRoute({
                         pattern: "/[...zefReserved]",
                         entrypoint: "@agence-zef/astro/routes/reserved.astro",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agence-zef/astro",
-  "version": "0.5.0",
+  "version": "0.6.0-pilot.1",
   "description": "Intégration Astro du CMS ZEF : routes, rendu des sections, aperçu, composants réutilisables sans style.",
   "license": "MIT",
   "type": "module",
@@ -63,7 +63,9 @@
     "./ui": {
       "types": "./dist/ui.d.ts",
       "import": "./dist/ui.js"
-    }
+    },
+    "./routes/page-cached.astro": "./components/routes/page-cached.astro",
+    "./routes/revalidate.ts": "./components/routes/revalidate.ts"
   },
   "files": [
     "dist",
@@ -81,8 +83,9 @@
     "@types/node": "^24.0.0"
   },
   "dependencies": {
-    "@agence-zef/schema": "0.5.0",
-    "@agence-zef/sdk": "0.5.0"
+    "jiti": "^2.6.1",
+    "@agence-zef/schema": "0.6.0-pilot.0",
+    "@agence-zef/sdk": "0.6.0-pilot.0"
   },
   "homepage": "https://agence-zef.fr",
   "scripts": {