sveltekit-admin 0.2.1 → 0.5.0

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

@@ -13,6 +13,8 @@ export interface PrismaField {
     isCreatedAt: boolean;
     hasDefault: boolean;
     defaultValue?: string;
+    /** true si `type` correspond à un `enum` déclaré dans le même schéma. */
+    isEnum?: boolean;
     relation?: {
         name?: string;
         model: string;
@@ -26,26 +28,31 @@ export interface PrismaModel {
     fields: PrismaField[];
     documentation?: string;
     primaryKey?: string;
+    isPivotTable?: boolean;
 }
 export interface PrismaSchema {
     models: PrismaModel[];
     enums: Map<string, string[]>;
+    /**
+     * Provider du bloc `datasource` (ex. "postgresql", "sqlite"), tel qu'écrit
+     * littéralement dans le schéma. `undefined` si absent ou si la valeur est
+     * une expression (`env("...")`, un provider non littéral) — dans ce cas
+     * le code appelant doit dégrader vers le comportement le plus prudent
+     * (voir `caseInsensitiveSearch` dans query/listQuery.ts).
+     */
+    provider?: string;
 }
 export declare function parsePrismaSchema(schemaPath: string): PrismaSchema;
 export declare function parseSchemaContent(content: string): PrismaSchema;
 /**
- * Get display fields for a model (fields suitable for list view)
- */
-export declare function getDisplayFields(model: PrismaModel): PrismaField[];
-/**
- * Get editable fields for a model (fields that can be edited in forms)
+ * Un champ est-il sensible par son nom ? Prédicat UNIQUE, partagé par
+ * `getDisplayFields` (liste) et par le module de recherche/filtre
+ * (`query/listQuery.ts`) — sans ce partage, les deux heuristiques
+ * divergeraient tôt ou tard et un champ masqué de la liste redeviendrait
+ * cherchable/filtrable par URL forgée.
  */
-export declare function getEditableFields(model: PrismaModel): PrismaField[];
+export declare function isSensitiveFieldName(name: string): boolean;
 /**
- * Get a human-readable label from a field name
- */
-export declare function fieldToLabel(fieldName: string): string;
-/**
- * Determine the input type for a Prisma field
+ * Get display fields for a model (fields suitable for list view)
  */
-export declare function getInputType(field: PrismaField): string;
+export declare function getDisplayFields(model: Pick<PrismaModel, 'fields'>): PrismaField[];

package/dist/server/introspection/parser.js

@@ -4,6 +4,36 @@
  */
 import { readFileSync } from 'fs';
 const SCALAR_TYPES = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'Bytes', 'Decimal', 'BigInt'];
+/**
+ * Detect if a model is a pivot/junction table for many-to-many relations.
+ * A pivot table typically:
+ * - Has a name starting with _ (Prisma implicit)
+ * - Has mostly foreign key fields (relations)
+ * - Has few or no "business" fields beyond IDs and timestamps
+ */
+function detectPivotTable(modelName, fields) {
+    // Prisma implicit many-to-many tables start with _
+    if (modelName.startsWith('_')) {
+        return true;
+    }
+    // Count different field types
+    const relationFields = fields.filter(f => f.relation);
+    const idFields = fields.filter(f => f.isId);
+    const timestampFields = fields.filter(f => f.isCreatedAt || f.isUpdatedAt);
+    const fkFields = fields.filter(f => f.name.toLowerCase().endsWith('id') &&
+        !f.isId &&
+        SCALAR_TYPES.includes(f.type));
+    // Total "structural" fields (not business data)
+    const structuralFields = idFields.length + timestampFields.length + fkFields.length + relationFields.length;
+    // If almost all fields are structural (IDs, FKs, relations, timestamps)
+    // and we have at least 2 FK/relation fields, it's likely a pivot table
+    const totalFields = fields.length;
+    const businessFields = totalFields - structuralFields;
+    // Pivot table: has 2+ relations/FKs and 0-1 business fields
+    const hasMultipleRelations = (relationFields.length + fkFields.length) >= 2;
+    const hasMinimalBusinessFields = businessFields <= 1;
+    return hasMultipleRelations && hasMinimalBusinessFields;
+}
 export function parsePrismaSchema(schemaPath) {
     const content = readFileSync(schemaPath, 'utf-8');
     return parseSchemaContent(content);
@@ -22,6 +52,12 @@ export function parseSchemaContent(content) {
             .filter(line => line && !line.startsWith('//'));
         enums.set(enumName, enumValues);
     }
+    // Parse provider du bloc datasource. On ne capture qu'une valeur littérale
+    // entre guillemets — `provider = env("DB_PROVIDER")` ou toute expression
+    // laisse `provider` à `undefined`, volontairement : le code appelant doit
+    // alors dégrader vers le comportement le plus prudent plutôt que deviner.
+    const providerMatch = content.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*"([^"]+)"/);
+    const provider = providerMatch?.[1];
     // Parse models
     const modelRegex = /(?:\/\/\/\s*(.+)\n)?model\s+(\w+)\s*\{([^}]+)\}/g;
     let modelMatch;
