@salifbiaye/create-boutique 0.5.0 → 0.7.0

package/templates/storefront/src/app/(main)/page.tsx

@@ -1,12 +1,11 @@
 import { Suspense } from "react"
 import { connection } from "next/server"
 
-import { campaignStatus, getCampaign } from "@lib/boutique/campaign"
+import { getCampaign } from "@lib/boutique/campaign"
 import { t } from "@lib/boutique/i18n"
 import { listCategories } from "@lib/data/categories"
 import { listProducts } from "@lib/data/products"
 import { Hero, PromoBanner, SectionHead, TrustBar } from "@modules/ub/campaign-blocks"
-import CampaignEnded from "@modules/ub/campaign-ended"
 import CategoryTiles from "@modules/ub/category-tiles"
 import { ProductGrid } from "@modules/ub/product-card"
 import { DealsFold, DealsSpotlight } from "@modules/ub/showcase"
@@ -16,7 +15,17 @@ import { CinemaHero, CinemaRow, CinemaScreening, CinemaTop } from "@modules/ub/c
 import { TechBento, TechFinal, TechFlash, TechGrid, TechHero, TechSpecs, TechTicker } from "@modules/ub/tech"
 import { GrimoireHero, GrimoireShelf, GrimoireSpell, GrimoireTarot } from "@modules/ub/grimoire"
 import { AlbumGarland, AlbumHero, AlbumPolaroids, AlbumStory, AlbumTicket } from "@modules/ub/album"
+import { RivieraColours, RivieraHero, RivieraLookbook, RivieraTailor } from "@modules/ub/riviera"
+import { SunsetBand, SunsetChecklistSection, SunsetHero, SunsetPostcards } from "@modules/ub/sunset"
+import { LockerHalftime, LockerHero, LockerLineup, LockerRack } from "@modules/ub/locker"
+import { TrainingHero, TrainingPack, TrainingProgram, TrainingPromise, TrainingTop } from "@modules/ub/training"
+import { ArenaHero, ArenaLanes, ArenaPodium, ArenaRecord } from "@modules/ub/arena"
+import { MosaicDisciplines, MosaicHero, MosaicMedals, MosaicRelay } from "@modules/ub/mosaic"
+import { LanternArches, LanternBudget, LanternHero, LanternNight } from "@modules/ub/lantern"
+import { SoukHero, SoukLetter, SoukStalls, SoukWho } from "@modules/ub/souk"
+import { discountOf } from "@modules/ub/home-kit"
 import { getBoutique } from "@lib/boutique/config"
+import { HomeReviews } from "@modules/ub/reviews"
 import type { Campaign } from "@lib/boutique/campaign"
 
 async function Categories({ title }: { title: string }) {
@@ -188,16 +197,152 @@ async function GalaProducts({ campaign }: { campaign: Campaign }) {
   )
 }
 
