sveltekit-admin 0.6.0 → 0.9.0

package/dist/server/pluginAccess.js

@@ -0,0 +1,79 @@
+import { normalizeScope } from './adapters/filter.js';
+import { redactForAudit } from './audit.js';
+import { coerceId, primaryKeyOf } from './data.js';
+import { isSensitiveFieldName } from './introspection/parser.js';
+import { listScopeFrom, modelScopeFrom, scopeFrom } from './runtime.js';
+import { filterSelectedIds } from './relationLoaders.js';
+import { escapeHtml } from './views/html.js';
+function andFilters(...parts) {
+    const clauses = parts.filter((p) => p !== undefined);
+    if (clauses.length === 0)
+        return undefined;
+    if (clauses.length === 1)
+        return clauses[0];
+    return { op: 'and', clauses: clauses };
+}
+function redactRow(runtime, model, row) {
+    return redactForAudit(row, model, runtime.hiddenFieldsOf(model));
+}
+export function createPluginPageContext(runtime, event, route, record) {
+    const loadRecord = async (modelName, id) => {
+        const model = runtime.findModel(modelName);
+        if (!model)
+            return null;
+        const scope = andFilters(modelScopeFrom(runtime, model, { locals: event.locals }), normalizeScope(listScopeFrom(runtime, model, { locals: event.locals })));
+        const idFilter = {
+            op: 'eq',
+            field: primaryKeyOf(model),
+            value: coerceId(String(id), model)
+        };
+        const filter = (scope ? { op: 'and', clauses: [idFilter, scope] } : idFilter);
+        const row = await runtime.adapter.data.findFirst(model, filter);
+        return row ? redactRow(runtime, model, row) : null;
+    };
+    const listRecords = async (modelName, extraFilter) => {
+        const model = runtime.findModel(modelName);
+        if (!model)
+            return [];
+        const scope = andFilters(modelScopeFrom(runtime, model, { locals: event.locals }), normalizeScope(listScopeFrom(runtime, model, { locals: event.locals })));
+        const filter = andFilters(scope, extraFilter);
+        const rows = await runtime.adapter.data.findMany(model, { filter: filter });
+        return rows.map((row) => redactRow(runtime, model, row));
+    };
+    const getM2mSelectedIds = async (modelName, fieldName, recordId) => {
+        const model = runtime.findModel(modelName);
+        if (!model) {
+            throw new Error(`[sveltekit-admin] getM2mSelectedIds: unknown model "${modelName}"`);
+        }
+        // Non-null par construction : `model` vient toujours de `runtime.models`,
+        // dérivé du schéma qu'on a parsé avec succès (même convention que
+        // `runtime.ts` `validateListFilterConfig` / `viewModel`).
+        const edge = runtime.relationGraph.edges.get(`${model.name}.${fieldName}`);
+        if (!edge || edge.kind !== 'm2m') {
+            throw new Error(`[sveltekit-admin] getM2mSelectedIds: "${model.name}.${fieldName}" is not an m2m relation`);
+        }
+        const target = runtime.findModel(edge.target);
+        if (!target) {
+            throw new Error(`[sveltekit-admin] getM2mSelectedIds: target model "${edge.target}" is not visible`);
+        }
+        if (!(await loadRecord(model.name, recordId)))
+            return [];
+        const selected = await runtime.adapter.data.getM2mSelectedIds(model, edge, target, recordId);
+        return (await filterSelectedIds(runtime, target, selected, { locals: event.locals }, scopeFrom(runtime.config.models?.[model.name]?.relations?.[fieldName], { locals: event.locals }))) ?? [];
+    };
+    return {
+        event,
+        route,
+        basePath: runtime.basePath,
+        record,
+        escapeHtml,
+        findModel: runtime.findModel,
+        relationGraph: runtime.relationGraph,
+        resolveLabel: runtime.resolveLabel,
+        hiddenFieldsOf: runtime.hiddenFieldsOf,
+        isSensitiveFieldName,
+        loadRecord,
+        listRecords,
+        getM2mSelectedIds
+    };
+}

package/dist/server/pluginRegistry.d.ts