@@ -31,14 +67,16 @@ export function parseSchemaContent(content) {
         const modelBody = modelMatch[3];
         const fields = parseModelFields(modelBody, enums);
         const primaryKey = fields.find(f => f.isId)?.name || 'id';
+        const isPivotTable = detectPivotTable(modelName, fields);
         models.push({
             name: modelName,
             fields,
             documentation,
-            primaryKey
+            primaryKey,
+            isPivotTable
         });
     }
-    return { models, enums };
+    return { models, enums, provider };
 }
 function parseModelFields(modelBody, enums) {
     const fields = [];
@@ -85,21 +123,29 @@ function parseFieldLine(line, enums, documentation) {
         (type === 'DateTime' && /@default\s*\(\s*now\s*\(\s*\)\s*\)/.test(attributes));
     // Parse default value
     let defaultValue;
-    const defaultMatch = attributes.match(/@default\s*\(([^)]+)\)/);
+    // Le motif accepte un niveau d'imbrication : sans lui, `[^)]+` s'arrêtait à la
+    // première parenthèse fermante et tronquait tout défaut sous forme d'appel
+    // (`autoincrement()` → 'autoincrement('). Couvre autoincrement/now/cuid/uuid et
+    // dbgenerated("…") sans appel imbriqué dans la chaîne.
+    const defaultMatch = attributes.match(/@default\s*\(((?:[^()]|\([^)]*\))*)\)/);
     if (defaultMatch) {
         defaultValue = defaultMatch[1].trim();
     }
-    // Parse relation
+    // Parse relation. Le motif accepte un niveau d'imbrication pour les
+    // arguments comme `fields: [authorId]` — sans lui, `[^)]+` s'arrêtait à la
+    // première parenthèse fermante et tronquait `name: "..."` placé après.
     let relation;
-    const relationMatch = attributes.match(/@relation\s*\(([^)]*)\)/);
+    const relationMatch = attributes.match(/@relation\s*\(((?:[^()]|\([^)]*\))*)\)/);
     if (relationMatch || (!SCALAR_TYPES.includes(type) && !enums.has(type))) {
         relation = {
             model: type,
         };
         if (relationMatch) {
             const relContent = relationMatch[1];
-            // Parse relation name
-            const nameMatch = relContent.match(/name:\s*"([^"]+)"/);
+            // Parse relation name : `name: "X"` (nommé) ou `"X"` en première
+            // position (chaîne positionnelle, forme utilisée côté back-reference).
+            const nameMatch = relContent.match(/name:\s*"([^"]+)"/) ??
+                relContent.match(/^\s*"([^"]+)"/);
             if (nameMatch)
                 relation.name = nameMatch[1];
             // Parse fields
