sveltekit-admin 0.6.0 → 0.8.1

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;

package/dist/server/router.js

@@ -1,27 +1,50 @@
-export function parseRoute(pathname, basePath) {
+export const BUILTIN_ROUTES = [
+    { pattern: [], view: 'dashboard' },
+    { pattern: ['_search'], view: 'search' },
+    { pattern: ['_logout'], view: 'logout' },
+    { pattern: [':model', 'new'], view: 'create' },
+    { pattern: [':model', ':id'], view: 'edit' },
+    { pattern: [':model'], view: 'list' }
+];
+function relativeSegments(pathname, basePath) {
     // Le `replace` n'est PAS redondant avec le `filter(Boolean)` plus bas : il est ce
     // qui fait que `/admin/` et `/admin///` donnent un `path` vide, donc le dashboard.
     // Sans lui, `path` vaudrait '/' — truthy — et le chemin tomberait sur `notFound`.
     const path = pathname.slice(basePath.length).replace(/^\/+|\/+$/g, '');
-    if (!path) {
-        return { view: 'dashboard' };
-    }
-    const segments = path.split('/').filter(Boolean);
-    if (segments.length === 1) {
-        if (segments[0] === '_search') {
-            return { view: 'search' };
-        }
-        if (segments[0] === '_logout') {
-            return { view: 'logout' };
-        }
-        return { view: 'list', model: segments[0] };
-    }
-    if (segments.length === 2) {
-        if (segments[1] === 'new') {
-            return { view: 'create', model: segments[0] };
+    if (!path)
+        return [];
+    return path.split('/').filter(Boolean);
+}
+export function matchRoute(pathname, basePath, routes) {
+    const segments = relativeSegments(pathname, basePath);
+    for (const route of routes) {
+        if (route.pattern.length !== segments.length)
+            continue;
+        const captured = {};
+        let ok = true;
+        for (let i = 0; i < route.pattern.length; i++) {
+            const token = route.pattern[i];
+            const seg = segments[i];
+            if (token === ':model') {
+                captured.model = seg;
+            }
+            else if (token === ':id') {
+                captured.id = seg;
+            }
+            else if (token !== seg) {
+                ok = false;
+                break;
+            }
         }
-        return { view: 'edit', model: segments[0], id: segments[1] };
+        if (ok)
+            return { view: route.view, ...captured };
     }
-    // 3 segments ou plus : aucune vue ne correspond.
     return { view: 'notFound' };
 }
+// Builtins-only helper — NOT the handler's dispatch path. `handler.ts` calls
+// `matchRoute` directly with `[...pluginRoutes, ...BUILTIN_ROUTES]` so plugin
+// patterns are considered first; this function stays around for tests and
+// any caller that only cares about the builtin route table.
+export function parseRoute(pathname, basePath) {
+    return matchRoute(pathname, basePath, BUILTIN_ROUTES);
+}

package/dist/server/runtime.d.ts

@@ -0,0 +1,46 @@
+import type { Schema, Model } from './types/schema.js';
+import { type RelationGraph } from './introspection/relations.js';
+import type { ViewModel } from './views/types.js';
+import type { DataAdapter, SchemaIntrospector, Filter } from './adapters/types.js';
+import type { AdminHandlerConfig } from './handler.js';
+export declare function scopeFrom(relConfig: {
+    where?: (ctx: any) => any;
+} | undefined, ctx: {
+    locals?: any;
+}): any;
+export declare function listScopeFrom(runtime: AdminRuntime, model: Model, ctx: {
+    locals?: any;
+}): Record<string, unknown> | undefined;
+export declare function modelScopeFrom(runtime: AdminRuntime, model: Model, ctx: {
+    locals?: any;
+}): Filter | undefined;
+/** Extract equality predicates so create can force tenant-owned columns. */
+export declare function modelScopeValues(runtime: AdminRuntime, model: Model, ctx: {
+    locals?: any;
+}): Record<string, unknown>;
+export interface AdminRuntime {
+    adapter: {
+        introspector: SchemaIntrospector;
+        data: DataAdapter;
+    };
+    schema: Schema | null;
+    relationGraph: RelationGraph | null;
+    models: Model[];
+    modelList: Array<{
+        name: string;
+        label: string;
+    }>;
+    config: AdminHandlerConfig;
+    basePath: string;
+    perPage: number;
+    selectThreshold: number;
+    filterLinkThreshold: number;
+    labelFieldCandidates: string[];
+    findModel(name?: string): Model | undefined;
+    labelOf(model: Model): string;
+    hiddenFieldsOf(model: Model): Set<string>;
+    viewModel(model: Model): ViewModel;
+    resolveLabel(target: Model, row: Record<string, unknown>, labelTemplate?: string): string;
+    resolveFilterableFields(model: Model): Set<string>;
+}
+export declare function createAdminRuntime(config: AdminHandlerConfig): AdminRuntime;

package/dist/server/runtime.js

@@ -0,0 +1,210 @@
+import { isSensitiveFieldName } from './introspection/parser.js';
+import { buildRelationGraph } from './introspection/relations.js';
+import { primaryKeyOf } from './data.js';
+import { validateListFilterConfig } from './query/filterDetection.js';
+import { isCompositeFilter, isLeafFilter, normalizeScope } from './adapters/filter.js';
+import { toLabel } from './views/html.js';
+import { AdminConfigError } from './errors.js';
+export function scopeFrom(relConfig, ctx) {
+    return relConfig?.where ? normalizeScope(relConfig.where(ctx)) : undefined;
+}
+export function listScopeFrom(runtime, model, ctx) {
+    const listScope = runtime.config.models?.[model.name]?.listWhere?.(ctx);
+    // A scope function returning `{}` (falsy-looking but truthy as
+    // an object) would otherwise silently fail OPEN — `{}` composed
+    // into an AND matches every row, exactly the opposite of what a
+    // caller configuring listWhere expects (real gap found in
+    // review: `locals.userId` undefined after a session expires is
+    // a realistic way to hit this). Fail loud instead: a scope
+    // function is either omitted entirely, or must return at least
+    // one condition every time it runs.
+    if (listScope && Object.keys(listScope).length === 0) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.listWhere returned an empty object ({}), ` +
+            `which would silently disable list scoping (fail-open). Return undefined/omit the ` +
+            `scope entirely if there is genuinely nothing to scope by for this request, or a ` +
+            `condition that actually restricts rows otherwise.`);
+    }
+    return listScope;
+}
+export function modelScopeFrom(runtime, model, ctx) {
+    const scope = runtime.config.models?.[model.name]?.scope;
+    if (!scope)
+        return undefined;
+    const raw = scope(ctx);
+    if (!raw || (typeof raw === 'object' && !Array.isArray(raw) && Object.keys(raw).length === 0)) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.scope must return a non-empty condition; ` +
+            'refusing to fail open.');
+    }
+    const normalized = normalizeScope(raw);
+    const valid = (node) => {
+        if (isLeafFilter(node))
+            return node.value !== undefined;
+        return isCompositeFilter(node) && node.clauses.length > 0 && node.clauses.every(valid);
+    };
+    if (!valid(normalized)) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.scope returned an invalid condition; refusing to fail open.`);
+    }
+    return normalized;
+}
+/** Extract equality predicates so create can force tenant-owned columns. */
+export function modelScopeValues(runtime, model, ctx) {
+    const normalized = modelScopeFrom(runtime, model, ctx);
+    if (!normalized)
+        return {};
+    const values = {};
+    const visit = (node) => {
+        if (isLeafFilter(node)) {
+            if (node.op !== 'eq')
+                return false;
+            if (node.field in values && values[node.field] !== node.value)
+                return false;
+            values[node.field] = node.value;
+            return true;
+        }
+        if (!isCompositeFilter(node) || node.op === 'or')
+            return false;
+        return node.clauses.every(visit);
+    };
+    if (!visit(normalized) || Object.keys(values).length === 0) {
+        throw new AdminConfigError(`[sveltekit-admin] models.${model.name}.scope must contain only equality conditions for creation`);
+    }
+    return values;
+}
+export function createAdminRuntime(config) {
+    const { basePath = '/admin', exclude = [], hidePivotTables = true, models: modelsConfig = {} } = config;
+    const adapter = config.adapter;
+    const introspector = adapter.introspector;
+    // Introspect the schema once at startup — same failure handling as before:
+    // a broken/missing schema source degrades to "no models known" rather than
+    // throwing out of `createAdminHandler` itself.
+    let schema = null;
+    let relationGraph = null;
+    try {
+        const introspected = introspector.introspect();
+        if (introspected instanceof Promise) {
+            throw new Error('[sveltekit-admin] SchemaIntrospector.introspect() returned a Promise — ' +
+                'createAdminHandler only supports synchronous introspection today.');
+        }
+        schema = introspected;
+        relationGraph = buildRelationGraph(schema);
+        for (const d of relationGraph.diagnostics) {
+            console.warn(`[sveltekit-admin] ${d}`);
+        }
+    }
+    catch (e) {
+        console.warn('[sveltekit-admin] Could not introspect schema:', e);
+    }
+    const models = schema?.models.filter((m) => {
+        // Exclude explicitly excluded models
+        if (exclude.includes(m.name))
+            return false;
+        // Exclude pivot tables if option is enabled
+        if (hidePivotTables && m.isPivotTable)
+            return false;
+        return true;
+    }) || [];
+    // Valider `listFilter` au démarrage : une config invalide (champ
+    // inexistant, sensible, relation, type non supporté) doit échouer fort
+    // ici plutôt que produire silencieusement un filtre mort à chaque rendu
+    // de liste (docs/design §8, même politique que le groupe ambigu de
+    // relations.ts).
+    const hiddenFieldsOf = (m) => new Set(modelsConfig[m.name]?.hidden ?? []);
+    for (const m of models) {
+        const entries = modelsConfig[m.name]?.listFilter;
+        // Non-null par construction : `models` n'existe que si le schéma
+        // a été parsé, et le graphe est construit dans la même branche de boot.
+        if (entries)
+            validateListFilterConfig(m.name, entries, m, relationGraph, hiddenFieldsOf(m));
+    }
+    const labelOf = (m) => {
+        const configured = modelsConfig[m.name]?.label;
+        if (configured)
+            return configured;
+        const label = toLabel(m.name);
+        return label.charAt(0).toUpperCase() + label.slice(1);
+    };
+    const modelList = models.map((m) => ({ name: m.name, label: labelOf(m) }));
+    const findModel = (name) => models.find((m) => m.name.toLowerCase() === name?.toLowerCase());
+    const viewModel = (m) => ({
+        name: m.name,
+        label: labelOf(m),
+        fields: m.fields,
+        primaryKey: primaryKeyOf(m),
+        // Non-null par construction : `m` vient toujours de `models`,
+        // dérivé du schéma qu'on vient de parser avec succès.
+        relationGraph: relationGraph
+    });
+    const selectThreshold = config.relationDefaults?.selectThreshold ?? 200;
+    const filterLinkThreshold = config.listFilterDefaults?.linkThreshold ?? 20;
+    const labelFieldCandidates = config.relationDefaults?.labelFields ?? [
+        'name', 'title', 'label', 'email', 'username', 'slug'
+    ];
+    /**
+     * Champs qu'un `?f.<field>=` est autorisé à cibler pour ce modèle : tout
+     * champ scalaire non-liste, non-relation, de type filtrable
+     * (String/Int/Float/Decimal/BigInt/Boolean/DateTime/enum — donc pas
+     * Json/Bytes), non sensible, et non listé dans `hidden` pour ce modèle.
+     * Sans ce dernier point, `hidden: ['internalNotes']` ne fait que masquer
+     * l'affichage : le champ reste un oracle de confirmation de valeur via
+     * `?f.internalNotes=...contains...`, exactement la faille §0.a fermée
+     * ailleurs pour les champs sensibles par nom — `hidden` et le prédicat
+     * de sensibilité sont deux sources distinctes, toutes deux doivent
+     * fermer l'oracle (docs/design §10, "deux sources, un seul prédicat
+     * partagé, sinon divergence garantie"). Défense en profondeur :
+     * `listQuery.ts` revérifie lui-même la sensibilité par nom, ce set est
+     * la première passe et la seule à connaître la config `hidden`.
+     */
+    const resolveFilterableFields = (model) => {
+        const hidden = hiddenFieldsOf(model);
+        const out = new Set();
+        for (const f of model.fields) {
+            if (f.relation || f.isList)
+                continue;
+            if (['Json', 'Bytes'].includes(f.type))
+                continue;
+            if (isSensitiveFieldName(f.name))
+                continue;
+            if (hidden.has(f.name))
+                continue;
+            out.add(f.name);
+        }
+        return out;
+    };
+    /**
+     * Résout le label BRUT (non échappé) d'une ligne : premier champ String
+     * candidat présent, sinon template `{a} {b}` si configuré, sinon la PK.
+     * Déterministe. Svelte échappe automatiquement à l'interpolation dans les
+     * composants — pas besoin d'échapper ici.
+     */
+    const resolveLabel = (targetModel, row, labelTemplate) => {
+        if (labelTemplate) {
+            return labelTemplate.replace(/\{(\w+)\}/g, (_, k) => String(row[k] ?? ''));
+        }
+        for (const candidate of labelFieldCandidates) {
+            const field = targetModel.fields.find((f) => f.name === candidate);
+            if (field && field.type === 'String' && row[candidate] != null) {
+                return String(row[candidate]);
+            }
+        }
+        return String(row[primaryKeyOf(targetModel)]);
+    };
+    return {
+        adapter,
+        schema,
+        relationGraph,
+        models,
+        modelList,
+        config,
+        basePath,
+        perPage: 20,
+        selectThreshold,
+        filterLinkThreshold,
+        labelFieldCandidates,
+        findModel,
+        labelOf,
+        hiddenFieldsOf,
+        viewModel,
+        resolveLabel,
+        resolveFilterableFields
+    };
+}

package/dist/server/search.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `_search` JSON endpoint — split out of `handler.ts`, pure orchestration
+ * over `AdminRuntime`.
+ */
+import { type AdminRuntime } from './runtime.js';
+/**
+ * Endpoint de recherche `GET {basePath}/_search?rel=Model.field&q=...&page=N`.
+ * Sert les options d'une relation to-one-owning ou m2m en JSON
+ * paginé — la voie prévue pour un futur widget autocomplete côté client
+ * quand le nombre d'options dépasse `selectThreshold`. Respecte le `where`
+ * de scoping configuré sur la relation, comme le select et la validation
+ * POST : même garantie anti-IDOR sur les trois chemins.
+ */
+export declare function handleSearch(runtime: AdminRuntime, event: any): Promise<Response>;

package/dist/server/search.js

@@ -0,0 +1,78 @@
+/**
+ * `_search` JSON endpoint — split out of `handler.ts`, pure orchestration
+ * over `AdminRuntime`.
+ */
+import { primaryKeyOf, paginate } from './data.js';
+import { scopeFrom, modelScopeFrom } from './runtime.js';
+/**
+ * Endpoint de recherche `GET {basePath}/_search?rel=Model.field&q=...&page=N`.
+ * Sert les options d'une relation to-one-owning ou m2m en JSON
+ * paginé — la voie prévue pour un futur widget autocomplete côté client
+ * quand le nombre d'options dépasse `selectThreshold`. Respecte le `where`
+ * de scoping configuré sur la relation, comme le select et la validation
+ * POST : même garantie anti-IDOR sur les trois chemins.
+ */
+export async function handleSearch(runtime, event) {
+    const modelsConfig = runtime.config.models ?? {};
+    const relParam = event.url.searchParams.get('rel') ?? '';
+    const [modelName, fieldName] = relParam.split('.');
+    const q = event.url.searchParams.get('q') ?? '';
+    const { page } = paginate(event.url.searchParams.get('page'), runtime.perPage);
+    const model = runtime.findModel(modelName);
+    const edge = model && runtime.relationGraph
+        ? runtime.relationGraph.edges.get(`${model.name}.${fieldName}`)
+        : undefined;
+    if (!model || !edge || (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m') || edge.unsupported) {
+        return new Response(JSON.stringify({ error: 'unknown relation' }), {
+            status: 404,
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+    const targetModel = runtime.schema.models.find((m) => m.name === edge.target);
+    const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
+    const configWhere = scopeFrom(relConfig, { locals: event.locals });
+    const modelWhere = modelScopeFrom(runtime, targetModel, { locals: event.locals });
+    // Recherche sur le premier champ String candidat du modèle cible — le
+    // même champ que celui utilisé pour construire le label par défaut.
+    const searchField = runtime.labelFieldCandidates.find((c) => targetModel.fields.some((f) => f.name === c && f.type === 'String'));
+    // `_search` must stay case-sensitive on every adapter/provider. A
+    // `{ op: 'contains' }` leaf would pick up the adapter-wide
+    // `caseInsensitiveSearch` flag (Prisma `mode: 'insensitive'`, Drizzle
+    // `ilike`). `containsExact` compiles to `{ contains }` / `LIKE` with
+    // no case-folding — same observable Prisma behavior as the previous
+    // opaque `{ [field]: { contains: q } }` pass-through.
+    const containsFilter = q && searchField
+        ? { op: 'containsExact', field: searchField, value: q }
+        : undefined;
+    const searchClauses = [modelWhere, configWhere, containsFilter].filter(Boolean);
+    const searchFilter = searchClauses.length > 1
+        ? { op: 'and', clauses: searchClauses }
+        : searchClauses[0];
+    try {
+        // Count + fetch are independent reads — run them in parallel (as this
+        // endpoint always has, pre-refactor) rather than doubling latency with
+        // two sequential awaits.
+        const [total, rows] = await Promise.all([
+            runtime.adapter.data.countRecords(targetModel, searchFilter),
+            runtime.adapter.data.findMany(targetModel, {
+                filter: searchFilter,
+                orderBy: relConfig?.orderBy,
+                skip: (page - 1) * runtime.perPage,
+                take: runtime.perPage
+            })
+        ]);
+        const options = rows.map((row) => ({
+            id: row[primaryKeyOf(targetModel)],
+            label: runtime.resolveLabel(targetModel, row, relConfig?.labelTemplate)
+        }));
+        return new Response(JSON.stringify({ options, total, page }), {
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+    catch {
+        return new Response(JSON.stringify({ error: 'search failed' }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' }
+        });
+    }
+}