@@ -0,0 +1,12 @@
+import type { RouteEntry } from './router.js';
+import type { AdminPlugin, AdminPluginPage, AdminPluginRecordAction } from './plugin.js';
+export interface PluginRegistry {
+    routes: RouteEntry[];
+    pagesByView: Map<string, AdminPluginPage>;
+    recordActions: AdminPluginRecordAction[];
+}
+export declare function pluginViewId(pluginName: string, pattern: string[]): string;
+export declare function resolvePluginRegistry(plugins: AdminPlugin[], builtinRoutes: RouteEntry[], visibleModels: Array<{
+    name: string;
+}>): PluginRegistry;
+export declare function actionsForModel(registry: PluginRegistry, modelName: string): AdminPluginRecordAction[];

package/dist/server/pluginRegistry.js

@@ -0,0 +1,72 @@
+export function pluginViewId(pluginName, pattern) {
+    return `plugin/${pluginName}/${pattern.join('/')}`;
+}
+function patternKey(pattern) {
+    return pattern.join('\0');
+}
+function modelVisible(visibleModels, entry) {
+    return visibleModels.some((m) => m.name.toLowerCase() === entry.toLowerCase());
+}
+function assertKnownModels(entries, visibleModels, pluginName) {
+    if (!entries)
+        return;
+    for (const entry of entries) {
+        if (!modelVisible(visibleModels, entry)) {
+            throw new Error(`[sveltekit-admin] plugin "${pluginName}" models[] includes unknown model "${entry}"`);
+        }
+    }
+}
+export function resolvePluginRegistry(plugins, builtinRoutes, visibleModels) {
+    const builtinKeys = new Map(builtinRoutes.map((r) => [patternKey(r.pattern), r.view]));
+    const taken = new Map();
+    const names = new Set();
+    const routes = [];
+    const pagesByView = new Map();
+    const recordActions = [];
+    for (const plugin of plugins) {
+        if (!plugin.name) {
+            throw new Error('[sveltekit-admin] plugin name must be a non-empty string');
+        }
+        if (names.has(plugin.name)) {
+            throw new Error(`[sveltekit-admin] duplicate plugin name "${plugin.name}"`);
+        }
+        names.add(plugin.name);
+        for (const page of plugin.pages ?? []) {
+            for (const token of page.pattern) {
+                if (token.startsWith(':') && token !== ':model' && token !== ':id') {
+                    throw new Error(`[sveltekit-admin] plugin "${plugin.name}" pattern token "${token}" is not :model or :id`);
+                }
+            }
+            const hasModel = page.pattern.includes(':model');
+            const hasId = page.pattern.includes(':id');
+            if (page.models && !hasModel) {
+                throw new Error(`[sveltekit-admin] plugin "${plugin.name}" page ${JSON.stringify(page.pattern)} sets models[] but pattern has no :model`);
+            }
+            if (hasId && !hasModel) {
+                throw new Error(`[sveltekit-admin] plugin "${plugin.name}" page ${JSON.stringify(page.pattern)} has :id but pattern has no :model`);
+            }
+            assertKnownModels(page.models, visibleModels, plugin.name);
+            const key = patternKey(page.pattern);
+            const builtinView = builtinKeys.get(key);
+            if (builtinView !== undefined) {
+                throw new Error(`[sveltekit-admin] plugin "${plugin.name}" pattern ${JSON.stringify(page.pattern)} overlays builtin route "${builtinView}"`);
+            }
+            const other = taken.get(key);
+            if (other !== undefined) {
+                throw new Error(`[sveltekit-admin] plugin "${plugin.name}" pattern ${JSON.stringify(page.pattern)} collides with plugin "${other}"`);
+            }
+            taken.set(key, plugin.name);
+            const view = pluginViewId(plugin.name, page.pattern);
+            routes.push({ pattern: page.pattern, view });
+            pagesByView.set(view, page);
+        }
+        for (const action of plugin.recordActions ?? []) {
+            assertKnownModels(action.models, visibleModels, plugin.name);
+            recordActions.push(action);
+        }
+    }
+    return { routes, pagesByView, recordActions };
+}
+export function actionsForModel(registry, modelName) {
+    return registry.recordActions.filter((action) => !action.models || action.models.some((n) => n.toLowerCase() === modelName.toLowerCase()));
+}

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/listQuery.d.ts