@@ -125,69 +171,33 @@ function parseFieldLine(line, enums, documentation) {
         isCreatedAt,
         hasDefault,
         defaultValue,
+        isEnum: enums.has(type),
         relation,
         documentation
     };
 }
 /**
- * Get display fields for a model (fields suitable for list view)
+ * Nom de champ considéré comme sensible : la comparaison est une inclusion en
+ * minuscules, donc 'password' couvre `hashedPassword`, 'hash' couvre
+ * `passwordHash` et 'token' couvre `apiToken`/`accessToken`/`refreshToken`.
  */
-export function getDisplayFields(model) {
-    return model.fields.filter(f => !f.relation?.fields && // Skip relation foreign keys shown separately
-        !f.isList && // Skip array fields
-        !['password', 'hashedPassword', 'hash', 'secret'].some(hidden => f.name.toLowerCase().includes(hidden)));
-}
+const SENSITIVE_FIELD_NAMES = ['password', 'hash', 'secret', 'token'];
 /**
- * Get editable fields for a model (fields that can be edited in forms)
+ * Un champ est-il sensible par son nom ? Prédicat UNIQUE, partagé par
+ * `getDisplayFields` (liste) et par le module de recherche/filtre
+ * (`query/listQuery.ts`) — sans ce partage, les deux heuristiques
+ * divergeraient tôt ou tard et un champ masqué de la liste redeviendrait
+ * cherchable/filtrable par URL forgée.
  */
