sveltekit-admin 0.5.3 → 0.8.1

package/dist/server/handler.js

@@ -3,379 +3,58 @@
  * Zero files needed in routes - everything handled via hook
  */
 import { render } from 'svelte/server';
-import { parsePrismaSchema, isSensitiveFieldName } from './introspection/parser.js';
-import { buildRelationGraph } from './introspection/relations.js';
-import { parseRoute } from './router.js';
-import { primaryKeyOf, toPrismaModel, coerceId, formDataToPrisma, paginate, listRecords, getRecord, createRecord, updateRecord, deleteRecord } from './data.js';
+import { matchRoute, BUILTIN_ROUTES } from './router.js';
+import { paginate, coerceId } from './data.js';
 import { parseListQuery, buildWhere, resolveSearchFields } from './query/listQuery.js';
-import { resolveListFilters, validateListFilterConfig, findFkEdge } from './query/filterDetection.js';
+import { normalizeScope } from './adapters/filter.js';
+import { resolveListFilters } from './query/filterDetection.js';
 import { escapeHtml, toLabel } from './views/html.js';
 import NotFound from './views/NotFound.svelte';
 import Layout from './views/Layout.svelte';
 import Dashboard from './views/Dashboard.svelte';
 import Form from './views/Form.svelte';
 import List from './views/List.svelte';