@@ -83,4 +83,4 @@ export declare function parseListQuery(searchParams: URLSearchParams, model: Pri
  * `normalizeScope`; nested Prisma where objects stay opaque for the Prisma
  * compiler. Drizzle's compiler throws on those opaques.
  */
-export declare function buildWhere(query: ListQuery, scope: Record<string, unknown> | undefined, caseInsensitiveSearch: boolean, model: PrismaModel): Filter | Record<string, unknown> | undefined;
+export declare function buildWhere(query: ListQuery, scope: Record<string, unknown> | Filter | undefined, caseInsensitiveSearch: boolean, model: PrismaModel): Filter | Record<string, unknown> | undefined;

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/relationLoaders.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Relation option loaders shared by the create/edit Form and the list-view
+ * FK filter sidebar. Split out of `handler.ts` — pure orchestration over
+ * `AdminRuntime` (schema/relationGraph/adapter already resolved at boot),
+ * no boot logic lives here.
+ */
+import type { PrismaModel } from './introspection/parser.js';
+import type { RelationMeta, FkFilterMeta } from './views/types.js';
+import { type AdminRuntime } from './runtime.js';
+import type { Filter } from './adapters/types.js';
+export declare function combinedScope(...scopes: Array<Filter | Record<string, unknown> | undefined>): Filter | undefined;
+export declare function filterSelectedIds(runtime: AdminRuntime, targetModel: PrismaModel, ids: Array<string | number> | undefined, ctx: {
+    locals?: any;
+}, relationScope?: Filter | Record<string, unknown>): Promise<Array<string | number> | undefined>;
+/**
+ * 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.
+ */
+export declare function loadRelationOptions(runtime: AdminRuntime, model: PrismaModel, ctx: {
+    locals?: any;
+}, currentId?: string): Promise<Map<string, RelationMeta>>;
+/**
+ * Options d'un filtre FK : charge et scope les valeurs possibles pour la
+ * sidebar, ET résout le label du chip actif. Doctrine IDOR (docs/design
+ * §6.3) : les options ET le label du chip passent par le `where` de
+ * scoping de la relation — un chip forgé avec un ID hors scope affiche
+ * l'ID brut, jamais le label (sinon c'est un oracle sur le nom d'un
+ * enregistrement d'un autre tenant).
+ */
+export declare function resolveFkFilterOptions(runtime: AdminRuntime, model: PrismaModel, fkFieldName: string, label: string, ctx: {
+    locals?: any;
+}, activeRawValue: string | undefined): Promise<FkFilterMeta>;
+/**
+ * Compte, pour chaque relation inverse (1-N, 1-1) d'un modèle, le nombre
+ * d'enregistrements liés côté cible. Résilient : une cible dont le client
+ * échoue (mock partiel, modèle absent) retombe sur 0 plutôt que de casser
+ * le rendu du formulaire.
+ */
+export declare function loadRelatedCounts(runtime: AdminRuntime, model: PrismaModel, currentId: string, ctx: {
+    locals?: any;
+}): Promise<Map<string, number>>;

package/dist/server/relationLoaders.js

@@ -0,0 +1,188 @@
+/**
+ * Relation option loaders shared by the create/edit Form and the list-view
+ * FK filter sidebar. Split out of `handler.ts` — pure orchestration over
+ * `AdminRuntime` (schema/relationGraph/adapter already resolved at boot),
+ * no boot logic lives here.
+ */
+import { primaryKeyOf, coerceId } from './data.js';
+import { findFkEdge } from './query/filterDetection.js';
+import { scopeFrom, modelScopeFrom } from './runtime.js';
+import { normalizeScope } from './adapters/filter.js';
+export function combinedScope(...scopes) {
+    const clauses = scopes.map((scope) => normalizeScope(scope)).filter((scope) => scope !== undefined);
+    if (clauses.length === 0)
+        return undefined;
+    if (clauses.length === 1)
+        return clauses[0];
+    return { op: 'and', clauses };
+}
+export async function filterSelectedIds(runtime, targetModel, ids, ctx, relationScope) {
+    if (!ids)
+        return undefined;
+    const scope = combinedScope(modelScopeFrom(runtime, targetModel, ctx), relationScope);
+    if (!scope || ids.length === 0)
+        return ids;
+    const rows = await runtime.adapter.data.findMany(targetModel, {
+        filter: combinedScope(scope, { op: 'in', field: primaryKeyOf(targetModel), value: ids })
+    });
+    const allowed = new Set(rows.map((row) => String(row[primaryKeyOf(targetModel)])));
+    return ids.filter((id) => allowed.has(String(id)));
+}
+/**
+ * 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.
+ */
+export async function loadRelationOptions(runtime, model, ctx, currentId) {
+    const modelsConfig = runtime.config.models ?? {};
+    const edges = [...runtime.relationGraph.edges.values()].filter((edge) => {
+        if (edge.model !== model.name)
+            return false;
+        if (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m')
+            return false;
+        if (edge.unsupported)
+            return false;
+        const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
+        return relConfig?.widget !== 'hidden';
+    });
+    // Une relation ne dépend pas de l'autre : chargées en parallèle plutôt
+    // qu'en série (un modèle avec N relations ne doit pas payer N
+    // aller-retours DB empilés pour afficher un seul formulaire).
+    const entries = await Promise.all(edges.map(async (edge) => {
+        const key = `${edge.model}.${edge.field}`;
+        const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
+        const targetModel = runtime.schema.models.find((m) => m.name === edge.target);
+        const filter = combinedScope(modelScopeFrom(runtime, targetModel, ctx), scopeFrom(relConfig, ctx));
+        try {
+            const total = await runtime.adapter.data.countRecords(targetModel, filter);
+            if (total > runtime.selectThreshold || relConfig?.widget === 'raw-id') {
+                const selectedIds = edge.kind === 'm2m' && currentId
+                    ? await filterSelectedIds(runtime, targetModel, await runtime.adapter.data.getM2mSelectedIds(model, edge, targetModel, currentId), ctx, scopeFrom(relConfig, ctx))
+                    : undefined;
+                return [key, { tooMany: true, options: [], selectedIds }];
+            }
+            const rows = await runtime.adapter.data.findMany(targetModel, { filter, orderBy: relConfig?.orderBy });
+            const options = rows.map((row) => ({
+                id: row[primaryKeyOf(targetModel)],
+                label: runtime.resolveLabel(targetModel, row, relConfig?.labelTemplate)
+            }));
+            const selectedIds = edge.kind === 'm2m' && currentId
+                ? await filterSelectedIds(runtime, targetModel, await runtime.adapter.data.getM2mSelectedIds(model, edge, targetModel, currentId), ctx, scopeFrom(relConfig, ctx))
+                : undefined;
+            return [key, { tooMany: false, options, selectedIds }];
+        }
+        catch {
+            // Cible absente de la base ou client incomplet : repli raw-id pour
+            // garder le champ éditable plutôt que de faire échouer tout le form.
+            return [key, { tooMany: true, options: [] }];
+        }
+    }));
+    return new Map(entries);
+}
+/**
+ * Options d'un filtre FK : charge et scope les valeurs possibles pour la
+ * sidebar, ET résout le label du chip actif. Doctrine IDOR (docs/design
+ * §6.3) : les options ET le label du chip passent par le `where` de
+ * scoping de la relation — un chip forgé avec un ID hors scope affiche
+ * l'ID brut, jamais le label (sinon c'est un oracle sur le nom d'un
+ * enregistrement d'un autre tenant).
+ */
+export async function resolveFkFilterOptions(runtime, model, fkFieldName, label, ctx, activeRawValue) {
+    // Appelé uniquement pour un filtre `kind: 'fk'` retourné par
+    // resolveListFilters avec CE MÊME graphe : graphe et arête existent donc
+    // par construction. Garder des gardes here masquerait une incohérence
+    // interne et ajouterait du code mort (coverage artificielle).
+    const edge = findFkEdge(runtime.relationGraph, model.name, fkFieldName);
+    // Non-null par construction : un filtre `kind: 'fk'` ne peut exister que
+    // via `models[model.name].listFilter` explicite (CLAUDE.md — les filtres
+    // FK ne sont jamais auto-détectés) ; `runtime.config.models` est donc
+    // déjà renseigné pour ce modèle avant que cette fonction ne soit appelée.
+    const modelsConfig = runtime.config.models;
+    const targetModel = runtime.schema.models.find((m) => m.name === edge.target);
+    // Non-null par construction : `edge` vient du graphe dérivé du même
+    // schéma parsé avec succès — une arête ne peut pas cibler un modèle qui
+    // n'existe pas dans `schema.models`.
+    const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
+    const scope = combinedScope(modelScopeFrom(runtime, targetModel, ctx), 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 runtime.adapter.data.countRecords(targetModel, scope);
+            if (total > runtime.selectThreshold) {
+                return { options: [], tooMany: true };
+            }
+            const rows = await runtime.adapter.data.findMany(targetModel, { filter: scope, orderBy: relConfig?.orderBy });
+            const options = rows.map((row) => ({
+                id: row[primaryKeyOf(targetModel)],
+                label: runtime.resolveLabel(targetModel, row, relConfig?.labelTemplate)
+            }));
+            return { options, tooMany: false };
+        }
+        catch {
+            return { options: [], tooMany: true };
+        }
+    };
+    // Un ID hors scope retourne null ici → le composant affiche l'ID brut,
+    // jamais le label (sinon c'est un oracle sur le nom d'un enregistrement
+    // d'un autre tenant).
+    const loadActiveLabel = async () => {
+        if (activeRawValue === undefined)
+            return undefined;
+        const activeId = coerceId(activeRawValue, targetModel);
+        try {
+            const idFilter = { op: 'eq', field: primaryKeyOf(targetModel), value: activeId };
+            const filter = scope ? { op: 'and', clauses: [idFilter, scope] } : idFilter;
+            const row = await runtime.adapter.data.findFirst(targetModel, filter);
+            return row ? runtime.resolveLabel(targetModel, row, relConfig?.labelTemplate) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const [{ options, tooMany }, activeLabel] = await Promise.all([loadOptions(), loadActiveLabel()]);
+    return {
+        field: fkFieldName,
+        label,
+        relationField: edge.field,
+        targetModel: edge.target,
+        options,
+        mode: tooMany ? 'raw-id' : options.length <= runtime.filterLinkThreshold ? 'links' : 'select',
+        tooMany,
+        activeLabel,
+        // Une cible exclue/masquée n'a pas de page admin : le chip reste du
+        // texte, jamais un lien mort (docs/design §6.4).
+        activeHref: activeLabel && runtime.findModel(edge.target)
+            ? `${runtime.basePath}/${edge.target.toLowerCase()}/${encodeURIComponent(activeRawValue)}`
+            : undefined
+    };
+}
+/**
+ * Compte, pour chaque relation inverse (1-N, 1-1) d'un modèle, le nombre
+ * d'enregistrements liés côté cible. Résilient : une cible dont le client
+ * échoue (mock partiel, modèle absent) retombe sur 0 plutôt que de casser
+ * le rendu du formulaire.
+ */
+export async function loadRelatedCounts(runtime, model, currentId, ctx) {
+    const edges = [...runtime.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 = [...runtime.relationGraph.edges.values()].find((o) => o.model === edge.target && o.kind === 'to-one-owning' && o.relationName === edge.relationName);
+        if (!owning || owning.unsupported)
+            return undefined;
+        const scalarName = owning.scalarFields[0];
+        const key = `${edge.model}.${edge.field}`;
+        const targetModel = runtime.schema.models.find((m) => m.name === edge.target);
+        try {
+            const count = await runtime.adapter.data.countRecords(targetModel, combinedScope(modelScopeFrom(runtime, targetModel, ctx), { op: 'eq', field: scalarName, value: coerceId(currentId, model) }));
+            return [key, count];
+        }
+        catch {
+            return [key, 0];
+        }
+    }));
+    return new Map(entries.filter((e) => e !== undefined));
+}

package/dist/server/router.d.ts

@@ -3,4 +3,14 @@ export interface ParsedRoute {
     model?: string;
     id?: string;
 }
+export interface RouteEntry {
+    pattern: string[];
+    view: string;
+}
+export declare const BUILTIN_ROUTES: RouteEntry[];
+export declare function matchRoute(pathname: string, basePath: string, routes: RouteEntry[]): {
+    view: string;
+    model?: string;
+    id?: string;
+};
 export declare function parseRoute(pathname: string, basePath: string): ParsedRoute;