sveltekit-admin 0.6.0 → 0.8.1

package/dist/server/mutations.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+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>;

package/dist/server/mutations.js

@@ -0,0 +1,295 @@
+/**
+ * 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.
+ */
+import { primaryKeyOf, coerceId, formDataToPrisma } from './data.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) {
+    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;
+    const model = runtime.findModel(route.model);
+    if (!model) {
+        throw new AdminMutationError('notFound', `Model "${route.model}" not found`);
+    }
+    const redirectToList = (modelName) => new Response(null, {
+        status: 303,
+        headers: { Location: `${runtime.basePath}/${modelName.toLowerCase()}` }
+    });
+    const scopedRecord = async (id) => {
+        const modelScope = modelScopeFrom(runtime, model, { locals: event.locals });
+        if (!modelScope)
+            return true;
+        return runtime.adapter.data.findFirst(model, {
+            op: 'and',
+            clauses: [{ op: 'eq', field: primaryKeyOf(model), value: coerceId(String(id), model) }, modelScope]
+        });
+    };
+    if (action === 'delete' && route.id) {
+        const id = coerceId(route.id, model);
+        if (!(await scopedRecord(id)))
+            return null;
+        const before = audit
+            ? await readAuditSnapshot((m, recId) => runtime.adapter.data.getRecord(m, recId), model, id)
+            : null;
+        try {
+            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.
+            throw classifyWriteError(e, 'delete') ?? e;
+        }
+        if (audit) {
+            await emitAudit(audit, buildAuditEvent({
+                event,
+                action: 'delete',
+                model,
+                id,
+                hidden: runtime.hiddenFieldsOf(model),
+                before
+            }));
+        }
+        return redirectToList(route.model);
+    }
+    if (action === 'create' || action === 'update') {
+        const data = formDataToPrisma(formData, model);
+        // 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
+        // a soumis, sinon la confrontation au scope plus bas ne verrait plus que la
+        // valeur déjà corrigée, et ne lèverait que pour les scalaires de relation
+        // — les seuls que la boucle FK réécrit.
+        const scopeValues = modelScopeValues(runtime, model, { locals: event.locals });
+        const m2mInput = {};
+        const targetGuards = [];
+        // Validation des FK owning : coercion + existence + self-ref.
+        // Rejoue le `where` de scoping : un ID hors du where est rejeté,
+        // pas seulement caché du select (IDOR par POST forgé).
+        if (runtime.relationGraph) {
+            for (const edge of runtime.relationGraph.edges.values()) {
+                if (edge.model !== model.name || edge.kind !== 'to-one-owning')
+                    continue;
+                if (edge.unsupported)
+                    continue;
+                const scalarName = edge.scalarFields[0];
+                // Lu directement depuis le FormData plutôt que `data` :
+                // `formDataToPrisma` omet la clé pour un scalaire required
+                // laissé vide, donc `data[scalarName]` ne suffirait pas ici.
+                const raw = formData.get(scalarName);
+                if (raw === null)
+                    continue;
+                const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
+                // Vide sur relation optionnelle → null (disconnect).
+                if (raw === '' || raw === undefined || raw === null) {
+                    if (edge.isRequired) {
+                        throw new AdminMutationError('validation', `${edge.field} is required`, edge.field);
+                    }
+                    data[scalarName] = null;
+                    continue;
+                }
+                // Coercion vers le type de la PK cible. `targetModel` existe
+                // toujours : le graphe n'aurait pas produit d'arête sinon.
+                const targetModel = runtime.schema.models.find((m) => m.name === edge.target);
+                const pkField = targetModel.fields.find((f) => f.isId);
+                const coerced = pkField?.type === 'Int' ? parseInt(String(raw)) : String(raw);
+                if (pkField?.type === 'Int' && !Number.isSafeInteger(coerced)) {
+                    throw new AdminMutationError('validation', `${edge.field}: invalid id`, edge.field);
+                }
+                // Self-ref : la ligne courante ne peut pas être sa propre cible.
+                if (edge.selfReferential && route.id && String(coerced) === String(coerceId(route.id, model))) {
+                    throw new AdminMutationError('validation', `${edge.field}: cannot reference itself`, edge.field);
+                }
+                // Existence + scoping. findFirst et non findUnique : le where
+                // peut porter des conditions arbitraires (scoping multi-tenant).
+                // Si le client ne sait pas répondre, on ne bloque pas l'écriture.
+                const scopeFilter = scopeFrom(relConfig, { locals: event.locals });
+                const modelFilter = modelScopeFrom(runtime, targetModel, { locals: event.locals });
+                try {
+                    const idFilter = { op: 'eq', field: primaryKeyOf(targetModel), value: coerced };
+                    const scopes = [scopeFilter, modelFilter].filter(Boolean);
+                    const filter = scopes.length ? { op: 'and', clauses: [idFilter, ...scopes] } : idFilter;
+                    targetGuards.push({ targetModel, targetPk: coerced, filter: scopes.length ? { op: 'and', clauses: scopes } : undefined });
+                    const found = await runtime.adapter.data.findFirst(targetModel, filter);
+                    if (!found) {
+                        throw new AdminMutationError('validation', `${edge.field}: invalid value`, edge.field);
+                    }
+                }
+                catch (e) {
+                    // Déjà typée par le `if (!found)` ci-dessus : la relayer telle quelle.
+                    // Toute autre cause (scope incompilable, champ inconnu, panne pilote)
+                    // devient le même refus : la valeur soumise n'est pas acceptable, et on
+                    // ne renvoie jamais au client ce que le pilote a dit.
+                    if (e instanceof AdminMutationError)
+                        throw e;
+                    throw new AdminMutationError('validation', `${edge.field}: invalid value`, edge.field);
+                }
+                data[scalarName] = coerced;
+            }
+            // N-N implicite : lit `__rel__<field>` (valeurs cochées) et
+            // `__rel_present__<field>` (sentinelle). Sans le sentinelle,
+            // le champ est absent du form (readonly/exclu) → no-op.
+            // Avec le sentinelle mais zéro valeur cochée → vider la
+            // relation (`set: []` / rien à connecter en création).
+            for (const edge of runtime.relationGraph.edges.values()) {
+                if (edge.model !== model.name || edge.kind !== 'm2m')
+                    continue;
+                // Pas de garde `edge.unsupported` ici : par construction du
+                // graphe, `unsupported` n'est jamais posé sur une arête
+                // m2m (seulement sur to-one-owning / groupes
+                // ambigus, qui retombent toujours en to-one-owning).
+                const present = formData.get(`__rel_present__${edge.field}`);
+                if (present === null)
+                    continue;
+                const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
+                const targetModel = runtime.schema.models.find((m) => m.name === edge.target);
+                const targetPk = primaryKeyOf(targetModel);
+                const pkIsInt = targetModel.fields.find((f) => f.isId)?.type === 'Int';
+                const submitted = formData.getAll(`__rel__${edge.field}`).map(String);
+                const rawIds = submitted.length === 1 && submitted[0].includes(',')
+                    ? submitted[0].split(',').map((s) => s.trim()).filter(Boolean)
+                    : submitted;
+                const ids = rawIds.map((v) => pkIsInt ? parseInt(v) : v);
+                if (pkIsInt && ids.some((v) => !Number.isSafeInteger(v))) {
+                    throw new AdminMutationError('validation', `${edge.field}: invalid id`, edge.field);
+                }
+                // Existence + scoping en une requête, sur l'ensemble des IDs
+                // soumis. Un compte différent = au moins un ID invalide ou
+                // hors scoping — IDOR bloqué au même titre que pour les FK.
+                if (ids.length > 0) {
+                    const inFilter = { op: 'in', field: targetPk, value: ids };
+                    const scopeFilter = scopeFrom(relConfig, { locals: event.locals });
+                    const modelFilter = modelScopeFrom(runtime, targetModel, { locals: event.locals });
+                    const scopes = [scopeFilter, modelFilter].filter(Boolean);
+                    const filter = scopes.length ? { op: 'and', clauses: [inFilter, ...scopes] } : inFilter;
+                    try {
+                        const found = await runtime.adapter.data.findMany(targetModel, { filter });
+                        for (const id of [...new Map(ids.map((id) => [String(id), id])).values()]) {
+                            targetGuards.push({ targetModel, targetPk: id, filter: scopes.length ? { op: 'and', clauses: scopes } : undefined });
+                        }
+                        if (found.length !== new Set(ids.map(String)).size) {
+                            throw new AdminMutationError('validation', `${edge.field}: invalid value`, edge.field);
+                        }
+                    }
+                    catch (e) {
+                        // Déjà typée par le contrôle de cardinalité ci-dessus : la relayer
+                        // telle quelle. Toute autre cause (scope incompilable, champ
+                        // inconnu, panne pilote) devient le même refus : la valeur soumise
+                        // n'est pas acceptable, et on ne renvoie jamais au client ce que le
+                        // pilote a dit.
+                        if (e instanceof AdminMutationError)
+                            throw e;
+                        throw new AdminMutationError('validation', `${edge.field}: invalid value`, edge.field);
+                    }
+                }
+                m2mInput[edge.field] = { targetPkField: targetPk, ids };
+            }
+        }
+        // Imposition du scope, en dernier et volontairement après les boucles
+        // ci-dessus : elles réécrivent `data[scalarName]` avec la valeur soumise,
+        // et la colonne de tenant est presque toujours un scalaire de relation
+        // (`organizationId`, `authorId`…). Sans ce passage, un POST forgé créait
+        // dans un autre tenant, ou y déplaçait un enregistrement possédé.
+        //
+        // Une valeur soumise divergente est rejetée, pour toute colonne de scope et
+        // pas seulement pour les scalaires de relation : la valeur est déterminée
+        // par le serveur, donc une divergence est soit un POST forgé, soit un
+        // formulaire qui offre un choix qu'il ne devrait pas offrir. Corriger en
+        // silence masquerait les deux. Comparaison par `String` comme ailleurs pour
+        // les ids (cf. la garde self-ref), afin qu'un scope numérique et une PK
+        // 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.
+        // Un vide veut dire « le formulaire n'a rien fourni », pas « le client
+        // revendique un autre tenant » : on impose alors la valeur sans lever.
+        //
+        // L'affectation est HORS du `if` : c'est elle qui porte la garantie, pas la
+        // comparaison. Replier ceci en `if (…) { … } else { … }` — un nettoyage
+        // d'apparence anodine — réintroduirait la faille dès qu'une comparaison
+        // `String` coïncide par accident.
+        for (const [field, value] of Object.entries(scopeValues)) {
+            const submitted = data[field];
+            const asserted = field in data && submitted !== null && submitted !== undefined && submitted !== '';
+            if (asserted && String(submitted) !== String(value)) {
+                throw new AdminMutationError('authorization', `${field}: value is outside the authorization scope`, field);
+            }
+            data[field] = value;
+        }
+        if (action === 'create') {
+            let created;
+            try {
+                created = await runtime.adapter.data.createRecord(model, {
+                    scalars: data,
+                    m2m: m2mInput,
+                    targetGuards
+                });
+            }
+            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.
+                throw classifyWriteError(e, 'create') ?? e;
+            }
+            if (audit) {
+                await emitAudit(audit, buildAuditEvent({
+                    event,
+                    action: 'create',
+                    model,
+                    id: created[primaryKeyOf(model)],
+                    hidden: runtime.hiddenFieldsOf(model),
+                    values: data,
+                    m2m: m2mInput,
+                    after: created
+                }));
+            }
+        }
+        else if (route.id) {
+            const id = coerceId(route.id, model);
+            if (!(await scopedRecord(id)))
+                return null;
+            const before = audit
+                ? await readAuditSnapshot((m, recId) => runtime.adapter.data.getRecord(m, recId), model, id)
+                : null;
+            let updated;
+            try {
+                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.
+                throw classifyWriteError(e, 'update') ?? e;
+            }
+            if (audit) {
+                await emitAudit(audit, buildAuditEvent({
+                    event,
+                    action: 'update',
+                    model,
+                    id,
+                    hidden: runtime.hiddenFieldsOf(model),
+                    values: data,
+                    m2m: m2mInput,
+                    before,
+                    after: updated
+                }));
+            }
+        }
+        return redirectToList(route.model);
+    }
+    return null;
+}

