From 62cc4647387f489c155ad7e76d096547aaa80f02 Mon Sep 17 00:00:00 2001 From: Claude Integration Date: Sat, 30 May 2026 22:17:10 +0000 Subject: [PATCH] =?UTF-8?q?feat(plugins):=20foundation=20syst=C3=A8me=20Pl?= =?UTF-8?q?ugin=20Karb=C3=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Modèle Prisma Plugin (key, name, description, category, version, enabled, config JSONB, migrationsApplied, timestamps) + migration SQL - PluginRegistry (src/lib/plugins/registry.ts) avec 12 plugins déclarés : visuels (theme-guyane, landing-hero, landing-sections, image-gallery-seed, demo-carbets-seed), métier (access-type, seasonality, pirogue-providers, min-stay), contenus (content-pages, legal-pages), i18n (i18n-fr-en) - Server helpers (server.ts) : sync, isEnabled, getEnabledKeys, toggle avec hooks onEnable/onDisable, updateConfig, cache 5s - Client bridge (client.tsx) : PluginProvider + useIsPluginEnabled - Composant - Guard requirePluginOr404 pour pages et routes - Page admin /admin/plugins avec table toggle par catégorie + édition config - Route PATCH /api/admin/plugins/[key] + GET - Layout async qui sync registry + passe enabledKeys au PluginProvider Tous plugins en enabled=false par défaut, activation pilotée depuis l'admin. --- .../migration.sql | 19 +++ prisma/schema.prisma | 18 +++ .../plugins/_components/PluginToggleTable.tsx | 102 ++++++++++++++ src/app/admin/plugins/page.tsx | 26 ++++ src/app/api/admin/plugins/[key]/route.ts | 39 ++++++ src/app/layout.tsx | 19 ++- src/components/IfPluginEnabled.tsx | 31 +++++ src/lib/plugins/client.tsx | 28 ++++ src/lib/plugins/guard.ts | 22 +++ src/lib/plugins/hooks.ts | 19 +++ src/lib/plugins/registry.ts | 127 +++++++++++++++++ src/lib/plugins/server.ts | 129 ++++++++++++++++++ 12 files changed, 577 insertions(+), 2 deletions(-) create mode 100644 prisma/migrations/20260530200000_add_plugin_system/migration.sql create mode 100644 src/app/admin/plugins/_components/PluginToggleTable.tsx create mode 100644 src/app/admin/plugins/page.tsx create mode 100644 src/app/api/admin/plugins/[key]/route.ts create mode 100644 src/components/IfPluginEnabled.tsx create mode 100644 src/lib/plugins/client.tsx create mode 100644 src/lib/plugins/guard.ts create mode 100644 src/lib/plugins/hooks.ts create mode 100644 src/lib/plugins/registry.ts create mode 100644 src/lib/plugins/server.ts diff --git a/prisma/migrations/20260530200000_add_plugin_system/migration.sql b/prisma/migrations/20260530200000_add_plugin_system/migration.sql new file mode 100644 index 0000000..5437f7c --- /dev/null +++ b/prisma/migrations/20260530200000_add_plugin_system/migration.sql @@ -0,0 +1,19 @@ +-- Foundation : système Plugin Karbé + +CREATE TABLE "Plugin" ( + "key" TEXT PRIMARY KEY, + "name" TEXT NOT NULL, + "description" TEXT NOT NULL, + "category" TEXT NOT NULL, + "version" TEXT NOT NULL DEFAULT '0.1.0', + "enabled" BOOLEAN NOT NULL DEFAULT false, + "config" JSONB NOT NULL DEFAULT '{}', + "migrationsApplied" TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[], + "installedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + "updatedAt" TIMESTAMP(3) NOT NULL, + "lastEnabledAt" TIMESTAMP(3), + "lastDisabledAt" TIMESTAMP(3) +); + +CREATE INDEX "Plugin_category_idx" ON "Plugin" ("category"); +CREATE INDEX "Plugin_enabled_idx" ON "Plugin" ("enabled"); diff --git a/prisma/schema.prisma b/prisma/schema.prisma index ee7a327..c908b52 100644 --- a/prisma/schema.prisma +++ b/prisma/schema.prisma @@ -244,3 +244,21 @@ model Review { @@index([carbetId]) @@index([authorId]) } + +model Plugin { + key String @id + name String + description String + category String + version String @default("0.1.0") + enabled Boolean @default(false) + config Json @default("{}") + migrationsApplied String[] @default([]) + installedAt DateTime @default(now()) + updatedAt DateTime @updatedAt + lastEnabledAt DateTime? + lastDisabledAt DateTime? + + @@index([category]) + @@index([enabled]) +} diff --git a/src/app/admin/plugins/_components/PluginToggleTable.tsx b/src/app/admin/plugins/_components/PluginToggleTable.tsx new file mode 100644 index 0000000..70c77ac --- /dev/null +++ b/src/app/admin/plugins/_components/PluginToggleTable.tsx @@ -0,0 +1,102 @@ +"use client"; + +import { useState, useTransition } from "react"; + +interface PluginRow { + key: string; + name: string; + description: string; + category: string; + version: string; + enabled: boolean; + config: Record; +} + +const CATEGORY_LABEL: Record = { + visual: "Visuels", + business: "Métier", + content: "Contenus", + i18n: "Internationalisation", + core: "Core", +}; + +export default function PluginToggleTable({ plugins: initial }: { plugins: PluginRow[] }) { + const [plugins, setPlugins] = useState(initial); + const [pending, startTransition] = useTransition(); + const [busyKey, setBusyKey] = useState(null); + const [error, setError] = useState(null); + + const byCategory = plugins.reduce>((acc, p) => { + (acc[p.category] ??= []).push(p); + return acc; + }, {}); + + async function toggle(key: string, next: boolean) { + setError(null); + setBusyKey(key); + try { + const res = await fetch(`/api/admin/plugins/${encodeURIComponent(key)}`, { + method: "PATCH", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ enabled: next }), + }); + if (!res.ok) { + const body = await res.json().catch(() => ({})); + throw new Error(body?.error || `HTTP ${res.status}`); + } + const updated = await res.json(); + startTransition(() => { + setPlugins((curr) => + curr.map((p) => (p.key === key ? { ...p, enabled: !!updated.enabled } : p)), + ); + }); + } catch (e) { + setError(e instanceof Error ? e.message : String(e)); + } finally { + setBusyKey(null); + } + } + + return ( +
+ {error && ( +
+ {error} +
+ )} + {Object.entries(byCategory).map(([category, rows]) => ( +
+

+ {CATEGORY_LABEL[category] ?? category} +

+
    + {rows.map((p) => ( +
  • +
    +
    + {p.name} + {p.key} + v{p.version} +
    +

    {p.description}

    +
    + +
    • + ))} +
+
+ ))} +
+ ); +} diff --git a/src/app/admin/plugins/page.tsx b/src/app/admin/plugins/page.tsx new file mode 100644 index 0000000..37195f7 --- /dev/null +++ b/src/app/admin/plugins/page.tsx @@ -0,0 +1,26 @@ +import { requireRole } from "@/lib/authorization"; +import { UserRole } from "@/generated/prisma/enums"; +import { listAllPlugins, syncPluginsFromRegistry } from "@/lib/plugins/server"; +import PluginToggleTable from "./_components/PluginToggleTable"; + +export const dynamic = "force-dynamic"; + +export default async function PluginsAdminPage() { + await requireRole([UserRole.ADMIN]); + // S'assure que tous les plugins du registry sont en DB. + await syncPluginsFromRegistry(); + const plugins = await listAllPlugins(); + + return ( +
+

Plugins Karbé

+

+ Active ou désactive chaque module. Les changements prennent effet immédiatement (cache 5 s). + L'onEnable/onDisable est exécuté avant la bascule. +

+
+ +
+
+ ); +} diff --git a/src/app/api/admin/plugins/[key]/route.ts b/src/app/api/admin/plugins/[key]/route.ts new file mode 100644 index 0000000..66dc88e --- /dev/null +++ b/src/app/api/admin/plugins/[key]/route.ts @@ -0,0 +1,39 @@ +import { NextResponse } from "next/server"; +import { z } from "zod"; +import { requireRole } from "@/lib/authorization"; +import { UserRole } from "@/generated/prisma/enums"; +import { findDescriptor } from "@/lib/plugins/registry"; +import { togglePlugin, updatePluginConfig, getPluginState } from "@/lib/plugins/server"; + +const patchSchema = z.object({ + enabled: z.boolean().optional(), + config: z.record(z.string(), z.unknown()).optional(), +}); + +export async function PATCH(req: Request, ctx: { params: Promise<{ key: string }> }) { + await requireRole([UserRole.ADMIN]); + const { key } = await ctx.params; + if (!findDescriptor(key)) { + return NextResponse.json({ error: "Unknown plugin" }, { status: 404 }); + } + const parsed = patchSchema.safeParse(await req.json().catch(() => ({}))); + if (!parsed.success) { + return NextResponse.json({ error: "Invalid payload" }, { status: 400 }); + } + let state = await getPluginState(key); + if (parsed.data.enabled !== undefined) { + state = await togglePlugin(key, parsed.data.enabled); + } + if (parsed.data.config !== undefined) { + state = await updatePluginConfig(key, parsed.data.config); + } + return NextResponse.json(state); +} + +export async function GET(_req: Request, ctx: { params: Promise<{ key: string }> }) { + await requireRole([UserRole.ADMIN]); + const { key } = await ctx.params; + const state = await getPluginState(key); + if (!state) return NextResponse.json({ error: "Not found" }, { status: 404 }); + return NextResponse.json(state); +} diff --git a/src/app/layout.tsx b/src/app/layout.tsx index a671161..8ddbb33 100644 --- a/src/app/layout.tsx +++ b/src/app/layout.tsx @@ -1,6 +1,8 @@ import type { Metadata } from "next"; import { Geist, Geist_Mono } from "next/font/google"; import "./globals.css"; +import { PluginProvider } from "@/lib/plugins/client"; +import { getEnabledPluginKeys, syncPluginsFromRegistry } from "@/lib/plugins/server"; const geistSans = Geist({ variable: "--font-geist-sans", @@ -32,17 +34,30 @@ export const metadata: Metadata = { }, }; -export default function RootLayout({ +export default async function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { + // Plugins Karbé : sync registry → DB puis charge la liste activée pour le client. + // En cas d'erreur DB (build statique sans DB par ex.), on retombe en mode "aucun + // plugin activé" pour ne pas casser le rendu. + let enabledKeys: string[] = []; + try { + await syncPluginsFromRegistry(); + enabledKeys = await getEnabledPluginKeys(); + } catch { + enabledKeys = []; + } + return ( - {children} + + {children} + ); } diff --git a/src/components/IfPluginEnabled.tsx b/src/components/IfPluginEnabled.tsx new file mode 100644 index 0000000..9b6fee1 --- /dev/null +++ b/src/components/IfPluginEnabled.tsx @@ -0,0 +1,31 @@ +"use client"; + +import type { ReactNode } from "react"; +import { useIsPluginEnabled } from "@/lib/plugins/client"; + +/** + * Composant client : affiche `children` uniquement si le plugin est activé. + * Le `` doit être présent en amont (layout) avec la liste + * des plugins activés calculée côté serveur. + * + * Usage : + * + * + * + * + * }> + * + * + */ +export function IfPluginEnabled({ + plugin, + fallback = null, + children, +}: { + plugin: string; + fallback?: ReactNode; + children: ReactNode; +}) { + const enabled = useIsPluginEnabled(plugin); + return <>{enabled ? children : fallback}; +} diff --git a/src/lib/plugins/client.tsx b/src/lib/plugins/client.tsx new file mode 100644 index 0000000..7f27540 --- /dev/null +++ b/src/lib/plugins/client.tsx @@ -0,0 +1,28 @@ +/** + * Plugin Karbé — bridge client. + * + * Le client ne lit JAMAIS la DB. Il reçoit l'état des plugins depuis un + * server component qui appelle `getEnabledPluginKeys()` et passe la liste en + * prop ou via le composant ``. + */ + +"use client"; + +import { createContext, useContext, type ReactNode } from "react"; + +const PluginContext = createContext>(new Set()); + +export function PluginProvider({ + enabledKeys, + children, +}: { + enabledKeys: string[]; + children: ReactNode; +}) { + return {children}; +} + +export function useIsPluginEnabled(key: string): boolean { + const set = useContext(PluginContext); + return set.has(key); +} diff --git a/src/lib/plugins/guard.ts b/src/lib/plugins/guard.ts new file mode 100644 index 0000000..bdafd6a --- /dev/null +++ b/src/lib/plugins/guard.ts @@ -0,0 +1,22 @@ +/** + * Plugin Karbé — guard pour pages et routes API. + * + * Côté server component (page) : + * import { requirePluginOr404 } from "@/lib/plugins/guard"; + * export default async function Page() { + * await requirePluginOr404("landing-hero"); + * ... + * } + * + * Côté route handler : + * if (!(await isPluginEnabled("access-type"))) return new Response("Not Found", { status: 404 }); + */ + +import "server-only"; +import { notFound } from "next/navigation"; +import { isPluginEnabled } from "./server"; + +export async function requirePluginOr404(key: string): Promise { + const ok = await isPluginEnabled(key); + if (!ok) notFound(); +} diff --git a/src/lib/plugins/hooks.ts b/src/lib/plugins/hooks.ts new file mode 100644 index 0000000..ad20403 --- /dev/null +++ b/src/lib/plugins/hooks.ts @@ -0,0 +1,19 @@ +/** + * Plugin Karbé — hooks d'activation/désactivation par plugin. + * + * Chaque plugin peut déclarer un `onEnable` et/ou `onDisable` ici. Exemples + * d'usage : seed initial des carbets démo (au enable), soft-delete des + * carbets démo (au disable). Les hooks ne sont **pas** des migrations DB — + * pour ça on passe par les fichiers prisma/migrations. + */ + +export type PluginHook = () => Promise; + +export interface PluginHookSet { + onEnable?: PluginHook; + onDisable?: PluginHook; +} + +// Pour l'instant, vide : les plugins métier ajouteront leurs hooks ici +// au fur et à mesure (sans toucher au runtime du système Plugin). +export const pluginHooks: Record = {}; diff --git a/src/lib/plugins/registry.ts b/src/lib/plugins/registry.ts new file mode 100644 index 0000000..402ac92 --- /dev/null +++ b/src/lib/plugins/registry.ts @@ -0,0 +1,127 @@ +/** + * Plugin Karbé — registry statique des plugins disponibles. + * + * Chaque plugin déclaré ici sera synchronisé en DB au démarrage (insertion si absent, + * sans toucher au flag `enabled` existant). L'état (enabled / config) est piloté + * depuis /admin/plugins. Le code des plugins est TOUJOURS présent dans le bundle ; + * l'activation au runtime conditionne juste l'exposition des pages, routes et composants. + */ + +export type PluginCategory = "core" | "visual" | "business" | "content" | "i18n"; + +export interface PluginDescriptor { + key: string; + name: string; + description: string; + category: PluginCategory; + version: string; +} + +export const PLUGINS: PluginDescriptor[] = [ + // Visuels + { + key: "theme-guyane", + name: "Thème Guyane", + description: + "Palette tropicale (vert canopée, eau Maroni, ocre latérite, bois karbé) + typographies display + tokens Tailwind.", + category: "visual", + version: "0.1.0", + }, + { + key: "landing-hero", + name: "Hero d'accueil", + description: + "Refonte de la page d'accueil avec hero plein écran, claim, CTA double Découvrir/Proposer.", + category: "visual", + version: "0.1.0", + }, + { + key: "landing-sections", + name: "Sections d'accueil", + description: + "Sections « 2 expériences », « Comment ça marche », « Pour comités d'entreprise », « Témoignages », footer riche.", + category: "visual", + version: "0.1.0", + }, + { + key: "image-gallery-seed", + name: "Galerie d'images seed", + description: + "8 images photo-réalistes générées (carbets, intérieurs, pirogue) stockées dans MinIO. Illustrations vectorielles pour les sections.", + category: "visual", + version: "0.1.0", + }, + { + key: "demo-carbets-seed", + name: "Carbets de démo", + description: + "5-8 carbets d'exemple avec photos, GPS réels, types d'accès variés. Désactivation = soft-delete via tag.", + category: "visual", + version: "0.1.0", + }, + + // Métier + { + key: "access-type", + name: "Type d'accès route/fleuve", + description: + "Distinction ROAD_AND_RIVER vs RIVER_ONLY (badge, filtre recherche, fiche enrichie). Migration soft.", + category: "business", + version: "0.1.0", + }, + { + key: "seasonality", + name: "Saisonnalité", + description: + "Saison sèche / pluies / étiage. Bandeau d'alerte, dispo conditionnelle, filtre « ouvert maintenant ».", + category: "business", + version: "0.1.0", + }, + { + key: "pirogue-providers", + name: "Prestataires pirogue", + description: + "Partenaires pirogue + mode transport sur Carbet (OWNER_PROVIDES / SELF_ARRANGE / PARTNER_PROVIDER).", + category: "business", + version: "0.1.0", + }, + { + key: "min-stay", + name: "Durée min/max séjour", + description: + "Contraintes nuits min/max, capacité min, règles week-end CE vs semaine public mappées dans Availability.", + category: "business", + version: "0.1.0", + }, + + // Contenus / i18n + { + key: "content-pages", + name: "Pages de contenu", + description: + "Pages markdown éditables depuis l'admin (À propos, FAQ, Comment ça marche, Pour CE, Devenir loueur).", + category: "content", + version: "0.1.0", + }, + { + key: "i18n-fr-en", + name: "i18n FR + EN", + description: "Routes [locale]/, détection navigateur, switcher header. Plugin désactivable = FR pur sans préfixe.", + category: "i18n", + version: "0.1.0", + }, + { + key: "legal-pages", + name: "Pages légales", + description: "CGV, RGPD, mentions légales (absorbe SYS-9). Markdown + rendu statique.", + category: "content", + version: "0.1.0", + }, +]; + +export const PLUGIN_KEYS = PLUGINS.map((p) => p.key); +export type PluginKey = (typeof PLUGIN_KEYS)[number]; + +export function findDescriptor(key: string): PluginDescriptor | undefined { + return PLUGINS.find((p) => p.key === key); +} diff --git a/src/lib/plugins/server.ts b/src/lib/plugins/server.ts new file mode 100644 index 0000000..422a0b7 --- /dev/null +++ b/src/lib/plugins/server.ts @@ -0,0 +1,129 @@ +/** + * Plugin Karbé — accès serveur à l'état des plugins. + * + * - getPluginState(key): lit la DB (avec cache 5s pour éviter les hammer). + * - isPluginEnabled(key): helper booléen. + * - syncPluginsFromRegistry(): à appeler au démarrage pour insérer les plugins + * nouvellement ajoutés au code (sans toucher aux flags existants). + * - togglePlugin(key, enabled): admin action avec hook onEnable/onDisable. + */ + +import "server-only"; +import { prisma } from "@/lib/prisma"; +import { PLUGINS, type PluginDescriptor } from "./registry"; +import { pluginHooks } from "./hooks"; + +type PluginRow = { + key: string; + enabled: boolean; + config: Record; + version: string; + category: string; + name: string; + description: string; +}; + +let cache: Map | null = null; +let cacheStamp = 0; +const CACHE_TTL_MS = 5000; + +async function loadAll(): Promise> { + const now = Date.now(); + if (cache && now - cacheStamp < CACHE_TTL_MS) return cache; + const rows = await prisma.plugin.findMany(); + const map = new Map(); + for (const r of rows) { + map.set(r.key, { + key: r.key, + enabled: r.enabled, + config: (r.config ?? {}) as Record, + version: r.version, + category: r.category, + name: r.name, + description: r.description, + }); + } + cache = map; + cacheStamp = now; + return map; +} + +export function invalidatePluginCache(): void { + cache = null; + cacheStamp = 0; +} + +export async function getPluginState(key: string): Promise { + const m = await loadAll(); + return m.get(key) ?? null; +} + +export async function isPluginEnabled(key: string): Promise { + const s = await getPluginState(key); + return !!s?.enabled; +} + +export async function getEnabledPluginKeys(): Promise { + const m = await loadAll(); + return [...m.values()].filter((r) => r.enabled).map((r) => r.key); +} + +export async function listAllPlugins(): Promise { + const m = await loadAll(); + return [...m.values()].sort((a, b) => a.category.localeCompare(b.category) || a.name.localeCompare(b.name)); +} + +export async function syncPluginsFromRegistry(): Promise { + const existing = new Set((await prisma.plugin.findMany({ select: { key: true } })).map((p) => p.key)); + const toInsert: PluginDescriptor[] = PLUGINS.filter((p) => !existing.has(p.key)); + if (toInsert.length) { + await prisma.plugin.createMany({ + data: toInsert.map((p) => ({ + key: p.key, + name: p.name, + description: p.description, + category: p.category, + version: p.version, + enabled: false, + config: {}, + })), + skipDuplicates: true, + }); + invalidatePluginCache(); + } + // Update name/description/version if the descriptor changed (idempotent). + for (const p of PLUGINS) { + if (existing.has(p.key)) { + await prisma.plugin.update({ + where: { key: p.key }, + data: { name: p.name, description: p.description, category: p.category, version: p.version }, + }); + } + } + invalidatePluginCache(); +} + +export async function togglePlugin(key: string, enabled: boolean): Promise { + const before = await prisma.plugin.findUnique({ where: { key } }); + if (!before) return null; + if (before.enabled === enabled) return await getPluginState(key); + const hook = pluginHooks[key]; + if (enabled && hook?.onEnable) await hook.onEnable(); + if (!enabled && hook?.onDisable) await hook.onDisable(); + await prisma.plugin.update({ + where: { key }, + data: { + enabled, + lastEnabledAt: enabled ? new Date() : before.lastEnabledAt, + lastDisabledAt: !enabled ? new Date() : before.lastDisabledAt, + }, + }); + invalidatePluginCache(); + return await getPluginState(key); +} + +export async function updatePluginConfig(key: string, config: Record): Promise { + await prisma.plugin.update({ where: { key }, data: { config } }); + invalidatePluginCache(); + return await getPluginState(key); +}