sveltekit-admin 0.5.3 → 0.8.1

package/dist/server/adapters/drizzle/inspect.js

@@ -0,0 +1,220 @@
+import { createTableRelationsHelpers, extractTablesRelationalConfig, is, Many, One, Table } from 'drizzle-orm';
+import { MySqlTable } from 'drizzle-orm/mysql-core';
+import { PgTable } from 'drizzle-orm/pg-core';
+import { SQLiteTable } from 'drizzle-orm/sqlite-core';
+function inferDialect(tables) {
+    const dialects = new Set();
+    for (const table of tables) {
+        if (is(table, PgTable))
+            dialects.add('postgresql');
+        else if (is(table, MySqlTable))
+            dialects.add('mysql');
+        else if (is(table, SQLiteTable))
+            dialects.add('sqlite');
+    }
+    if (dialects.size > 1) {
+        throw new Error('[sveltekit-admin] createDrizzleAdapter: mixed table dialects in schema (pgTable / mysqlTable / sqliteTable)');
+    }
+    if (dialects.size === 0)
+        return 'sqlite';
+    return [...dialects][0];
+}
+export function mapColumnType(column, enumTypeName) {
+    const enumValues = column.enumValues;
+    if (enumValues && enumValues.length > 0) {
+        return {
+            type: (enumTypeName ?? column.columnType.replace(/^(Pg|MySql|SQLite)/, '')) || 'String',
+            isEnum: true
+        };
+    }
+    const dataType = column.dataType;
+    const columnType = column.columnType;
+    if (dataType === 'date' || /Timestamp/i.test(columnType)) {
+        return { type: 'DateTime', isEnum: false };
+    }
+    if (dataType === 'boolean')
+        return { type: 'Boolean', isEnum: false };
+    if (dataType === 'json')
+        return { type: 'Json', isEnum: false };
+    if (dataType === 'bigint')
+        return { type: 'BigInt', isEnum: false };
+    if (dataType === 'buffer')
+        return { type: 'Bytes', isEnum: false };
+    if (dataType === 'string')
+        return { type: 'String', isEnum: false };
+    if (dataType === 'number') {
+        if (/Numeric|Decimal/i.test(columnType))
+            return { type: 'Decimal', isEnum: false };
+        if (/Real|Float|Double/i.test(columnType))
+            return { type: 'Float', isEnum: false };
+        return { type: 'Int', isEnum: false };
+    }
+    return { type: 'String', isEnum: false };
+}
+function timestampFlag(jsName, type) {
+    if (type !== 'DateTime')
+        return { isCreatedAt: false, isUpdatedAt: false };
+    const normalizedName = jsName.toLowerCase().replace(/_/g, '');
+    return {
+        isCreatedAt: normalizedName === 'createdat',
+        isUpdatedAt: normalizedName === 'updatedat'
+    };
+}
+export function inspectDrizzleSchema(schemaObj, dialectOverride) {
+    const rawTables = [];
+    const tables = {};
+    for (const [key, value] of Object.entries(schemaObj)) {
+        if (is(value, Table)) {
+            rawTables.push(value);
+            tables[key] = value;
+        }
+    }
+    const inferred = inferDialect(rawTables);
+    if (dialectOverride && rawTables.length > 0 && inferred !== dialectOverride) {
+        throw new Error(`[sveltekit-admin] createDrizzleAdapter: dialect override '${dialectOverride}' does not match inferred '${inferred}'`);
+    }
+    const resolved = dialectOverride ?? inferred;
+    const { tables: relationalTables } = extractTablesRelationalConfig(schemaObj, createTableRelationsHelpers);
+    const enums = new Map();
+    const models = [];
+    const modelByName = new Map();
+    const relationsByModel = new Map();
+    for (const [tsName, config] of Object.entries(relationalTables)) {
+        const fields = [];
+        for (const [jsName, column] of Object.entries(config.columns)) {
+            const enumName = column.enum?.enumName;
+            const syntheticEnumName = enumName ?? `DrizzleEnum:${tsName.length}:${tsName}:${jsName.length}:${jsName}`;
+            const { type, isEnum } = mapColumnType(column, syntheticEnumName);
+            if (isEnum) {
+                const enumValues = column.enumValues;
+                enums.set(type, enumValues);
+            }
+            const { isCreatedAt, isUpdatedAt } = timestampFlag(jsName, type);
+            fields.push({
+                name: jsName,
+                type,
+                isRequired: Boolean(column.notNull),
+                isList: false,
+                isUnique: Boolean(column.isUnique),
+                isId: Boolean(column.primary),
+                isUpdatedAt,
+                isCreatedAt,
+                hasDefault: Boolean(column.hasDefault),
+                isEnum: isEnum || undefined
+            });
+        }
+        const model = { name: tsName, fields };
+        models.push(model);
+        modelByName.set(tsName, model);
+    }
+    for (const [tsName, config] of Object.entries(relationalTables)) {
+        const inspectedRelations = [];
+        for (const [name, relation] of Object.entries(config.relations)) {
+            const targetTsName = Object.entries(tables).find(([, table]) => table === relation.referencedTable)[0];
+            const relationFields = is(relation, One) && relation.config?.fields
+                ? relation.config.fields.map((field) => Object.entries(config.columns).find(([, column]) => column === field)[0])
+                : undefined;
+            modelByName.get(tsName).fields.push({
+                name,
+                type: targetTsName,
+                isRequired: false,
+                isList: is(relation, Many),
+                isUnique: false,
+                isId: false,
+                isUpdatedAt: false,
+                isCreatedAt: false,
+                hasDefault: false,
+                relation: {
+                    model: targetTsName,
+                    name: relation.relationName,
+                    fields: relationFields
+                }
+            });
+            inspectedRelations.push({ name, relation, targetTsName });
+        }
+        relationsByModel.set(tsName, inspectedRelations);
+    }
+    const m2m = new Map();
+    for (const [pivotTsName, pivotRelations] of relationsByModel) {
+        const owning = pivotRelations.filter(({ relation }) => is(relation, One) && Boolean(relation.config?.fields));
+        if (owning.length !== 2 || owning[0].targetTsName === owning[1].targetTsName)
+            continue;
+        const [a, b] = owning;
+        const aMany = relationsByModel
+            .get(a.targetTsName)
+            .find(({ relation, targetTsName }) => is(relation, Many) && targetTsName === pivotTsName);
+        const bMany = relationsByModel
+            .get(b.targetTsName)
+            .find(({ relation, targetTsName }) => is(relation, Many) && targetTsName === pivotTsName);
+        if (!aMany || !bMany)
+            continue;
+        const pivotModel = modelByName.get(pivotTsName);
+        const aFk = a.relation.config.fields[0];
+        const bFk = b.relation.config.fields[0];
+        const aFkJs = Object.entries(relationalTables[pivotTsName].columns).find(([, column]) => column === aFk)[0];
+        const bFkJs = Object.entries(relationalTables[pivotTsName].columns).find(([, column]) => column === bFk)[0];
+        const businessColumns = pivotModel.fields.filter((field) => !field.relation &&
+            !field.isId &&
+            field.name !== aFkJs &&
+            field.name !== bFkJs &&
+            !field.isCreatedAt &&
+            !field.isUpdatedAt);
+        if (businessColumns.length > 0)
+            continue;
+        const aModel = modelByName.get(a.targetTsName);
+        const bModel = modelByName.get(b.targetTsName);
+        if (aModel.fields.some((field) => field.name === b.targetTsName) ||
+            bModel.fields.some((field) => field.name === a.targetTsName)) {
+            continue;
+        }
+        pivotModel.isPivotTable = true;
+        aModel.fields = aModel.fields.filter((field) => field.name !== aMany.name);
+        bModel.fields = bModel.fields.filter((field) => field.name !== bMany.name);
+        aModel.fields.push({
+            name: b.targetTsName,
+            type: b.targetTsName,
+            isRequired: false,
+            isList: true,
+            isUnique: false,
+            isId: false,
+            isUpdatedAt: false,
+            isCreatedAt: false,
+            hasDefault: false,
+            relation: { model: b.targetTsName }
+        });
+        bModel.fields.push({
+            name: a.targetTsName,
+            type: a.targetTsName,
+            isRequired: false,
+            isList: true,
+            isUnique: false,
+            isId: false,
+            isUpdatedAt: false,
+            isCreatedAt: false,
+            hasDefault: false,
+            relation: { model: a.targetTsName }
+        });
+        m2m.set(`${a.targetTsName}.${b.targetTsName}`, {
+            pivot: tables[pivotTsName],
+            selfColumn: aFk,
+            otherColumn: bFk,
+            selfKey: aFkJs,
+            otherKey: bFkJs,
+            targetTsName: b.targetTsName
+        });
+        m2m.set(`${b.targetTsName}.${a.targetTsName}`, {
+            pivot: tables[pivotTsName],
+            selfColumn: bFk,
+            otherColumn: aFk,
+            selfKey: bFkJs,
+            otherKey: aFkJs,
+            targetTsName: a.targetTsName
+        });
+    }
+    return {
+        schema: { models, enums, provider: resolved },
+        tables,
+        m2m,
+        dialect: resolved
+    };
+}