package/dist/server/plugin.d.ts

@@ -0,0 +1,47 @@
+import type { Filter } from './adapters/types.js';
+import type { RelationGraph } from './introspection/relations.js';
+import type { Model } from './types/schema.js';
+export interface AdminPlugin {
+    name: string;
+    pages?: AdminPluginPage[];
+    recordActions?: AdminPluginRecordAction[];
+}
+export interface AdminPluginPage {
+    pattern: string[];
+    models?: string[];
+    render: (ctx: PluginPageContext) => PluginPageResult | Promise<PluginPageResult>;
+}
+export interface PluginPageResult {
+    html: string;
+    styles?: string;
+    scripts?: string;
+}
+export interface AdminPluginRecordAction {
+    label: string;
+    models?: string[];
+    href: (ctx: {
+        model: string;
+        id: string | number;
+        basePath: string;
+    }) => string;
+}
+export interface PluginPageContext {
+    event: any;
+    route: {
+        view: string;
+        model?: string;
+        id?: string;
+    };
+    basePath: string;
+    /** Set only when the page pattern captures `:id` (after a 404 skip). */
+    record?: Record<string, unknown>;
+    escapeHtml: (s: string) => string;
+    findModel: (name?: string) => Model | undefined;
+    relationGraph: RelationGraph | null;
+    resolveLabel: (target: Model, row: Record<string, unknown>, labelTemplate?: string) => string;
+    hiddenFieldsOf: (model: Model) => Set<string>;
+    isSensitiveFieldName: (name: string) => boolean;
+    loadRecord: (modelName: string, id: string | number) => Promise<Record<string, unknown> | null>;
+    listRecords: (modelName: string, extraFilter?: Filter) => Promise<Record<string, unknown>[]>;
+    getM2mSelectedIds: (modelName: string, fieldName: string, recordId: string | number) => Promise<Array<string | number>>;
+}

package/dist/server/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/server/pluginAccess.d.ts

@@ -0,0 +1,7 @@
+import type { PluginPageContext } from './plugin.js';
+import { type AdminRuntime } from './runtime.js';
+export declare function createPluginPageContext(runtime: AdminRuntime, event: any, route: {
+    view: string;
+    model?: string;
+    id?: string;
+}, record?: Record<string, unknown>): PluginPageContext;

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/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/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>>;