sveltekit-admin 0.8.1 → 0.9.0

package/dist/server/mutations.js

@@ -1,17 +1,23 @@
 /**
  * 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 { primaryKeyOf, coerceId, formDataToPrisma } from './data.js';
+import { isSensitiveStringField } from './introspection/parser.js';
 import { AdminMutationError, classifyWriteError } from './errors.js';
 import { buildAuditEvent, emitAudit, readAuditSnapshot } from './audit.js';
 import { scopeFrom, modelScopeFrom, modelScopeValues } from './runtime.js';
-export async function handleMutation(runtime, event, route) {
+/** Plafond de sélection : la page la plus large de l'admin fait 200 lignes. */
+const MAX_BULK_IDS = 200;
+export async function handleMutation(runtime, event, route, formData) {
     const modelsConfig = runtime.config.models ?? {};
     const audit = runtime.config.audit;
-    const formData = await event.request.formData();
     const action = formData.get('_action');
     if (!route.model)
         return null;
@@ -43,10 +49,10 @@ export async function handleMutation(runtime, event, route) {
             await runtime.adapter.data.deleteRecord(model, route.id, modelScopeFrom(runtime, model, { locals: event.locals }));
         }
         catch (e) {
-            // Classé ici et non dans `handler.ts` : seul ce site connaît l'action réelle
-            // (`handleMutation` a déjà consommé le corps de la requête, donc le handler
-            // ne peut plus lire `_action`). Un code non reconnu est relayé tel quel, et
-            // c'est le handler qui le masquera.
+            // Classé ici et non dans `handler.ts` : seul ce site connaît l'action
+            // réellement en cours, et `reference` / `restrict` partagent le même code
+            // SQLSTATE — c'est l'action qui les sépare. Un code non reconnu est relayé
+            // tel quel, et c'est le handler qui le masquera.
             throw classifyWriteError(e, 'delete') ?? e;
         }
         if (audit) {
@@ -61,8 +67,88 @@ export async function handleMutation(runtime, event, route) {
         }
         return redirectToList(route.model);
     }
+    /**
+     * Suppression en masse. Une seule opération d'écriture, pas une boucle de
+     * `deleteRecord` : une boucle qui casse au septième id sur une contrainte de
+     * clé étrangère laisserait six lignes supprimées et rien pour revenir en
+     * arrière. Ici, tout part ou rien ne part.
+     *
+     * La portée du modèle est composée avec les ids DANS le `where` de
+     * l'adapter, jamais vérifiée à part : un id hors portée ne matche pas, sans
+     * erreur — donc rien ne distingue « n'existe pas » de « appartient à un
+     * autre tenant ». Le compte rendu est celui des lignes réellement
+     * supprimées ; un écart avec la sélection ne peut venir que d'un POST forgé,
+     * puisque l'interface n'offre que des lignes en portée.
+     */
+    if (action === 'bulk-delete') {
+        const ids = formData.getAll('ids').map(String);
+        if (ids.length === 0) {
+            throw new AdminMutationError('validation', 'Select at least one record to delete.');
+        }
+        // L'interface ne peut cocher que ce qu'elle affiche, et une page plafonne
+        // à 200 lignes : au-delà la requête est forgée, et un `IN (…)` de plusieurs
+        // milliers d'éléments est un vecteur de charge à lui seul.
+        if (ids.length > MAX_BULK_IDS) {
+            throw new AdminMutationError('validation', `Cannot delete more than ${MAX_BULK_IDS} records at once.`);
+        }
+        const coerced = ids.map((id) => coerceId(id, model));
+        const scope = modelScopeFrom(runtime, model, { locals: event.locals });
+        // Instantané AVANT suppression, et seulement si un puits d'audit existe :
+        // sans lui le journal serait muet sur l'opération la plus destructive.
+        // Lu avec la même portée que la suppression, donc exactement les lignes qui
+        // vont partir.
+        const idFilter = { op: 'in', field: primaryKeyOf(model), value: coerced };
+        const before = audit
+            ? await runtime.adapter.data.findMany(model, {
+                filter: scope ? { op: 'and', clauses: [idFilter, scope] } : idFilter
+            })
+            : [];
+        let deleted;
+        try {
+            deleted = await runtime.adapter.data.deleteMany(model, coerced, scope);
+        }
+        catch (e) {
+            throw classifyWriteError(e, 'delete') ?? e;
+        }
+        for (const row of before) {
+            await emitAudit(audit, buildAuditEvent({
+                event,
+                action: 'delete',
+                model,
+                id: row[primaryKeyOf(model)],
+                hidden: runtime.hiddenFieldsOf(model),
+                before: row
+            }));
+        }
+        return new Response(null, {
+            status: 303,
+            headers: {
+                Location: `${runtime.basePath}/${route.model.toLowerCase()}?deleted=${deleted}`
+            }
+        });
+    }
     if (action === 'create' || action === 'update') {
-        const data = formDataToPrisma(formData, model);
+        const { data, invalid } = formDataToPrisma(formData, model);
+        // Refusé d'entrée : la valeur ne se convertit pas vers le type de la
+        // colonne (JSON illisible, nombre qui n'en est pas un), donc il n'y a même
+        // pas de payload à valider plus loin. Un seul champ est rapporté, comme
+        // partout ailleurs sur ce chemin — le formulaire re-rendu porte une erreur,
+        // pas une liste.
+        //
+        // Aucun conflit avec l'imposition du scope plus bas : le formulaire de
+        // création rend la colonne de tenant VIDE, et un vide n'est pas une valeur
+        // illisible (voir `formDataToPrisma`), donc rien ne devient incréable ici.
+        //
+        // Les scalaires de relation en sont exclus : la boucle FK plus bas fait sa
+        // propre coercion en relisant le FormData, et rattache son refus à l'arête
+        // (`author: invalid id`) plutôt qu'au scalaire (`authorId`). Contrairement
+        // au contrôle du vide, ce garde-ci n'est pas redondant avec l'ordre des
+        // boucles : `parseInt('abc')` produit un NaN que celle-ci verrait en
+        // premier, et le message perdrait le nom de la relation.
+        const firstInvalid = invalid.find((name) => !runtime.relationGraph?.scalarToRelation.has(name));
+        if (firstInvalid !== undefined) {
+            throw new AdminMutationError('validation', `${firstInvalid}: invalid value`, firstInvalid);
+        }
         // Appelé tôt pour échouer vite sur un scope non injectable (`or`, opérateur
         // autre que `eq`, tenant absent), avant tout travail de validation.
         // Volontairement PAS appliqué ici : `data` doit conserver ce que le client
@@ -72,6 +158,68 @@ export async function handleMutation(runtime, event, route) {
         const scopeValues = modelScopeValues(runtime, model, { locals: event.locals });
         const m2mInput = {};
         const targetGuards = [];
+        // Colonnes de texte sensibles (`password`, `passwordHash`, `apiToken`…).
+        // Le formulaire d'édition ne les rend pas — cf. `Form.svelte` — donc rien
+        // de légitime n'arrive par là ; une valeur présente vient d'un POST forgé
+        // ou d'un client qui invente un champ, et l'écrire remplacerait un
+        // credential par ce que l'appelant a choisi. La clé sort du payload, sans
+        // lever : ce n'est pas une donnée refusée, c'est une donnée non demandée.
+        //
+        // À la création, à l'inverse, le champ est offert. Un vide y était écrit
+        // comme `''`, ce qui produisait un compte au credential inutilisable avec
+        // un `303` d'apparence réussie. On refuse plutôt, et seulement quand la
+        // colonne est réellement obligatoire — une colonne optionnelle garde le
+        // droit d'être vide.
+        for (const field of model.fields) {
+            if (!isSensitiveStringField(field))
+                continue;
+            if (action === 'update') {
+                delete data[field.name];
+                continue;
+            }
+            const submitted = data[field.name];
+            const isEmpty = submitted === undefined || submitted === null || submitted === '';
+            if (isEmpty && field.isRequired && !field.hasDefault) {
+                throw new AdminMutationError('validation', `${field.name} is required`, field.name);
+            }
+            // Optionnelle et vide : ne rien écrire plutôt qu'une chaîne vide, qui
+            // serait indistinguable d'un secret réellement égal à ''.
+            if (isEmpty)
+                delete data[field.name];
+        }
+        /**
+         * Revalidation des enums. Le `<select>` rendu par `FieldInput` ne propose
+         * que des valeurs déclarées, mais un POST forgé n'y est pas tenu — même
+         * raison que la revalidation des cibles FK/m2m plus bas : ce que
+         * l'interface n'aurait pas offert ne doit pas passer sous prétexte qu'elle
+         * ne l'aurait pas offert. Sans ça, la valeur inventée part au pilote et
+         * ressort en message générique, sans désigner le champ fautif.
+         *
+         * `schema!` et `get(...)!` sont sûrs par construction : `isEnum` n'est posé
+         * qu'à partir de la table des enums du schéma (`parser.ts:220`, et
+         * `inspect.ts` côté Drizzle qui alimente les deux ensemble), et un modèle
+         * résolu implique un schéma introspecté.
+         *
+         * Le vide se décide sur `isRequired` seul, sans le `!hasDefault` de la
+         * boucle au-dessus : celle-ci couvre une création où le défaut de la base
+         * peut encore remplir la colonne, alors qu'ici « vide » vise une colonne
+         * qui n'accepte pas NULL — un `@default` n'y change rien.
+         */
+        const schemaEnums = runtime.schema.enums;
+        for (const field of model.fields) {
+            if (!field.isEnum || !(field.name in data))
+                continue;
+            // Le vide (ce que poste le « — aucun — » du widget) ne se décide pas ici
+            // mais dans le contrôle unique en fin de fonction, après l'imposition du
+            // scope : une colonne de tenant qui se trouve être un enum est rendue
+            // vide par le formulaire de création, et la refuser ici rendrait le
+            // modèle incréable. Cette boucle ne valide plus que le domaine.
+            if (data[field.name] === null)
+                continue;
+            if (!schemaEnums.get(field.type).includes(String(data[field.name]))) {
+                throw new AdminMutationError('validation', `${field.name}: invalid value`, field.name);
+            }
+        }
         // 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é).
@@ -209,10 +357,10 @@ export async function handleMutation(runtime, event, route) {
         // coercée ne divergent pas sur le seul type.
         //
         // Seule une valeur réellement affirmée par le client est confrontée au
-        // scope. `formDataToPrisma` renvoie `''` (String) ou `null` (Int, Float,
-        // DateTime) pour un champ présent mais vide — et le formulaire de création
-        // rend justement la colonne de scope vide. Traiter ce vide comme un conflit
-        // rendrait toute création impossible dès que la colonne est visible.
+        // scope. `formDataToPrisma` renvoie `null` pour un champ présent mais vide,
+        // quel que soit son type — et le formulaire de création rend justement la
+        // colonne de scope vide. Traiter ce vide comme un conflit rendrait toute
+        // création impossible dès que la colonne est visible.
         // Un vide veut dire « le formulaire n'a rien fourni », pas « le client
         // revendique un autre tenant » : on impose alors la valeur sans lever.
         //
@@ -228,6 +376,39 @@ export async function handleMutation(runtime, event, route) {
             }
             data[field] = value;
         }
+        /**
+         * Vide sur une colonne qui n'accepte pas NULL : refus, et le champ fautif
+         * est nommé. `formDataToPrisma` distingue déjà les deux sens du mot vide —
+         * une clé ABSENTE n'a pas été soumise (readonly, masquée, colonne à défaut
+         * que le formulaire de création n'affiche pas) et n'écrit rien ; une clé
+         * PRÉSENTE à `null` est une saisie vidée.
+         *
+         * Placé ici, en dernier, et pas plus haut avec les autres validations :
+         *
+         * - après l'imposition du scope, parce que le formulaire de création rend
+         *   la colonne de tenant vide (voir le bloc juste au-dessus). À ce point la
+         *   valeur imposée par le serveur est déjà posée, donc plus rien à refuser ;
+         * - après la boucle FK, qui rattache son refus à l'arête (`author is
+         *   required`) et non au scalaire (`authorId`). C'est cet ordre qui lui en
+         *   laisse la propriété, pas un garde ici : une arête optionnelle a un
+         *   scalaire optionnel (Prisma lie les deux), donc le seul scalaire de
+         *   relation qui puisse encore être `null` en arrivant ici appartient à une
+         *   arête que la boucle FK ne gère pas — une FK composite, qu'aucun widget
+         *   ne rend et que seul ce contrôle-ci peut alors nommer.
+         *
+         * Les champs sensibles n'y passent pas non plus : leur boucle, tout en
+         * haut, supprime déjà la clé d'une colonne optionnelle vide plutôt que d'y
+         * écrire `null` — `''` y serait indistinguable d'un secret réellement vide.
+         *
+         * `hasDefault` n'entre pas dans la décision : à la création la colonne à
+         * défaut n'est pas rendue, donc la clé est absente ; à l'édition la ligne a
+         * déjà une valeur, et la vider est une saisie, pas une absence.
+         */
+        for (const field of model.fields) {
+            if (!field.isRequired || !(field.name in data) || data[field.name] !== null)
+                continue;
+            throw new AdminMutationError('validation', `${field.name} is required`, field.name);
+        }
         if (action === 'create') {
             let created;
             try {
@@ -238,10 +419,10 @@ export async function handleMutation(runtime, event, route) {
                 });
             }
             catch (e) {
-                // Classé ici et non dans `handler.ts` : seul ce site connaît l'action réelle
-                // (`handleMutation` a déjà consommé le corps de la requête, donc le handler
-                // ne peut plus lire `_action`). Un code non reconnu est relayé tel quel, et
-                // c'est le handler qui le masquera.
+                // Classé ici et non dans `handler.ts` : seul ce site connaît l'action
+                // réellement en cours, et `reference` / `restrict` partagent le même code
+                // SQLSTATE — c'est l'action qui les sépare. Un code non reconnu est relayé
+                // tel quel, et c'est le handler qui le masquera.
                 throw classifyWriteError(e, 'create') ?? e;
             }
             if (audit) {
@@ -269,10 +450,10 @@ export async function handleMutation(runtime, event, route) {
                 updated = await runtime.adapter.data.updateRecord(model, route.id, { scalars: data, m2m: m2mInput, targetGuards }, modelScopeFrom(runtime, model, { locals: event.locals }));
             }
             catch (e) {
-                // Classé ici et non dans `handler.ts` : seul ce site connaît l'action réelle
-                // (`handleMutation` a déjà consommé le corps de la requête, donc le handler
-                // ne peut plus lire `_action`). Un code non reconnu est relayé tel quel, et
-                // c'est le handler qui le masquera.
+                // Classé ici et non dans `handler.ts` : seul ce site connaît l'action
+                // réellement en cours, et `reference` / `restrict` partagent le même code
+                // SQLSTATE — c'est l'action qui les sépare. Un code non reconnu est relayé
+                // tel quel, et c'est le handler qui le masquera.
                 throw classifyWriteError(e, 'update') ?? e;
             }
             if (audit) {

package/dist/server/query/listColumns.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Colonnes réellement rendues par la vue liste.
+ *
+ * Extrait de `List.svelte`, où cette composition vivait dans un `$derived` de
+ * composant : le handler en a besoin CÔTÉ SERVEUR pour décider quels champs un
+ * `?sort=` a le droit de désigner. Deux implémentations de « ce que la liste
+ * affiche » finiraient par diverger, et un tri autorisé sur une colonne que la
+ * liste n'affiche pas est un oracle — `?sort=passwordHash` plus la pagination
+ * suffit à ordonner des secrets par dichotomie. Même raison que le prédicat de
+ * sensibilité partagé (`parser.ts`) : une seule source, jamais deux.
+ *
+ * `getDisplayFields` reste la première passe (relations, listes, noms
+ * sensibles) ; cette fonction y ajoute ce que seule la config connaît.
+ */
+import { type PrismaField } from '../introspection/parser.js';
+export declare function resolveListColumns(fields: PrismaField[], opts: {
+    hidden?: string[];
+    listFields?: string[];
+}): PrismaField[];

package/dist/server/query/listColumns.js

@@ -0,0 +1,43 @@
+/**
+ * Colonnes réellement rendues par la vue liste.
+ *
+ * Extrait de `List.svelte`, où cette composition vivait dans un `$derived` de
+ * composant : le handler en a besoin CÔTÉ SERVEUR pour décider quels champs un
+ * `?sort=` a le droit de désigner. Deux implémentations de « ce que la liste
+ * affiche » finiraient par diverger, et un tri autorisé sur une colonne que la
+ * liste n'affiche pas est un oracle — `?sort=passwordHash` plus la pagination
+ * suffit à ordonner des secrets par dichotomie. Même raison que le prédicat de
+ * sensibilité partagé (`parser.ts`) : une seule source, jamais deux.
+ *
+ * `getDisplayFields` reste la première passe (relations, listes, noms
+ * sensibles) ; cette fonction y ajoute ce que seule la config connaît.
+ */
+import { getDisplayFields } from '../introspection/parser.js';
+/** Types qu'aucune cellule ne sait rendre lisiblement. */
+const UNRENDERABLE_TYPES = ['Json', 'Bytes'];
+/** Au-delà, la table déborde horizontalement sur un écran ordinaire. */
+const MAX_COLUMNS = 6;
+export function resolveListColumns(fields, opts) {
+    const hidden = opts.hidden ?? [];
+    const listFields = opts.listFields;
+    const explicit = new Set(listFields ?? []);
+    const safeNames = new Set(getDisplayFields({ fields }).map((f) => f.name));
+    let columns = fields.filter((f) => 
+    // `listFields` explicite l'emporte sur l'heuristique de nom sensible —
+    // échappatoire documentée pour ses faux positifs (`tokenCount`,
+    // `hashtagCount`), et couverte par les tests de `List.svelte`. Elle ne
+    // l'emporte jamais sur `hidden`, qui est un refus explicite.
+    //
+    // C'est aussi ce qui rend la whitelist de tri sûre sans règle en plus :
+    // trier ne porte que sur des colonnes DÉJÀ rendues, donc sur des valeurs
+    // que le lecteur peut lire de toute façon. Le tri n'ouvre aucun oracle
+    // qui ne soit pas déjà une lecture directe.
+    (explicit.has(f.name) || safeNames.has(f.name)) &&
+        !hidden.includes(f.name) &&
+        !f.relation &&
+        !UNRENDERABLE_TYPES.includes(f.type));
+    if (listFields?.length) {
+        columns = columns.filter((f) => listFields.includes(f.name));
+    }
+    return columns.slice(0, MAX_COLUMNS);
+}

package/dist/server/query/pageSize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Taille de page : celle configurée, et celles qu'un `?perPage=` a le droit de
+ * demander.
+ *
+ * Le point qui compte : la valeur venue de l'URL n'est jamais utilisée telle
+ * quelle. Elle doit appartenir à la liste proposée, sinon `?perPage=100000`
+ * devient un `take` non borné — un déni de service à un paramètre près, et sur
+ * une table volumineuse une requête qui tient la connexion. C'est la même règle
+ * d'or que les opérateurs de filtre et les colonnes de tri : l'URL choisit dans
+ * une liste finie, elle ne décrit rien.
+ */
+/**
+ * Tailles sélectionnables : les options configurées, plus la taille par défaut
+ * (sinon elle serait active sans figurer dans le sélecteur), triées et
+ * dédoublonnées. Une liste d'options vide désactive entièrement le mécanisme —
+ * pas de sélecteur, et `?perPage=` sans effet.
+ */
+export declare function resolvePageSizes(perPage: number, options: number[]): number[];
+export declare function parsePageSize(params: URLSearchParams, fallback: number, selectable: number[]): number;

package/dist/server/query/pageSize.js

@@ -0,0 +1,26 @@
+/**
+ * Taille de page : celle configurée, et celles qu'un `?perPage=` a le droit de
+ * demander.
+ *
+ * Le point qui compte : la valeur venue de l'URL n'est jamais utilisée telle
+ * quelle. Elle doit appartenir à la liste proposée, sinon `?perPage=100000`
+ * devient un `take` non borné — un déni de service à un paramètre près, et sur
+ * une table volumineuse une requête qui tient la connexion. C'est la même règle
+ * d'or que les opérateurs de filtre et les colonnes de tri : l'URL choisit dans
+ * une liste finie, elle ne décrit rien.
+ */
+/**
+ * Tailles sélectionnables : les options configurées, plus la taille par défaut
+ * (sinon elle serait active sans figurer dans le sélecteur), triées et
+ * dédoublonnées. Une liste d'options vide désactive entièrement le mécanisme —
+ * pas de sélecteur, et `?perPage=` sans effet.
+ */
+export function resolvePageSizes(perPage, options) {
+    if (options.length === 0)
+        return [];
+    return [...new Set([...options, perPage])].sort((a, b) => a - b);
+}
+export function parsePageSize(params, fallback, selectable) {
+    const requested = Number(params.get('perPage'));
+    return selectable.includes(requested) ? requested : fallback;
+}

package/dist/server/query/sortQuery.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `?sort=<colonne>&dir=asc|desc` → ordre de tri de la vue liste.
+ *
+ * Même règle d'or que les filtres (`listQuery.ts`) : la chaîne venue de l'URL
+ * ne devient jamais une clé de requête. Elle est cherchée dans la liste des
+ * colonnes que la vue rend réellement (`resolveListColumns`), et seul un membre
+ * de cette liste ressort. Une colonne masquée par `hidden`, écartée par
+ * l'heuristique de nom, ou simplement tronquée par le plafond de colonnes n'y
+ * est pas — donc pas triable.
+ *
+ * Trier ne peut ainsi ordonner que des valeurs déjà lisibles à l'écran : le tri
+ * n'ouvre aucune lecture que la liste n'offrait pas.
+ */
+export type SortDirection = 'asc' | 'desc';
+export interface ActiveSort {
+    field: string;
+    dir: SortDirection;
+}
+export interface SortState {
+    /** null = ordre par défaut (clé primaire décroissante, côté adapter). */
+    active: ActiveSort | null;
+    /** true quand l'URL a demandé une colonne non triable — rendu comme message. */
+    ignored: boolean;
+}
+/**
+ * `fallback` est le `models[].defaultSort` déjà validé au démarrage. Il
+ * s'applique quand l'URL ne demande rien, ET quand elle demande une colonne
+ * refusée : le refus reste signalé (`ignored`), mais la liste garde un ordre
+ * intentionnel plutôt que de retomber sur la clé primaire.
+ */
+export declare function parseSortQuery(params: URLSearchParams, sortable: string[], fallback?: ActiveSort): SortState;

package/dist/server/query/sortQuery.js

@@ -0,0 +1,33 @@
+/**
+ * `?sort=<colonne>&dir=asc|desc` → ordre de tri de la vue liste.
+ *
+ * Même règle d'or que les filtres (`listQuery.ts`) : la chaîne venue de l'URL
+ * ne devient jamais une clé de requête. Elle est cherchée dans la liste des
+ * colonnes que la vue rend réellement (`resolveListColumns`), et seul un membre
+ * de cette liste ressort. Une colonne masquée par `hidden`, écartée par
+ * l'heuristique de nom, ou simplement tronquée par le plafond de colonnes n'y
+ * est pas — donc pas triable.
+ *
+ * Trier ne peut ainsi ordonner que des valeurs déjà lisibles à l'écran : le tri
+ * n'ouvre aucune lecture que la liste n'offrait pas.
+ */
+/**
+ * `fallback` est le `models[].defaultSort` déjà validé au démarrage. Il
+ * s'applique quand l'URL ne demande rien, ET quand elle demande une colonne
+ * refusée : le refus reste signalé (`ignored`), mais la liste garde un ordre
+ * intentionnel plutôt que de retomber sur la clé primaire.
+ */
+export function parseSortQuery(params, sortable, fallback) {
+    const requested = params.get('sort');
+    // Vide == absent : `?sort=` est un artefact d'interface (un form GET qui
+    // sérialise un champ non renseigné), pas une demande à refuser bruyamment.
+    if (!requested)
+        return { active: fallback ?? null, ignored: false };
+    if (!sortable.includes(requested))
+        return { active: fallback ?? null, ignored: true };
+    // Domaine à deux valeurs : tout ce qui n'est pas `desc` est ascendant. Rien à
+    // refuser ici — contrairement au champ, une direction inconnue ne désigne
+    // aucune colonne et ne peut donc rien révéler.
+    const dir = params.get('dir') === 'desc' ? 'desc' : 'asc';
+    return { active: { field: requested, dir }, ignored: false };
+}

package/dist/server/query/urls.js

@@ -7,6 +7,12 @@
  * "always drop `page` on filter change" invariant (docs/design §3.3, §7.1)
  * and risks parameter-order drift, which makes snapshots flaky.
  */
+/**
+ * Paramètres qui ne sont pas un état de liste : un compte rendu d'action posé
+ * une fois par une redirection après écriture. Retiré de tout lien construit
+ * ensuite, sinon « 3 supprimés » réapparaît à chaque clic de filtre ou de page.
+ */
+const ONE_SHOT_PARAMS = ['deleted'];
 /**
  * Build a list-view URL from the current one, applying a patch of query
  * params. `null` in the patch removes that key. `page` is ALWAYS dropped
@@ -23,6 +29,8 @@ export function buildListUrl(currentUrl, patch) {
     if (!('page' in patch)) {
         params.delete('page');
     }
+    for (const key of ONE_SHOT_PARAMS)
+        params.delete(key);
     for (const [key, value] of Object.entries(patch)) {
         if (value === null)
             params.delete(key);
@@ -47,7 +55,7 @@ export function buildListUrl(currentUrl, patch) {
  * `page` is always excluded too, since any new search/filter resets it.
  */
 export function hiddenParams(currentUrl, exclude) {
-    const excluded = new Set([...exclude, 'page']);
+    const excluded = new Set([...exclude, 'page', ...ONE_SHOT_PARAMS]);
     const out = [];
     for (const [key, value] of currentUrl.searchParams) {
         if (excluded.has(key))

package/dist/server/runtime.d.ts

@@ -1,4 +1,5 @@
 import type { Schema, Model } from './types/schema.js';
+import type { ActiveSort } from './query/sortQuery.js';
 import { type RelationGraph } from './introspection/relations.js';
 import type { ViewModel } from './views/types.js';
 import type { DataAdapter, SchemaIntrospector, Filter } from './adapters/types.js';
@@ -33,6 +34,10 @@ export interface AdminRuntime {
     config: AdminHandlerConfig;
     basePath: string;
     perPage: number;
+    /** Tailles sélectionnables, vide quand le mécanisme est désactivé. */
+    pageSizes: number[];
+    /** `models[].defaultSort` validé au démarrage, par nom de modèle. */
+    defaultSortOf(model: Model): ActiveSort | undefined;
     selectThreshold: number;
     filterLinkThreshold: number;
     labelFieldCandidates: string[];

package/dist/server/runtime.js

@@ -1,4 +1,6 @@
 import { isSensitiveFieldName } from './introspection/parser.js';
+import { resolveListColumns } from './query/listColumns.js';
+import { resolvePageSizes } from './query/pageSize.js';
 import { buildRelationGraph } from './introspection/relations.js';
 import { primaryKeyOf } from './data.js';
 import { validateListFilterConfig } from './query/filterDetection.js';
@@ -94,6 +96,13 @@ export function createAdminRuntime(config) {
     catch (e) {
         console.warn('[sveltekit-admin] Could not introspect schema:', e);
     }
+    /**
+     * Résolu une fois ici plutôt que dans `viewModel` : un `schema?.enums ?? …`
+     * par appel serait une branche que rien ne peut exercer (un schéma nul donne
+     * `models` vide, donc aucune vue à construire), alors qu'à ce niveau les deux
+     * cas sont ceux du démarrage — schéma lu, ou introspection en échec.
+     */
+    const schemaEnums = schema?.enums ?? new Map();
     const models = schema?.models.filter((m) => {
         // Exclude explicitly excluded models
         if (exclude.includes(m.name))
@@ -116,6 +125,31 @@ export function createAdminRuntime(config) {
         if (entries)
             validateListFilterConfig(m.name, entries, m, relationGraph, hiddenFieldsOf(m));
     }
+    /**
+     * `defaultSort` validé ici pour la même raison que `listFilter` : une colonne
+     * inexistante, ou que la liste n'affiche pas, produirait un tri mort à chaque
+     * rendu sans qu'aucun en-tête ne l'annonce — et l'utilisateur n'aurait aucun
+     * moyen d'en sortir, puisque seule une colonne affichée porte un lien. La
+     * liste des colonnes autorisées est la même que celle du tri par URL.
+     */
+    const defaultSortOf = (m) => {
+        const configured = modelsConfig[m.name]?.defaultSort;
+        if (!configured)
+            return undefined;
+        const sortable = resolveListColumns(m.fields, {
+            hidden: modelsConfig[m.name]?.hidden,
+            listFields: modelsConfig[m.name]?.listFields
+        }).map((f) => f.name);
+        if (!sortable.includes(configured.field)) {
+            throw new AdminConfigError(`[sveltekit-admin] models.${m.name}.defaultSort targets "${configured.field}", ` +
+                `which the list view does not display. Displayed columns: [${sortable.join(', ')}].`);
+        }
+        if (configured.dir !== undefined && configured.dir !== 'asc' && configured.dir !== 'desc') {
+            throw new AdminConfigError(`[sveltekit-admin] models.${m.name}.defaultSort.dir must be "asc" or "desc".`);
+        }
+        return { field: configured.field, dir: configured.dir ?? 'asc' };
+    };
+    const defaultSorts = new Map(models.map((m) => [m.name, defaultSortOf(m)]));
     const labelOf = (m) => {
         const configured = modelsConfig[m.name]?.label;
         if (configured)
@@ -130,10 +164,27 @@ export function createAdminRuntime(config) {
         label: labelOf(m),
         fields: m.fields,
         primaryKey: primaryKeyOf(m),
+        enums: schemaEnums,
         // Non-null par construction : `m` vient toujours de `models`,
         // dérivé du schéma qu'on vient de parser avec succès.
         relationGraph: relationGraph
     });
+    /**
+     * Plafond dur. Au-delà ce n'est plus une page mais un export, et sur une
+     * table volumineuse une requête qui tient la connexion. Vaut pour la valeur
+     * configurée comme pour chaque option proposée.
+     */
+    const MAX_PAGE_SIZE = 200;
+    const validPageSize = (n) => typeof n === 'number' && Number.isSafeInteger(n) && n >= 1 && n <= MAX_PAGE_SIZE;
+    if (config.perPage !== undefined && !validPageSize(config.perPage)) {
+        throw new AdminConfigError(`[sveltekit-admin] perPage must be an integer between 1 and ${MAX_PAGE_SIZE}.`);
+    }
+    const perPage = config.perPage ?? 20;
+    const configuredSizes = config.pageSizeOptions ?? [10, 20, 50, 100];
+    if (!Array.isArray(configuredSizes) || !configuredSizes.every(validPageSize)) {
+        throw new AdminConfigError(`[sveltekit-admin] pageSizeOptions must be integers between 1 and ${MAX_PAGE_SIZE}.`);
+    }
+    const pageSizes = resolvePageSizes(perPage, configuredSizes);
     const selectThreshold = config.relationDefaults?.selectThreshold ?? 200;
     const filterLinkThreshold = config.listFilterDefaults?.linkThreshold ?? 20;
     const labelFieldCandidates = config.relationDefaults?.labelFields ?? [
@@ -196,7 +247,9 @@ export function createAdminRuntime(config) {
         modelList,
         config,
         basePath,
-        perPage: 20,
+        perPage,
+        pageSizes,
+        defaultSortOf: (m) => defaultSorts.get(m.name),
         selectThreshold,
         filterLinkThreshold,
         labelFieldCandidates,

package/dist/server/submitted.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Extraction des valeurs réellement soumises par un POST de formulaire admin,
+ * pour les re-rendre après un échec de mutation.
+ *
+ * Ce module ne rend rien : il traduit un `FormData` en la forme minimale dont
+ * les vues ont besoin. Il porte en revanche la décision de sécurité de ce
+ * chemin — ce qui NE doit pas repartir dans le HTML.
+ */
+export interface SubmittedForm {
+    /** Scalaires et scalaires de relation, par nom de champ. */
+    values: Record<string, string>;
+    /**
+     * IDs cochés par arête m2m. Une entrée présente avec un tableau vide dit
+     * « l'utilisateur a tout décoché » ; une arête absente dit « le widget
+     * n'était pas dans le formulaire ». Même distinction, et même raison, que
+     * le sentinelle côté écriture.
+     */
+    m2m: Record<string, string[]>;
+}
+export declare function readSubmittedForm(formData: FormData, hidden: ReadonlySet<string>): SubmittedForm;