sveltekit-admin 0.5.0 → 0.6.0

package/dist/server/data.js

@@ -73,44 +73,3 @@ export function paginate(pageParam, perPage) {
     const page = Number.isSafeInteger(parsed) && parsed >= 1 ? parsed : 1;
     return { page, skip: (page - 1) * perPage, take: perPage };
 }
-export async function listRecords(prisma, model, page, perPage, where) {
-    const key = toPrismaModel(model.name);
-    const primaryKey = primaryKeyOf(model);
-    // Le calcul `(page - 1) * perPage` est dupliqué avec `paginate` DÉLIBÉRÉMENT.
-    // Router `listRecords` vers `paginate(String(page), perPage)` serait lossy : la
-    // conversion aller-retour passe par `parseInt`, et `String(1e24)` donne
-    // `'1e+24'`, que `parseInt` ramène à `1`. `listRecords` reçoit un `number` déjà
-    // validé par l'appelant ; ne pas « simplifier » en réintroduisant un parse.
-    const [items, total] = await Promise.all([
-        prisma[key].findMany({
-            where,
-            skip: (page - 1) * perPage,
-            take: perPage,
-            orderBy: { [primaryKey]: 'desc' }
-        }),
-        prisma[key].count({ where })
-    ]);
-    return { items, total };
-}
-export function getRecord(prisma, model, id) {
-    const primaryKey = primaryKeyOf(model);
-    return prisma[toPrismaModel(model.name)].findUnique({
-        where: { [primaryKey]: coerceId(id, model) }
-    });
-}
-export async function createRecord(prisma, model, data) {
-    await prisma[toPrismaModel(model.name)].create({ data });
-}
-export async function updateRecord(prisma, model, id, data) {
-    const primaryKey = primaryKeyOf(model);
-    await prisma[toPrismaModel(model.name)].update({
-        where: { [primaryKey]: coerceId(id, model) },
-        data
-    });
-}
-export async function deleteRecord(prisma, model, id) {
-    const primaryKey = primaryKeyOf(model);
-    await prisma[toPrismaModel(model.name)].delete({
-        where: { [primaryKey]: coerceId(id, model) }
-    });
-}

package/dist/server/handler.d.ts

@@ -2,11 +2,27 @@
  * SvelteKit Admin - Standalone Handler
  * Zero files needed in routes - everything handled via hook
  */