-const PER_PAGE = 20;
+import { createAdminRuntime, listScopeFrom, modelScopeFrom } from './runtime.js';
+import { loadRelationOptions, resolveFkFilterOptions, loadRelatedCounts } from './relationLoaders.js';
+import { handleSearch } from './search.js';
+import { handleMutation } from './mutations.js';
+import { AdminMutationError, AdminConfigError } from './errors.js';
+import { verifyOrigin, resolveCsrfConfig } from './csrf.js';
+import { resolvePluginRegistry, actionsForModel } from './pluginRegistry.js';
+import { createPluginPageContext } from './pluginAccess.js';
 // ============================================
 // Main Handler
 // ============================================
 export function createAdminHandler(config) {
-    const { prisma, prismaSchemaPath = './prisma/schema.prisma', basePath = '/admin', authCheck, logout, logoutRedirectTo = '/', exclude = [], hidePivotTables = true, models: modelsConfig = {} } = config;
-    // Parse schema once at startup
-    let schema = null;
-    let relationGraph = null;
-    try {
-        schema = parsePrismaSchema(prismaSchemaPath);
-        relationGraph = buildRelationGraph(schema);
-        for (const d of relationGraph.diagnostics) {
-            console.warn(`[sveltekit-admin] ${d}`);
-        }
-    }
-    catch (e) {
-        console.warn('[sveltekit-admin] Could not parse Prisma schema:', e);
+    if (!config.adapter) {
+        throw new Error('[sveltekit-admin] createAdminHandler requires `adapter`.');
     }
-    const filteredModels = schema?.models.filter((m) => {
-        // Exclude explicitly excluded models
-        if (exclude.includes(m.name))
-            return false;
-        // Exclude pivot tables if option is enabled
-        if (hidePivotTables && m.isPivotTable)
-            return false;
-        return true;
-    }) || [];
-    // Valider `listFilter` au démarrage : une config invalide (champ
-    // inexistant, sensible, relation, type non supporté) doit échouer fort
-    // ici plutôt que produire silencieusement un filtre mort à chaque rendu
-    // de liste (docs/design §8, même politique que le groupe ambigu de
-    // relations.ts).
-    const hiddenFieldsOf = (m) => new Set(modelsConfig[m.name]?.hidden ?? []);
-    for (const m of filteredModels) {
-        const entries = modelsConfig[m.name]?.listFilter;
-        // Non-null par construction : `filteredModels` n'existe que si le schéma
-        // a été parsé, et le graphe est construit dans la même branche de boot.
-        if (entries)
-            validateListFilterConfig(m.name, entries, m, relationGraph, hiddenFieldsOf(m));
-    }
-    const labelOf = (m) => modelsConfig[m.name]?.label || toLabel(m.name);
-    const modelList = filteredModels.map((m) => ({ name: m.name, label: labelOf(m) }));
-    const findModel = (name) => filteredModels.find((m) => m.name.toLowerCase() === name?.toLowerCase());
-    const viewModel = (m) => ({
-        name: m.name,
-        label: labelOf(m),
-        fields: m.fields,
-        primaryKey: primaryKeyOf(m),
-        // Non-null par construction : `m` vient toujours de `filteredModels`,
-        // dérivé du schéma qu'on vient de parser avec succès.
-        relationGraph: relationGraph
-    });
-    const redirectToList = (model) => new Response(null, {
-        status: 303,
-        headers: { Location: `${basePath}/${model.toLowerCase()}` }
-    });
-    const selectThreshold = config.relationDefaults?.selectThreshold ?? 200;
-    const filterLinkThreshold = config.listFilterDefaults?.linkThreshold ?? 20;
-    const labelFieldCandidates = config.relationDefaults?.labelFields ?? [
-        'name', 'title', 'label', 'email', 'username', 'slug'
-    ];
-    // `mode: 'insensitive'` n'est supporté par Prisma que sur
-    // postgresql/cockroachdb/mongodb — l'émettre sur sqlite/mysql/sqlserver
-    // lève une erreur Prisma dure. Détection auto via le provider extrait du
-    // schéma ; `search.mode` permet de forcer le comportement (provider non
-    // littéral dans le schéma, index citext, etc.). Voir docs/design §2.5.
-    const searchMode = config.search?.mode ?? 'auto';
-    const caseInsensitiveSearch = searchMode === 'insensitive' ||
-        (searchMode === 'auto' &&
-            ['postgresql', 'cockroachdb', 'mongodb'].includes(schema?.provider ?? ''));
-    /**
-     * Champs qu'un `?f.<field>=` est autorisé à cibler pour ce modèle : tout
-     * champ scalaire non-liste, non-relation, de type filtrable
-     * (String/Int/Float/Decimal/BigInt/Boolean/DateTime/enum — donc pas
-     * Json/Bytes), non sensible, et non listé dans `hidden` pour ce modèle.
-     * Sans ce dernier point, `hidden: ['internalNotes']` ne fait que masquer
-     * l'affichage : le champ reste un oracle de confirmation de valeur via
-     * `?f.internalNotes=...contains...`, exactement la faille §0.a fermée
-     * ailleurs pour les champs sensibles par nom — `hidden` et le prédicat
-     * de sensibilité sont deux sources distinctes, toutes deux doivent
-     * fermer l'oracle (docs/design §10, "deux sources, un seul prédicat
-     * partagé, sinon divergence garantie"). Défense en profondeur :
-     * `listQuery.ts` revérifie lui-même la sensibilité par nom, ce set est
-     * la première passe et la seule à connaître la config `hidden`.
-     */
-    const resolveFilterableFields = (model) => {
-        const hidden = hiddenFieldsOf(model);
-        const out = new Set();
-        for (const f of model.fields) {
-            if (f.relation || f.isList)
-                continue;
-            if (['Json', 'Bytes'].includes(f.type))
-                continue;
-            if (isSensitiveFieldName(f.name))
-                continue;
-            if (hidden.has(f.name))
-                continue;
-            out.add(f.name);
-        }
-        return out;
-    };
-    /**
-     * Résout le label BRUT (non échappé) d'une ligne : premier champ String
-     * candidat présent, sinon template `{a} {b}` si configuré, sinon la PK.
-     * Déterministe. Svelte échappe automatiquement à l'interpolation dans les
-     * composants — pas besoin d'échapper ici.
-     */
-    const resolveLabel = (targetModel, row, labelTemplate) => {
-        if (labelTemplate) {
-            return labelTemplate.replace(/\{(\w+)\}/g, (_, k) => String(row[k] ?? ''));
-        }
-        for (const candidate of labelFieldCandidates) {
-            const field = targetModel.fields.find((f) => f.name === candidate);
-            if (field && field.type === 'String' && row[candidate] != null) {
-                return String(row[candidate]);
-            }
-        }
-        return String(row[primaryKeyOf(targetModel)]);
-    };
-    /**
-     * Charge les options pour toutes les arêtes to-one-owning et m2m-implicite
-     * d'un modèle. Une requête COUNT par relation avant le findMany : évite de
-     * charger 10k lignes pour découvrir qu'il y en a 10k.
-     */
-    const loadRelationOptions = async (model, ctx, currentId) => {
-        const edges = [...relationGraph.edges.values()].filter((edge) => {
-            if (edge.model !== model.name)
-                return false;
-            if (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m-implicit')
-                return false;
-            if (edge.unsupported)
-                return false;
-            const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
-            return relConfig?.widget !== 'hidden';
-        });
-        // Une relation ne dépend pas de l'autre : chargées en parallèle plutôt
-        // qu'en série (un modèle avec N relations ne doit pas payer N
-        // aller-retours DB empilés pour afficher un seul formulaire).
-        const entries = await Promise.all(edges.map(async (edge) => {
-            const key = `${edge.model}.${edge.field}`;
-            const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
-            const targetModel = schema.models.find((m) => m.name === edge.target);
-            const where = relConfig?.where ? relConfig.where(ctx) : undefined;
-            const prismaKey = toPrismaModel(edge.target);
-            try {
-                const total = await prisma[prismaKey].count({ where });
-                if (total > selectThreshold || relConfig?.widget === 'raw-id') {
-                    const selectedIds = edge.kind === 'm2m-implicit' && currentId
-                        ? await loadSelectedIds(model, edge, currentId, targetModel)
-                        : undefined;
-                    return [key, { tooMany: true, options: [], selectedIds }];
-                }
-                const rows = await prisma[prismaKey].findMany({
-                    where,
-                    orderBy: relConfig?.orderBy
-                });
-                const options = rows.map((row) => ({
-                    id: row[primaryKeyOf(targetModel)],
-                    label: resolveLabel(targetModel, row, relConfig?.labelTemplate)
-                }));
-                const selectedIds = edge.kind === 'm2m-implicit' && currentId
-                    ? await loadSelectedIds(model, edge, currentId, targetModel)
-                    : undefined;
-                return [key, { tooMany: false, options, selectedIds }];
-            }
-            catch {
-                // Cible absente de la base ou client incomplet : repli raw-id pour
-                // garder le champ éditable plutôt que de faire échouer tout le form.
-                return [key, { tooMany: true, options: [] }];
-            }
-        }));
-        return new Map(entries);
-    };
-    /**
-     * Options d'un filtre FK : charge et scope les valeurs possibles pour la
-     * sidebar, ET résout le label du chip actif. Doctrine IDOR (docs/design
-     * §6.3) : les options ET le label du chip passent par le `where` de
-     * scoping de la relation — un chip forgé avec un ID hors scope affiche
-     * l'ID brut, jamais le label (sinon c'est un oracle sur le nom d'un
-     * enregistrement d'un autre tenant).
-     */
-    const resolveFkFilterOptions = async (model, fkFieldName, label, ctx, activeRawValue) => {
-        // Appelé uniquement pour un filtre `kind: 'fk'` retourné par
-        // resolveListFilters avec CE MÊME graphe : graphe et arête existent donc
-        // par construction. Garder des gardes here masquerait une incohérence
-        // interne et ajouterait du code mort (coverage artificielle).
-        const edge = findFkEdge(relationGraph, model.name, fkFieldName);
-        const targetModel = schema.models.find((m) => m.name === edge.target);
-        // Non-null par construction : `edge` vient du graphe dérivé du même
-        // schéma parsé avec succès — une arête ne peut pas cibler un modèle qui
-        // n'existe pas dans `schema.models`.
-        const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
-        const scope = relConfig?.where ? relConfig.where(ctx) : undefined;
-        const prismaKey = toPrismaModel(edge.target);
-        // Options de la sidebar (comptées puis chargées si sous le seuil) et
-        // label du chip actif (§6.3.b) sont deux requêtes indépendantes — l'une
-        // ne dépend pas du résultat de l'autre — donc en parallèle plutôt qu'en
-        // série.
-        const loadOptions = async () => {
-            try {
-                const total = await prisma[prismaKey].count({ where: scope });
-                if (total > selectThreshold) {
-                    return { options: [], tooMany: true };
-                }
-                const rows = await prisma[prismaKey].findMany({
-                    where: scope,
-                    orderBy: relConfig?.orderBy
-                });
-                const options = rows.map((row) => ({
-                    id: row[primaryKeyOf(targetModel)],
-                    label: resolveLabel(targetModel, row, relConfig?.labelTemplate)
-                }));
-                return { options, tooMany: false };
-            }
-            catch {
-                return { options: [], tooMany: true };
-            }
-        };
-        // Un ID hors scope retourne null ici → le composant affiche l'ID brut,
-        // jamais le label (sinon c'est un oracle sur le nom d'un enregistrement
-        // d'un autre tenant).
-        const loadActiveLabel = async () => {
-            if (activeRawValue === undefined)
-                return undefined;
-            const activeId = coerceId(activeRawValue, targetModel);
-            try {
-                const row = await prisma[prismaKey].findFirst({
-                    where: scope ? { AND: [{ [primaryKeyOf(targetModel)]: activeId }, scope] } : { [primaryKeyOf(targetModel)]: activeId }
-                });
-                return row ? resolveLabel(targetModel, row, relConfig?.labelTemplate) : undefined;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        const [{ options, tooMany }, activeLabel] = await Promise.all([loadOptions(), loadActiveLabel()]);
-        return {
-            field: fkFieldName,
-            label,
-            relationField: edge.field,
-            targetModel: edge.target,
-            options,
-            mode: tooMany ? 'raw-id' : options.length <= filterLinkThreshold ? 'links' : 'select',
-            tooMany,
-            activeLabel,
-            // Une cible exclue/masquée n'a pas de page admin : le chip reste du
-            // texte, jamais un lien mort (docs/design §6.4).
-            activeHref: activeLabel && findModel(edge.target)
-                ? `${basePath}/${edge.target.toLowerCase()}/${encodeURIComponent(activeRawValue)}`
-                : undefined
-        };
-    };
-    /** IDs liés côté N-N implicite, via une requête sur le join field Prisma. */
-    const loadSelectedIds = async (model, edge, currentId, targetModel) => {
-        try {
-            const current = await prisma[toPrismaModel(model.name)].findUnique({
-                where: { [primaryKeyOf(model)]: coerceId(currentId, model) },
-                include: { [edge.field]: true }
-            });
-            const linked = current?.[edge.field] ?? [];
-            return linked.map((row) => row[primaryKeyOf(targetModel)]);
-        }
-        catch {
-            return [];
-        }
-    };
-    /**
-     * Compte, pour chaque relation inverse (1-N, 1-1) d'un modèle, le nombre
-     * d'enregistrements liés côté cible. Résilient : une cible dont le client
-     * échoue (mock partiel, modèle absent) retombe sur 0 plutôt que de casser
-     * le rendu du formulaire.
-     */
-    const loadRelatedCounts = async (model, currentId) => {
-        const edges = [...relationGraph.edges.values()].filter((edge) => edge.model === model.name && (edge.kind === 'to-many-inverse' || edge.kind === 'to-one-inverse'));
-        // Un count par relation inverse, indépendants entre eux : en parallèle
-        // plutôt qu'empilés un par un (même raisonnement que loadRelationOptions).
-        const entries = await Promise.all(edges.map(async (edge) => {
-            const owning = [...relationGraph.edges.values()].find((o) => o.model === edge.target && o.kind === 'to-one-owning' && o.relationName === edge.relationName);
-            if (!owning || owning.unsupported)
-                return undefined;
-            const scalarName = owning.scalarFields[0];
-            const key = `${edge.model}.${edge.field}`;
-            try {
-                const count = await prisma[toPrismaModel(edge.target)].count({
-                    where: { [scalarName]: coerceId(currentId, model) }
-                });
-                return [key, count];
-            }
-            catch {
-                return [key, 0];
-            }
-        }));
-        return new Map(entries.filter((e) => e !== undefined));
-    };
-    /**
-     * Endpoint de recherche `GET {basePath}/_search?rel=Model.field&q=...&page=N`.
-     * Sert les options d'une relation to-one-owning ou m2m-implicite en JSON
-     * paginé — la voie prévue pour un futur widget autocomplete côté client
-     * quand le nombre d'options dépasse `selectThreshold`. Respecte le `where`
-     * de scoping configuré sur la relation, comme le select et la validation
-     * POST : même garantie anti-IDOR sur les trois chemins.
-     */
-    const handleSearch = async (event) => {
-        const relParam = event.url.searchParams.get('rel') ?? '';
-        const [modelName, fieldName] = relParam.split('.');
-        const q = event.url.searchParams.get('q') ?? '';
-        const { page } = paginate(event.url.searchParams.get('page'), PER_PAGE);
-        const model = findModel(modelName);
-        const edge = model && relationGraph
-            ? relationGraph.edges.get(`${model.name}.${fieldName}`)
-            : undefined;
-        if (!model || !edge || (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m-implicit') || edge.unsupported) {
-            return new Response(JSON.stringify({ error: 'unknown relation' }), {
-                status: 404,
-                headers: { 'Content-Type': 'application/json' }
-            });
-        }
-        const targetModel = schema.models.find((m) => m.name === edge.target);
-        const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
-        const configWhere = relConfig?.where ? relConfig.where({ locals: event.locals }) : {};
-        // Recherche sur le premier champ String candidat du modèle cible — le
-        // même champ que celui utilisé pour construire le label par défaut.
-        const searchField = labelFieldCandidates.find((c) => targetModel.fields.some((f) => f.name === c && f.type === 'String'));
-        const where = {
-            ...configWhere,
-            ...(q && searchField ? { [searchField]: { contains: q } } : {})
-        };
-        const prismaKey = toPrismaModel(edge.target);
-        try {
-            const [total, rows] = await Promise.all([
-                prisma[prismaKey].count({ where }),
-                prisma[prismaKey].findMany({
-                    where,
-                    skip: (page - 1) * PER_PAGE,
-                    take: PER_PAGE,
-                    orderBy: relConfig?.orderBy
-                })
-            ]);
-            const options = rows.map((row) => ({
-                id: row[primaryKeyOf(targetModel)],
-                label: resolveLabel(targetModel, row, relConfig?.labelTemplate)
-            }));
-            return new Response(JSON.stringify({ options, total, page }), {
-                headers: { 'Content-Type': 'application/json' }
-            });
-        }
-        catch {
-            return new Response(JSON.stringify({ error: 'search failed' }), {
-                status: 500,
-                headers: { 'Content-Type': 'application/json' }
-            });
-        }
-    };
+    const runtime = createAdminRuntime(config);
+    const csrf = resolveCsrfConfig(config.csrf);
+    const registry = resolvePluginRegistry(config.plugins ?? [], BUILTIN_ROUTES, runtime.models);
+    const { authCheck, logout, logoutRedirectTo = '/' } = config;
     return async ({ event, resolve }) => {
         const { pathname } = event.url;
         // Only handle admin routes
-        if (!pathname.startsWith(basePath)) {
+        if (!pathname.startsWith(runtime.basePath)) {
             return resolve(event);
         }
-        const route = parseRoute(pathname, basePath);
+        // Avant `matchRoute` : couvre le logout (dispatché avant `authCheck`),
+        // `_search`, les mutations, et toute route ajoutée plus tard.
+        const forbidden = verifyOrigin(csrf, event);
+        if (forbidden)
+            return forbidden;
+        // Plugin routes are checked BEFORE builtins: `resolvePluginRegistry` only
+        // rejects a plugin pattern that is an EXACT token-for-token match of a
+        // builtin one (e.g. `[':model', ':id']`), not one that merely happens to
+        // overlap at match time (e.g. `[':model', 'stats']` vs the builtin edit
+        // route `[':model', ':id']` — both match `user/stats`, ':id' being a
+        // wildcard). Checking builtins first would let that generic edit route
+        // silently swallow every such plugin page.
+        const route = matchRoute(pathname, runtime.basePath, [
+            ...registry.routes,
+            ...BUILTIN_ROUTES
+        ]);
         // Logout: dispatched BEFORE authCheck, deliberately. A user whose
         // session already expired (authCheck would now reject them) must
         // still be able to hit this route to clear client-side state (a
@@ -399,233 +78,196 @@ export function createAdminHandler(config) {
                 return new Response('Unauthorized', { status: 401 });
             }
         }
-        let content = '';
-        let currentModel;
         if (route.view === 'search') {
-            return handleSearch(event);
+            return handleSearch(runtime, event);
         }
+        // Plugin page views are GET-only: dispatched here, BEFORE `handleMutation`,
+        // so a forged POST to a plugin route (e.g. `/user/1/graph` with
+        // `_action=delete`) can never reach the mutation path just because its
+        // pattern happens to overlap `:model/:id`-shaped segments.
+        const pluginPage = registry.pagesByView.get(route.view);
+        if (pluginPage) {
+            if (event.request.method !== 'GET') {
+                return new Response('Method Not Allowed', { status: 405, headers: { Allow: 'GET' } });
+            }
+        }
+        let content = '';
+        let currentModel;
+        let extraStyles = '';
+        let extraScripts = '';
+        let mutationError;
         try {
             // Handle POST requests (create, update, delete). Unrecognised actions fall
             // through to the GET rendering below, as they always have.
+            // Invariant: a plugin view never reaches this call — `pluginPage` above
+            // already 405'd any non-GET before this `try` block. `handleMutation`
+            // only ever reads `route.model` / `route.id` / the `_action` form
+            // field, never `route.view`, so it cannot be confused by a plugin's
+            // view id landing here.
             if (event.request.method === 'POST') {
-                const formData = await event.request.formData();
-                const action = formData.get('_action');
-                if (route.model) {
-                    const model = findModel(route.model);
-                    if (!model) {
-                        throw new Error(`Model "${route.model}" not found`);
+                // `try` propre au chemin de mutation, et non le `catch` partagé plus
+                // bas : celui-ci couvre aussi le rendu GET et les pages de plugin,
+                // dont le contrat (rendre le message levé) ne change pas ici.
+                try {
+                    const mutationResponse = await handleMutation(runtime, event, route);
+                    if (mutationResponse)
+                        return mutationResponse;
+                }
+                catch (e) {
+                    // Plus de classification ici : `handleMutation` a déjà consommé le
+                    // corps de la requête, donc ce site ne peut plus lire `_action` et
+                    // ne saurait pas distinguer une création d'une suppression. La
+                    // classification par code pilote se fait désormais dans
+                    // `mutations.ts`, au site d'appel qui connaît l'action réelle —
+                    // ce `catch` ne fait plus qu'un aiguillage à trois branches sur le
+                    // type de l'erreur déjà classée.
+                    if (e instanceof AdminMutationError) {
+                        // Message construit par la bibliothèque (validation, scope, ou
+                        // code pilote reconnu) : sûr à rendre tel quel.
+                        mutationError = e.message;
                     }
-                    if (action === 'delete' && route.id) {
-                        await deleteRecord(prisma, model, route.id);
-                        return redirectToList(route.model);
+                    else if (e instanceof AdminConfigError) {
+                        // Mauvaise configuration côté consommateur : message écrit par la
+                        // bibliothèque, destiné au développeur. Le `catch` partagé plus bas
+                        // garde son contrat historique — on le laisse la traiter.
+                        throw e;
                     }
-                    if (action === 'create' || action === 'update') {
-                        const data = formDataToPrisma(formData, model);
-                        // Validation des FK owning : coercion + existence + self-ref.
-                        // Rejoue le `where` de scoping : un ID hors du where est rejeté,
-                        // pas seulement caché du select (IDOR par POST forgé).
-                        if (relationGraph) {
-                            for (const edge of relationGraph.edges.values()) {
-                                if (edge.model !== model.name || edge.kind !== 'to-one-owning')
-                                    continue;
-                                if (edge.unsupported)
-                                    continue;
-                                const scalarName = edge.scalarFields[0];
-                                // Lu directement depuis le FormData plutôt que `data` :
-                                // `formDataToPrisma` omet la clé pour un scalaire required
-                                // laissé vide, donc `data[scalarName]` ne suffirait pas ici.
-                                const raw = formData.get(scalarName);
-                                if (raw === null)
-                                    continue;
-                                const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
-                                // Vide sur relation optionnelle → null (disconnect).
-                                if (raw === '' || raw === undefined || raw === null) {
-                                    if (edge.isRequired) {
-                                        throw new Error(`${edge.field} is required`);
-                                    }
-                                    data[scalarName] = null;
-                                    continue;
-                                }
-                                // Coercion vers le type de la PK cible. `targetModel` existe
-                                // toujours : le graphe n'aurait pas produit d'arête sinon.
-                                const targetModel = schema.models.find((m) => m.name === edge.target);
-                                const pkField = targetModel.fields.find((f) => f.isId);
-                                const coerced = pkField?.type === 'Int' ? parseInt(String(raw)) : String(raw);
-                                if (pkField?.type === 'Int' && !Number.isSafeInteger(coerced)) {
-                                    throw new Error(`${edge.field}: invalid id`);
-                                }
-                                // Self-ref : la ligne courante ne peut pas être sa propre cible.
-                                if (edge.selfReferential && route.id && String(coerced) === String(coerceId(route.id, model))) {
-                                    throw new Error(`${edge.field}: cannot reference itself`);
-                                }
-                                // Existence + scoping. findFirst et non findUnique : le where
-                                // peut porter des conditions arbitraires (scoping multi-tenant).
-                                // Si le client ne sait pas répondre, on ne bloque pas l'écriture.
-                                try {
-                                    const where = {
-                                        [primaryKeyOf(targetModel)]: coerced,
-                                        ...(relConfig?.where ? relConfig.where({ locals: event.locals }) : {})
-                                    };
-                                    const found = await prisma[toPrismaModel(edge.target)].findFirst({ where });
-                                    if (!found) {
-                                        throw new Error(`${edge.field}: invalid value`);
-                                    }
-                                }
-                                catch (e) {
-                                    if (e?.message?.includes('invalid value'))
-                                        throw e;
-                                    // Client incapable de vérifier (mock partiel, etc.) : on laisse passer.
-                                }
-                                data[scalarName] = coerced;
-                            }
-                            // N-N implicite : lit `__rel__<field>` (valeurs cochées) et
-                            // `__rel_present__<field>` (sentinelle). Sans le sentinelle,
-                            // le champ est absent du form (readonly/exclu) → no-op.
-                            // Avec le sentinelle mais zéro valeur cochée → vider la
-                            // relation (`set: []` / rien à connecter en création).
-                            for (const edge of relationGraph.edges.values()) {
-                                if (edge.model !== model.name || edge.kind !== 'm2m-implicit')
-                                    continue;
-                                // Pas de garde `edge.unsupported` ici : par construction du
-                                // graphe, `unsupported` n'est jamais posé sur une arête
-                                // m2m-implicite (seulement sur to-one-owning / groupes
-                                // ambigus, qui retombent toujours en to-one-owning).
-                                const present = formData.get(`__rel_present__${edge.field}`);
-                                if (present === null)
-                                    continue;
-                                const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
-                                const targetModel = schema.models.find((m) => m.name === edge.target);
-                                const targetPk = primaryKeyOf(targetModel);
-                                const pkIsInt = targetModel.fields.find((f) => f.isId)?.type === 'Int';
-                                const submitted = formData.getAll(`__rel__${edge.field}`).map(String);
-                                const rawIds = submitted.length === 1 && submitted[0].includes(',')
-                                    ? submitted[0].split(',').map((s) => s.trim()).filter(Boolean)
-                                    : submitted;
-                                const ids = rawIds.map((v) => pkIsInt ? parseInt(v) : v);
-                                if (pkIsInt && ids.some((v) => !Number.isSafeInteger(v))) {
-                                    throw new Error(`${edge.field}: invalid id`);
-                                }
-                                // Existence + scoping en une requête, sur l'ensemble des IDs
-                                // soumis. Un compte différent = au moins un ID invalide ou
-                                // hors scoping — IDOR bloqué au même titre que pour les FK.
-                                if (ids.length > 0) {
-                                    const where = {
-                                        [targetPk]: { in: ids },
-                                        ...(relConfig?.where ? relConfig.where({ locals: event.locals }) : {})
-                                    };
-                                    try {
-                                        const found = await prisma[toPrismaModel(edge.target)].findMany({ where });
-                                        if (found.length !== new Set(ids.map(String)).size) {
-                                            throw new Error(`${edge.field}: invalid value`);
-                                        }
-                                    }
-                                    catch (e) {
-                                        if (e?.message?.includes('invalid value'))
-                                            throw e;
-                                        // Client incapable de vérifier : on laisse passer.
-                                    }
+                    else {
+                        // Tout le reste est présumé venir du moteur : son texte peut porter le nom
+                        // de la table, un fragment de requête ou un dump d'arguments. Jamais rendu.
+                        console.error('[sveltekit-admin] mutation failed:', e);
+                        mutationError = 'The change could not be saved.';
+                    }
+                }
+            }
+            // GET requests - render views
+            if (pluginPage) {
+                const hasModel = pluginPage.pattern.includes(':model');
+                const hasId = pluginPage.pattern.includes(':id');
+                if (hasModel) {
+                    currentModel = route.model;
+                    const model = runtime.findModel(route.model);
+                    const allowed = model &&
+                        (!pluginPage.models ||
+                            pluginPage.models.some((n) => n.toLowerCase() === model.name.toLowerCase()));
+                    if (!model || !allowed) {
+                        content = render(NotFound, {
+                            props: { message: 'Page not found', basePath: runtime.basePath }
+                        }).body;
+                    }
+                    else if (hasId) {
+                        const ctx = createPluginPageContext(runtime, event, route);
+                        const loaded = await ctx.loadRecord(model.name, route.id);
+                        if (!loaded) {
+                            content = render(NotFound, {
+                                props: {
+                                    message: `${model.name} with ID "${route.id}" not found`,
+                                    basePath: runtime.basePath
                                 }
-                                const idRefs = ids.map((id) => ({ [targetPk]: id }));
-                                data[edge.field] =
-                                    action === 'create' ? { connect: idRefs } : { set: idRefs };
-                            }
-                        }
-                        if (action === 'create') {
-                            await createRecord(prisma, model, data);
+                            }).body;
                         }
-                        else if (route.id) {
-                            await updateRecord(prisma, model, route.id, data);
+                        else {
+                            const result = await pluginPage.render(createPluginPageContext(runtime, event, route, loaded));
+                            content = result.html;
+                            extraStyles = result.styles ?? '';
+                            extraScripts = result.scripts ?? '';
                         }
-                        return redirectToList(route.model);
                     }
+                    else {
+                        const result = await pluginPage.render(createPluginPageContext(runtime, event, route));
+                        content = result.html;
+                        extraStyles = result.styles ?? '';
+                        extraScripts = result.scripts ?? '';
+                    }
+                }
+                else {
+                    const result = await pluginPage.render(createPluginPageContext(runtime, event, route));
+                    content = result.html;
+                    extraStyles = result.styles ?? '';
+                    extraScripts = result.scripts ?? '';
                 }
             }
-            // GET requests - render views
-            if (route.view === 'notFound') {
-                content = render(NotFound, { props: { message: 'Page not found', basePath } }).body;
+            else if (route.view === 'notFound') {
+                content = render(NotFound, { props: { message: 'Page not found', basePath: runtime.basePath } }).body;
             }
             else if (route.view === 'dashboard') {
-                const modelsWithCounts = await Promise.all(filteredModels.map(async (m) => {
+                const modelsWithCounts = await Promise.all(runtime.models.map(async (m) => {
                     let count = 0;
                     try {
-                        count = await prisma[toPrismaModel(m.name)].count();
+                        count = await runtime.adapter.data.countRecords(m, modelScopeFrom(runtime, m, { locals: event.locals }));
                     }
                     catch {
                         // model absent from the database
                     }
-                    return { name: m.name, label: labelOf(m), count };
+                    return { name: m.name, label: runtime.labelOf(m), count };
                 }));
                 const totalRecords = modelsWithCounts.reduce((sum, m) => sum + m.count, 0);
                 content = render(Dashboard, {
                     props: {
                         models: modelsWithCounts,
                         stats: { total: totalRecords, models: modelsWithCounts.length },
-                        basePath
+                        basePath: runtime.basePath
                     }
                 }).body;
             }
             else if (route.model) {
                 currentModel = route.model;
-                const model = findModel(route.model);
+                const model = runtime.findModel(route.model);
                 if (!model) {
                     content = render(NotFound, {
-                        props: { message: `Model "${route.model}" not found`, basePath }
+                        props: { message: `Model "${route.model}" not found`, basePath: runtime.basePath }
                     }).body;
                 }
                 else if (route.view === 'list') {
-                    const { page } = paginate(event.url.searchParams.get('page'), PER_PAGE);
+                    const modelsConfig = runtime.config.models ?? {};
+                    const { page } = paginate(event.url.searchParams.get('page'), runtime.perPage);
                     const modelSearchConfig = modelsConfig[model.name]?.searchFields;
-                    const searchFields = resolveSearchFields(model, modelSearchConfig, labelFieldCandidates, hiddenFieldsOf(model));
-                    const filterableFields = resolveFilterableFields(model);
-                    const listQuery = parseListQuery(event.url.searchParams, model, schema.enums, searchFields, filterableFields);
-                    const listScope = modelsConfig[model.name]?.listWhere?.({ locals: event.locals });
-                    // A scope function returning `{}` (falsy-looking but truthy as
-                    // an object) would otherwise silently fail OPEN — `{}` composed
-                    // into an AND matches every row, exactly the opposite of what a
-                    // caller configuring listWhere expects (real gap found in
-                    // review: `locals.userId` undefined after a session expires is
-                    // a realistic way to hit this). Fail loud instead: a scope
-                    // function is either omitted entirely, or must return at least
-                    // one condition every time it runs.
-                    if (listScope && Object.keys(listScope).length === 0) {
-                        throw new Error(`[sveltekit-admin] models.${model.name}.listWhere returned an empty object ({}), ` +
-                            `which would silently disable list scoping (fail-open). Return undefined/omit the ` +
-                            `scope entirely if there is genuinely nothing to scope by for this request, or a ` +
-                            `condition that actually restricts rows otherwise.`);
-                    }
-                    const where = buildWhere(listQuery, listScope, caseInsensitiveSearch, model);
-                    const { items, total } = await listRecords(prisma, model, page, PER_PAGE, where);
-                    const listFilters = resolveListFilters(model, schema.enums, modelsConfig[model.name]?.listFilter, toLabel, relationGraph, hiddenFieldsOf(model), config.listFilterDefaults?.autoDetect ?? true);
+                    const searchFields = resolveSearchFields(model, modelSearchConfig, runtime.labelFieldCandidates, runtime.hiddenFieldsOf(model));
+                    const filterableFields = runtime.resolveFilterableFields(model);
+                    const listQuery = parseListQuery(event.url.searchParams, model, runtime.schema.enums, searchFields, filterableFields);
+                    const listScope = listScopeFrom(runtime, model, { locals: event.locals });
+                    const modelScope = modelScopeFrom(runtime, model, { locals: event.locals });
+                    const scope = modelScope && listScope
+                        ? { op: 'and', clauses: [modelScope, normalizeScope(listScope)] }
+                        : modelScope ?? listScope;
+                    // Adapter compiles case-sensitivity; this arg is unused by buildWhere.
+                    const filter = buildWhere(listQuery, scope, false, model);
+                    const { rows: items, total } = await runtime.adapter.data.listRecords(model, { filter, skip: (page - 1) * runtime.perPage, take: runtime.perPage });
+                    const listFilters = resolveListFilters(model, runtime.schema.enums, modelsConfig[model.name]?.listFilter, toLabel, runtime.relationGraph, runtime.hiddenFieldsOf(model), runtime.config.listFilterDefaults?.autoDetect ?? true);
                     // Un filtre FK ne dépend pas de l'autre : résolus en parallèle
                     // plutôt qu'un par un (même raisonnement que loadRelationOptions).
                     const fkFilterEntries = await Promise.all(listFilters
                         .filter((filter) => filter.kind === 'fk')
                         .map(async (filter) => {
                         const activeRawValue = listQuery.filters.find((f) => f.field === filter.field && f.op === 'equals')?.raw;
-                        const meta = await resolveFkFilterOptions(model, filter.field, filter.label, { locals: event.locals }, activeRawValue);
+                        const meta = await resolveFkFilterOptions(runtime, model, filter.field, filter.label, { locals: event.locals }, activeRawValue);
                         return [filter.field, meta];
                     }));
                     const fkFilterMeta = new Map(fkFilterEntries);
                     content = render(List, {
                         props: {
-                            model: viewModel(model),
+                            model: runtime.viewModel(model),
                             items,
-                            pagination: { page, perPage: PER_PAGE, total },
-                            basePath,
-                            config,
+                            pagination: { page, perPage: runtime.perPage, total },
+                            basePath: runtime.basePath,
+                            config: runtime.config,
                             query: listQuery,
                             currentUrl: event.url,
                             listFilters,
-                            fkFilterMeta
+                            fkFilterMeta,
+                            recordActions: actionsForModel(registry, model.name).map((action) => ({
+                                label: action.label,
+                                hrefFor: (id) => action.href({ model: model.name, id, basePath: runtime.basePath })
+                            }))
                         }
                     }).body;
                 }
                 else if (route.view === 'create') {
-                    const relationOptions = await loadRelationOptions(model, { locals: event.locals });
+                    const relationOptions = await loadRelationOptions(runtime, model, { locals: event.locals });
                     // Pré-remplissage FK depuis la query string (`?authorId=3`), posé
                     // par le lien "Ajouter" du bloc de liaisons inverses.
                     const prefill = {};
-                    for (const edge of relationGraph.edges.values()) {
+                    for (const edge of runtime.relationGraph.edges.values()) {
                         if (edge.model !== model.name || edge.kind !== 'to-one-owning')
                             continue;
                         const scalarName = edge.scalarFields[0];
@@ -637,10 +279,11 @@ export function createAdminHandler(config) {
                     content = render(Form, {
                         props: {
                             mode: 'create',
-                            model: { ...viewModel(model), relationOptions },
-                            basePath,
-                            config,
-                            item: itemPrefill
+                            model: { ...runtime.viewModel(model), relationOptions },
+                            basePath: runtime.basePath,
+                            config: runtime.config,
+                            item: itemPrefill,
+                            recordActions: []
                         }
                     }).body;
                 }
@@ -650,21 +293,38 @@ export function createAdminHandler(config) {
                     // atteint ce `else` — or 'edit' est la branche à 2 segments, donc `id` y est
                     // toujours défini. La variante 'notFound' ne porte pas de `model` : elle est
                     // interceptée en amont et ne peut pas arriver ici.
-                    const item = await getRecord(prisma, model, route.id);
-                    const relationOptions = await loadRelationOptions(model, { locals: event.locals }, route.id);
-                    const relatedCounts = item ? await loadRelatedCounts(model, route.id) : undefined;
+                    const modelScope = modelScopeFrom(runtime, model, { locals: event.locals });
+                    const item = modelScope
+                        ? await runtime.adapter.data.findFirst(model, {
+                            op: 'and',
+                            clauses: [
+                                { op: 'eq', field: runtime.viewModel(model).primaryKey, value: coerceId(route.id, model) },
+                                modelScope
+                            ]
+                        })
+                        : await runtime.adapter.data.getRecord(model, route.id);
+                    const relationOptions = await loadRelationOptions(runtime, model, { locals: event.locals }, route.id);
+                    const relatedCounts = item ? await loadRelatedCounts(runtime, model, route.id, { locals: event.locals }) : undefined;
                     content = item
                         ? render(Form, {
                             props: {
                                 mode: 'edit',
-                                model: { ...viewModel(model), relationOptions, relatedCounts },
-                                basePath,
-                                config,
-                                item
+                                model: { ...runtime.viewModel(model), relationOptions, relatedCounts },
+                                basePath: runtime.basePath,
+                                config: runtime.config,
+                                item,
+                                recordActions: actionsForModel(registry, model.name).map((action) => ({
+                                    label: action.label,
+                                    href: action.href({
+                                        model: model.name,
+                                        id: item[runtime.viewModel(model).primaryKey],
+                                        basePath: runtime.basePath
+                                    })
+                                }))
                             }
                         }).body
                         : render(NotFound, {
-                            props: { message: `${model.name} with ID "${route.id}" not found`, basePath }
+                            props: { message: `${model.name} with ID "${route.id}" not found`, basePath: runtime.basePath }
                         }).body;
                 }
             }
@@ -673,7 +333,24 @@ export function createAdminHandler(config) {
             console.error('[sveltekit-admin] Error:', e);
             content = `<div class="ska-alert ska-alert--error">Error: ${escapeHtml(e.message || 'Unknown error')}</div>`;
         }
-        const html = render(Layout, { props: { content, config, modelList, currentModel } }).body;
+        if (mutationError) {
+            // Même préfixe « Error: » que le `catch` partagé, pour une seule
+            // convention d'alerte dans toute la page (cf. handler.test.ts, l'alerte
+            // « modèle inconnu en POST »).
+            content =
+                `<div class="ska-alert ska-alert--error">Error: ${escapeHtml(mutationError)}</div>` +
+                    content;
+        }
+        const html = render(Layout, {
+            props: {
+                content,
+                config: runtime.config,
+                modelList: runtime.modelList,
+                currentModel,
+                extraStyles,
+                extraScripts
+            }
+        }).body;
         return new Response(html, {
             headers: {
                 'Content-Type': 'text/html; charset=utf-8'