+/** Produits de l'accueil : tels quels et triés par remise (plus forte d'abord). */
+async function homeProducts(limit = 12) {
+  const {
+    response: { products },
+  } = await listProducts({ queryParams: { limit, fields: "*categories,*collection" } })
+  return { products, sorted: [...products].sort((a, b) => discountOf(b) - discountOf(a)) }
+}
+
+/** Accueil « Riviera » (Summer). */
+async function RivieraPage({ campaign }: { campaign: Campaign }) {
+  const { products } = await homeProducts()
+  return (
+    <>
+      <RivieraLookbook products={products} title={campaign.sections?.products ?? t("section.products")} />
+      <RivieraColours products={products} />
+      <RivieraTailor campaign={campaign} />
+    </>
+  )
+}
+
+/** Accueil « Sunset » (Summer 2) : cartes postales des plus fortes remises, liste de plage interactive. */
+async function SunsetPage({ campaign }: { campaign: Campaign }) {
+  const { products, sorted } = await homeProducts()
+  return (
+    <>
+      <SunsetPostcards products={sorted} campaign={campaign} title={campaign.sections?.products ?? t("section.products")} />
+      <SunsetChecklistSection products={products} />
+      <SunsetBand campaign={campaign} />
+    </>
+  )
+}
+
+/** Accueil « Vestiaire » (Sport). */
+async function LockerPage({ campaign }: { campaign: Campaign }) {
+  const { products, sorted } = await homeProducts()
+  return (
+    <>
+      <LockerLineup products={sorted} title={campaign.sections?.products ?? t("section.products")} />
+      <LockerRack products={products} title={campaign.sections?.categories ?? t("section.categories")} />
+      <LockerHalftime campaign={campaign} />
+    </>
+  )
+}
+
+/** Accueil « Training » (Sport 2) : les plus choisis juste sous le hero. */
+async function TrainingPage({ campaign }: { campaign: Campaign }) {
+  const { products, sorted } = await homeProducts()
+  return (
+    <>
+      <TrainingTop products={sorted} title={campaign.sections?.products ?? t("section.products")} />
+      <TrainingProgram products={products} />
+      <TrainingPack campaign={campaign} products={sorted.slice(4)} />
+      <TrainingPromise freeShipping={campaign.freeShipping} />
+    </>
+  )
+}
+
+/** Accueil « Arène » (Jeux) : podium des 3 plus fortes remises, puis les couloirs. */
+async function ArenaPage({ campaign }: { campaign: Campaign }) {
+  const { sorted } = await homeProducts()
+  return (
+    <>
+      <ArenaPodium products={sorted} />
+      <ArenaLanes products={sorted} title={campaign.sections?.products ?? t("section.products")} />
+      <ArenaRecord campaign={campaign} />
+    </>
+  )
+}
+
+/** Accueil « Mosaïque » (Jeux 2). */
+async function MosaicPage({ campaign }: { campaign: Campaign }) {
+  const [{ products, sorted }, categories] = await Promise.all([homeProducts(), listCategories().catch(() => [])])
+  return (
+    <>
+      <MosaicDisciplines categories={categories} title={campaign.sections?.categories ?? t("section.categories")} />
+      <MosaicMedals products={sorted} title={campaign.sections?.products ?? t("section.products")} />
+      <MosaicRelay campaign={campaign} products={products} />
+    </>
+  )
+}
+
+/** Accueil « Lanterne » (Mubarak · Nuit) : la sélection (plus fortes remises), idées cadeaux par budget. */
+async function LanternPage({ campaign }: { campaign: Campaign }) {
+  const { products, sorted } = await homeProducts()
+  return (
+    <>
+      <LanternArches products={sorted} title={campaign.sections?.products ?? t("section.products")} />
+      <LanternBudget products={products} />
+      <LanternNight campaign={campaign} />
+    </>
+  )
+}
+
+/** Accueil « Souk » (Mubarak · Sable). */
+async function SoukPage({ campaign }: { campaign: Campaign }) {
+  const [{ sorted }, categories] = await Promise.all([homeProducts(), listCategories().catch(() => [])])
+  return (
+    <>
+      <SoukStalls products={sorted} title={campaign.sections?.products ?? t("section.products")} />
+      <SoukWho categories={categories} title={campaign.sections?.categories ?? t("section.categories")} />
+      <SoukLetter campaign={campaign} />
+    </>
+  )
+}
+
 function GridFallback() {
   return <div className="ub-section" aria-busy="true" style={{ minHeight: 320 }} />
 }
 
