sveltekit-admin 0.5.3 → 0.6.0

package/dist/server/handler.js

@@ -3,11 +3,15 @@
  * Zero files needed in routes - everything handled via hook
  */
 import { render } from 'svelte/server';
-import { parsePrismaSchema, isSensitiveFieldName } from './introspection/parser.js';
+import { isSensitiveFieldName } from './introspection/parser.js';
 import { buildRelationGraph } from './introspection/relations.js';
 import { parseRoute } from './router.js';
-import { primaryKeyOf, toPrismaModel, coerceId, formDataToPrisma, paginate, listRecords, getRecord, createRecord, updateRecord, deleteRecord } from './data.js';
+import { primaryKeyOf, coerceId, formDataToPrisma, paginate } from './data.js';
 import { parseListQuery, buildWhere, resolveSearchFields } from './query/listQuery.js';
+import { createPrismaIntrospector } from './adapters/prisma/introspector.js';
+import { createPrismaDataAdapter } from './adapters/prisma/dataAdapter.js';
+import { resolveCaseInsensitiveSearch } from './adapters/prisma/index.js';
+import { normalizeScope, OPAQUE_FILTER_ERROR } from './adapters/filter.js';
 import { resolveListFilters, validateListFilterConfig, findFkEdge } from './query/filterDetection.js';
 import { escapeHtml, toLabel } from './views/html.js';
 import NotFound from './views/NotFound.svelte';
@@ -16,23 +20,37 @@ import Dashboard from './views/Dashboard.svelte';
 import Form from './views/Form.svelte';
 import List from './views/List.svelte';
 const PER_PAGE = 20;
