sveltekit-admin 0.5.3 → 0.6.0

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,96 @@
+import { toPrismaModel, primaryKeyOf, coerceId } from '../../data.js';
+import { compileFilterToPrismaWhere } from './filterCompiler.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 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 ?? {});
+            if (m2mFields.length === 0) {
+                return prisma[key].create({ data: input.scalars });
+            }
+            return prisma.$transaction(async (tx) => {
+                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 });
+            });
+        },
+        async updateRecord(model, id, input) {
+            const key = toPrismaModel(model.name);
+            const primaryKey = primaryKeyOf(model);
+            const where = { [primaryKey]: coerceId(String(id), model) };
+            const m2mFields = Object.keys(input.m2m ?? {});
+            if (m2mFields.length === 0) {
+                return prisma[key].update({ where, data: input.scalars });
+            }
+            return prisma.$transaction(async (tx) => {
+                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 });
+            });
+        },
+        async deleteRecord(model, id) {
+            const primaryKey = primaryKeyOf(model);
+            await prisma[toPrismaModel(model.name)].delete({ where: { [primaryKey]: coerceId(String(id), model) } });
+        },
+        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/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);
+        }
+    };
+}

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

@@ -0,0 +1,79 @@
+/**
+ * ORM-agnostic where-clause AST. `listQuery.ts#buildWhere` produces this;
+ * each adapter's own `filterCompiler` (see `adapters/prisma/filterCompiler.ts`)
+ * turns it into that ORM's native query shape. Never expose an ORM-specific
+ * operator here (no `mode: 'insensitive'`, no Prisma `not`) — those are
+ * compiler-side decisions made from `LeafFilter.op`, not carried in the AST.
+ */
+export type Filter = CompositeFilter | LeafFilter;
+export interface CompositeFilter {
+    op: 'and' | 'or';
+    clauses: Filter[];
+}
+export interface LeafFilter {
+    op: 'eq' | 'contains' | 'containsExact' | 'startsWith' | 'gte' | 'lte' | 'lt' | 'in' | 'isNull' | 'isNotNull';
+    field: string;
+    value?: unknown;
+}
+import type { Schema, Model } from '../types/schema.js';
+import type { RelationEdge } from '../introspection/relations.js';
+/** Boot-time schema source. One call per handler lifetime — no per-request cost. */
+export interface SchemaIntrospector {
+    introspect(): Schema | Promise<Schema>;
+}
+/**
+ * Per-request CRUD + relation-read surface `handler.ts` talks to instead of
+ * a raw ORM client. See docs/superpowers/specs/2026-08-13-db-adapter-abstraction-design.md
+ * for the rationale behind each method's shape.
+ */
+export interface DataAdapter {
+    /** Vue liste paginée : toujours tri PK desc, toujours count + fetch ensemble. */
+    listRecords(model: Model, opts: {
+        filter?: Filter;
+        skip: number;
+        take: number;
+    }): Promise<{
+        rows: Record<string, unknown>[];
+        total: number;
+    }>;
+    /**
+     * Lecture générale sans pagination forcée : options de relation FK/m2m,
+     * options de filtre FK sidebar, endpoint `_search`. `orderBy` est le
+     * `Record<string, 'asc' | 'desc'>` déjà exposé tel quel côté config
+     * publique (`AdminHandlerConfig.models[].relations[field].orderBy`) —
+     * transmis de façon opaque, sans traduction.
+     */
+    findMany(model: Model, opts: {
+        filter?: Filter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
+        skip?: number;
+        take?: number;
+    }): Promise<Record<string, unknown>[]>;
+    getRecord(model: Model, id: string | number): Promise<Record<string, unknown> | null>;
+    findFirst(model: Model, filter: Filter): Promise<Record<string, unknown> | null>;
+    countRecords(model: Model, filter?: Filter): Promise<number>;
+    /**
+     * `m2m`'s value carries the TARGET model's PK field name alongside the raw
+     * ids, not just the ids: this adapter has no `Schema`/`RelationGraph` of
+     * its own to resolve a target model from an edge, and `handler.ts` (the
+     * only caller) already resolves the target model before building this
+     * payload, at zero extra cost to it.
+     */
+    createRecord(model: Model, input: {
+        scalars: Record<string, unknown>;
+        m2m?: Record<string, {
+            targetPkField: string;
+            ids: Array<string | number>;
+        }>;
+    }): Promise<Record<string, unknown>>;
+    updateRecord(model: Model, id: string | number, input: {
+        scalars: Record<string, unknown>;
+        m2m?: Record<string, {
+            targetPkField: string;
+            ids: Array<string | number>;
+        }>;
+    }): Promise<Record<string, unknown>>;
+    deleteRecord(model: Model, id: string | number): Promise<void>;
+    /** `targetModel` est fourni par l'appelant : chaque site d'appel actuel l'a déjà résolu. */
+    getM2mSelectedIds(model: Model, edge: RelationEdge, targetModel: Model, recordId: string | number): Promise<Array<string | number>>;
+}