package/dist/server/adapters/drizzle/introspector.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaIntrospector } from "../types.js";
+import type { Schema } from "../../types/schema.js";
+export declare function createDrizzleIntrospector(schema: Schema): SchemaIntrospector;

package/dist/server/adapters/drizzle/introspector.js

@@ -0,0 +1,3 @@
+export function createDrizzleIntrospector(schema) {
+    return { introspect: () => schema };
+}

package/dist/server/adapters/filter.d.ts

@@ -0,0 +1,12 @@
+import type { CompositeFilter, Filter, LeafFilter } from './types.js';
+export declare const OPAQUE_FILTER_ERROR = "nested Prisma `where` is not supported by the Drizzle adapter; return a Filter or a flat `{ field: scalar }` map";
+export declare const LEAF_OPS: Set<"startsWith" | "eq" | "contains" | "containsExact" | "gte" | "lte" | "lt" | "in" | "isNull" | "isNotNull">;
+export declare function isCompositeFilter(node: unknown): node is CompositeFilter;
+export declare function isLeafFilter(node: unknown): node is LeafFilter;
+/** Flat `{ field: scalar }` map — the 99% listWhere sugar. Empty `{}` is NOT flat (handler throws on listWhere `{}`; other callers keep it opaque). */
+export declare function isFlatEqMap(node: unknown): node is Record<string, string | number | boolean | bigint | Date | null>;
+/**
+ * Turns a listWhere / relations.where return value into a Filter when we can
+ * do so without guessing. Nested Prisma where objects stay opaque.
+ */
+export declare function normalizeScope(scope: Record<string, unknown> | Filter | undefined): Filter | Record<string, unknown> | undefined;

