sveltekit-admin 0.5.3 → 0.8.1

package/README.md

@@ -5,7 +5,8 @@
 ![Version](https://img.shields.io/npm/v/sveltekit-admin)
 ![License](https://img.shields.io/npm/l/sveltekit-admin)
 
-See [CHANGELOG.md](./CHANGELOG.md) for release notes and breaking changes.
+See [CHANGELOG.md](./CHANGELOG.md) for release notes and breaking changes, and
+[CONTRIBUTING.md](./CONTRIBUTING.md) for the versioning policy and release process.
 
 ## Features
 
@@ -15,6 +16,9 @@ See [CHANGELOG.md](./CHANGELOG.md) for release notes and breaking changes.
 - ⚡ **Zero routes** - everything handled via a single hook
 - 🪶 **3 lines of code** to setup
 - 🔧 **Customizable** - hide fields, set readonly, custom labels
+- 📋 **Audit log** - optional callback after every successful write
+- 🧩 **Plugins** - optional extra pages and record actions (`plugins: []`)
+- 🔌 **Drizzle adapter** (optional subpath export)
 
 ## Installation
 
@@ -42,6 +46,39 @@ That's it! Navigate to `/admin` and you'll see:
 - Create/Edit forms auto-generated from your Prisma schema
 - Delete with confirmation
 
+## Drizzle
+
+Prisma stays the default on the root entry (`createAdminHandler({ prisma })`).
+For Drizzle, import **both** the handler and the adapter from the subpath
+so a Drizzle-only app never evaluates the Prisma adapter modules:
+
+```typescript
+import { createAdminHandler, createDrizzleAdapter } from 'sveltekit-admin/adapters/drizzle';
+import { db } from './db';
+import * as schema from './db/schema';
+
+export const handle = createAdminHandler({
+  adapter: createDrizzleAdapter({ db, schema }),
+  authCheck: (event) => event.locals.session?.user?.role === 'admin'
+});
+```
+
+Importing `createAdminHandler` from `sveltekit-admin` and the adapter from
+the subpath still works, but it loads the Prisma adapter JavaScript (it does
+not require installing `@prisma/client`).
+
+Pass the same `schema` object you already export (tables + `relations()`).
+Model names in `config.models` are the JS export keys (`users`, not `User`).
+`config.search.mode` only applies to `createAdminHandler({ prisma })`;
+pass `searchMode` to `createDrizzleAdapter` instead. Nested Prisma `where`
+objects in `listWhere` are not supported — use a flat `{ tenantId: 1 }` or
+a `Filter` AST.
+
+Many-to-many writes on SQLite currently require better-sqlite3's synchronous
+`db.transaction` with `.get()` and `.run()`. Async SQLite drivers such as
+libsql/Turso, D1, and `bun:sqlite` are not supported for many-to-many writes in
+this version; PostgreSQL and MySQL use async transactions.
+
 ## Configuration
 
 ```typescript
@@ -132,6 +169,37 @@ prefetch would allow), and this route is checked *before* `authCheck`, so
 a user whose session already expired can still use it to clean up
 client-side state instead of being stuck behind a 401 with no way back.
 
+### Audit log
+
+Same philosophy as `authCheck` / `logout`: the library has no log table of
+its own. Provide an `audit` callback and it is called after every
+**successful** create, update, or delete with a redacted `AuditEvent`.
+The actor is whatever you already put on `event.locals`. Sensitive and
+`hidden` fields are stripped. If the callback throws, the mutation still
+redirects.
+
+```typescript
+const adminHandle = createAdminHandler({
+  prisma,
+  authCheck: (event) => event.locals.session?.user?.role === 'admin',
+  audit: async (entry) => {
+    await prisma.auditLog.create({
+      data: {
+        at: entry.at,
+        actorId: entry.event.locals.session?.user?.id,
+        action: entry.action,
+        model: entry.model,
+        recordId: String(entry.id),
+        changes: entry.action === 'update' ? entry.changes : undefined
+      }
+    });
+  }
+});
+```
+
+No callback means no behaviour change. Persist to your own model if you
+want the log to appear in the admin like any other table.
+
 ## How It Works
 
 The admin handler intercepts all requests to `/admin/*` and:
@@ -146,6 +214,26 @@ Routes handled:
 - `/admin/user/new` → Create user form
 - `/admin/user/123` → Edit user form
 
+## Plugins
+
+Pass `plugins` to register extra admin pages (SSR HTML + inline CSS/JS)
+and links on edit screens and list rows. See the exported `AdminPlugin`
+type and the documentation site's Plugins page.
+
+```typescript
+createAdminHandler({
+  prisma,
+  plugins: [
+    {
+      name: 'hello',
+      pages: [{ pattern: ['hello'], render: () => ({ html: '<p>Hello</p>' }) }]
+    }
+  ]
+});
+```
+
+Omit `plugins` and the admin is unchanged.
+
 ## Model Configuration
 
 ```typescript

package/dist/index.d.ts

@@ -2,6 +2,11 @@
  * SvelteKit Admin
  * Django-like admin panel for SvelteKit + Prisma
  */
-export { createAdminHandler, type AdminHandlerConfig } from './server/handler.js';
+export { createAdminHandler, type AdminHandlerConfig } from './server/adapters/prisma/handler.js';
 export { defaultAdminCheck } from './server/auth.js';
+export type { AuditAction, AuditEvent } from './server/audit.js';
 export { parsePrismaSchema, parseSchemaContent, type PrismaSchema, type PrismaModel, type PrismaField } from './server/introspection/parser.js';
+export type { Schema, Model, Field } from './server/types/schema.js';
+export { createPrismaAdapter } from './server/adapters/prisma/index.js';
+export type { DataAdapter, SchemaIntrospector, Filter } from './server/adapters/types.js';
+export type { AdminPlugin, AdminPluginPage, AdminPluginRecordAction, PluginPageContext, PluginPageResult } from './server/plugin.js';

package/dist/index.js

@@ -2,6 +2,7 @@
  * SvelteKit Admin
  * Django-like admin panel for SvelteKit + Prisma
  */
-export { createAdminHandler } from './server/handler.js';
+export { createAdminHandler } from './server/adapters/prisma/handler.js';
 export { defaultAdminCheck } from './server/auth.js';
 export { parsePrismaSchema, parseSchemaContent } from './server/introspection/parser.js';
+export { createPrismaAdapter } from './server/adapters/prisma/index.js';

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

@@ -0,0 +1,11 @@
+import type { Table } from "drizzle-orm";
+import type { DataAdapter } from "../types.js";
+import type { DrizzleDialect, M2mLink } from "./inspect.js";
+interface DrizzleDataAdapterContext {
+    tables: Record<string, Table>;
+    m2m: Map<string, M2mLink>;
+    dialect: DrizzleDialect;
+    caseInsensitiveSearch: boolean;
+}
+export declare function createDrizzleDataAdapter(db: any, ctx: DrizzleDataAdapterContext): DataAdapter;
+export {};

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

@@ -0,0 +1,328 @@
+import { and, asc, count, desc, eq, getTableColumns } from "drizzle-orm";
+import { coerceId, primaryKeyOf } from "../../data.js";
+import { withWriteRetry } from "../retry.js";
+import { compileFilterToDrizzle } from "./filterCompiler.js";
+function tableFor(ctx, model) {
+    const table = ctx.tables[model.name];
+    if (!table) {
+        throw new Error(`[sveltekit-admin] missing Drizzle table '${model.name}'`);
+    }
+    return table;
+}
+function primaryKeyColumn(table, model) {
+    return getTableColumns(table)[primaryKeyOf(model)];
+}
+/**
+ * Ordre de verrouillage déterministe. Les guards m2m sont empilés dans l'ordre
+ * des ids soumis par le formulaire, donc sous contrôle du client : deux
+ * requêtes concurrentes envoyant [1,2] et [2,1] verrouilleraient les mêmes
+ * lignes en sens inverse et se deadlockeraient (PostgreSQL 40P01), ce qui est
+ * bien plus facile à déclencher que la course qu'on cherche à empêcher.
+ * Trier sur (modèle, pk) donne un ordre total stable et supprime le cycle.
+ */
+function orderedGuards(guards) {
+    return [...guards].sort((a, b) => a.targetModel.name.localeCompare(b.targetModel.name) ||
+        String(a.targetPk).localeCompare(String(b.targetPk)));
+}
+async function validateTargetGuards(ctx, tx, guards, compile) {
+    for (const guard of orderedGuards(guards)) {
+        const table = tableFor(ctx, guard.targetModel);
+        const where = and(eq(primaryKeyColumn(table, guard.targetModel), guard.targetPk), compile(table, guard.filter));
+        const query = tx.select().from(table).where(where).limit(1);
+        // Verrou partagé tenu jusqu'au commit, PostgreSQL uniquement.
+        //
+        // Mesuré (PG 16, les 4 combinaisons) : SERIALIZABLE seul n'annule PAS la
+        // séquence « lire le guard -> un tiers sort la cible du scope -> écrire ».
+        // SSI n'y voit aucun cycle de dépendances, donc cet ordre reste
+        // sérialisable et les deux transactions committent. Seul le verrou de
+        // ligne ferme la fenêtre. Ne pas le retirer en pensant que le niveau
+        // d'isolation suffit : c'est faux, et ça a été vérifié.
+        //
+        // MySQL est exclu volontairement : SERIALIZABLE y transforme déjà les
+        // SELECT en lectures verrouillantes (mesuré : le writer concurrent est
+        // bloqué), donc le verrou n'apporterait rien — et `for share` est une
+        // syntaxe 8.0+, l'émettre casserait les schémas encore en 5.7.
+        const rows = await (ctx.dialect === "postgresql" ? query.for("share") : query);
+        if (rows.length === 0)
+            throw new Error("relation target is outside the authorization scope");
+    }
+}
+function validateTargetGuardsSqlite(ctx, tx, guards, compile) {
+    // Pas de clause de verrou en SQLite (absente de sqlite-core, et inutile :
+    // l'écriture concurrente échoue fermée, cf. le commentaire ci-dessus).
+    for (const guard of orderedGuards(guards)) {
+        const table = tableFor(ctx, guard.targetModel);
+        const where = and(eq(primaryKeyColumn(table, guard.targetModel), guard.targetPk), compile(table, guard.filter));
+        const row = tx.select().from(table).where(where).limit(1).get();
+        if (!row)
+            throw new Error("relation target is outside the authorization scope");
+    }
+}
+async function selectByPrimaryKey(db, table, model, id, authorizationFilter) {
+    const primaryKeyWhere = eq(primaryKeyColumn(table, model), coerceId(String(id), model));
+    const rows = await db
+        .select()
+        .from(table)
+        .where(authorizationFilter ? and(primaryKeyWhere, authorizationFilter) : primaryKeyWhere)
+        .limit(1);
+    return rows[0] ?? null;
+}
+async function insertAndReturn(db, table, model, scalars, dialect) {
+    if (dialect === "mysql") {
+        const ids = await db.insert(table).values(scalars).$returningId();
+        const primaryKey = primaryKeyOf(model);
+        const rows = await db
+            .select()
+            .from(table)
+            .where(eq(primaryKeyColumn(table, model), ids[0][primaryKey]));
+        return rows[0];
+    }
+    const rows = await db.insert(table).values(scalars).returning();
+    return rows[0];
+}
+async function updateAndReturn(db, table, model, id, scalars, dialect, authorizationFilter) {
+    const coercedId = coerceId(String(id), model);
+    const where = authorizationFilter
+        ? and(eq(primaryKeyColumn(table, model), coercedId), authorizationFilter)
+        : eq(primaryKeyColumn(table, model), coercedId);
+    if (dialect === "mysql") {
+        await db.update(table).set(scalars).where(where);
+        const row = await selectByPrimaryKey(db, table, model, coercedId, authorizationFilter);
+        if (!row)
+            throw new Error("record is outside the authorization scope");
+        return row;
+    }
+    const rows = await db.update(table).set(scalars).where(where).returning();
+    const row = rows[0];
+    if (!row)
+        throw new Error("record is outside the authorization scope");
+    return row;
+}
+async function insertM2mRows(db, link, parentId, ids) {
+    if (ids.length === 0)
+        return;
+    await db.insert(link.pivot).values(ids.map((id) => ({
+        [link.selfKey]: parentId,
+        [link.otherKey]: id,
+    })));
+}
+function insertAndReturnSqlite(db, table, scalars) {
+    return db.insert(table).values(scalars).returning().get();
+}
+function updateAndReturnSqlite(db, table, model, id, scalars, authorizationFilter) {
+    const row = db
+        .update(table)
+        .set(scalars)
+        .where(authorizationFilter ? and(eq(primaryKeyColumn(table, model), coerceId(String(id), model)), authorizationFilter) : eq(primaryKeyColumn(table, model), coerceId(String(id), model)))
+        .returning()
+        .get();
+    if (!row)
+        throw new Error("record is outside the authorization scope");
+    return row;
+}
+function insertM2mRowsSqlite(db, link, parentId, ids) {
+    if (ids.length === 0)
+        return;
+    db.insert(link.pivot)
+        .values(ids.map((id) => ({
+        [link.selfKey]: parentId,
+        [link.otherKey]: id,
+    })))
+        .run();
+}
+export function createDrizzleDataAdapter(db, ctx) {
+    const compileHere = (table, filter) => compileFilterToDrizzle(table, filter, {
+        caseInsensitiveSearch: ctx.caseInsensitiveSearch,
+        dialect: ctx.dialect,
+    });
+    return {
+        async listRecords(model, opts) {
+            const table = tableFor(ctx, model);
+            const where = compileHere(table, opts.filter);
+            const primaryKey = primaryKeyColumn(table, model);
+            const [rows, totals] = await Promise.all([
+                db
+                    .select()
+                    .from(table)
+                    .where(where)
+                    .orderBy(desc(primaryKey))
+                    .limit(opts.take)
+                    .offset(opts.skip),
+                db.select({ n: count() }).from(table).where(where),
+            ]);
+            return { rows, total: totals[0].n };
+        },
+        async findMany(model, opts) {
+            const table = tableFor(ctx, model);
+            const columns = getTableColumns(table);
+            const orderBy = Object.entries(opts.orderBy ?? {}).map(([field, direction]) => {
+                const column = columns[field];
+                if (!column) {
+                    throw new Error(`[sveltekit-admin] unknown field '${field}' on Drizzle table`);
+                }
+                return direction === "asc" ? asc(column) : desc(column);
+            });
+            let query = db
+                .select()
+                .from(table)
+                .where(compileHere(table, opts.filter));
+            if (orderBy.length > 0)
+                query = query.orderBy(...orderBy);
+            if (opts.take !== undefined)
+                query = query.limit(opts.take);
+            if (opts.skip !== undefined)
+                query = query.offset(opts.skip);
+            return query;
+        },
+        async getRecord(model, id) {
+            return selectByPrimaryKey(db, tableFor(ctx, model), model, id);
+        },
+        async findFirst(model, filter) {
+            const table = tableFor(ctx, model);
+            const rows = await db
+                .select()
+                .from(table)
+                .where(compileHere(table, filter))
+                .limit(1);
+            return rows[0] ?? null;
+        },
+        async countRecords(model, filter) {
+            const table = tableFor(ctx, model);
+            const rows = await db
+                .select({ n: count() })
+                .from(table)
+                .where(compileHere(table, filter));
+            return rows[0].n;
+        },
+        async createRecord(model, input) {
+            const table = tableFor(ctx, model);
+            const m2mFields = Object.entries(input.m2m ?? {});
+            const guards = input.targetGuards ?? [];
+            if (m2mFields.length === 0 && guards.length === 0) {
+                return insertAndReturn(db, table, model, input.scalars, ctx.dialect);
+            }
+            if (ctx.dialect === "sqlite") {
+                return db.transaction((tx) => {
+                    validateTargetGuardsSqlite(ctx, tx, guards, compileHere);
+                    const parent = insertAndReturnSqlite(tx, table, input.scalars);
+                    const parentId = parent[primaryKeyOf(model)];
+                    for (const [field, relation] of m2mFields) {
+                        const link = ctx.m2m.get(`${model.name}.${field}`);
+                        if (!link)
+                            continue;
+                        insertM2mRowsSqlite(tx, link, parentId, relation.ids);
+                    }
+                    return parent;
+                }, { behavior: "immediate" });
+            }
+            return withWriteRetry(() => db.transaction(async (tx) => {
+                await validateTargetGuards(ctx, tx, guards, compileHere);
+                const parent = await insertAndReturn(tx, table, model, input.scalars, ctx.dialect);
+                const parentId = parent[primaryKeyOf(model)];
+                for (const [field, relation] of m2mFields) {
+                    const link = ctx.m2m.get(`${model.name}.${field}`);
+                    if (!link)
+                        continue;
+                    await insertM2mRows(tx, link, parentId, relation.ids);
+                }
+                return parent;
+            }, { isolationLevel: "serializable" }));
+        },
+        async updateRecord(model, id, input, authorizationFilter) {
+            const table = tableFor(ctx, model);
+            const m2mFields = Object.entries(input.m2m ?? {});
+            const guards = input.targetGuards ?? [];
+            if (m2mFields.length === 0 && guards.length === 0) {
+                return updateAndReturn(db, table, model, id, input.scalars, ctx.dialect, compileHere(table, authorizationFilter));
+            }
+            if (ctx.dialect === "sqlite") {
+                return db.transaction((tx) => {
+                    validateTargetGuardsSqlite(ctx, tx, guards, compileHere);
+                    const parent = updateAndReturnSqlite(tx, table, model, id, input.scalars, compileHere(table, authorizationFilter));
+                    const parentId = coerceId(String(id), model);
+                    for (const [field, relation] of m2mFields) {
+                        const link = ctx.m2m.get(`${model.name}.${field}`);
+                        if (!link)
+                            continue;
+                        tx.delete(link.pivot).where(eq(link.selfColumn, parentId)).run();
+                        insertM2mRowsSqlite(tx, link, parentId, relation.ids);
+                    }
+                    return parent;
+                }, { behavior: "immediate" });
+            }
+            return withWriteRetry(() => db.transaction(async (tx) => {
+                await validateTargetGuards(ctx, tx, guards, compileHere);
+                const parent = await updateAndReturn(tx, table, model, id, input.scalars, ctx.dialect, compileHere(table, authorizationFilter));
+                const parentId = coerceId(String(id), model);
+                for (const [field, relation] of m2mFields) {
+                    const link = ctx.m2m.get(`${model.name}.${field}`);
+                    if (!link)
+                        continue;
+                    await tx.delete(link.pivot).where(eq(link.selfColumn, parentId));
+                    await insertM2mRows(tx, link, parentId, relation.ids);
+                }
+                return parent;
+            }, { isolationLevel: "serializable" }));
+        },
+        async deleteRecord(model, id, authorizationFilter) {
+            const table = tableFor(ctx, model);
+            const coercedId = coerceId(String(id), model);
+            const links = [...ctx.m2m.entries()]
+                .filter(([key]) => key.startsWith(`${model.name}.`))
+                .map(([, link]) => link);
+            const parentWhere = and(eq(primaryKeyColumn(table, model), coercedId), compileHere(table, authorizationFilter));
+            if (links.length === 0) {
+                if (ctx.dialect === "sqlite") {
+                    const result = db.delete(table).where(parentWhere).run();
+                    if (result.changes !== 1)
+                        throw new Error("record is outside the authorization scope");
+                }
+                else {
+                    const result = await db.delete(table).where(parentWhere);
+                    if (Number(result?.affectedRows ?? 0) !== 1)
+                        throw new Error("record is outside the authorization scope");
+                }
+                return;
+            }
+            // Les pivots partent avant le parent, l'ordre qu'imposent les FK. Le DELETE
+            // scopé du parent sert lui-même de garde : zéro ligne touchée => throw =>
+            // rollback des pivots. Pas de SELECT de vérification préalable, donc aucune
+            // fenêtre TOCTOU entre la lecture du scope et la suppression, et aucune
+            // branche défensive inatteignable.
+            if (ctx.dialect === "sqlite") {
+                db.transaction((tx) => {
+                    for (const link of links)
+                        tx.delete(link.pivot).where(eq(link.selfColumn, coercedId)).run();
+                    const result = tx.delete(table).where(parentWhere).run();
+                    if (result.changes !== 1)
+                        throw new Error("record is outside the authorization scope");
+                }, { behavior: "immediate" });
+                return;
+            }
+            await withWriteRetry(() => db.transaction(async (tx) => {
+                for (const link of links)
+                    await tx.delete(link.pivot).where(eq(link.selfColumn, coercedId));
+                if (ctx.dialect === "postgresql") {
+                    const deleted = await tx.delete(table).where(parentWhere).returning({ id: primaryKeyColumn(table, model) });
+                    if (deleted.length !== 1)
+                        throw new Error("record is outside the authorization scope");
+                }
+                else {
+                    const result = await tx.delete(table).where(parentWhere);
+                    if (Number(result?.affectedRows ?? 0) !== 1)
+                        throw new Error("record is outside the authorization scope");
+                }
+            }, { isolationLevel: "serializable" }));
+        },
+        async getM2mSelectedIds(model, edge, _targetModel, recordId) {
+            const link = ctx.m2m.get(`${model.name}.${edge.field}`);
+            if (!link)
+                return [];
+            const rows = await db
+                .select({ id: link.otherColumn })
+                .from(link.pivot)
+                .where(eq(link.selfColumn, coerceId(String(recordId), model)));
+            return rows.map((row) => row.id);
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { SQL, Table } from "drizzle-orm";
+import type { Filter } from "../types.js";
+import type { DrizzleDialect } from "./inspect.js";
+export { OPAQUE_FILTER_ERROR } from "../filter.js";
+export declare function compileFilterToDrizzle(table: Table, filter: Filter | Record<string, unknown> | undefined, opts: {
+    caseInsensitiveSearch: boolean;
+    dialect: DrizzleDialect;
+}): SQL | undefined;

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

@@ -0,0 +1,61 @@
+import { and, eq, getTableColumns, gte, inArray, isNotNull, isNull, lt, lte, or, sql, } from "drizzle-orm";
+import { isCompositeFilter, isLeafFilter, OPAQUE_FILTER_ERROR, } from "../filter.js";
+export { OPAQUE_FILTER_ERROR } from "../filter.js";
+function escapeLikePattern(value) {
+    return String(value).replace(/([%_!])/g, "!$1");
+}
+function likeWithEscape(column, pattern) {
+    return sql `${column} like ${pattern} escape '!'`;
+}
+function ilikeWithEscape(column, pattern) {
+    return sql `${column} ilike ${pattern} escape '!'`;
+}
+function compileLeaf(table, filter, opts) {
+    const columns = getTableColumns(table);
+    const column = columns[filter.field];
+    if (!column) {
+        throw new Error(`[sveltekit-admin] unknown field '${filter.field}' on Drizzle table`);
+    }
+    switch (filter.op) {
+        case "eq":
+            return eq(column, filter.value);
+        case "contains": {
+            const pattern = `%${escapeLikePattern(filter.value)}%`;
+            if (!opts.caseInsensitiveSearch)
+                return likeWithEscape(column, pattern);
+            if (opts.dialect === "postgresql")
+                return ilikeWithEscape(column, pattern);
+            return sql `lower(${column}) like lower(${pattern}) escape '!'`;
+        }
+        case "containsExact":
+            return likeWithEscape(column, `%${escapeLikePattern(filter.value)}%`);
+        case "startsWith":
+            return likeWithEscape(column, `${escapeLikePattern(filter.value)}%`);
+        case "gte":
+            return gte(column, filter.value);
+        case "lte":
+            return lte(column, filter.value);
+        case "lt":
+            return lt(column, filter.value);
+        case "in":
+            return inArray(column, filter.value);
+        case "isNull":
+            return isNull(column);
+        case "isNotNull":
+            return isNotNull(column);
+    }
+}
+function compile(table, node, opts) {
+    if (isCompositeFilter(node)) {
+        const clauses = node.clauses.map((clause) => compile(table, clause, opts));
+        return node.op === "and" ? and(...clauses) : or(...clauses);
+    }
+    if (isLeafFilter(node))
+        return compileLeaf(table, node, opts);
+    throw new Error(OPAQUE_FILTER_ERROR);
+}
+export function compileFilterToDrizzle(table, filter, opts) {
+    if (filter === undefined)
+        return undefined;
+    return compile(table, filter, opts);
+}

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

@@ -0,0 +1,22 @@
+import { defaultAdminCheck } from "../../auth.js";
+import { createAdminHandler, type AdminHandlerConfig } from "../../handler.js";
+import type { Schema, Model, Field } from "../../types/schema.js";
+import type { DataAdapter, Filter, SchemaIntrospector } from "../types.js";
+import type { DrizzleDialect } from "./inspect.js";
+export { createAdminHandler, type AdminHandlerConfig };
+export { defaultAdminCheck };
+export type { AuditAction, AuditEvent } from "../../audit.js";
+export type { Schema, Model, Field };
+export type { DataAdapter, SchemaIntrospector, Filter };
+export type { DrizzleDialect };
+export type { AdminPlugin, AdminPluginPage, AdminPluginRecordAction, PluginPageContext, PluginPageResult, } from "../../plugin.js";
+export declare function resolveCaseInsensitiveSearch(dialect: DrizzleDialect, searchMode?: "auto" | "insensitive" | "default"): boolean;
+export declare function createDrizzleAdapter(opts: {
+    db: any;
+    schema: Record<string, unknown>;
+    dialect?: DrizzleDialect;
+    searchMode?: "auto" | "insensitive" | "default";
+}): {
+    introspector: SchemaIntrospector;
+    data: DataAdapter;
+};

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

@@ -0,0 +1,27 @@
+import { defaultAdminCheck } from "../../auth.js";
+import { createAdminHandler } from "../../handler.js";
+import { createDrizzleDataAdapter } from "./dataAdapter.js";
+import { inspectDrizzleSchema } from "./inspect.js";
+import { createDrizzleIntrospector } from "./introspector.js";
+export { createAdminHandler };
+export { defaultAdminCheck };
+export function resolveCaseInsensitiveSearch(dialect, searchMode = "auto") {
+    if (searchMode === "insensitive")
+        return true;
+    if (searchMode === "default")
+        return false;
+    return dialect === "postgresql";
+}
+export function createDrizzleAdapter(opts) {
+    const inspected = inspectDrizzleSchema(opts.schema, opts.dialect);
+    const caseInsensitiveSearch = resolveCaseInsensitiveSearch(inspected.dialect, opts.searchMode);
+    return {
+        introspector: createDrizzleIntrospector(inspected.schema),
+        data: createDrizzleDataAdapter(opts.db, {
+            tables: inspected.tables,
+            m2m: inspected.m2m,
+            dialect: inspected.dialect,
+            caseInsensitiveSearch,
+        }),
+    };
+}

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

@@ -0,0 +1,23 @@
+import { Table } from 'drizzle-orm';
+import type { Column } from 'drizzle-orm';
+import type { Schema } from '../../types/schema.js';
+export type DrizzleDialect = 'postgresql' | 'mysql' | 'sqlite';
+export interface M2mLink {
+    pivot: Table;
+    selfColumn: Column;
+    otherColumn: Column;
+    selfKey: string;
+    otherKey: string;
+    targetTsName: string;
+}
+export interface InspectedDrizzleSchema {
+    schema: Schema;
+    tables: Record<string, Table>;
+    m2m: Map<string, M2mLink>;
+    dialect: DrizzleDialect;
+}
+export declare function mapColumnType(column: Column, enumTypeName?: string): {
+    type: string;
+    isEnum: boolean;
+};
+export declare function inspectDrizzleSchema(schemaObj: Record<string, unknown>, dialectOverride?: DrizzleDialect): InspectedDrizzleSchema;