sveltekit-admin 0.5.0 → 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dotNacer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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,7 @@ 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
+- 🔌 **Drizzle adapter** (optional subpath export)
 
 ## Installation
 
@@ -42,6 +44,35 @@ 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. For Drizzle, pass an adapter from the subpath
+export (this does not pull in `drizzle-orm` for Prisma apps):
+
+```typescript
+import { createAdminHandler } from 'sveltekit-admin';
+import { 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'
+});
+```
+
+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

package/dist/index.d.ts

@@ -5,3 +5,6 @@
 export { createAdminHandler, type AdminHandlerConfig } from './server/handler.js';
 export { defaultAdminCheck } from './server/auth.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';

package/dist/index.js

@@ -5,3 +5,4 @@
 export { createAdminHandler } from './server/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,243 @@
+import { asc, count, desc, eq, getTableColumns } from "drizzle-orm";
+import { coerceId, primaryKeyOf } from "../../data.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)];
+}
+async function selectByPrimaryKey(db, table, model, id) {
+    const rows = await db
+        .select()
+        .from(table)
+        .where(eq(primaryKeyColumn(table, model), coerceId(String(id), model)))
+        .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) {
+    const coercedId = coerceId(String(id), model);
+    const where = eq(primaryKeyColumn(table, model), coercedId);
+    if (dialect === "mysql") {
+        await db.update(table).set(scalars).where(where);
+        return (await selectByPrimaryKey(db, table, model, coercedId));
+    }
+    const rows = await db.update(table).set(scalars).where(where).returning();
+    return rows[0];
+}
+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) {
+    return db
+        .update(table)
+        .set(scalars)
+        .where(eq(primaryKeyColumn(table, model), coerceId(String(id), model)))
+        .returning()
+        .get();
+}
+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 ?? {});
+            if (m2mFields.length === 0) {
+                return insertAndReturn(db, table, model, input.scalars, ctx.dialect);
+            }
+            if (ctx.dialect === "sqlite") {
+                return db.transaction((tx) => {
+                    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;
+                });
+            }
+            return db.transaction(async (tx) => {
+                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;
+            });
+        },
+        async updateRecord(model, id, input) {
+            const table = tableFor(ctx, model);
+            const m2mFields = Object.entries(input.m2m ?? {});
+            if (m2mFields.length === 0) {
+                return updateAndReturn(db, table, model, id, input.scalars, ctx.dialect);
+            }
+            if (ctx.dialect === "sqlite") {
+                return db.transaction((tx) => {
+                    const parent = updateAndReturnSqlite(tx, table, model, id, input.scalars);
+                    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;
+                });
+            }
+            return db.transaction(async (tx) => {
+                const parent = await updateAndReturn(tx, table, model, id, input.scalars, ctx.dialect);
+                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;
+            });
+        },
+        async deleteRecord(model, id) {
+            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);
+            if (links.length === 0) {
+                await db
+                    .delete(table)
+                    .where(eq(primaryKeyColumn(table, model), coercedId));
+                return;
+            }
+            if (ctx.dialect === "sqlite") {
+                db.transaction((tx) => {
+                    for (const link of links) {
+                        tx.delete(link.pivot).where(eq(link.selfColumn, coercedId)).run();
+                    }
+                    tx.delete(table)
+                        .where(eq(primaryKeyColumn(table, model), coercedId))
+                        .run();
+                });
+                return;
+            }
+            await db.transaction(async (tx) => {
+                for (const link of links) {
+                    await tx.delete(link.pivot).where(eq(link.selfColumn, coercedId));
+                }
+                await tx.delete(table).where(eq(primaryKeyColumn(table, model), coercedId));
+            });
+        },
+        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,13 @@
+import type { DataAdapter, SchemaIntrospector } from "../types.js";
+import type { DrizzleDialect } from "./inspect.js";
+export type { DrizzleDialect };
+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,23 @@
+import { createDrizzleDataAdapter } from "./dataAdapter.js";
+import { inspectDrizzleSchema } from "./inspect.js";
+import { createDrizzleIntrospector } from "./introspector.js";
+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;