package/dist/server/adapters/filter.js

@@ -0,0 +1,72 @@
+export const OPAQUE_FILTER_ERROR = 'nested Prisma `where` is not supported by the Drizzle adapter; return a Filter or a flat `{ field: scalar }` map';
+export const LEAF_OPS = new Set([
+    'eq',
+    'contains',
+    'containsExact',
+    'startsWith',
+    'gte',
+    'lte',
+    'lt',
+    'in',
+    'isNull',
+    'isNotNull'
+]);
+export function isCompositeFilter(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'op' in node &&
+        (node.op === 'and' || node.op === 'or') &&
+        'clauses' in node &&
+        Array.isArray(node.clauses));
+}
+export function isLeafFilter(node) {
+    return (typeof node === 'object' &&
+        node !== null &&
+        'op' in node &&
+        typeof node.op === 'string' &&
+        LEAF_OPS.has(node.op) &&
+        'field' in node &&
+        typeof node.field === 'string');
+}
+function isScalar(value) {
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        typeof value === 'bigint' ||
+        value instanceof Date);
+}
+/** Flat `{ field: scalar }` map — the 99% listWhere sugar. Empty `{}` is NOT flat (handler throws on listWhere `{}`; other callers keep it opaque). */
+export function isFlatEqMap(node) {
+    if (typeof node !== 'object' || node === null || Array.isArray(node))
+        return false;
+    if (isLeafFilter(node) || isCompositeFilter(node))
+        return false;
+    const values = Object.values(node);
+    if (values.length === 0)
+        return false;
+    return values.every(isScalar);
+}
+function flatEqMapToFilter(map) {
+    const clauses = Object.entries(map).map(([field, value]) => ({
+        op: 'eq',
+        field,
+        value
+    }));
+    if (clauses.length === 1)
+        return clauses[0];
+    return { op: 'and', clauses };
+}
+/**
+ * Turns a listWhere / relations.where return value into a Filter when we can
+ * do so without guessing. Nested Prisma where objects stay opaque.
+ */
+export function normalizeScope(scope) {
+    if (scope === undefined)
+        return undefined;
+    if (isLeafFilter(scope) || isCompositeFilter(scope))
+        return scope;
+    if (isFlatEqMap(scope))
+        return flatEqMapToFilter(scope);
+    return scope;
+}