+function scopeFrom(relConfig, ctx) {
+    return relConfig?.where ? normalizeScope(relConfig.where(ctx)) : undefined;
+}
 // ============================================
 // Main Handler
 // ============================================
 export function createAdminHandler(config) {
     const { prisma, prismaSchemaPath = './prisma/schema.prisma', basePath = '/admin', authCheck, logout, logoutRedirectTo = '/', exclude = [], hidePivotTables = true, models: modelsConfig = {} } = config;
-    // Parse schema once at startup
+    if (!config.adapter && !prisma) {
+        throw new Error('[sveltekit-admin] createAdminHandler requires either `prisma` (with optional `prismaSchemaPath`) or `adapter` — neither was provided.');
+    }
+    const introspector = config.adapter?.introspector ?? createPrismaIntrospector({ schemaPath: prismaSchemaPath });
+    // 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 {
-        schema = parsePrismaSchema(prismaSchemaPath);
+        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 parse Prisma schema:', e);
+        console.warn('[sveltekit-admin] Could not introspect schema:', e);
     }
     const filteredModels = schema?.models.filter((m) => {
         // Exclude explicitly excluded models
@@ -56,7 +74,13 @@ export function createAdminHandler(config) {
         if (entries)
             validateListFilterConfig(m.name, entries, m, relationGraph, hiddenFieldsOf(m));
     }
-    const labelOf = (m) => modelsConfig[m.name]?.label || toLabel(m.name);
+    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 = filteredModels.map((m) => ({ name: m.name, label: labelOf(m) }));
     const findModel = (name) => filteredModels.find((m) => m.name.toLowerCase() === name?.toLowerCase());
     const viewModel = (m) => ({
@@ -82,10 +106,8 @@ export function createAdminHandler(config) {
     // lève une erreur Prisma dure. Détection auto via le provider extrait du
     // schéma ; `search.mode` permet de forcer le comportement (provider non
     // littéral dans le schéma, index citext, etc.). Voir docs/design §2.5.
-    const searchMode = config.search?.mode ?? 'auto';
-    const caseInsensitiveSearch = searchMode === 'insensitive' ||
-        (searchMode === 'auto' &&
-            ['postgresql', 'cockroachdb', 'mongodb'].includes(schema?.provider ?? ''));
+    const caseInsensitiveSearch = resolveCaseInsensitiveSearch(schema, config.search?.mode);
+    const adapter = config.adapter ?? { introspector, data: createPrismaDataAdapter(prisma, { caseInsensitiveSearch }) };
     /**
      * Champs qu'un `?f.<field>=` est autorisé à cibler pour ce modèle : tout
      * champ scalaire non-liste, non-relation, de type filtrable
@@ -136,7 +158,7 @@ export function createAdminHandler(config) {
         return String(row[primaryKeyOf(targetModel)]);
     };
     /**
-     * Charge les options pour toutes les arêtes to-one-owning et m2m-implicite
+     * 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.
      */
@@ -144,7 +166,7 @@ export function createAdminHandler(config) {
         const edges = [...relationGraph.edges.values()].filter((edge) => {
             if (edge.model !== model.name)
                 return false;
-            if (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m-implicit')
+            if (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m')
                 return false;
             if (edge.unsupported)
                 return false;
@@ -158,26 +180,22 @@ export function createAdminHandler(config) {
             const key = `${edge.model}.${edge.field}`;
             const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
             const targetModel = schema.models.find((m) => m.name === edge.target);
-            const where = relConfig?.where ? relConfig.where(ctx) : undefined;
-            const prismaKey = toPrismaModel(edge.target);
+            const filter = scopeFrom(relConfig, ctx);
             try {
-                const total = await prisma[prismaKey].count({ where });
+                const total = await adapter.data.countRecords(targetModel, filter);
                 if (total > selectThreshold || relConfig?.widget === 'raw-id') {
-                    const selectedIds = edge.kind === 'm2m-implicit' && currentId
-                        ? await loadSelectedIds(model, edge, currentId, targetModel)
+                    const selectedIds = edge.kind === 'm2m' && currentId
+                        ? await adapter.data.getM2mSelectedIds(model, edge, targetModel, currentId)
                         : undefined;
                     return [key, { tooMany: true, options: [], selectedIds }];
                 }
-                const rows = await prisma[prismaKey].findMany({
-                    where,
-                    orderBy: relConfig?.orderBy
-                });
+                const rows = await adapter.data.findMany(targetModel, { filter, orderBy: relConfig?.orderBy });
                 const options = rows.map((row) => ({
                     id: row[primaryKeyOf(targetModel)],
                     label: resolveLabel(targetModel, row, relConfig?.labelTemplate)
                 }));
-                const selectedIds = edge.kind === 'm2m-implicit' && currentId
-                    ? await loadSelectedIds(model, edge, currentId, targetModel)
+                const selectedIds = edge.kind === 'm2m' && currentId
+                    ? await adapter.data.getM2mSelectedIds(model, edge, targetModel, currentId)
                     : undefined;
                 return [key, { tooMany: false, options, selectedIds }];
             }
@@ -208,22 +226,18 @@ export function createAdminHandler(config) {
         // 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 = relConfig?.where ? relConfig.where(ctx) : undefined;
-        const prismaKey = toPrismaModel(edge.target);
+        const scope = 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 prisma[prismaKey].count({ where: scope });
+                const total = await adapter.data.countRecords(targetModel, scope);
                 if (total > selectThreshold) {
                     return { options: [], tooMany: true };
                 }
-                const rows = await prisma[prismaKey].findMany({
-                    where: scope,
-                    orderBy: relConfig?.orderBy
-                });
+                const rows = await adapter.data.findMany(targetModel, { filter: scope, orderBy: relConfig?.orderBy });
                 const options = rows.map((row) => ({
                     id: row[primaryKeyOf(targetModel)],
                     label: resolveLabel(targetModel, row, relConfig?.labelTemplate)
@@ -242,9 +256,9 @@ export function createAdminHandler(config) {
                 return undefined;
             const activeId = coerceId(activeRawValue, targetModel);
             try {
-                const row = await prisma[prismaKey].findFirst({
-                    where: scope ? { AND: [{ [primaryKeyOf(targetModel)]: activeId }, scope] } : { [primaryKeyOf(targetModel)]: activeId }
-                });
+                const idFilter = { op: 'eq', field: primaryKeyOf(targetModel), value: activeId };
+                const filter = scope ? { op: 'and', clauses: [idFilter, scope] } : idFilter;
+                const row = await adapter.data.findFirst(targetModel, filter);
                 return row ? resolveLabel(targetModel, row, relConfig?.labelTemplate) : undefined;
             }
             catch {
@@ -268,20 +282,6 @@ export function createAdminHandler(config) {
                 : undefined
         };
     };
-    /** IDs liés côté N-N implicite, via une requête sur le join field Prisma. */
-    const loadSelectedIds = async (model, edge, currentId, targetModel) => {
-        try {
-            const current = await prisma[toPrismaModel(model.name)].findUnique({
-                where: { [primaryKeyOf(model)]: coerceId(currentId, model) },
-                include: { [edge.field]: true }
-            });
-            const linked = current?.[edge.field] ?? [];
-            return linked.map((row) => row[primaryKeyOf(targetModel)]);
-        }
-        catch {
-            return [];
-        }
-    };
     /**
      * 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
@@ -298,9 +298,12 @@ export function createAdminHandler(config) {
                 return undefined;
             const scalarName = owning.scalarFields[0];
             const key = `${edge.model}.${edge.field}`;
+            const targetModel = schema.models.find((m) => m.name === edge.target);
             try {
-                const count = await prisma[toPrismaModel(edge.target)].count({
-                    where: { [scalarName]: coerceId(currentId, model) }
+                const count = await adapter.data.countRecords(targetModel, {
+                    op: 'eq',
+                    field: scalarName,
+                    value: coerceId(currentId, model)
                 });
                 return [key, count];
             }
@@ -312,7 +315,7 @@ export function createAdminHandler(config) {
     };
     /**
      * Endpoint de recherche `GET {basePath}/_search?rel=Model.field&q=...&page=N`.
-     * Sert les options d'une relation to-one-owning ou m2m-implicite en JSON
+     * 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
@@ -327,7 +330,7 @@ export function createAdminHandler(config) {
         const edge = model && relationGraph
             ? relationGraph.edges.get(`${model.name}.${fieldName}`)
             : undefined;
-        if (!model || !edge || (edge.kind !== 'to-one-owning' && edge.kind !== 'm2m-implicit') || edge.unsupported) {
+        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' }
@@ -335,23 +338,33 @@ export function createAdminHandler(config) {
         }
         const targetModel = schema.models.find((m) => m.name === edge.target);
         const relConfig = modelsConfig[model.name]?.relations?.[edge.field];
-        const configWhere = relConfig?.where ? relConfig.where({ locals: event.locals }) : {};
+        const configWhere = scopeFrom(relConfig, { 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 = labelFieldCandidates.find((c) => targetModel.fields.some((f) => f.name === c && f.type === 'String'));
-        const where = {
-            ...configWhere,
-            ...(q && searchField ? { [searchField]: { contains: q } } : {})
-        };
-        const prismaKey = toPrismaModel(edge.target);
+        // `_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 searchFilter = containsFilter && configWhere
+            ? { op: 'and', clauses: [configWhere, containsFilter] }
+            : containsFilter ?? configWhere;
         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([
-                prisma[prismaKey].count({ where }),
-                prisma[prismaKey].findMany({
-                    where,
+                adapter.data.countRecords(targetModel, searchFilter),
+                adapter.data.findMany(targetModel, {
+                    filter: searchFilter,
+                    orderBy: relConfig?.orderBy,
                     skip: (page - 1) * PER_PAGE,
-                    take: PER_PAGE,
-                    orderBy: relConfig?.orderBy
+                    take: PER_PAGE
                 })
             ]);
             const options = rows.map((row) => ({
@@ -416,11 +429,12 @@ export function createAdminHandler(config) {
                         throw new Error(`Model "${route.model}" not found`);
                     }
                     if (action === 'delete' && route.id) {
-                        await deleteRecord(prisma, model, route.id);
+                        await adapter.data.deleteRecord(model, route.id);
                         return redirectToList(route.model);
                     }
                     if (action === 'create' || action === 'update') {
                         const data = formDataToPrisma(formData, model);
+                        const m2mInput = {};
                         // 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é).
@@ -462,11 +476,10 @@ export function createAdminHandler(config) {
                                 // peut porter des conditions arbitraires (scoping multi-tenant).
                                 // Si le client ne sait pas répondre, on ne bloque pas l'écriture.
                                 try {
-                                    const where = {
-                                        [primaryKeyOf(targetModel)]: coerced,
-                                        ...(relConfig?.where ? relConfig.where({ locals: event.locals }) : {})
-                                    };
-                                    const found = await prisma[toPrismaModel(edge.target)].findFirst({ where });
+                                    const idFilter = { op: 'eq', field: primaryKeyOf(targetModel), value: coerced };
+                                    const scopeFilter = scopeFrom(relConfig, { locals: event.locals });
+                                    const filter = scopeFilter ? { op: 'and', clauses: [idFilter, scopeFilter] } : idFilter;
+                                    const found = await adapter.data.findFirst(targetModel, filter);
                                     if (!found) {
                                         throw new Error(`${edge.field}: invalid value`);
                                     }
@@ -474,6 +487,14 @@ export function createAdminHandler(config) {
                                 catch (e) {
                                     if (e?.message?.includes('invalid value'))
                                         throw e;
+                                    if (e?.message &&
+                                        (e.message.includes(OPAQUE_FILTER_ERROR) ||
+                                            OPAQUE_FILTER_ERROR.startsWith(e.message))) {
+                                        throw new Error(`${edge.field}: invalid value`);
+                                    }
+                                    if (e?.message?.includes('unknown field')) {
+                                        throw new Error(`${edge.field}: invalid value`);
+                                    }
                                     // Client incapable de vérifier (mock partiel, etc.) : on laisse passer.
                                 }
                                 data[scalarName] = coerced;
@@ -484,11 +505,11 @@ export function createAdminHandler(config) {
                             // Avec le sentinelle mais zéro valeur cochée → vider la
                             // relation (`set: []` / rien à connecter en création).
                             for (const edge of relationGraph.edges.values()) {
-                                if (edge.model !== model.name || edge.kind !== 'm2m-implicit')
+                                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-implicite (seulement sur to-one-owning / groupes
+                                // 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)
@@ -509,12 +530,11 @@ export function createAdminHandler(config) {
                                 // 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 where = {
-                                        [targetPk]: { in: ids },
-                                        ...(relConfig?.where ? relConfig.where({ locals: event.locals }) : {})
-                                    };
+                                    const inFilter = { op: 'in', field: targetPk, value: ids };
+                                    const scopeFilter = scopeFrom(relConfig, { locals: event.locals });
+                                    const filter = scopeFilter ? { op: 'and', clauses: [inFilter, scopeFilter] } : inFilter;
                                     try {
-                                        const found = await prisma[toPrismaModel(edge.target)].findMany({ where });
+                                        const found = await adapter.data.findMany(targetModel, { filter });
                                         if (found.length !== new Set(ids.map(String)).size) {
                                             throw new Error(`${edge.field}: invalid value`);
                                         }
@@ -522,19 +542,25 @@ export function createAdminHandler(config) {
                                     catch (e) {
                                         if (e?.message?.includes('invalid value'))
                                             throw e;
+                                        if (e?.message &&
+                                            (e.message.includes(OPAQUE_FILTER_ERROR) ||
+                                                OPAQUE_FILTER_ERROR.startsWith(e.message))) {
+                                            throw new Error(`${edge.field}: invalid value`);
+                                        }
+                                        if (e?.message?.includes('unknown field')) {
+                                            throw new Error(`${edge.field}: invalid value`);
+                                        }
                                         // Client incapable de vérifier : on laisse passer.
                                     }
                                 }
-                                const idRefs = ids.map((id) => ({ [targetPk]: id }));
-                                data[edge.field] =
-                                    action === 'create' ? { connect: idRefs } : { set: idRefs };
+                                m2mInput[edge.field] = { targetPkField: targetPk, ids };
                             }
                         }
                         if (action === 'create') {
-                            await createRecord(prisma, model, data);
+                            await adapter.data.createRecord(model, { scalars: data, m2m: m2mInput });
                         }
                         else if (route.id) {
-                            await updateRecord(prisma, model, route.id, data);
+                            await adapter.data.updateRecord(model, route.id, { scalars: data, m2m: m2mInput });
                         }
                         return redirectToList(route.model);
                     }
@@ -548,7 +574,7 @@ export function createAdminHandler(config) {
                 const modelsWithCounts = await Promise.all(filteredModels.map(async (m) => {
                     let count = 0;
                     try {
-                        count = await prisma[toPrismaModel(m.name)].count();
+                        count = await adapter.data.countRecords(m);
                     }
                     catch {
                         // model absent from the database
@@ -593,8 +619,8 @@ export function createAdminHandler(config) {
                             `scope entirely if there is genuinely nothing to scope by for this request, or a ` +
                             `condition that actually restricts rows otherwise.`);
                     }
-                    const where = buildWhere(listQuery, listScope, caseInsensitiveSearch, model);
-                    const { items, total } = await listRecords(prisma, model, page, PER_PAGE, where);
+                    const filter = buildWhere(listQuery, listScope, caseInsensitiveSearch, model);
+                    const { rows: items, total } = await adapter.data.listRecords(model, { filter, skip: (page - 1) * PER_PAGE, take: PER_PAGE });
                     const listFilters = resolveListFilters(model, schema.enums, modelsConfig[model.name]?.listFilter, toLabel, relationGraph, hiddenFieldsOf(model), config.listFilterDefaults?.autoDetect ?? true);
                     // Un filtre FK ne dépend pas de l'autre : résolus en parallèle
                     // plutôt qu'un par un (même raisonnement que loadRelationOptions).
@@ -650,7 +676,7 @@ export function createAdminHandler(config) {
                     // atteint ce `else` — or 'edit' est la branche à 2 segments, donc `id` y est
                     // toujours défini. La variante 'notFound' ne porte pas de `model` : elle est
                     // interceptée en amont et ne peut pas arriver ici.
-                    const item = await getRecord(prisma, model, route.id);
+                    const item = await adapter.data.getRecord(model, route.id);
                     const relationOptions = await loadRelationOptions(model, { locals: event.locals }, route.id);
                     const relatedCounts = item ? await loadRelatedCounts(model, route.id) : undefined;
                     content = item

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

@@ -2,46 +2,10 @@
  * Prisma Schema Parser
  * Extracts model information from Prisma schema files
  */
-export interface PrismaField {
-    name: string;
-    type: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isUpdatedAt: boolean;
-    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;
-        fields?: string[];
-        references?: string[];
-    };
-    documentation?: string;
-}
-export interface PrismaModel {
-    name: string;
-    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;
-}
+import type { Field, Model, Schema } from '../types/schema.js';
+export type PrismaField = Field;
+export type PrismaModel = Model;
+export type PrismaSchema = Schema;
 export declare function parsePrismaSchema(schemaPath: string): PrismaSchema;
 export declare function parseSchemaContent(content: string): PrismaSchema;
 /**

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

@@ -13,7 +13,7 @@
  * 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 RelationKind = 'to-one-owning' | 'to-one-inverse' | 'to-many-inverse' | 'm2m';
 export type UnsupportedReason = 'composite-fk' | 'ambiguous';
 export interface RelationEdge {
     /** Modèle porteur du champ */

package/dist/server/introspection/relations.js

@@ -74,7 +74,7 @@ export function buildRelationGraph(schema) {
         for (const c of group) {
             let kind;
             if (isImplicitM2M) {
-                kind = 'm2m-implicit';
+                kind = 'm2m';
             }
             else if (c.field.isList) {
                 kind = 'to-many-inverse';

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

@@ -12,6 +12,7 @@
  * string) becomes the Prisma operator key.
  */
 import type { PrismaModel } from '../introspection/parser.js';
+import type { Filter } from '../adapters/types.js';
 export type FilterOp = 'equals' | 'contains' | 'startsWith' | 'gte' | 'lte' | 'isnull';
 export interface ActiveFilter {
     field: string;
@@ -76,17 +77,10 @@ export declare function resolveDateShortcut(raw: string, now?: () => Date): Date
  * is known to be eligible.
  */
 export declare function parseListQuery(searchParams: URLSearchParams, model: PrismaModel, enums: Map<string, string[]>, searchFields: string[], filterableFields: Set<string>, now?: () => Date): ListQuery;
-/** A Prisma `where` clause built from a `ListQuery`. Opaque to callers — pass straight to Prisma. */
-export type PrismaWhere = Record<string, unknown>;
 /**
- * Compose the final Prisma `where`: `AND: [scope, ...filters, {OR: search}]`.
- * NEVER a spread — a spread of `{...scope, ...filterWhere}` lets a filter
- * on the same field as the developer's scoping silently overwrite it
- * (docs/design §0.c, the exact IDOR the previous `?filter=` had). Two
- * clauses on the same field inside `AND` intersect; they never merge.
- *
- * Returns `undefined` when nothing is active, so the query shape sent to
- * Prisma is byte-for-byte identical to today's unfiltered call — no
- * regression on existing snapshots/assertions.
+ * Compose the final generic `Filter`: `and: [scope, ...filters, {or: search}]`.
+ * NEVER a spread. Flat `{ tenantId: 1 }` scopes become `eq` leaves via
+ * `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): PrismaWhere | undefined;
+export declare function buildWhere(query: ListQuery, scope: Record<string, unknown> | undefined, caseInsensitiveSearch: boolean, model: PrismaModel): Filter | Record<string, unknown> | undefined;