sveltekit-admin 0.8.1 → 0.9.0

package/dist/server/adapters/drizzle/dataAdapter.js

@@ -1,4 +1,4 @@
-import { and, asc, count, desc, eq, getTableColumns } from "drizzle-orm";
+import { and, asc, count, desc, eq, getTableColumns, inArray } from "drizzle-orm";
 import { coerceId, primaryKeyOf } from "../../data.js";
 import { withWriteRetry } from "../retry.js";
 import { compileFilterToDrizzle } from "./filterCompiler.js";
@@ -12,6 +12,21 @@ function tableFor(ctx, model) {
 function primaryKeyColumn(table, model) {
     return getTableColumns(table)[primaryKeyOf(model)];
 }
+/**
+ * Résolution d'une colonne par nom, partagée par les deux chemins de tri
+ * (`listRecords` pour `?sort=`, `findMany` pour un `orderBy` de config). Un
+ * nom inconnu lève : côté `?sort=` il ne peut pas arriver — `sortQuery.ts` ne
+ * laisse sortir que des colonnes rendues — donc s'il arrive, c'est la table
+ * Drizzle qui ne correspond pas au schéma introspecté, et échouer fort vaut
+ * mieux qu'un tri silencieusement absent.
+ */
+function columnFor(table, field) {
+    const column = getTableColumns(table)[field];
+    if (!column) {
+        throw new Error(`[sveltekit-admin] unknown field '${field}' on Drizzle table`);
+    }
+    return column;
+}
 /**
  * Ordre de verrouillage déterministe. Les guards m2m sont empilés dans l'ordre
  * des ids soumis par le formulaire, donc sous contrôle du client : deux
@@ -140,12 +155,23 @@ export function createDrizzleDataAdapter(db, ctx) {
             const table = tableFor(ctx, model);
             const where = compileHere(table, opts.filter);
             const primaryKey = primaryKeyColumn(table, model);
+            const requested = opts.orderBy;
+            // Départage systématique par la clé primaire, sauf quand c'est elle qu'on
+            // trie : deux lignes de même valeur doivent garder le même rang d'une
+            // requête à l'autre, sinon la fenêtre skip/take fait sauter des lignes.
+            const orderBy = !requested
+                ? [desc(primaryKey)]
+                : (() => {
+                    const column = columnFor(table, requested.field);
+                    const primary = column === primaryKey ? [] : [desc(primaryKey)];
+                    return [requested.dir === "asc" ? asc(column) : desc(column), ...primary];
+                })();
             const [rows, totals] = await Promise.all([
                 db
                     .select()
                     .from(table)
                     .where(where)
-                    .orderBy(desc(primaryKey))
+                    .orderBy(...orderBy)
                     .limit(opts.take)
                     .offset(opts.skip),
                 db.select({ n: count() }).from(table).where(where),
@@ -154,12 +180,8 @@ export function createDrizzleDataAdapter(db, ctx) {
         },
         async findMany(model, opts) {
             const table = tableFor(ctx, model);
-            const columns = getTableColumns(table);
             const orderBy = Object.entries(opts.orderBy ?? {}).map(([field, direction]) => {
-                const column = columns[field];
-                if (!column) {
-                    throw new Error(`[sveltekit-admin] unknown field '${field}' on Drizzle table`);
-                }
+                const column = columnFor(table, field);
                 return direction === "asc" ? asc(column) : desc(column);
             });
             let query = db
@@ -314,6 +336,53 @@ export function createDrizzleDataAdapter(db, ctx) {
                 }
             }, { isolationLevel: "serializable" }));
         },
+        async deleteMany(model, ids, authorizationFilter) {
+            const table = tableFor(ctx, model);
+            const primaryKey = primaryKeyColumn(table, model);
+            const coerced = ids.map((id) => coerceId(String(id), model));
+            const scopedWhere = and(inArray(primaryKey, coerced), compileHere(table, authorizationFilter));
+            const links = [...ctx.m2m.entries()]
+                .filter(([key]) => key.startsWith(`${model.name}.`))
+                .map(([, link]) => link);
+            /**
+             * Les ids réellement concernés sont LUS avant de toucher quoi que ce
+             * soit, à l'intérieur de la transaction. Ce n'est pas une vérification
+             * défensive : les pivots m2m doivent être supprimés pour ces lignes-là et
+             * pas pour les autres. Composer le scope directement dans le DELETE des
+             * pivots effacerait les liaisons d'une ligne hors portée que le DELETE du
+             * parent, lui, ne toucherait pas — une ligne d'un autre tenant amputée de
+             * ses relations sans que rien ne l'indique.
+             *
+             * `deleteRecord` peut s'en passer parce qu'il vise UNE ligne et lève quand
+             * elle n'est pas dans la portée, ce qui annule tout. Ici une portée
+             * partielle est un résultat normal, pas une erreur : le compte renvoyé est
+             * celui des lignes supprimées.
+             */
+            if (ctx.dialect === "sqlite") {
+                return db.transaction((tx) => {
+                    const matched = tx.select({ id: primaryKey }).from(table).where(scopedWhere).all()
+                        .map((row) => row.id);
+                    if (matched.length === 0)
+                        return 0;
+                    for (const link of links) {
+                        tx.delete(link.pivot).where(inArray(link.selfColumn, matched)).run();
+                    }
+                    tx.delete(table).where(inArray(primaryKey, matched)).run();
+                    return matched.length;
+                }, { behavior: "immediate" });
+            }
+            return withWriteRetry(() => db.transaction(async (tx) => {
+                const rows = await tx.select({ id: primaryKey }).from(table).where(scopedWhere);
+                const matched = rows.map((row) => row.id);
+                if (matched.length === 0)
+                    return 0;
+                for (const link of links) {
+                    await tx.delete(link.pivot).where(inArray(link.selfColumn, matched));
+                }
+                await tx.delete(table).where(inArray(primaryKey, matched));
+                return matched.length;
+            }, { isolationLevel: "serializable" }));
+        },
         async getM2mSelectedIds(model, edge, _targetModel, recordId) {
             const link = ctx.m2m.get(`${model.name}.${edge.field}`);
             if (!link)

package/dist/server/adapters/prisma/dataAdapter.js

@@ -49,8 +49,17 @@ export function createPrismaDataAdapter(prisma, opts = {}) {
             const key = toPrismaModel(model.name);
             const primaryKey = primaryKeyOf(model);
             const where = compileHere(listOpts.filter);
+            const requested = listOpts.orderBy;
+            // Objet (et non tableau à un élément) quand rien n'est demandé : c'est la
+            // forme historique, et la garder évite de faire bouger des attentes de
+            // tests qui ne parlent pas de tri.
+            const orderBy = !requested
+                ? { [primaryKey]: 'desc' }
+                : requested.field === primaryKey
+                    ? [{ [primaryKey]: requested.dir }]
+                    : [{ [requested.field]: requested.dir }, { [primaryKey]: 'desc' }];
             const [rows, total] = await Promise.all([
-                prisma[key].findMany({ where, skip: listOpts.skip, take: listOpts.take, orderBy: { [primaryKey]: 'desc' } }),
+                prisma[key].findMany({ where, skip: listOpts.skip, take: listOpts.take, orderBy }),
                 prisma[key].count({ where })
             ]);
             return { rows, total };
@@ -119,6 +128,15 @@ export function createPrismaDataAdapter(prisma, opts = {}) {
                 : { [primaryKey]: coerceId(String(id), model) };
             await prisma[toPrismaModel(model.name)].delete({ where });
         },
+        async deleteMany(model, ids, authorizationFilter) {
+            const primaryKey = primaryKeyOf(model);
+            const coerced = ids.map((id) => coerceId(String(id), model));
+            const where = authorizationFilter
+                ? { [primaryKey]: { in: coerced }, AND: [compileHere(authorizationFilter)] }
+                : { [primaryKey]: { in: coerced } };
+            const { count } = await prisma[toPrismaModel(model.name)].deleteMany({ where });
+            return count;
+        },
         async getM2mSelectedIds(model, edge, targetModel, recordId) {
             try {
                 const primaryKey = primaryKeyOf(model);

package/dist/server/adapters/types.d.ts

@@ -26,17 +26,36 @@ export interface TargetGuard {
     targetPk: string | number;
     filter?: Filter;
 }
+/** Tri demandé par `?sort=`, déjà validé contre les colonnes que la vue rend. */
+export interface ListOrder {
+    field: string;
+    dir: 'asc' | 'desc';
+}
 /**
  * Per-request CRUD + relation-read surface `handler.ts` talks to instead of
  * a raw ORM client. See docs/superpowers/specs/2026-08-13-db-adapter-abstraction-design.md
  * for the rationale behind each method's shape.
  */
 export interface DataAdapter {
-    /** Vue liste paginée : toujours tri PK desc, toujours count + fetch ensemble. */
+    /**
+     * Vue liste paginée : toujours count + fetch ensemble.
+     *
+     * `orderBy` absent = clé primaire décroissante, l'ordre historique. Présent,
+     * il est TOUJOURS départagé par la clé primaire décroissante, sauf quand
+     * c'est elle qu'on trie : sans ce départage, deux lignes de même valeur
+     * peuvent changer de page d'une requête à l'autre, et une fenêtre
+     * `skip`/`take` posée par-dessus perd son sens (une ligne vue deux fois, une
+     * autre jamais). C'est à l'adapter de le composer — lui seul sait nommer la
+     * clé primaire dans le langage de son moteur.
+     *
+     * `field` n'est jamais une chaîne libre : `sortQuery.ts` ne le laisse sortir
+     * que s'il appartient aux colonnes réellement rendues par la liste.
+     */
     listRecords(model: Model, opts: {
         filter?: Filter;
         skip: number;
         take: number;
+        orderBy?: ListOrder;
     }): Promise<{
         rows: Record<string, unknown>[];
         total: number;
@@ -81,6 +100,19 @@ export interface DataAdapter {
         targetGuards?: TargetGuard[];
     }, authorizationFilter?: Filter): Promise<Record<string, unknown>>;
     deleteRecord(model: Model, id: string | number, authorizationFilter?: Filter): Promise<void>;
+    /**
+     * Suppression en masse, en UNE opération et non une boucle de
+     * `deleteRecord` : une boucle qui casse au septième id sur une contrainte de
+     * clé étrangère laisse six lignes supprimées et rien pour revenir en
+     * arrière. Ici les deux seules réponses possibles sont « tout est supprimé »
+     * et « rien ne l'est, parce que telle ligne est encore référencée ».
+     *
+     * `authorizationFilter` est composé avec les ids DANS le `where` plutôt que
+     * vérifié à part : un id hors portée ne matche simplement pas, sans erreur,
+     * donc rien ne distingue « n'existe pas » de « appartient à un autre
+     * tenant ». Le compte renvoyé est celui des lignes réellement supprimées.
+     */
+    deleteMany(model: Model, ids: Array<string | number>, authorizationFilter?: Filter): Promise<number>;
     /** `targetModel` est fourni par l'appelant : chaque site d'appel actuel l'a déjà résolu. */
     getM2mSelectedIds(model: Model, edge: RelationEdge, targetModel: Model, recordId: string | number): Promise<Array<string | number>>;
 }

package/dist/server/data.d.ts

@@ -16,8 +16,24 @@ export declare function primaryKeyOf(model: PrismaModel): string;
  * côté intégration.
  */
 export declare function coerceId(id: string, model: PrismaModel): string | number;
-/** Convertit un FormData en payload Prisma, en ignorant les champs auto-gérés. */
-export declare function formDataToPrisma(formData: FormData, model: PrismaModel): Record<string, unknown>;
+/**
+ * Convertit un FormData en payload Prisma, en ignorant les champs auto-gérés.
+ *
+ * Renvoie aussi la liste des champs dont la valeur soumise ne se convertit pas
+ * vers le type de la colonne : un JSON illisible, un nombre qui n'en est pas
+ * un. Leur clé est laissée HORS du payload, et c'est `mutations.ts` — le seul
+ * producteur de refus côté bibliothèque, cf. `errors.ts` — qui décide quoi en
+ * faire. Cette fonction ne lève pas : elle convertit et rapporte.
+ *
+ * Ces valeurs étaient auparavant écrites en `null` sans un mot. Sur une colonne
+ * nullable, la saisie et la valeur déjà stockée disparaissaient ensemble
+ * derrière un `303` d'apparence réussie ; sur une colonne obligatoire, le
+ * pilote répondait par un message générique ne nommant aucun champ.
+ */
+export declare function formDataToPrisma(formData: FormData, model: PrismaModel): {
+    data: Record<string, unknown>;
+    invalid: string[];
+};
 /**
  * Traduit le paramètre `?page=` en fenêtre Prisma. Toute entrée qui n'est pas un
  * entier sûr >= 1 retombe sur la première page : sans ce garde-fou, `?page=abc`

package/dist/server/data.js

@@ -22,9 +22,23 @@ export function coerceId(id, model) {
     const pkField = model.fields.find((f) => f.name === primaryKeyOf(model));
     return pkField?.type === 'Int' ? parseInt(id) : id;
 }
-/** Convertit un FormData en payload Prisma, en ignorant les champs auto-gérés. */
+/**
+ * Convertit un FormData en payload Prisma, en ignorant les champs auto-gérés.
+ *
+ * Renvoie aussi la liste des champs dont la valeur soumise ne se convertit pas
+ * vers le type de la colonne : un JSON illisible, un nombre qui n'en est pas
+ * un. Leur clé est laissée HORS du payload, et c'est `mutations.ts` — le seul
+ * producteur de refus côté bibliothèque, cf. `errors.ts` — qui décide quoi en
+ * faire. Cette fonction ne lève pas : elle convertit et rapporte.
+ *
+ * Ces valeurs étaient auparavant écrites en `null` sans un mot. Sur une colonne
+ * nullable, la saisie et la valeur déjà stockée disparaissaient ensemble
+ * derrière un `303` d'apparence réussie ; sur une colonne obligatoire, le
+ * pilote répondait par un message générique ne nommant aucun champ.
+ */
 export function formDataToPrisma(formData, model) {
     const data = {};
+    const invalid = [];
     for (const field of model.fields) {
         if (field.isId || field.isUpdatedAt || field.isCreatedAt || field.relation)
             continue;
@@ -36,13 +50,23 @@ export function formDataToPrisma(formData, model) {
         }
         switch (field.type) {
             case 'Int':
-            case 'BigInt':
-                data[field.name] = value ? parseInt(value.toString()) : null;
+            case 'BigInt': {
+                const parsed = value ? parseInt(value.toString()) : null;
+                if (Number.isNaN(parsed))
+                    invalid.push(field.name);
+                else
+                    data[field.name] = parsed;
                 break;
+            }
             case 'Float':
-            case 'Decimal':
-                data[field.name] = value ? parseFloat(value.toString()) : null;
+            case 'Decimal': {
+                const parsed = value ? parseFloat(value.toString()) : null;
+                if (Number.isNaN(parsed))
+                    invalid.push(field.name);
+                else
+                    data[field.name] = parsed;
                 break;
+            }
             case 'Boolean':
                 data[field.name] = value === 'on' || value === 'true' || value === '1';
                 break;
@@ -54,14 +78,21 @@ export function formDataToPrisma(formData, model) {
                     data[field.name] = value ? JSON.parse(value.toString()) : null;
                 }
                 catch {
-                    data[field.name] = null;
+                    invalid.push(field.name);
                 }
                 break;
             default:
-                data[field.name] = value.toString();
+                // Le vide vaut `null`, comme pour les types au-dessus. Écrire `''`
+                // rendait une chaîne vide indistinguable d'une valeur voulue, violait
+                // une colonne `String? @unique` dès la deuxième ligne vidée, et
+                // n'était de toute façon pas une valeur qu'un type enum déclare.
+                // Un champ ABSENT du formulaire ne passe pas par ici (`continue`
+                // au-dessus) : c'est cette distinction que `mutations.ts` exploite
+                // pour séparer « non soumis » de « vidé ».
+                data[field.name] = value.toString() || null;
         }
     }
-    return data;
+    return { data, invalid };
 }
 /**
  * Traduit le paramètre `?page=` en fenêtre Prisma. Toute entrée qui n'est pas un

package/dist/server/handler.d.ts

@@ -153,7 +153,42 @@ export interface AdminHandlerConfig {
          * doit échouer fort plutôt que produire un filtre silencieusement mort.
          */
         listFilter?: import('./query/filterDetection.js').ListFilterConfigEntry[];
+        /**
+         * Ordre d'arrivée sur la liste, avant tout `?sort=` dans l'URL. `dir` vaut
+         * `'asc'` par défaut.
+         *
+         * Volontairement explicite plutôt qu'auto-détecté : deviner « trie par
+         * `name` s'il y en a un » changerait l'ordre de toutes les listes
+         * existantes sans que personne l'ait demandé, et l'heuristique dériverait
+         * de ce que la vue affiche réellement.
+         *
+         * `field` doit être une colonne que la liste AFFICHE — sinon aucun en-tête
+         * ne peut annoncer le tri ni permettre d'en sortir. Validé au démarrage :
+         * une colonne inexistante ou non affichée lève, plutôt que de produire un
+         * tri mort à chaque rendu.
+         */
+        defaultSort?: {
+            field: string;
+            dir?: 'asc' | 'desc';
+        };
     }>;
+    /**
+     * Lignes par page de la vue liste (défaut : 20). Entier de 1 à 200 : au-delà
+     * ce n'est plus une page, c'est un export — et une requête qui tient la
+     * connexion sur une table volumineuse. Validé au démarrage.
+     */
+    perPage?: number;
+    /**
+     * Tailles de page qu'un visiteur peut choisir (défaut : `[10, 20, 50, 100]`).
+     * `perPage` y est ajouté d'office s'il n'y figure pas, sinon la taille active
+     * n'apparaîtrait pas dans le sélecteur.
+     *
+     * Un `?perPage=` n'est honoré que s'il appartient à cette liste : sans cette
+     * règle, `?perPage=100000` est un `take` non borné, donc un déni de service à
+     * un paramètre près. `[]` désactive entièrement le mécanisme — aucun
+     * sélecteur rendu, `?perPage=` sans effet.
+     */
+    pageSizeOptions?: number[];
     /** Models to exclude from admin */
     exclude?: string[];
     /** Hide pivot/junction tables automatically (default: true) */

package/dist/server/handler.js

@@ -8,6 +8,9 @@ import { paginate, coerceId } from './data.js';
 import { parseListQuery, buildWhere, resolveSearchFields } from './query/listQuery.js';
 import { normalizeScope } from './adapters/filter.js';
 import { resolveListFilters } from './query/filterDetection.js';
+import { resolveListColumns } from './query/listColumns.js';
+import { parseSortQuery } from './query/sortQuery.js';
+import { parsePageSize } from './query/pageSize.js';
 import { escapeHtml, toLabel } from './views/html.js';
 import NotFound from './views/NotFound.svelte';
 import Layout from './views/Layout.svelte';
@@ -20,6 +23,7 @@ import { handleSearch } from './search.js';
 import { handleMutation } from './mutations.js';
 import { AdminMutationError, AdminConfigError } from './errors.js';
 import { verifyOrigin, resolveCsrfConfig } from './csrf.js';
+import { readSubmittedForm } from './submitted.js';
 import { resolvePluginRegistry, actionsForModel } from './pluginRegistry.js';
 import { createPluginPageContext } from './pluginAccess.js';
 // ============================================
@@ -95,7 +99,9 @@ export function createAdminHandler(config) {
         let currentModel;
         let extraStyles = '';
         let extraScripts = '';
+        /** Renseignés ensemble : un formulaire re-rendu porte toujours les deux. */
         let mutationError;
+        let submitted;
         try {
             // Handle POST requests (create, update, delete). Unrecognised actions fall
             // through to the GET rendering below, as they always have.
@@ -105,26 +111,29 @@ export function createAdminHandler(config) {
             // field, never `route.view`, so it cannot be confused by a plugin's
             // view id landing here.
             if (event.request.method === 'POST') {
+                // Lu ici et non dans `handleMutation` : un corps de requête ne se lit
+                // qu'une fois, et il faut le garder pour re-rendre le formulaire si la
+                // mutation échoue.
+                const formData = await event.request.formData();
                 // `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);
+                    const mutationResponse = await handleMutation(runtime, event, route, formData);
                     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.
+                    // Pas de classification ici, même si `formData` est maintenant à
+                    // portée : ce site verrait bien `_action`, mais `reference` et
+                    // `restrict` se distinguent par l'écriture qui a effectivement
+                    // échoué, pas par l'action demandée. Seul `mutations.ts` le sait,
+                    // au site d'appel de chaque `*Record`. Ce `catch` n'est donc 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;
+                        mutationError = { message: e.message, field: e.field };
                     }
                     else if (e instanceof AdminConfigError) {
                         // Mauvaise configuration côté consommateur : message écrit par la
@@ -136,8 +145,20 @@ export function createAdminHandler(config) {
                         // 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.';
+                        mutationError = { message: 'The change could not be saved.' };
                     }
+                    // Placé après le `throw` de la branche AdminConfigError : une erreur
+                    // de montage remplace la page entière (contrat inchangé) et ne
+                    // re-rend aucun formulaire, donc rien à conserver pour elle.
+                    //
+                    // `findModel` peut ne rien rendre — un POST sur un modèle inconnu est
+                    // justement ce que la branche `notFound` de `handleMutation` lève. Ce
+                    // cas ne rend aucun formulaire, la liste de champs masqués y est donc
+                    // sans objet. Pas de garde sur `route.model` en revanche : sans
+                    // modèle, `handleMutation` rend `null` sans lever et ce `catch` n'est
+                    // pas atteint.
+                    const errorModel = runtime.findModel(route.model);
+                    submitted = readSubmittedForm(formData, errorModel ? runtime.hiddenFieldsOf(errorModel) : new Set());
                 }
             }
             // GET requests - render views
@@ -220,7 +241,8 @@ export function createAdminHandler(config) {
                 }
                 else if (route.view === 'list') {
                     const modelsConfig = runtime.config.models ?? {};
-                    const { page } = paginate(event.url.searchParams.get('page'), runtime.perPage);
+                    const perPage = parsePageSize(event.url.searchParams, runtime.perPage, runtime.pageSizes);
+                    const { page } = paginate(event.url.searchParams.get('page'), perPage);
                     const modelSearchConfig = modelsConfig[model.name]?.searchFields;
                     const searchFields = resolveSearchFields(model, modelSearchConfig, runtime.labelFieldCandidates, runtime.hiddenFieldsOf(model));
                     const filterableFields = runtime.resolveFilterableFields(model);
@@ -232,7 +254,20 @@ export function createAdminHandler(config) {
                         : 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 });
+                    // Whitelist de tri = colonnes RÉELLEMENT rendues, résolues par la même
+                    // fonction que la vue et à partir de la même config. Un `?sort=` ne
+                    // peut donc ordonner que des valeurs déjà lisibles à l'écran.
+                    const sortableColumns = resolveListColumns(model.fields, {
+                        hidden: modelsConfig[model.name]?.hidden,
+                        listFields: modelsConfig[model.name]?.listFields
+                    }).map((f) => f.name);
+                    const sort = parseSortQuery(event.url.searchParams, sortableColumns, runtime.defaultSortOf(model));
+                    const { rows: items, total } = await runtime.adapter.data.listRecords(model, {
+                        filter,
+                        skip: (page - 1) * perPage,
+                        take: perPage,
+                        orderBy: sort.active ?? undefined
+                    });
                     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).
@@ -248,13 +283,15 @@ export function createAdminHandler(config) {
                         props: {
                             model: runtime.viewModel(model),
                             items,
-                            pagination: { page, perPage: runtime.perPage, total },
+                            pagination: { page, perPage, total },
+                            pageSizes: runtime.pageSizes,
                             basePath: runtime.basePath,
                             config: runtime.config,
                             query: listQuery,
                             currentUrl: event.url,
                             listFilters,
                             fkFilterMeta,
+                            sort,
                             recordActions: actionsForModel(registry, model.name).map((action) => ({
                                 label: action.label,
                                 hrefFor: (id) => action.href({ model: model.name, id, basePath: runtime.basePath })
@@ -283,7 +320,9 @@ export function createAdminHandler(config) {
                             basePath: runtime.basePath,
                             config: runtime.config,
                             item: itemPrefill,
-                            recordActions: []
+                            recordActions: [],
+                            submitted,
+                            mutationError
                         }
                     }).body;
                 }
@@ -313,6 +352,8 @@ export function createAdminHandler(config) {
                                 basePath: runtime.basePath,
                                 config: runtime.config,
                                 item,
+                                submitted,
+                                mutationError,
                                 recordActions: actionsForModel(registry, model.name).map((action) => ({
                                     label: action.label,
                                     href: action.href({
@@ -338,7 +379,7 @@ export function createAdminHandler(config) {
             // 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>` +
+                `<div class="ska-alert ska-alert--error">Error: ${escapeHtml(mutationError.message)}</div>` +
                     content;
         }
         const html = render(Layout, {
@@ -352,6 +393,17 @@ export function createAdminHandler(config) {
             }
         }).body;
         return new Response(html, {
+            // 422 pour un formulaire refusé : la requête était bien formée, son
+            // contenu a été rejeté. Un 200 fait passer l'échec pour un succès aux
+            // yeux de tout ce qui lit le statut sans lire le HTML — un test, un
+            // client, un log, un cache. Uniforme sur tous les `kind` : la nuance
+            // entre 409 (conflit) et 403 (scope) n'apporterait rien à un formulaire
+            // rendu en HTML, et le seul consommateur est un navigateur qui affiche
+            // la page.
+            //
+            // Le `catch` partagé plus haut garde son 200 : il couvre aussi le rendu
+            // GET et les pages de plugin, dont le contrat ne change pas ici.
+            status: mutationError ? 422 : 200,
             headers: {
                 'Content-Type': 'text/html; charset=utf-8'
             }

package/dist/server/introspection/parser.d.ts

@@ -16,6 +16,21 @@ export declare function parseSchemaContent(content: string): PrismaSchema;
  * cherchable/filtrable par URL forgée.
  */
 export declare function isSensitiveFieldName(name: string): boolean;
+/**
+ * Restreint `isSensitiveFieldName` aux colonnes de texte, pour le chemin
+ * formulaire/écriture.
+ *
+ * Le prédicat de nom matche par sous-chaîne : sans le filtre de type, un
+ * `tokenCount` ou un `hashtagCount` (`Int`) serait traité comme un secret et
+ * deviendrait impossible à éditer dans l'admin. Un mot de passe, un secret,
+ * un token sont du texte ; un compteur ne l'est pas.
+ *
+ * Volontairement plus étroit que `isSensitiveFieldName` seul, qui reste le
+ * prédicat utilisé pour l'affichage, la recherche, les filtres et l'audit :
+ * là, ne pas montrer un `tokenCount` est sans conséquence, alors qu'ici ça
+ * retirerait une capacité.
+ */
+export declare function isSensitiveStringField(field: Pick<PrismaField, 'name' | 'type'>): boolean;
 /**
  * Get display fields for a model (fields suitable for list view)
  */

package/dist/server/introspection/parser.js

@@ -193,6 +193,23 @@ export function isSensitiveFieldName(name) {
     const lower = name.toLowerCase();
     return SENSITIVE_FIELD_NAMES.some((hidden) => lower.includes(hidden));
 }
+/**
+ * Restreint `isSensitiveFieldName` aux colonnes de texte, pour le chemin
+ * formulaire/écriture.
+ *
+ * Le prédicat de nom matche par sous-chaîne : sans le filtre de type, un
+ * `tokenCount` ou un `hashtagCount` (`Int`) serait traité comme un secret et
+ * deviendrait impossible à éditer dans l'admin. Un mot de passe, un secret,
+ * un token sont du texte ; un compteur ne l'est pas.
+ *
+ * Volontairement plus étroit que `isSensitiveFieldName` seul, qui reste le
+ * prédicat utilisé pour l'affichage, la recherche, les filtres et l'audit :
+ * là, ne pas montrer un `tokenCount` est sans conséquence, alors qu'ici ça
+ * retirerait une capacité.
+ */
+export function isSensitiveStringField(field) {
+    return field.type === 'String' && isSensitiveFieldName(field.name);
+}
 /**
  * Get display fields for a model (fields suitable for list view)
  */

package/dist/server/mutations.d.ts

@@ -1,9 +1,13 @@
 /**
  * POST create/update/delete handling — split out of `handler.ts`, pure
- * orchestration over `AdminRuntime`. Reads `formData` unconditionally: the
- * handler only calls this on `event.request.method === 'POST'`, so the
- * request body is never consumed on GET.
+ * orchestration over `AdminRuntime`.
+ *
+ * Le corps est lu par l'appelant et reçu en paramètre, pas consommé ici : le
+ * handler doit garder ce qui a été soumis pour le re-rendre si cette fonction
+ * lève (`readSubmittedForm`), et un corps de requête ne se lit qu'une fois.
+ * L'appelant n'invoque cette fonction que sur `POST`, donc aucun GET ne lit de
+ * corps.
  */
 import type { ParsedRoute } from './router.js';
 import { type AdminRuntime } from './runtime.js';
-export declare function handleMutation(runtime: AdminRuntime, event: any, route: ParsedRoute): Promise<Response | null>;
+export declare function handleMutation(runtime: AdminRuntime, event: any, route: ParsedRoute, formData: FormData): Promise<Response | null>;