package/dist/server/adapters/prisma/dataAdapter.d.ts

@@ -0,0 +1,13 @@
+import type { DataAdapter } from '../types.js';
+/**
+ * Prisma implementation of `DataAdapter`. `caseInsensitiveSearch` is fixed
+ * at construction time (Task 5's boot block resolves it from the schema's
+ * `provider`/`config.search.mode` before building this adapter) — it's the
+ * same value `buildWhere`'s caller in `handler.ts` used to pass directly to
+ * `buildWhere`, just applied one layer later, at compile-to-Prisma-where
+ * time instead of at Filter-construction time. It only affects `contains`
+ * leaves; every other leaf/composite op ignores it.
+ */
+export declare function createPrismaDataAdapter(prisma: any, opts?: {
+    caseInsensitiveSearch?: boolean;
+}): DataAdapter;

package/dist/server/adapters/prisma/dataAdapter.js

@@ -0,0 +1,138 @@
+import { toPrismaModel, primaryKeyOf, coerceId } from '../../data.js';
+import { compileFilterToPrismaWhere } from './filterCompiler.js';
+import { withWriteRetry } from '../retry.js';
+/**
+ * Revalidation des cibles de relation à l'intérieur de la transaction d'écriture.
+ *
+ * Fenêtre résiduelle, assumée : cette lecture ne pose aucun verrou de ligne.
+ * Sur PostgreSQL, `Serializable` ne l'empêche PAS — mesuré sur PG 16 : SSI ne
+ * voit aucun cycle de dépendances dans « lire le guard -> un tiers sort la
+ * cible du scope -> écrire », donc les deux transactions committent. L'adapter
+ * Drizzle ferme cette fenêtre avec un `FOR SHARE` ; Prisma n'expose aucune API
+ * de verrou, et l'émettre demanderait du `$queryRaw` par dialecte, donc les
+ * noms physiques de tables et colonnes (les `@@map`/`@map` ne sont pas parsés)
+ * et un second compilateur de filtres à garder en phase avec
+ * `compileFilterToPrismaWhere` — exactement le duplicata divergent que ce
+ * codebase a déjà payé une fois.
+ *
+ * L'exposition reste bornée : `mutations.ts` a déjà revalidé chaque FK et m2m
+ * par un `findFirst` scopé avant d'appeler l'adapter, et gagner cette course
+ * ne produit qu'une référence orpheline inter-tenant — aucune lecture des
+ * données de l'autre tenant, le scoping des dropdowns et la « chip » anti-oracle
+ * tenant par ailleurs. C'est un défaut d'intégrité, pas une divulgation.
+ */
+async function validateTargetGuards(tx, guards, compile) {
+    for (const guard of guards) {
+        const key = toPrismaModel(guard.targetModel.name);
+        const pk = primaryKeyOf(guard.targetModel);
+        const where = guard.filter
+            ? { [pk]: guard.targetPk, AND: [compile(guard.filter)] }
+            : { [pk]: guard.targetPk };
+        if (!(await tx[key].findFirst({ where }))) {
+            throw new Error('relation target is outside the authorization scope');
+        }
+    }
+}
+/**
+ * Prisma implementation of `DataAdapter`. `caseInsensitiveSearch` is fixed
+ * at construction time (Task 5's boot block resolves it from the schema's
+ * `provider`/`config.search.mode` before building this adapter) — it's the
+ * same value `buildWhere`'s caller in `handler.ts` used to pass directly to
+ * `buildWhere`, just applied one layer later, at compile-to-Prisma-where
+ * time instead of at Filter-construction time. It only affects `contains`
+ * leaves; every other leaf/composite op ignores it.
+ */
+export function createPrismaDataAdapter(prisma, opts = {}) {
+    const compileHere = (filter) => compileFilterToPrismaWhere(filter, opts.caseInsensitiveSearch ?? false);
+    return {
+        async listRecords(model, listOpts) {
+            const key = toPrismaModel(model.name);
+            const primaryKey = primaryKeyOf(model);
+            const where = compileHere(listOpts.filter);
+            const [rows, total] = await Promise.all([
+                prisma[key].findMany({ where, skip: listOpts.skip, take: listOpts.take, orderBy: { [primaryKey]: 'desc' } }),
+                prisma[key].count({ where })
+            ]);
+            return { rows, total };
+        },
+        findMany(model, findOpts) {
+            const key = toPrismaModel(model.name);
+            const where = compileHere(findOpts.filter);
+            return prisma[key].findMany({ where, orderBy: findOpts.orderBy, skip: findOpts.skip, take: findOpts.take });
+        },
+        getRecord(model, id) {
+            const primaryKey = primaryKeyOf(model);
+            return prisma[toPrismaModel(model.name)].findUnique({
+                where: { [primaryKey]: coerceId(String(id), model) }
+            });
+        },
+        findFirst(model, filter) {
+            const key = toPrismaModel(model.name);
+            return prisma[key].findFirst({ where: compileHere(filter) });
+        },
+        countRecords(model, filter) {
+            const key = toPrismaModel(model.name);
+            return prisma[key].count({ where: compileHere(filter) });
+        },
+        async createRecord(model, input) {
+            const key = toPrismaModel(model.name);
+            const m2mFields = Object.keys(input.m2m ?? {});
+            const guards = input.targetGuards ?? [];
+            if (m2mFields.length === 0 && guards.length === 0) {
+                return prisma[key].create({ data: input.scalars });
+            }
+            return withWriteRetry(() => prisma.$transaction(async (tx) => {
+                await validateTargetGuards(tx, guards, compileHere);
+                const data = { ...input.scalars };
+                for (const field of m2mFields) {
+                    const { targetPkField, ids } = input.m2m[field];
+                    data[field] = { connect: ids.map((id) => ({ [targetPkField]: id })) };
+                }
+                return tx[key].create({ data });
+            }, { isolationLevel: "Serializable" }));
+        },
+        async updateRecord(model, id, input, authorizationFilter) {
+            const key = toPrismaModel(model.name);
+            const primaryKey = primaryKeyOf(model);
+            const where = authorizationFilter
+                ? { [primaryKey]: coerceId(String(id), model), AND: [compileHere(authorizationFilter)] }
+                : { [primaryKey]: coerceId(String(id), model) };
+            const m2mFields = Object.keys(input.m2m ?? {});
+            const guards = input.targetGuards ?? [];
+            if (m2mFields.length === 0 && guards.length === 0) {
+                return prisma[key].update({ where, data: input.scalars });
+            }
+            return withWriteRetry(() => prisma.$transaction(async (tx) => {
+                await validateTargetGuards(tx, guards, compileHere);
+                const data = { ...input.scalars };
+                for (const field of m2mFields) {
+                    const { targetPkField, ids } = input.m2m[field];
+                    data[field] = { set: ids.map((id) => ({ [targetPkField]: id })) };
+                }
+                return tx[key].update({ where, data });
+            }, { isolationLevel: "Serializable" }));
+        },
+        async deleteRecord(model, id, authorizationFilter) {
+            const primaryKey = primaryKeyOf(model);
+            const where = authorizationFilter
+                ? { [primaryKey]: coerceId(String(id), model), AND: [compileHere(authorizationFilter)] }
+                : { [primaryKey]: coerceId(String(id), model) };
+            await prisma[toPrismaModel(model.name)].delete({ where });
+        },
+        async getM2mSelectedIds(model, edge, targetModel, recordId) {
+            try {
+                const primaryKey = primaryKeyOf(model);
+                const current = await prisma[toPrismaModel(model.name)].findUnique({
+                    where: { [primaryKey]: coerceId(String(recordId), model) },
+                    include: { [edge.field]: true }
+                });
+                const linked = current?.[edge.field] ?? [];
+                const targetPk = primaryKeyOf(targetModel);
+                return linked.map((row) => row[targetPk]);
+            }
+            catch {
+                return [];
+            }
+        }
+    };
+}