+/** Accueil : la mise en page du thème, puis les derniers avis clients (section commune, aux couleurs du thème). */
 export default async function Home() {
+  return (
+    <>
+      <HomeBody />
+      <Suspense fallback={null}>
+        <HomeReviews />
+      </Suspense>
+    </>
+  )
+}
+
+async function HomeBody() {
   await connection()
   const campaign = await getCampaign()
 
-  if (campaignStatus(campaign) === "ended") {
-    return <CampaignEnded nextUrl={campaign.nextCampaignUrl} />
+
+  const home = getBoutique().theme.home
+  const themed: Partial<Record<string, [string, React.ReactNode, React.ReactNode]>> = {
+    riviera: ["ub-riviera", <RivieraHero key="h" campaign={campaign} />, <RivieraPage campaign={campaign} />],
+    sunset: ["ub-sunset", <SunsetHero key="h" campaign={campaign} />, <SunsetPage campaign={campaign} />],
+    locker: ["ub-locker", <LockerHero key="h" campaign={campaign} />, <LockerPage campaign={campaign} />],
+    training: ["ub-training", <TrainingHero key="h" campaign={campaign} />, <TrainingPage campaign={campaign} />],
+    arena: ["ub-arena", <ArenaHero key="h" campaign={campaign} />, <ArenaPage campaign={campaign} />],
+    mosaic: ["ub-mosaic", <MosaicHero key="h" campaign={campaign} />, <MosaicPage campaign={campaign} />],
+    lantern: ["ub-lantern", <LanternHero key="h" campaign={campaign} />, <LanternPage campaign={campaign} />],
+    souk: ["ub-souk", <SoukHero key="h" campaign={campaign} />, <SoukPage campaign={campaign} />],
+  }
+  const page = home ? themed[home] : undefined
+  if (page) {
+    const [cls, hero, rest] = page
+    return (
+      <div className={cls}>
+        {hero}
+        <Suspense fallback={<GridFallback />}>{rest}</Suspense>
+      </div>
+    )
   }
 
   if (getBoutique().theme.home === "grimoire") {

package/templates/storefront/src/app/(main)/products/[handle]/page.tsx

@@ -1,5 +1,6 @@
 import { Metadata } from "next"
-import { notFound } from "next/navigation"
+import { notFound, redirect } from "next/navigation"
+import { isSingleSite } from "@lib/boutique/config"
 import { listProducts } from "@lib/data/products"
 import { getRegion } from "@lib/data/regions"
 import ProductTemplate from "@modules/products/templates"
@@ -71,6 +72,8 @@ export default async function ProductPage(props: Props) {
   }).then(({ response }) => response.products[0])
 
   if (!pricedProduct) {
+    // Mode single : lien vers un produit d'une boutique qui n'est plus en ligne → la boutique actuelle
+    if (isSingleSite()) redirect("/store")
     notFound()
   }
 

package/templates/storefront/src/app/(main)/review/page.tsx

@@ -0,0 +1,60 @@
+import { Metadata } from "next"
+import Link from "next/link"
+import { t } from "@lib/boutique/i18n"
+import { getReviewOrder } from "@lib/data/reviews"
+import FadeImg from "@modules/ub/fade-img"
+import ReviewForm from "@modules/ub/review-form"
+
+export async function generateMetadata(): Promise<Metadata> {
+  return { title: t("reviews.pageTitle"), robots: { index: false, follow: false } }
+}
+
+type Props = { searchParams: Promise<{ token?: string }> }
+
+/**
+ * « Laisser un avis » : ouverte depuis le lien de l'e-mail « commande livrée » (jeton signé).
+ * Un formulaire par produit de la commande ; les produits déjà notés sont indiqués. Page non indexée.
+ */
+export default async function ReviewPage(props: Props) {
+  const { token = "" } = await props.searchParams
+  const order = token ? await getReviewOrder(token) : null
+
+  return (
+    <section className="ub-section ub-reviewpage">
+      <div className="ub-wrap">
+        <h1 className="ub-head ub-reviewpage__title">{t("reviews.pageTitle")}</h1>
+        {!order ? (
+          <>
+            <p className="ub-reviewpage__lead">{t("reviews.invalidLink")}</p>
+            <Link href="/" className="ub-rform__btn">
+              {t("reviews.backHome")}
+            </Link>
+          </>
+        ) : (
+          <>
+            <p className="ub-reviewpage__lead">{t("reviews.pageLead", { number: String(order.number) })}</p>
+            <ul className="ub-reviewpage__list">
+              {order.products.map((p) => (
+                <li key={p.product_id} className="ub-reviewpage__item">
+                  <div className="ub-reviewpage__product">
+                    {p.thumbnail && (
+                      <span className="ub-reviewpage__img">
+                        <FadeImg src={p.thumbnail} alt="" />
+                      </span>
+                    )}
+                    <b>{p.title}</b>
+                  </div>
+                  {p.reviewed ? (
+                    <p className="ub-rform__done">{t("reviews.already")}</p>
+                  ) : (
+                    <ReviewForm token={token} productId={p.product_id} firstName={order.first_name} />
+                  )}
+                </li>
+              ))}
+            </ul>
+          </>
+        )}
+      </div>
+    </section>
+  )
+}

package/templates/storefront/src/app/(main)/store/page.tsx

@@ -13,18 +13,20 @@ type Params = {
     sortBy?: SortOptions
     page?: string
     category?: string
+    q?: string
   }>
 }
 
 export default async function StorePage(props: Params) {
   const searchParams = await props.searchParams;
-  const { sortBy, page, category } = searchParams
+  const { sortBy, page, category, q } = searchParams
 
   return (
     <StoreTemplate
       sortBy={sortBy}
       page={page}
       category={category}
+      q={typeof q === "string" ? q.slice(0, 100) : undefined}
     />
   )
 }

package/templates/storefront/src/app/(main)/template.tsx

@@ -1,4 +1,19 @@
-/** Remonté à chaque navigation : sert de point d'accroche à la transition entre pages (styles/ub/motion.css, desktop). */
+"use client"
+
+import { usePathname, useSearchParams } from "next/navigation"
+import { pageName } from "@lib/boutique/page-name"
+
+/**
+ * Remonté à chaque navigation : point d'accroche de la transition entre pages (styles/ub/motion.css, desktop)
+ * et nom de la page (data-page) pour la cibler dans styles/custom.css. Calculé depuis l'adresse courante (côté client) :
+ * juste au premier affichage comme après chaque clic dans le site.
+ */
 export default function Template({ children }: { children: React.ReactNode }) {
-  return <div className="ub-page">{children}</div>
+  const path = usePathname()
+  const search = useSearchParams().toString()
+  return (
+    <div className="ub-page" data-page={pageName(path, search ? `?${search}` : "")}>
+      {children}
+    </div>
+  )
 }

package/templates/storefront/src/app/layout.tsx

@@ -4,6 +4,7 @@ import { themeFontClasses } from "@lib/boutique/fonts"
 import { messages } from "@lib/boutique/i18n"
 import { I18nProvider } from "@lib/boutique/i18n-client"
 import Motion from "@modules/ub/motion"
+import CookieBanner from "@modules/ub/cookie-banner"
 import { Metadata } from "next"
 import "styles/globals.css"
 import "styles/ub/tokens.css"
@@ -20,12 +21,22 @@ import "styles/ub/cinema.css"
 import "styles/ub/album.css"
 import "styles/ub/tech.css"
 import "styles/ub/grimoire.css"
+import "styles/ub/riviera.css"
+import "styles/ub/sunset.css"
+import "styles/ub/locker.css"
+import "styles/ub/training.css"
+import "styles/ub/arena.css"
+import "styles/ub/mosaic.css"
+import "styles/ub/lantern.css"
+import "styles/ub/souk.css"
+import "styles/ub/reviews.css"
 import "styles/ub/motion.css"
 import "styles/ub/media.css"
 import "styles/ub/responsive.css"
 import "styles/ub/fonts.css"
 import "styles/ub/medusa-ui.css"
 import "styles/ub/overrides.css"
+import "styles/custom.css" // retouches du projet, conservées par update (toujours en dernier)
 
 // Tout dépend de la boutique de l'instance (lue à l'exécution) : rien n'est pré-rendu au build.
 export const dynamic = "force-dynamic"
@@ -63,11 +74,12 @@ export default function RootLayout(props: { children: React.ReactNode }) {
   const b = getBoutique()
 
   return (
-    <html lang={b.locale} data-theme={b.theme.layout ?? b.theme.id} data-variant={b.theme.layout ? b.theme.id : undefined} data-event={b.theme.id.replace(/-2$/, "")} data-mode="light" className={themeFontClasses(b.theme)}>
+    <html lang={b.locale} data-theme={b.theme.layout ?? b.theme.id} data-variant={b.theme.layout ? b.theme.id : undefined} data-event={b.theme.id.replace(/-2$/, "")} data-boutique={b.slug} data-mode="light" className={themeFontClasses(b.theme)}>
       <body className="ub">
         <I18nProvider messages={messages("")} locale={b.locale}>
           <main className="relative">{props.children}</main>
           <Motion event={b.theme.id.replace(/-2$/, "")} />
+          <CookieBanner />
         </I18nProvider>
       </body>
     </html>

package/templates/storefront/src/lib/boutique/campaign.ts

@@ -20,6 +20,8 @@ export type Campaign = CampaignTexts & {
   seo?: { title?: string; description?: string; image?: string }
   /** Compte à rebours : undefined = selon le thème (CSS), true = toujours, false = jamais */
   showCountdown?: boolean
+  /** Site ouvert (défaut) ou fermé dans l'admin. Les dates de campagne ne ferment jamais le site. */
+  online: boolean
 }
 
 function readJsonIfExists(file: string): unknown | undefined {
@@ -105,8 +107,10 @@ export const getCampaign = cache(async (): Promise<Campaign> => {
     nextCampaignUrl: own.nextCampaign ? b.siblings[own.nextCampaign] : undefined,
     freeShipping: own.vars?.freeShipping,
     logo: own.logo,
-    showCountdown: own.showCountdown,
+    // Campagne terminée : le site reste une boutique normale, seul le compte à rebours disparaît
+    showCountdown: campaignStatus(own) === "ended" ? false : own.showCountdown,
     seo: own.seo,
+    online: own.online !== false,
   }
 })
 

package/templates/storefront/src/lib/boutique/config.ts

@@ -3,12 +3,14 @@ import "server-only"
 import fs from "node:fs"
 import path from "node:path"
 import { z } from "zod"
-import { projectSchema, themeSchema, type Theme } from "./schema"
+import { projectSchema, themeSchema, type Project, type Theme } from "./schema"
 
 /**
- * Configuration de l'instance. La boutique est fixée par la variable
- * d'environnement BOUTIQUE et par rien d'autre : aucun paramètre d'URL,
- * cookie ou en-tête ne peut en changer.
+ * Configuration de l'instance. La boutique est fixée par la variable d'environnement BOUTIQUE :
+ * - mode multi : BOUTIQUE=<slug>, une instance par boutique ;
+ * - mode single : BOUTIQUE=auto, la boutique affichée est celle mise en ligne dans l'admin
+ *   (fichier KEYS_DIR/_active écrit par le backend).
+ * Aucun paramètre d'URL, cookie ou en-tête ne peut changer la boutique affichée.
  */
 export type Boutique = {
   project: string
@@ -22,7 +24,7 @@ export type Boutique = {
   language: string
   /** ex. "en-US" : pour Intl et <html lang> */
   locale: string
-  port: number
+  port?: number
   publishableKey: string
   merchantEmail?: string
   /** URL publique des autres boutiques du projet (lien « campagne suivante ») */
@@ -78,19 +80,14 @@ function loadTheme(id: string): Theme {
   return parseOrThrow(themeSchema, readJson(file), file)
 }
 
-function load(): Boutique {
-  const slug = process.env.BOUTIQUE
-  if (!slug) {
-    throw new BoutiqueConfigError("variable d'environnement BOUTIQUE absente (ex. BOUTIQUE=yout-black-friday)")
-  }
+const projectFile = () => path.join(/*turbopackIgnore: true*/ CONFIG_DIR, "project.json")
 
-  const projectFile = path.join(/*turbopackIgnore: true*/ CONFIG_DIR, "project.json")
-  const project = parseOrThrow(projectSchema, readJson(projectFile), projectFile)
+function load(slug: string, project: Project): Boutique {
 
   const entry = project.boutiques.find((b) => b.slug === slug)
   if (!entry) {
     throw new BoutiqueConfigError(
-      `boutique « ${slug} » absente de ${projectFile}. Boutiques déclarées : ${project.boutiques.map((b) => b.slug).join(", ")}`
+      `boutique « ${slug} » absente de ${projectFile()}. Boutiques déclarées : ${project.boutiques.map((b) => b.slug).join(", ")}`
     )
   }
 
@@ -131,23 +128,74 @@ function load(): Boutique {
     port: entry.port,
     publishableKey,
     merchantEmail: defaults.merchantEmail,
+    // Mode single : toutes les boutiques partagent l'adresse du site unique
     siblings: Object.fromEntries(
-      project.boutiques.map((b) => [b.slug, b.url ?? `http://localhost:${b.port}`])
+      project.boutiques.map((b) => [
+        b.slug,
+        project.mode === "single"
+          ? (project.site?.url ?? `http://localhost:${project.site?.port ?? 8000}`)
+          : (b.url ?? `http://localhost:${b.port}`),
+      ])
     ),
   }
 }
 
-let cached: Boutique | undefined
+// Cache relu si project.json change (mode single : une boutique ajoutée par `apply` sans redémarrage)
+let project: { mtime: number; data: Project } | undefined
+const boutiques = new Map<string, Boutique>()
+
+function readProject(): Project {
+  const file = projectFile()
+  const mtime = fs.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? 0
+  if (!project || project.mtime !== mtime) {
+    project = { mtime, data: parseOrThrow(projectSchema, readJson(file), file) }
+    boutiques.clear()
+  }
+  return project.data
+}
+
+// Mode single : boutique active, relue au plus toutes les 2 s (le changement dans l'admin est quasi immédiat)
+let active: { at: number; slug: string } | undefined
+function activeSlug(p: Project): string {
+  if (active && Date.now() - active.at < 2000) return active.slug
+  let slug = ""
+  try {
+    slug = fs.readFileSync(path.join(/*turbopackIgnore: true*/ KEYS_DIR, "_active"), "utf8").trim()
+  } catch {
+    // pas encore écrit par le backend : première boutique
+  }
+  if (!p.boutiques.some((b) => b.slug === slug)) slug = p.boutiques[0].slug
+  active = { at: Date.now(), slug }
+  return slug
+}
+
+/** Mode du projet : multi (une instance par boutique) ou single (un site, la boutique active). */
+export function isSingleSite(): boolean {
+  return process.env.BOUTIQUE === "auto"
+}
 
 /**
- * Boutique de cette instance. Lue une fois (au démarrage via instrumentation.ts),
- * puis gardée en mémoire : modifier project.json demande un redémarrage (`apply`).
+ * Boutique affichée par cette instance (mode single : la boutique en ligne en ce moment),
+ * ou une boutique précise du projet (slug) : utilisé pour finir un panier commencé dans une autre boutique.
  */
-export function getBoutique(): Boutique {
-  if (!cached) {
-    cached = load()
-    // Lu par lib/util/money.ts, partagé avec les composants client (qui lisent <html lang>).
-    process.env.BOUTIQUE_LOCALE = cached.locale
+export function getBoutique(slug?: string): Boutique {
+  const env = process.env.BOUTIQUE
+  if (!env) {
+    throw new BoutiqueConfigError("variable d'environnement BOUTIQUE absente (ex. BOUTIQUE=yout-black-friday, ou auto en mode single)")
+  }
+  const p = readProject()
+  const wanted = slug ?? (env === "auto" ? activeSlug(p) : env)
+  if (!p.boutiques.some((b) => b.slug === wanted)) {
+    throw new BoutiqueConfigError(
+      `boutique « ${wanted} » absente de ${projectFile()}. Boutiques déclarées : ${p.boutiques.map((b) => b.slug).join(", ")}`
+    )
+  }
+  let b = boutiques.get(wanted)
+  if (!b) {
+    b = load(wanted, p)
+    boutiques.set(wanted, b)
+    // Lu par lib/util/money.ts, partagé avec les composants client (qui lisent <html lang>) ; même langue pour tout le projet.
+    process.env.BOUTIQUE_LOCALE = b.locale
   }
-  return cached
+  return b
 }

package/templates/storefront/src/lib/boutique/page-name.ts

@@ -0,0 +1,25 @@
+/**
+ * Nom de la page courante, posé en data-page sur .ub-page (app/(main)/template.tsx) et sur le checkout :
+ * sert à cibler une page dans styles/custom.css, ex. [data-page="product"] .ub-… ou :root:has([data-page="home"]) .ub-nav
+ */
+export type PageName =
+  | "home" | "store" | "search" | "product" | "category" | "collection" | "cart" | "checkout"
+  | "account" | "order" | "track" | "contact" | "shipping" | "returns" | "privacy" | "terms" | "review" | "other"
+
+export function pageName(path: string, search = ""): PageName {
+  const p = path.replace(/\/+$/, "") || "/"
+  if (p === "/") return "home"
+  if (p === "/store") return /(^|[?&])q=/.test(search) ? "search" : "store"
+  if (p.startsWith("/products/")) return "product"
+  if (p.startsWith("/categories/")) return "category"
+  if (p.startsWith("/collections/")) return "collection"
+  if (p === "/cart") return "cart"
+  if (p.startsWith("/checkout")) return "checkout"
+  if (p.startsWith("/account")) return "account"
+  if (p === "/review") return "review"
+  if (p === "/order/track") return "track"
+  if (p.startsWith("/order/")) return "order"
+  const legal = p.match(/^\/legal\/(contact|shipping|returns|privacy|terms)$/)
+  if (legal) return legal[1] as PageName
+  return "other"
+}

package/templates/storefront/src/lib/boutique/schema.ts

@@ -33,6 +33,9 @@ const overridable = {
 export const projectSchema = z.object({
   project: z.string().regex(SLUG),
   templateVersion: z.string().optional(),
+  /** single : un seul site (site.port, site.url) qui affiche la boutique active (choisie dans l'admin) */
+  mode: z.enum(["multi", "single"]).default("multi"),
+  site: z.object({ port: z.number().int().min(1).max(65535), url: z.url().optional() }).optional(),
   defaults: z
     .object({
       ...overridable,
@@ -48,7 +51,7 @@ export const projectSchema = z.object({
         .object({
           slug: z.string().regex(SLUG, "slug : minuscules, chiffres et tirets"),
           theme: z.string().regex(SLUG),
-          port: z.number().int().min(1).max(65535),
+          port: z.number().int().min(1).max(65535).optional(),
           url: z.url().optional(),
           storeName: overridable.storeName.optional(),
           currency: overridable.currency.optional(),
@@ -71,7 +74,7 @@ export const themeSchema = z.object({
   /** Variante : reprend la mise en page (règles CSS) de ce thème, avec la palette de styles/ub/variants.css. */
   layout: z.string().regex(SLUG).optional(),
   /** Page d'accueil : « default » (sections standard) ou « harvest » (accueil éditorial des thèmes Thanksgiving) */
-  home: z.enum(["default", "harvest", "gala", "cinema", "album", "tech", "grimoire"]).optional(),
+  home: z.enum(["default", "harvest", "gala", "cinema", "album", "tech", "grimoire", "riviera", "sunset", "locker", "training", "arena", "mosaic", "lantern", "souk"]).optional(),
   fonts: z.object({
     head: z.enum(["inter", "jakarta", "oswald", "outfit", "poppins", "serif", "sora", "space-grotesk"]),
     body: z.enum(["inter", "jakarta", "oswald", "outfit", "poppins", "serif", "sora", "space-grotesk"]),
@@ -131,6 +134,8 @@ export const campaignFileSchema = z
     logo: z.url().max(500).optional(),
     /** undefined = selon le thème */
     showCountdown: z.boolean().optional(),
+    /** Site ouvert (défaut) ou fermé, décidé dans admin → Campagnes (mode multi) ; indépendant des dates */
+    online: z.boolean().optional(),
   })
   .refine((c) => new Date(c.startsAt) < new Date(c.endsAt), "startsAt doit précéder endsAt")
 

package/templates/storefront/src/lib/config.ts

@@ -2,21 +2,45 @@ import "server-only"
 
 import { getBoutique } from "@lib/boutique/config"
 import Medusa, { FetchArgs, FetchInput } from "@medusajs/js-sdk"
+import { cookies } from "next/headers"
 
 // URL interne du backend (réseau Docker) : jamais exposée au navigateur.
 const MEDUSA_BACKEND_URL = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000"
 
-let client: Medusa | undefined
+/** Cookie : boutique où le panier a été créé (mode single, cf. setCartId). */
+export const CART_BOUTIQUE_COOKIE = "_ub_cart_boutique"
+
+// Requêtes liées au panier : elles utilisent la clé de la boutique du panier, pas celle affichée.
+const CART_PATHS = /^\/?store\/(carts|payment-collections|shipping-options)\b/
 
 /**
- * Client Medusa de la boutique : la publishable key vient de KEYS_DIR/<slug>,
+ * Mode single : un client qui a commencé son panier avant un changement de boutique le termine
+ * dans sa boutique d'origine (même canal de vente, mêmes prix et même livraison). Mode multi : sans effet.
+ */
+async function cartKey(input: FetchInput): Promise<string | undefined> {
+  if (process.env.BOUTIQUE !== "auto" || !CART_PATHS.test(String(input))) return undefined
+  try {
+    const slug = (await cookies()).get(CART_BOUTIQUE_COOKIE)?.value
+    if (!slug || slug === getBoutique().slug) return undefined
+    return getBoutique(slug).publishableKey
+  } catch {
+    // Boutique retirée du projet, ou appel hors requête : clé de la boutique affichée
+    return undefined
+  }
+}
+
+const clients = new Map<string, Medusa>()
+
+/**
+ * Client Medusa de la boutique affichée : la publishable key vient de KEYS_DIR/<slug>,
  * lue à l'exécution (pas de variable NEXT_PUBLIC_* figée au build).
- * Créé au premier usage pour que `next build` n'ait besoin d'aucune boutique.
+ * Un client par boutique (mode single : la boutique active change sans redémarrage).
  */
 function getClient(): Medusa {
-  if (client) return client
-
   const boutique = getBoutique()
+  const existing = clients.get(boutique.slug)
+  if (existing) return existing
+
   const medusa = new Medusa({
     baseUrl: MEDUSA_BACKEND_URL,
     debug: process.env.NODE_ENV === "development",
@@ -26,12 +50,17 @@ function getClient(): Medusa {
   // Langue fixée par l'instance : les traductions Medusa suivent la langue du projet.
   const originalFetch = medusa.client.fetch.bind(medusa.client)
   medusa.client.fetch = async <T>(input: FetchInput, init?: FetchArgs): Promise<T> => {
-    const headers = { "x-medusa-locale": boutique.locale, ...(init?.headers ?? {}) }
+    const key = await cartKey(input)
+    const headers = {
+      "x-medusa-locale": boutique.locale,
+      ...(key ? { "x-publishable-api-key": key } : {}),
+      ...(init?.headers ?? {}),
+    }
     return originalFetch(input, { ...init, headers })
   }
 
-  client = medusa
-  return client
+  clients.set(boutique.slug, medusa)
+  return medusa
 }
 
 export const sdk = new Proxy({} as Medusa, {