+import type { DataAdapter, SchemaIntrospector } from './adapters/types.js';
 export interface AdminHandlerConfig {
-    /** Prisma client instance */
-    prisma: any;
+    /**
+     * Prisma client instance. Required unless `adapter` is provided directly —
+     * exactly one of the two must be set. Kept required-looking here (not `?`)
+     * for source compatibility with every existing call site; passing neither
+     * throws at handler-creation time (see the boot block).
+     */
+    prisma?: any;
     /** Path to Prisma schema file */
     prismaSchemaPath?: string;
+    /**
+     * Explicit adapter, built via `createPrismaAdapter(...)` (or, in a future
+     * release, a Drizzle/other adapter). Takes priority over `prisma`/
+     * `prismaSchemaPath` when both are somehow set. Most consumers never touch
+     * this — passing `prisma`/`prismaSchemaPath` builds one internally.
+     */
+    adapter?: {
+        introspector: SchemaIntrospector;
+        data: DataAdapter;
+    };
     /** Base path for admin routes (default: /admin) */
     basePath?: string;
     /** Authentication check - return true if user can access admin */

package/dist/server/handler.js

@@ -3,11 +3,15 @@
  * Zero files needed in routes - everything handled via hook
  */
 import { render } from 'svelte/server';
-import { parsePrismaSchema, isSensitiveFieldName } from './introspection/parser.js';
+import { 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 { primaryKeyOf, coerceId, formDataToPrisma, paginate } from './data.js';
 import { parseListQuery, buildWhere, resolveSearchFields } from './query/listQuery.js';
+import { createPrismaIntrospector } from './adapters/prisma/introspector.js';
+import { createPrismaDataAdapter } from './adapters/prisma/dataAdapter.js';
+import { resolveCaseInsensitiveSearch } from './adapters/prisma/index.js';
+import { normalizeScope, OPAQUE_FILTER_ERROR } from './adapters/filter.js';
 import { resolveListFilters, validateListFilterConfig, findFkEdge } from './query/filterDetection.js';
 import { escapeHtml, toLabel } from './views/html.js';
 import NotFound from './views/NotFound.svelte';
@@ -16,23 +20,37 @@ import Dashboard from './views/Dashboard.svelte';
 import Form from './views/Form.svelte';
 import List from './views/List.svelte';
 const PER_PAGE = 20;
+function scopeFrom(relConfig, ctx) {
+    return relConfig?.where ? normalizeScope(relConfig.where(ctx)) : undefined;
+}
 // ============================================
 // 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
+    if (!config.adapter && !prisma) {
+        throw new Error('[sveltekit-admin] createAdminHandler requires either `prisma` (with optional `prismaSchemaPath`) or `adapter` — neither was provided.');
+    }
+    const introspector = config.adapter?.introspector ?? createPrismaIntrospector({ schemaPath: prismaSchemaPath });
+    // Introspect the schema once at startup — same failure handling as before:
+    // a broken/missing schema source degrades to "no models known" rather than
+    // throwing out of `createAdminHandler` itself.
     let schema = null;
     let relationGraph = null;
     try {
-        schema = parsePrismaSchema(prismaSchemaPath);
+        const introspected = introspector.introspect();
+        if (introspected instanceof Promise) {
+            throw new Error('[sveltekit-admin] SchemaIntrospector.introspect() returned a Promise — ' +
+                'createAdminHandler only supports synchronous introspection today.');
+        }
+        schema = introspected;
         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);
+        console.warn('[sveltekit-admin] Could not introspect schema:', e);
     }
     const filteredModels = schema?.models.filter((m) => {
         // Exclude explicitly excluded models
@@ -56,7 +74,13 @@ export function createAdminHandler(config) {
         if (entries)
             validateListFilterConfig(m.name, entries, m, relationGraph, hiddenFieldsOf(m));
     }
-    const labelOf = (m) => modelsConfig[m.name]?.label || toLabel(m.name);
+    const labelOf = (m) => {
+        const configured = modelsConfig[m.name]?.label;
+        if (configured)
+            return configured;
+        const label = toLabel(m.name);
+        return label.charAt(0).toUpperCase() + label.slice(1);
+    };
     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) => ({
@@ -82,10 +106,8 @@ export function createAdminHandler(config) {
     // 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 ?? ''));
+    const caseInsensitiveSearch = resolveCaseInsensitiveSearch(schema, config.search?.mode);
+    const adapter = config.adapter ?? { introspector, data: createPrismaDataAdapter(prisma, { caseInsensitiveSearch }) };
     /**
      * Champs qu'un `?f.<field>=` est autorisé à cibler pour ce modèle : tout
      * champ scalaire non-liste, non-relation, de type filtrable
@@ -136,54 +158,54 @@ export function createAdminHandler(config) {
         return String(row[primaryKeyOf(targetModel)]);
     };
     /**
-     * Charge les options pour toutes les arêtes to-one-owning et m2m-implicite
+     * Charge les options pour toutes les arêtes to-one-owning et m2m
      * 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 out = new Map();
-        for (const edge of relationGraph.edges.values()) {
+        const edges = [...relationGraph.edges.values()].filter((edge) => {
             if (edge.model !== model.name)
-                continue;
-            if (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m-implicit')
-                continue;
+                return false;
+            if (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m')
+                return false;
             if (edge.unsupported)
-                continue;
+                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];
-            if (relConfig?.widget === 'hidden')
-                continue;
             const targetModel = schema.models.find((m) => m.name === edge.target);
-            const where = relConfig?.where ? relConfig.where(ctx) : undefined;
-            const prismaKey = toPrismaModel(edge.target);
+            const filter = scopeFrom(relConfig, ctx);
             try {
-                const total = await prisma[prismaKey].count({ where });
+                const total = await adapter.data.countRecords(targetModel, filter);
                 if (total > selectThreshold || relConfig?.widget === 'raw-id') {
-                    const selectedIds = edge.kind === 'm2m-implicit' && currentId
-                        ? await loadSelectedIds(model, edge, currentId, targetModel)
+                    const selectedIds = edge.kind === 'm2m' && currentId
+                        ? await adapter.data.getM2mSelectedIds(model, edge, targetModel, currentId)
                         : undefined;
-                    out.set(`${edge.model}.${edge.field}`, { tooMany: true, options: [], selectedIds });
-                    continue;
+                    return [key, { tooMany: true, options: [], selectedIds }];
                 }
-                const rows = await prisma[prismaKey].findMany({
-                    where,
-                    orderBy: relConfig?.orderBy
-                });
+                const rows = await adapter.data.findMany(targetModel, { filter, 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)
+                const selectedIds = edge.kind === 'm2m' && currentId
+                    ? await adapter.data.getM2mSelectedIds(model, edge, targetModel, currentId)
                     : undefined;
-                out.set(`${edge.model}.${edge.field}`, { tooMany: false, options, selectedIds });
+                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.
-                out.set(`${edge.model}.${edge.field}`, { tooMany: true, options: [] });
+                return [key, { tooMany: true, options: [] }];
             }
-        }
-        return out;
+        }));
+        return new Map(entries);
     };
     /**
      * Options d'un filtre FK : charge et scope les valeurs possibles pour la
@@ -204,45 +226,46 @@ export function createAdminHandler(config) {
         // 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 : scopées, comptées puis chargées si sous le seuil.
-        let options = [];
-        let tooMany = false;
-        try {
-            const total = await prisma[prismaKey].count({ where: scope });
-            if (total > selectThreshold) {
-                tooMany = true;
-            }
-            else {
-                const rows = await prisma[prismaKey].findMany({
-                    where: scope,
-                    orderBy: relConfig?.orderBy
-                });
-                options = rows.map((row) => ({
+        const scope = scopeFrom(relConfig, ctx);
+        // 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 adapter.data.countRecords(targetModel, scope);
+                if (total > selectThreshold) {
+                    return { options: [], tooMany: true };
+                }
+                const rows = await adapter.data.findMany(targetModel, { filter: scope, orderBy: relConfig?.orderBy });
+                const options = rows.map((row) => ({
                     id: row[primaryKeyOf(targetModel)],
                     label: resolveLabel(targetModel, row, relConfig?.labelTemplate)
                 }));
+                return { options, tooMany: false };
             }
-        }
-        catch {
-            tooMany = true;
-        }
-        // Label du chip actif : résolu via findFirst scopé (§6.3.b). Un ID hors
-        // scope retourne null ici → le composant affiche l'ID brut, pas de label.
-        let activeLabel;
-        if (activeRawValue !== undefined) {
+            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 }
-                });
-                activeLabel = row ? resolveLabel(targetModel, row, relConfig?.labelTemplate) : undefined;
+                const idFilter = { op: 'eq', field: primaryKeyOf(targetModel), value: activeId };
+                const filter = scope ? { op: 'and', clauses: [idFilter, scope] } : idFilter;
+                const row = await adapter.data.findFirst(targetModel, filter);
+                return row ? resolveLabel(targetModel, row, relConfig?.labelTemplate) : undefined;
             }
             catch {
-                activeLabel = undefined;
+                return undefined;
             }
-        }
+        };
+        const [{ options, tooMany }, activeLabel] = await Promise.all([loadOptions(), loadActiveLabel()]);
         return {
             field: fkFieldName,
             label,
@@ -259,20 +282,6 @@ export function createAdminHandler(config) {
                 : 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
@@ -280,31 +289,33 @@ export function createAdminHandler(config) {
      * le rendu du formulaire.
      */
     const loadRelatedCounts = async (model, currentId) => {
-        const out = new Map();
-        for (const edge of relationGraph.edges.values()) {
-            if (edge.model !== model.name)
-                continue;
-            if (edge.kind !== 'to-many-inverse' && edge.kind !== 'to-one-inverse')
-                continue;
+        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)
-                continue;
+                return undefined;
             const scalarName = owning.scalarFields[0];
+            const key = `${edge.model}.${edge.field}`;
+            const targetModel = schema.models.find((m) => m.name === edge.target);
             try {
-                const count = await prisma[toPrismaModel(edge.target)].count({
-                    where: { [scalarName]: coerceId(currentId, model) }
+                const count = await adapter.data.countRecords(targetModel, {
+                    op: 'eq',
+                    field: scalarName,
+                    value: coerceId(currentId, model)
                 });
-                out.set(`${edge.model}.${edge.field}`, count);
+                return [key, count];
             }
             catch {
-                out.set(`${edge.model}.${edge.field}`, 0);
+                return [key, 0];
             }
-        }
-        return out;
+        }));
+        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
+     * Sert les options d'une relation to-one-owning ou m2m 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
@@ -319,7 +330,7 @@ export function createAdminHandler(config) {
         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) {
+        if (!model || !edge || (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m') || edge.unsupported) {
             return new Response(JSON.stringify({ error: 'unknown relation' }), {
                 status: 404,
                 headers: { 'Content-Type': 'application/json' }
@@ -327,23 +338,33 @@ export function createAdminHandler(config) {
         }
         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 }) : {};
+        const configWhere = scopeFrom(relConfig, { 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);
+        // `_search` must stay case-sensitive on every adapter/provider. A
+        // `{ op: 'contains' }` leaf would pick up the adapter-wide
+        // `caseInsensitiveSearch` flag (Prisma `mode: 'insensitive'`, Drizzle
+        // `ilike`). `containsExact` compiles to `{ contains }` / `LIKE` with
+        // no case-folding — same observable Prisma behavior as the previous
+        // opaque `{ [field]: { contains: q } }` pass-through.
+        const containsFilter = q && searchField
+            ? { op: 'containsExact', field: searchField, value: q }
+            : undefined;
+        const searchFilter = containsFilter && configWhere
+            ? { op: 'and', clauses: [configWhere, containsFilter] }
+            : containsFilter ?? configWhere;
         try {
+            // Count + fetch are independent reads — run them in parallel (as this
+            // endpoint always has, pre-refactor) rather than doubling latency with
+            // two sequential awaits.
             const [total, rows] = await Promise.all([
-                prisma[prismaKey].count({ where }),
-                prisma[prismaKey].findMany({
-                    where,
+                adapter.data.countRecords(targetModel, searchFilter),
+                adapter.data.findMany(targetModel, {
+                    filter: searchFilter,
+                    orderBy: relConfig?.orderBy,
                     skip: (page - 1) * PER_PAGE,
-                    take: PER_PAGE,
-                    orderBy: relConfig?.orderBy
+                    take: PER_PAGE
                 })
             ]);
             const options = rows.map((row) => ({
@@ -408,11 +429,12 @@ export function createAdminHandler(config) {
                         throw new Error(`Model "${route.model}" not found`);
                     }
                     if (action === 'delete' && route.id) {
-                        await deleteRecord(prisma, model, route.id);
+                        await adapter.data.deleteRecord(model, route.id);
                         return redirectToList(route.model);
                     }
                     if (action === 'create' || action === 'update') {
                         const data = formDataToPrisma(formData, model);
+                        const m2mInput = {};
                         // 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é).
@@ -454,11 +476,10 @@ export function createAdminHandler(config) {
                                 // 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 });
+                                    const idFilter = { op: 'eq', field: primaryKeyOf(targetModel), value: coerced };
+                                    const scopeFilter = scopeFrom(relConfig, { locals: event.locals });
+                                    const filter = scopeFilter ? { op: 'and', clauses: [idFilter, scopeFilter] } : idFilter;
+                                    const found = await adapter.data.findFirst(targetModel, filter);
                                     if (!found) {
                                         throw new Error(`${edge.field}: invalid value`);
                                     }
@@ -466,6 +487,14 @@ export function createAdminHandler(config) {
                                 catch (e) {
                                     if (e?.message?.includes('invalid value'))
                                         throw e;
+                                    if (e?.message &&
+                                        (e.message.includes(OPAQUE_FILTER_ERROR) ||
+                                            OPAQUE_FILTER_ERROR.startsWith(e.message))) {
+                                        throw new Error(`${edge.field}: invalid value`);
+                                    }
+                                    if (e?.message?.includes('unknown field')) {
+                                        throw new Error(`${edge.field}: invalid value`);
+                                    }
                                     // Client incapable de vérifier (mock partiel, etc.) : on laisse passer.
                                 }
                                 data[scalarName] = coerced;
@@ -476,11 +505,11 @@ export function createAdminHandler(config) {
                             // 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')
+                                if (edge.model !== model.name || edge.kind !== 'm2m')
                                     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
+                                // m2m (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)
@@ -501,12 +530,11 @@ export function createAdminHandler(config) {
                                 // 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 }) : {})
-                                    };
+                                    const inFilter = { op: 'in', field: targetPk, value: ids };
+                                    const scopeFilter = scopeFrom(relConfig, { locals: event.locals });
+                                    const filter = scopeFilter ? { op: 'and', clauses: [inFilter, scopeFilter] } : inFilter;
                                     try {
-                                        const found = await prisma[toPrismaModel(edge.target)].findMany({ where });
+                                        const found = await adapter.data.findMany(targetModel, { filter });
                                         if (found.length !== new Set(ids.map(String)).size) {
                                             throw new Error(`${edge.field}: invalid value`);
                                         }
@@ -514,19 +542,25 @@ export function createAdminHandler(config) {
                                     catch (e) {
                                         if (e?.message?.includes('invalid value'))
                                             throw e;
+                                        if (e?.message &&
+                                            (e.message.includes(OPAQUE_FILTER_ERROR) ||
+                                                OPAQUE_FILTER_ERROR.startsWith(e.message))) {
+                                            throw new Error(`${edge.field}: invalid value`);
+                                        }
+                                        if (e?.message?.includes('unknown field')) {
+                                            throw new Error(`${edge.field}: invalid value`);
+                                        }
                                         // Client incapable de vérifier : on laisse passer.
                                     }
                                 }
-                                const idRefs = ids.map((id) => ({ [targetPk]: id }));
-                                data[edge.field] =
-                                    action === 'create' ? { connect: idRefs } : { set: idRefs };
+                                m2mInput[edge.field] = { targetPkField: targetPk, ids };
                             }
                         }
                         if (action === 'create') {
-                            await createRecord(prisma, model, data);
+                            await adapter.data.createRecord(model, { scalars: data, m2m: m2mInput });
                         }
                         else if (route.id) {
-                            await updateRecord(prisma, model, route.id, data);
+                            await adapter.data.updateRecord(model, route.id, { scalars: data, m2m: m2mInput });
                         }
                         return redirectToList(route.model);
                     }
@@ -540,7 +574,7 @@ export function createAdminHandler(config) {
                 const modelsWithCounts = await Promise.all(filteredModels.map(async (m) => {
                     let count = 0;
                     try {
-                        count = await prisma[toPrismaModel(m.name)].count();
+                        count = await adapter.data.countRecords(m);
                     }
                     catch {
                         // model absent from the database
@@ -585,17 +619,19 @@ export function createAdminHandler(config) {
                             `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 filter = buildWhere(listQuery, listScope, caseInsensitiveSearch, model);
+                    const { rows: items, total } = await adapter.data.listRecords(model, { filter, skip: (page - 1) * PER_PAGE, take: PER_PAGE });
                     const listFilters = resolveListFilters(model, schema.enums, modelsConfig[model.name]?.listFilter, toLabel, relationGraph, hiddenFieldsOf(model), config.listFilterDefaults?.autoDetect ?? true);
-                    const fkFilterMeta = new Map();
-                    for (const filter of listFilters) {
-                        if (filter.kind !== 'fk')
-                            continue;
+                    // 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);
-                        fkFilterMeta.set(filter.field, meta);
-                    }
+                        return [filter.field, meta];
+                    }));
+                    const fkFilterMeta = new Map(fkFilterEntries);
                     content = render(List, {
                         props: {
                             model: viewModel(model),
@@ -640,7 +676,7 @@ 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 item = await adapter.data.getRecord(model, route.id);
                     const relationOptions = await loadRelationOptions(model, { locals: event.locals }, route.id);
                     const relatedCounts = item ? await loadRelatedCounts(model, route.id) : undefined;
                     content = item