package/dist/server/adapters/prisma/filterCompiler.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compiles the generic `Filter` AST (see ../types.ts) into a Prisma `where`
+ * object. This is the ONLY place in the Prisma adapter that knows Prisma's
+ * where-clause vocabulary (`AND`/`OR`/`contains`/`startsWith`/`gte`/`lte`/
+ * `equals`/`not`/`in`/`mode: 'insensitive'`).
+ */
+import type { Filter } from '../types.js';
+export type PrismaWhere = Record<string, unknown>;
+export declare function compileFilterToPrismaWhere(filter: Filter | PrismaWhere | undefined, caseInsensitiveSearch: boolean): PrismaWhere | undefined;

package/dist/server/adapters/prisma/filterCompiler.js

@@ -0,0 +1,42 @@
+import { isCompositeFilter, isLeafFilter } from '../filter.js';
+function compileLeaf(filter, caseInsensitiveSearch) {
+    switch (filter.op) {
+        case 'eq':
+            return { [filter.field]: filter.value };
+        case 'contains':
+            return caseInsensitiveSearch
+                ? { [filter.field]: { contains: filter.value, mode: 'insensitive' } }
+                : { [filter.field]: { contains: filter.value } };
+        case 'containsExact':
+            return { [filter.field]: { contains: filter.value } };
+        case 'startsWith':
+            return { [filter.field]: { startsWith: filter.value } };
+        case 'gte':
+            return { [filter.field]: { gte: filter.value } };
+        case 'lte':
+            return { [filter.field]: { lte: filter.value } };
+        case 'lt':
+            return { [filter.field]: { lt: filter.value } };
+        case 'in':
+            return { [filter.field]: { in: filter.value } };
+        case 'isNull':
+            return { [filter.field]: { equals: null } };
+        case 'isNotNull':
+            return { [filter.field]: { not: null } };
+    }
+}
+function compile(node, caseInsensitiveSearch) {
+    if (isCompositeFilter(node)) {
+        const clauses = node.clauses.map((c) => compile(c, caseInsensitiveSearch));
+        return node.op === 'and' ? { AND: clauses } : { OR: clauses };
+    }
+    if (isLeafFilter(node)) {
+        return compileLeaf(node, caseInsensitiveSearch);
+    }
+    return node;
+}
+export function compileFilterToPrismaWhere(filter, caseInsensitiveSearch) {
+    if (filter === undefined)
+        return undefined;
+    return compile(filter, caseInsensitiveSearch);
+}