package/dist/server/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/data.d.ts

@@ -28,11 +28,3 @@ export declare function paginate(pageParam: string | null, perPage: number): {
     skip: number;
     take: number;
 };
-export declare function listRecords(prisma: any, model: PrismaModel, page: number, perPage: number, where?: Record<string, unknown>): Promise<{
-    items: any[];
-    total: number;
-}>;
-export declare function getRecord(prisma: any, model: PrismaModel, id: string): Promise<any | null>;
-export declare function createRecord(prisma: any, model: PrismaModel, data: Record<string, unknown>): Promise<void>;
-export declare function updateRecord(prisma: any, model: PrismaModel, id: string, data: Record<string, unknown>): Promise<void>;
-export declare function deleteRecord(prisma: any, model: PrismaModel, id: string): Promise<void>;

package/dist/server/data.js

@@ -73,44 +73,3 @@ export function paginate(pageParam, perPage) {
     const page = Number.isSafeInteger(parsed) && parsed >= 1 ? parsed : 1;
     return { page, skip: (page - 1) * perPage, take: perPage };
 }
-export async function listRecords(prisma, model, page, perPage, where) {
-    const key = toPrismaModel(model.name);
-    const primaryKey = primaryKeyOf(model);
-    // Le calcul `(page - 1) * perPage` est dupliqué avec `paginate` DÉLIBÉRÉMENT.
-    // Router `listRecords` vers `paginate(String(page), perPage)` serait lossy : la
-    // conversion aller-retour passe par `parseInt`, et `String(1e24)` donne
-    // `'1e+24'`, que `parseInt` ramène à `1`. `listRecords` reçoit un `number` déjà
-    // validé par l'appelant ; ne pas « simplifier » en réintroduisant un parse.
-    const [items, total] = await Promise.all([
-        prisma[key].findMany({
-            where,
-            skip: (page - 1) * perPage,
-            take: perPage,
-            orderBy: { [primaryKey]: 'desc' }
-        }),
-        prisma[key].count({ where })
-    ]);
-    return { items, total };
-}
-export function getRecord(prisma, model, id) {
-    const primaryKey = primaryKeyOf(model);
-    return prisma[toPrismaModel(model.name)].findUnique({
-        where: { [primaryKey]: coerceId(id, model) }
-    });
-}
-export async function createRecord(prisma, model, data) {
-    await prisma[toPrismaModel(model.name)].create({ data });
-}
-export async function updateRecord(prisma, model, id, data) {
-    const primaryKey = primaryKeyOf(model);
-    await prisma[toPrismaModel(model.name)].update({
-        where: { [primaryKey]: coerceId(id, model) },
-        data
-    });
-}
-export async function deleteRecord(prisma, model, id) {
-    const primaryKey = primaryKeyOf(model);
-    await prisma[toPrismaModel(model.name)].delete({
-        where: { [primaryKey]: coerceId(id, model) }
-    });
-}

package/dist/server/handler.d.ts

@@ -2,11 +2,27 @@
  * SvelteKit Admin - Standalone Handler
  * Zero files needed in routes - everything handled via hook
  */
+import type { DataAdapter, SchemaIntrospector } from './adapters/types.js';
 export interface AdminHandlerConfig {
-    /** Prisma client instance */
-    prisma: any;
+    /**
+     * Prisma client instance. Required unless `adapter` is provided directly —
+     * exactly one of the two must be set. Kept required-looking here (not `?`)
+     * for source compatibility with every existing call site; passing neither
+     * throws at handler-creation time (see the boot block).
+     */
+    prisma?: any;
     /** Path to Prisma schema file */
     prismaSchemaPath?: string;
+    /**
+     * Explicit adapter, built via `createPrismaAdapter(...)` (or, in a future
+     * release, a Drizzle/other adapter). Takes priority over `prisma`/
+     * `prismaSchemaPath` when both are somehow set. Most consumers never touch
+     * this — passing `prisma`/`prismaSchemaPath` builds one internally.
+     */
+    adapter?: {
+        introspector: SchemaIntrospector;
+        data: DataAdapter;
+    };
     /** Base path for admin routes (default: /admin) */
     basePath?: string;
     /** Authentication check - return true if user can access admin */