-export function getEditableFields(model) {
-    return model.fields.filter(f => !f.isId &&
-        !f.isCreatedAt &&
-        !f.isUpdatedAt &&
-        !f.isList &&
-        !f.relation?.references // Skip the "other side" of relations
-    );
+export function isSensitiveFieldName(name) {
+    const lower = name.toLowerCase();
+    return SENSITIVE_FIELD_NAMES.some((hidden) => lower.includes(hidden));
 }
 /**
- * Get a human-readable label from a field name
- */
-export function fieldToLabel(fieldName) {
-    return fieldName
-        .replace(/([A-Z])/g, ' $1')
-        .replace(/^./, str => str.toUpperCase())
-        .trim();
-}
-/**
- * Determine the input type for a Prisma field
+ * Get display fields for a model (fields suitable for list view)
  */
-export function getInputType(field) {
-    if (field.relation)
-        return 'relation';
-    switch (field.type) {
-        case 'String':
-            if (field.name.toLowerCase().includes('email'))
-                return 'email';
-            if (field.name.toLowerCase().includes('password'))
-                return 'password';
-            if (field.name.toLowerCase().includes('url'))
-                return 'url';
-            if (field.name.toLowerCase().includes('description') ||
-                field.name.toLowerCase().includes('content') ||
-                field.name.toLowerCase().includes('bio'))
-                return 'textarea';
-            return 'text';
-        case 'Int':
-        case 'Float':
-        case 'Decimal':
-        case 'BigInt':
-            return 'number';
-        case 'Boolean':
-            return 'checkbox';
-        case 'DateTime':
-            return 'datetime';
-        case 'Json':
-            return 'json';
-        default:
-            return 'text';
-    }
+export function getDisplayFields(model) {
+    return model.fields.filter(f => !f.relation?.fields && // Skip relation foreign keys shown separately
+        !f.isList && // Skip array fields
+        !isSensitiveFieldName(f.name));
 }

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

@@ -0,0 +1,49 @@
+/**
+ * Relation graph builder.
+ *
+ * Passe de post-traitement sur l'AST brut du parser : apparie les champs
+ * relation par clé (modelA, modelB, relationName), classifie chaque arête,
+ * et produit les maps de lien entre scalaires FK et relations.
+ *
+ * Référence design : docs/design/relations.md §1.
+ *
+ * Règle d'or : ne JAMAIS apparier deux champs relation par « ils pointent
+ * vers le même modèle » — `Post { author User, reviewer User }` produirait
+ * un appariement aléatoire et silencieusement faux. L'appariement se fait
+ * par nom de relation, que Prisma garantit unique pour un couple de modèles.
+ */
+import type { PrismaModel, PrismaSchema } from './parser.js';
+export type RelationKind = 'to-one-owning' | 'to-one-inverse' | 'to-many-inverse' | 'm2m-implicit';
+export type UnsupportedReason = 'composite-fk' | 'ambiguous';
+export interface RelationEdge {
+    /** Modèle porteur du champ */
+    model: string;
+    /** Nom du champ relation */
+    field: string;
+    kind: RelationKind;
+    /** Modèle cible */
+    target: string;
+    /** Nom de relation (@relation("...")), chaîne vide si absent */
+    relationName: string;
+    isRequired: boolean;
+    isList: boolean;
+    /** Noms des scalaires FK portés par ce champ (vide si non owning) */
+    scalarFields: string[];
+    selfReferential: boolean;
+    /** false quand la back-reference n'existe pas dans le schéma */
+    hasBackReference: boolean;
+    unsupported?: UnsupportedReason;
+}
+export interface RelationGraph {
+    /** Arêtes indexées par "Model.field" */
+    edges: Map<string, RelationEdge>;
+    /** "authorId" → "author" (nom du champ relation owning) */
+    scalarToRelation: Map<string, string>;
+    /** "Post.author" → ["authorId"] */
+    relationToScalars: Map<string, string[]>;
+    /** Diagnostics non bloquants (groupes ambigus, etc.) */
+    diagnostics: string[];
+}
+export declare function buildRelationGraph(schema: PrismaSchema): RelationGraph;
+/** Raccourci : arêtes d'un modèle donné, dans l'ordre déclaré du schéma. */
+export declare function relationsOf(model: PrismaModel, graph: RelationGraph): RelationEdge[];

package/dist/server/introspection/relations.js

@@ -0,0 +1,128 @@
+/**
+ * Relation graph builder.
+ *
+ * Passe de post-traitement sur l'AST brut du parser : apparie les champs
+ * relation par clé (modelA, modelB, relationName), classifie chaque arête,
+ * et produit les maps de lien entre scalaires FK et relations.
+ *
+ * Référence design : docs/design/relations.md §1.
+ *
+ * Règle d'or : ne JAMAIS apparier deux champs relation par « ils pointent
+ * vers le même modèle » — `Post { author User, reviewer User }` produirait
+ * un appariement aléatoire et silencieusement faux. L'appariement se fait
+ * par nom de relation, que Prisma garantit unique pour un couple de modèles.
+ */
+const key = (model, field) => `${model}.${field}`;
+/**
+ * Clé d'appariement normalisée : les deux noms de modèle triés + le nom de
+ * relation. Triés parce que l'arête owning et l'arête inverse déclarent le
+ * même couple dans l'ordre inverse. Les relations self-referential ont
+ * naturellement (A, A, name).
+ */
+function pairKey(modelA, modelB, relationName) {
+    const [lo, hi] = [modelA, modelB].sort();
+    return `${lo}|${hi}|${relationName}`;
+}
+export function buildRelationGraph(schema) {
+    const modelNames = new Set(schema.models.map((m) => m.name));
+    const edges = new Map();
+    const scalarToRelation = new Map();
+    const relationToScalars = new Map();
+    const diagnostics = [];
+    // 1. Collecter les champs dont le type est un nom de modèle.
+    const candidates = [];
+    for (const model of schema.models) {
+        for (const field of model.fields) {
+            if (!field.relation || !modelNames.has(field.relation.model))
+                continue;
+            candidates.push({
+                model: model.name,
+                field,
+                relationName: field.relation.name ?? ''
+            });
+        }
+    }
+    // 2. Grouper par clé d'appariement.
+    const groups = new Map();
+    for (const c of candidates) {
+        const pk = pairKey(c.model, c.field.relation.model, c.relationName);
+        const group = groups.get(pk) ?? [];
+        group.push(c);
+        groups.set(pk, group);
+    }
+    // 3. Classifier chaque groupe.
+    for (const [, group] of groups) {
+        if (group.length > 2) {
+            // Schéma invalide ou bug d'appariement : ne pas deviner. On marque
+            // toutes les arêtes du groupe comme ambiguës et on passe à la suite.
+            diagnostics.push(`Ambiguous relation group (${group.map((c) => key(c.model, c.field.name)).join(', ')}) — editing disabled`);
+            for (const c of group) {
+                edges.set(key(c.model, c.field.name), makeEdge(c, {
+                    kind: 'to-one-owning',
+                    hasBackReference: true,
+                    unsupported: 'ambiguous'
+                }));
+            }
+            continue;
+        }
+        const owning = group.filter((c) => !c.field.isList && (c.field.relation.fields?.length ?? 0) > 0);
+        // N-N implicite : groupe de 2, list des deux côtés, aucun fields.
+        const [a, b] = group;
+        const isImplicitM2M = group.length === 2 && a.field.isList && b.field.isList
+            ? !a.field.relation.fields?.length && !b.field.relation.fields?.length
+            : false;
+        for (const c of group) {
+            let kind;
+            if (isImplicitM2M) {
+                kind = 'm2m-implicit';
+            }
+            else if (c.field.isList) {
+                kind = 'to-many-inverse';
+            }
+            else if (owning.includes(c)) {
+                kind = 'to-one-owning';
+            }
+            else {
+                kind = 'to-one-inverse';
+            }
+            const hasBackReference = group.length === 2;
+            const owningFields = c.field.relation.fields;
+            const edge = makeEdge(c, { kind, hasBackReference });
+            // FK composite : un <option value> ne peut pas porter un tuple.
+            if (kind === 'to-one-owning' && owningFields && owningFields.length > 1) {
+                edge.unsupported = 'composite-fk';
+                diagnostics.push(`Composite FK on ${key(c.model, c.field.name)} — editing disabled, use raw-id`);
+            }
+            edges.set(key(c.model, c.field.name), edge);
+            // 4. Lien scalaires FK ↔ relation owning.
+            if (kind === 'to-one-owning' && owningFields) {
+                relationToScalars.set(key(c.model, c.field.name), owningFields);
+                for (const s of owningFields) {
+                    scalarToRelation.set(s, c.field.name);
+                }
+            }
+        }
+    }
+    return { edges, scalarToRelation, relationToScalars, diagnostics };
+}
+function makeEdge(c, opts) {
+    return {
+        model: c.model,
+        field: c.field.name,
+        kind: opts.kind,
+        target: c.field.relation.model,
+        relationName: c.relationName,
+        isRequired: c.field.isRequired,
+        isList: c.field.isList,
+        scalarFields: c.field.relation.fields ?? [],
+        selfReferential: c.model === c.field.relation.model,
+        hasBackReference: opts.hasBackReference,
+        unsupported: opts.unsupported
+    };
+}
+/** Raccourci : arêtes d'un modèle donné, dans l'ordre déclaré du schéma. */
+export function relationsOf(model, graph) {
+    return model.fields
+        .filter((f) => graph.edges.has(`${model.name}.${f.name}`))
+        .map((f) => graph.edges.get(`${model.name}.${f.name}`));
+}

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

@@ -0,0 +1,71 @@
+/**
+ * Filter sidebar detection and configuration resolution.
+ *
+ * Design reference: docs/design/list-search-filters.md §3.5, §5.5, §6, §8.
+ *
+ * Auto-detection is intentionally narrow — Boolean and enum only — because
+ * their value domain is known STATICALLY from the schema (zero extra query
+ * to render the sidebar). DateTime, numeric ranges, and FK all require
+ * explicit `listFilter` config (DateTime presets are an editorial choice,
+ * ranges need two inputs not a fixed set, FK needs a query to load options
+ * — see §3.5, §6.2). This is a deliberate perf guard: an auto-detect
+ * heuristic that fires `groupBy`/`findMany` on every list render is a trap
+ * that can't be removed later without a breaking change.
+ */
+import type { PrismaModel } from '../introspection/parser.js';
+import type { RelationGraph } from '../introspection/relations.js';
+export declare const DATETIME_PRESETS: readonly ["today", "7d", "month", "year"];
+export type DateTimePreset = (typeof DATETIME_PRESETS)[number];
+export type ListFilterConfigEntry = string | {
+    field: string;
+    label?: string;
+    /** DateTime only: which shortcuts to offer as sidebar links (default: all four, §5.5). */
+    presets?: DateTimePreset[];
+    /** Numeric field only: render two `gte`/`lte` inputs in a GET form instead of a fixed link set. */
+    range?: boolean;
+};
+export interface ResolvedFilterField {
+    field: string;
+    label: string;
+    kind: 'boolean' | 'enum' | 'datetime' | 'range' | 'fk';
+    /** Only present for kind 'enum'. */
+    enumValues?: string[];
+    /** Only present for kind 'datetime'. */
+    presets?: DateTimePreset[];
+}
+/** A filter entry that was configured as an FK scalar (e.g. `authorId` on Post), with its target relation resolved. */
+export interface FkFilterSpec {
+    /** Scalar FK field name, e.g. `authorId`. */
+    field: string;
+    label: string;
+    /** Owning relation field name on this model, e.g. `author`. */
+    relationField: string;
+    /** Target model name, e.g. `User`. */
+    targetModel: string;
+}
+/**
+ * Validate a `listFilter` config entry against the schema at boot time.
+ * Invalid config throws immediately — a developer typo (unknown field,
+ * sensitive field, relation, Json/Bytes) should fail loud at startup, not
+ * silently produce a sidebar entry that does nothing. This is a DIFFERENT
+ * failure mode than a forged URL (§5.4 of the design doc): bad config is a
+ * developer error, a bad URL is untrusted input that must degrade quietly.
+ */
+export declare function validateListFilterConfig(modelName: string, entries: ListFilterConfigEntry[], model: PrismaModel, relationGraph?: RelationGraph, hidden?: Set<string>): void;
+/**
+ * Trouve l'arête to-one-owning qui porte ce scalaire FK sur ce modèle, si
+ * elle existe. Lookup direct sur `edges` avec la clé `"Model.field"` — on ne
+ * passe PAS par `scalarToRelation` (indexée par nom de champ seul, donc
+ * ambiguë si deux modèles ont une FK du même nom, ex: `Post.authorId` et
+ * `Comment.authorId`).
+ */
+export declare function findFkEdge(relationGraph: RelationGraph, modelName: string, scalarFieldName: string): import("../introspection/relations.js").RelationEdge | undefined;
+/**
+ * Resolve the filter sidebar entries for a model: explicit `listFilter`
+ * config wins (already validated at boot by `validateListFilterConfig`),
+ * otherwise the auto-detect heuristic (Boolean + enum fields) — unless
+ * `autoDetect` is explicitly disabled, in which case a model with no
+ * explicit `listFilter` gets no sidebar at all rather than a heuristic
+ * one it didn't ask for.
+ */
+export declare function resolveListFilters(model: PrismaModel, enums: Map<string, string[]>, configured: ListFilterConfigEntry[] | undefined, toLabel: (name: string) => string, relationGraph?: RelationGraph, hidden?: Set<string>, autoDetect?: boolean): ResolvedFilterField[];

package/dist/server/query/filterDetection.js

@@ -0,0 +1,153 @@
+/**
+ * Filter sidebar detection and configuration resolution.
+ *
+ * Design reference: docs/design/list-search-filters.md §3.5, §5.5, §6, §8.
+ *
+ * Auto-detection is intentionally narrow — Boolean and enum only — because
+ * their value domain is known STATICALLY from the schema (zero extra query
+ * to render the sidebar). DateTime, numeric ranges, and FK all require
+ * explicit `listFilter` config (DateTime presets are an editorial choice,
+ * ranges need two inputs not a fixed set, FK needs a query to load options
+ * — see §3.5, §6.2). This is a deliberate perf guard: an auto-detect
+ * heuristic that fires `groupBy`/`findMany` on every list render is a trap
+ * that can't be removed later without a breaking change.
+ */
+import { isSensitiveFieldName } from '../introspection/parser.js';
+const NUMERIC_TYPES = ['Int', 'Float', 'Decimal', 'BigInt'];
+export const DATETIME_PRESETS = ['today', '7d', 'month', 'year'];
+/** Whether a field is eligible for auto-detection: Boolean or enum, not sensitive/hidden/list/relation. */
+function isAutoDetectable(field, hidden) {
+    if (field.relation || field.isList)
+        return false;
+    if (isSensitiveFieldName(field.name))
+        return false;
+    if (hidden.has(field.name))
+        return false;
+    return field.type === 'Boolean' || Boolean(field.isEnum);
+}
+/**
+ * Validate a `listFilter` config entry against the schema at boot time.
+ * Invalid config throws immediately — a developer typo (unknown field,
+ * sensitive field, relation, Json/Bytes) should fail loud at startup, not
+ * silently produce a sidebar entry that does nothing. This is a DIFFERENT
+ * failure mode than a forged URL (§5.4 of the design doc): bad config is a
+ * developer error, a bad URL is untrusted input that must degrade quietly.
+ */
+export function validateListFilterConfig(modelName, entries, model, relationGraph, hidden = new Set()) {
+    for (const entry of entries) {
+        const fieldName = typeof entry === 'string' ? entry : entry.field;
+        const field = model.fields.find((f) => f.name === fieldName);
+        if (!field) {
+            throw new Error(`[sveltekit-admin] listFilter: model "${modelName}" has no field "${fieldName}"`);
+        }
+        if (field.relation || field.isList) {
+            throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" is a relation/list field, not filterable`);
+        }
+        if (['Json', 'Bytes'].includes(field.type)) {
+            throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" is a ${field.type} field, not filterable`);
+        }
+        if (isSensitiveFieldName(fieldName)) {
+            throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" looks sensitive by name, refusing to expose it as a filter`);
+        }
+        if (hidden.has(fieldName)) {
+            throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" is listed in \`hidden\`, refusing to expose it as a filter`);
+        }
+        const range = typeof entry !== 'string' && entry.range;
+        const presets = typeof entry !== 'string' ? entry.presets : undefined;
+        if (range && !NUMERIC_TYPES.includes(field.type)) {
+            throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" has range:true but type ${field.type} is not numeric`);
+        }
+        if (presets && field.type !== 'DateTime') {
+            throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" has presets but is not a DateTime field`);
+        }
+        if (presets) {
+            const invalid = presets.filter((p) => !DATETIME_PRESETS.includes(p));
+            if (invalid.length > 0) {
+                throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" has unknown preset(s) ${invalid.join(', ')}, ` +
+                    `expected one of ${DATETIME_PRESETS.join(', ')}`);
+            }
+        }
+        // Un scalaire FK (to-one owning) est un cas légitime de config explicite
+        // — les options seront chargées et scopées au moment du rendu, jamais
+        // auto-détectées (docs/design §3.5, §6).
+        const isFk = Boolean(relationGraph && findFkEdge(relationGraph, modelName, fieldName));
+        // Champ finalement supporté par la sidebar si : Boolean, enum, DateTime
+        // (avec ou sans presets), numérique avec range:true, ou scalaire FK.
+        // Tout le reste (String libre, Int/Float sans range, Json déjà rejeté
+        // plus haut) est refusé — pas de filtre silencieusement mort.
+        const supported = field.type === 'Boolean' ||
+            field.isEnum ||
+            field.type === 'DateTime' ||
+            (range && NUMERIC_TYPES.includes(field.type)) ||
+            isFk;
+        if (!supported) {
+            throw new Error(`[sveltekit-admin] listFilter: "${modelName}.${fieldName}" has type ${field.type}, ` +
+                `only Boolean, enum, DateTime, range:true numeric, and FK scalar fields are supported by the sidebar filter`);
+        }
+    }
+}
+/**
+ * Trouve l'arête to-one-owning qui porte ce scalaire FK sur ce modèle, si
+ * elle existe. Lookup direct sur `edges` avec la clé `"Model.field"` — on ne
+ * passe PAS par `scalarToRelation` (indexée par nom de champ seul, donc
+ * ambiguë si deux modèles ont une FK du même nom, ex: `Post.authorId` et
+ * `Comment.authorId`).
+ */
+export function findFkEdge(relationGraph, modelName, scalarFieldName) {
+    for (const edge of relationGraph.edges.values()) {
+        if (edge.model === modelName &&
+            edge.kind === 'to-one-owning' &&
+            !edge.unsupported &&
+            edge.scalarFields.length === 1 &&
+            edge.scalarFields[0] === scalarFieldName) {
+            return edge;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the filter sidebar entries for a model: explicit `listFilter`
+ * config wins (already validated at boot by `validateListFilterConfig`),
+ * otherwise the auto-detect heuristic (Boolean + enum fields) — unless
+ * `autoDetect` is explicitly disabled, in which case a model with no
+ * explicit `listFilter` gets no sidebar at all rather than a heuristic
+ * one it didn't ask for.
+ */
+export function resolveListFilters(model, enums, configured, toLabel, relationGraph, hidden = new Set(), autoDetect = true) {
+    const fieldNames = configured
+        ? configured.map((e) => (typeof e === 'string' ? e : e.field))
+        : autoDetect
+            ? model.fields.filter((f) => isAutoDetectable(f, hidden)).map((f) => f.name)
+            : [];
+    const entryOf = (fieldName) => configured?.find((e) => (typeof e === 'string' ? e : e.field) === fieldName);
+    const labelOf = (fieldName) => {
+        const entry = entryOf(fieldName);
+        return entry && typeof entry !== 'string' ? entry.label : undefined;
+    };
+    const out = [];
+    for (const fieldName of fieldNames) {
+        const field = model.fields.find((f) => f.name === fieldName);
+        if (!field)
+            continue; // Already validated at boot for explicit config; defensive no-op otherwise.
+        const entry = entryOf(fieldName);
+        const range = Boolean(entry && typeof entry !== 'string' && entry.range);
+        const label = labelOf(fieldName) ?? toLabel(fieldName);
+        if (range && NUMERIC_TYPES.includes(field.type)) {
+            out.push({ field: fieldName, label, kind: 'range' });
+        }
+        else if (field.type === 'DateTime') {
+            const presets = (entry && typeof entry !== 'string' ? entry.presets : undefined) ?? [...DATETIME_PRESETS];
+            out.push({ field: fieldName, label, kind: 'datetime', presets });
+        }
+        else if (field.type === 'Boolean') {
+            out.push({ field: fieldName, label, kind: 'boolean' });
+        }
+        else if (field.isEnum) {
+            out.push({ field: fieldName, label, kind: 'enum', enumValues: enums.get(field.type) ?? [] });
+        }
+        else if (relationGraph && findFkEdge(relationGraph, model.name, fieldName)) {
+            out.push({ field: fieldName, label, kind: 'fk' });
+        }
+    }
+    return out;
+}