package/dist/server/adapters/prisma/handler.d.ts

@@ -0,0 +1,14 @@
+import { type AdminHandlerConfig as CoreAdminHandlerConfig } from '../../handler.js';
+export interface AdminHandlerConfig extends Omit<CoreAdminHandlerConfig, 'adapter' | 'prisma' | 'prismaSchemaPath' | 'search'> {
+    prisma?: any;
+    prismaSchemaPath?: string;
+    adapter?: CoreAdminHandlerConfig['adapter'];
+    search?: {
+        mode?: 'auto' | 'insensitive' | 'default';
+    };
+}
+export declare function createAdminHandler(config: AdminHandlerConfig): ({ event, resolve }: {
+    event: any;
+    resolve: (event: any) => Response | Promise<Response>;
+}) => Promise<Response>;
+export type { AdminPlugin, AdminPluginPage, AdminPluginRecordAction, PluginPageContext, PluginPageResult } from '../../plugin.js';

package/dist/server/adapters/prisma/handler.js

@@ -0,0 +1,37 @@
+import { createAdminHandler as createCoreHandler } from '../../handler.js';
+import { createPrismaDataAdapter } from './dataAdapter.js';
+import { createPrismaIntrospector } from './introspector.js';
+import { resolveCaseInsensitiveSearch } from './index.js';
+function omitPrismaShortcutFields(config) {
+    const { prisma: _prisma, prismaSchemaPath: _path, search: _search, adapter: _adapter, ...rest } = config;
+    return rest;
+}
+function buildPrismaAdapter(config) {
+    const schemaPath = config.prismaSchemaPath ?? './prisma/schema.prisma';
+    const introspector = createPrismaIntrospector({ schemaPath });
+    let schema = null;
+    try {
+        schema = introspector.introspect();
+    }
+    catch {
+        schema = null;
+    }
+    return {
+        introspector: schema ? { introspect: () => schema } : introspector,
+        data: createPrismaDataAdapter(config.prisma, {
+            caseInsensitiveSearch: resolveCaseInsensitiveSearch(schema, config.search?.mode)
+        })
+    };
+}
+export function createAdminHandler(config) {
+    if (config.adapter) {
+        return createCoreHandler({ ...omitPrismaShortcutFields(config), adapter: config.adapter });
+    }
+    if (!config.prisma) {
+        throw new Error('[sveltekit-admin] createAdminHandler requires either `prisma` (with optional `prismaSchemaPath`) or `adapter` — neither was provided.');
+    }
+    return createCoreHandler({
+        ...omitPrismaShortcutFields(config),
+        adapter: buildPrismaAdapter(config)
+    });
+}

package/dist/server/adapters/prisma/index.d.ts

@@ -0,0 +1,28 @@
+import type { SchemaIntrospector, DataAdapter } from '../types.js';
+import type { Schema } from '../../types/schema.js';
+export { compileFilterToPrismaWhere } from './filterCompiler.js';
+/**
+ * `mode: 'insensitive'` is only valid Prisma-side on postgresql/cockroachdb/
+ * mongodb — emitting it on sqlite/mysql/sqlserver is a hard Prisma error.
+ * `schema` is `null` when introspection failed (the caller degraded
+ * gracefully instead of throwing) — in that case `'auto'` can never detect a
+ * supported provider, so it resolves to `false`, same as today.
+ */
+export declare function resolveCaseInsensitiveSearch(schema: Schema | null, searchMode?: 'auto' | 'insensitive' | 'default'): boolean;
+/**
+ * Builds a ready-to-use Prisma adapter. Introspects eagerly (throws
+ * immediately on a bad `schemaPath`) — this is the explicit-construction
+ * path (`createAdminHandler({ adapter: createPrismaAdapter(...) })`), where
+ * failing loud on a caller's own mistake is correct. `createAdminHandler`'s
+ * OWN legacy `{ prisma, prismaSchemaPath }` path does NOT call this function
+ * — it builds the introspector/data pair itself so it can keep degrading
+ * gracefully to "no models known" on a bad path, exactly as it always has.
+ */
+export declare function createPrismaAdapter(opts: {
+    prisma: any;
+    schemaPath: string;
+    searchMode?: 'auto' | 'insensitive' | 'default';
+}): {
+    introspector: SchemaIntrospector;
+    data: DataAdapter;
+};

package/dist/server/adapters/prisma/index.js

@@ -0,0 +1,32 @@
+import { createPrismaIntrospector } from './introspector.js';
+import { createPrismaDataAdapter } from './dataAdapter.js';
+export { compileFilterToPrismaWhere } from './filterCompiler.js';
+/**
+ * `mode: 'insensitive'` is only valid Prisma-side on postgresql/cockroachdb/
+ * mongodb — emitting it on sqlite/mysql/sqlserver is a hard Prisma error.
+ * `schema` is `null` when introspection failed (the caller degraded
+ * gracefully instead of throwing) — in that case `'auto'` can never detect a
+ * supported provider, so it resolves to `false`, same as today.
+ */
+export function resolveCaseInsensitiveSearch(schema, searchMode = 'auto') {
+    return (searchMode === 'insensitive' ||
+        (searchMode === 'auto' && ['postgresql', 'cockroachdb', 'mongodb'].includes(schema?.provider ?? '')));
+}
+/**
+ * Builds a ready-to-use Prisma adapter. Introspects eagerly (throws
+ * immediately on a bad `schemaPath`) — this is the explicit-construction
+ * path (`createAdminHandler({ adapter: createPrismaAdapter(...) })`), where
+ * failing loud on a caller's own mistake is correct. `createAdminHandler`'s
+ * OWN legacy `{ prisma, prismaSchemaPath }` path does NOT call this function
+ * — it builds the introspector/data pair itself so it can keep degrading
+ * gracefully to "no models known" on a bad path, exactly as it always has.
+ */
+export function createPrismaAdapter(opts) {
+    const introspector = createPrismaIntrospector({ schemaPath: opts.schemaPath });
+    const schema = introspector.introspect();
+    const caseInsensitiveSearch = resolveCaseInsensitiveSearch(schema, opts.searchMode);
+    return {
+        introspector: { introspect: () => schema }, // memoized: introspect() already ran once above
+        data: createPrismaDataAdapter(opts.prisma, { caseInsensitiveSearch })
+    };
+}

package/dist/server/adapters/prisma/introspector.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaIntrospector } from '../types.js';
+export declare function createPrismaIntrospector(opts: {
+    schemaPath: string;
+}): SchemaIntrospector;

package/dist/server/adapters/prisma/introspector.js

@@ -0,0 +1,9 @@
+/** Wraps the existing regex-based `.prisma` file parser behind `SchemaIntrospector`. */
+import { parsePrismaSchema } from '../../introspection/parser.js';
+export function createPrismaIntrospector(opts) {
+    return {
+        introspect() {
+            return parsePrismaSchema(opts.schemaPath);
+        }
+    };
+}