sveltekit-admin 0.6.0 → 0.9.0

package/dist/server/errors.js

@@ -0,0 +1,90 @@
+/**
+ * Forme unique des échecs de mutation admin.
+ *
+ * Deux producteurs, un seul type : `mutations.ts` pour les refus que la
+ * bibliothèque décide elle-même (validation, scope), `classifyWriteError`
+ * pour ceux que le moteur signale. Un seul consommateur : le site d'appel
+ * de `handleMutation` dans `handler.ts`, qui ne rend QUE le message d'une
+ * `AdminMutationError` — jamais celui d'une erreur pilote brute.
+ *
+ * La classification se fait par code, jamais par texte : les messages des
+ * pilotes changent entre versions, les codes non.
+ */
+export class AdminMutationError extends Error {
+    kind;
+    field;
+    constructor(kind, message, field) {
+        super(message);
+        this.name = 'AdminMutationError';
+        this.kind = kind;
+        this.field = field;
+    }
+}
+/**
+ * Erreur de configuration de la bibliothèque elle-même (scope non injectable,
+ * tenant absent…), destinée au développeur intégrateur et non à l'utilisateur
+ * de l'admin. Distincte d'`AdminMutationError` : elle ne décrit pas un refus
+ * de la donnée soumise, mais un montage incorrect côté consommateur, et c'est
+ * la SEULE erreur non typée que le chemin de mutation relaie telle quelle.
+ */
+export class AdminConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AdminConfigError';
+    }
+}
+/**
+ * Les pilotes exposent le code SQLSTATE à des endroits différents : `code` sur
+ * `pg`, `mysql2` et `better-sqlite3`, `meta.code` sur une
+ * `PrismaClientKnownRequestError` issue d'une transaction interactive.
+ *
+ * Vit ici plutôt que dans `retry.ts` : deux modules classent désormais les
+ * erreurs pilote, et un second exemplaire de ce helper dériverait du premier.
+ */
+export function codeOf(error) {
+    const candidate = error;
+    const raw = candidate?.code ?? candidate?.meta?.code;
+    return typeof raw === 'string' ? raw : undefined;
+}
+const UNIQUE_CODES = new Set([
+    'P2002', // Prisma
+    '23505', // PostgreSQL — unique_violation
+    'ER_DUP_ENTRY', // MySQL 1062
+    'SQLITE_CONSTRAINT_UNIQUE'
+]);
+const FOREIGN_KEY_CODES = new Set([
+    'P2003', // Prisma
+    '23503', // PostgreSQL — foreign_key_violation
+    'ER_NO_REFERENCED_ROW_2', // MySQL 1452 — la cible soumise n'existe pas
+    'ER_ROW_IS_REFERENCED_2', // MySQL 1451 — la ligne est référencée ailleurs
+    'SQLITE_CONSTRAINT_FOREIGNKEY'
+]);
+const NOT_FOUND_CODES = new Set(['P2025']);
+/**
+ * Traduit un échec d'écriture en `AdminMutationError`, ou `null` si le code
+ * n'est pas reconnu — l'appelant rend alors un message générique.
+ *
+ * `reference` et `restrict` partagent le même code SQLSTATE (PostgreSQL 23503,
+ * SQLite SQLITE_CONSTRAINT_FOREIGNKEY) : c'est l'action en cours qui les
+ * sépare, pas le message. Sur create/update une cible soumise est invalide ;
+ * sur delete la ligne est référencée ailleurs.
+ */
+export function classifyWriteError(error, action) {
+    if (error instanceof AdminMutationError)
+        return error;
+    const code = codeOf(error);
+    if (code === undefined)
+        return null;
+    if (UNIQUE_CODES.has(code)) {
+        return new AdminMutationError('conflict', 'A record with these values already exists.');
+    }
+    if (FOREIGN_KEY_CODES.has(code)) {
+        return action === 'delete'
+            ? new AdminMutationError('restrict', 'This record is referenced by other records.')
+            : new AdminMutationError('reference', 'A referenced record no longer exists.');
+    }
+    if (NOT_FOUND_CODES.has(code)) {
+        return new AdminMutationError('notFound', 'This record no longer exists.');
+    }
+    return null;
+}

package/dist/server/handler.d.ts

@@ -3,23 +3,17 @@
  * Zero files needed in routes - everything handled via hook
  */
 import type { DataAdapter, SchemaIntrospector } from './adapters/types.js';
+import type { AuditEvent } from './audit.js';
+import { type CsrfConfig } from './csrf.js';
+import type { AdminPlugin } from './plugin.js';
 export interface AdminHandlerConfig {
     /**
-     * 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).
+     * Explicit `{ introspector, data }` pair, from `createPrismaAdapter`,
+     * `createDrizzleAdapter`, or a custom implementation. The `{ prisma,
+     * prismaSchemaPath }` shortcut lives on the Prisma wrapper exported by
+     * the package root, not here.
      */
-    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?: {
+    adapter: {
         introspector: SchemaIntrospector;
         data: DataAdapter;
     };
@@ -48,12 +42,50 @@ export interface AdminHandlerConfig {
     logout?: (event: any) => void | Promise<void>;
     /** Where to redirect after logout (default: '/') */
     logoutRedirectTo?: string;
+    /**
+     * Cross-site protection for every state-changing admin request (create /
+     * update / delete, `_logout`, `_search`). On by default; a missing `Origin`
+     * is rejected, as SvelteKit does. `trustedOrigins` allows a second
+     * legitimate origin, `csrf: false` opts out entirely.
+     *
+     * Why this isn't left to `kit.csrf.checkOrigin`, and the same-origin threat
+     * it does not cover: see `csrf.ts` and /docs/csrf.
+     */
+    csrf?: CsrfConfig;
+    /**
+     * Audit sink — same "bring your own" philosophy as `authCheck` / `logout`.
+     * The library has no log table and no session of its own, so it cannot
+     * know where to persist "admin X changed row Y" (your `AuditLog` model,
+     * a logger, an HTTP sink…). You provide the side effect; the handler
+     * calls it **after a successful create / update / delete** with a
+     * redacted `AuditEvent`. No callback means no behaviour change: no
+     * extra reads, no calls.
+     *
+     * The actor is whatever you already put on `event.locals` (the same
+     * object `authCheck` sees). Sensitive field names (`password` / `hash` /
+     * `secret` / `token`) and per-model `hidden` fields are stripped from
+     * `values` / `before` / `after` / `changes` so the sink cannot become a
+     * second oracle for secrets. Reads (GET), logout, and `_search` are
+     * not audited.
+     *
+     * Awaited before the 303 so a `prisma.auditLog.create(...)` inside the
+     * callback commits before the redirect. If the callback throws, the
+     * mutation still redirects — the write is the source of truth, the log
+     * is a sidecar (`console.error` with prefix
+     * `[sveltekit-admin] audit callback failed:`). There is no way to wrap
+     * the adapter write and your sink in one transaction without owning
+     * both stores.
+     */
+    audit?: (entry: AuditEvent) => void | Promise<void>;
     /** Per-model configuration */
     models?: Record<string, {
         hidden?: string[];
         readonly?: string[];
         listFields?: string[];
         label?: string;
+        scope?: (ctx: {
+            locals?: any;
+        }) => Record<string, unknown> | import('./adapters/types.js').Filter;
         /**
          * Scoping `where` applied to the LIST VIEW ONLY of this model
          * (search, sidebar filters, FK filter, pagination count) — composed
@@ -121,7 +153,42 @@ export interface AdminHandlerConfig {
          * doit échouer fort plutôt que produire un filtre silencieusement mort.
          */
         listFilter?: import('./query/filterDetection.js').ListFilterConfigEntry[];
+        /**
+         * Ordre d'arrivée sur la liste, avant tout `?sort=` dans l'URL. `dir` vaut
+         * `'asc'` par défaut.
+         *
+         * Volontairement explicite plutôt qu'auto-détecté : deviner « trie par
+         * `name` s'il y en a un » changerait l'ordre de toutes les listes
+         * existantes sans que personne l'ait demandé, et l'heuristique dériverait
+         * de ce que la vue affiche réellement.
+         *
+         * `field` doit être une colonne que la liste AFFICHE — sinon aucun en-tête
+         * ne peut annoncer le tri ni permettre d'en sortir. Validé au démarrage :
+         * une colonne inexistante ou non affichée lève, plutôt que de produire un
+         * tri mort à chaque rendu.
+         */
+        defaultSort?: {
+            field: string;
+            dir?: 'asc' | 'desc';
+        };
     }>;
+    /**
+     * Lignes par page de la vue liste (défaut : 20). Entier de 1 à 200 : au-delà
+     * ce n'est plus une page, c'est un export — et une requête qui tient la
+     * connexion sur une table volumineuse. Validé au démarrage.
+     */
+    perPage?: number;
+    /**
+     * Tailles de page qu'un visiteur peut choisir (défaut : `[10, 20, 50, 100]`).
+     * `perPage` y est ajouté d'office s'il n'y figure pas, sinon la taille active
+     * n'apparaîtrait pas dans le sélecteur.
+     *
+     * Un `?perPage=` n'est honoré que s'il appartient à cette liste : sans cette
+     * règle, `?perPage=100000` est un `take` non borné, donc un déni de service à
+     * un paramètre près. `[]` désactive entièrement le mécanisme — aucun
+     * sélecteur rendu, `?perPage=` sans effet.
+     */
+    pageSizeOptions?: number[];
     /** Models to exclude from admin */
     exclude?: string[];
     /** Hide pivot/junction tables automatically (default: true) */
@@ -145,23 +212,22 @@ export interface AdminHandlerConfig {
         linkThreshold?: number;
         autoDetect?: boolean;
     };
-    /**
-     * Recherche texte libre : configuration globale.
-     * `mode`: 'auto' détecte le provider du schéma et n'émet `mode: 'insensitive'`
-     * que sur postgresql/cockroachdb/mongodb (les seuls où Prisma le supporte —
-     * l'émettre sur sqlite/mysql/sqlserver lève une erreur Prisma). 'insensitive'
-     * et 'default' forcent le comportement, pour un provider non détectable
-     * (`provider = env(...)`) ou un besoin spécifique (index `citext`, etc.).
-     * Voir docs/design/list-search-filters.md §2.5.
-     */
-    search?: {
-        mode?: 'auto' | 'insensitive' | 'default';
-    };
     /** Custom branding */
     branding?: {
         title?: string;
         primaryColor?: string;
     };
+    /**
+     * Optional admin plugins (new pages + record actions). Omitted or `[]`
+     * keeps every builtin view byte-identical to a build without plugins.
+     * Plugin routes are matched before builtins, so a registered pattern
+     * with a literal token in a `:model`/`:id` position can take over a
+     * builtin path when it matches first (e.g. `['user']` shadows the User
+     * list); only an identical, token-for-token overlay throws at boot.
+     * See `AdminPlugin`. Options like graph `depth` belong on the author's
+     * factory, not here.
+     */
+    plugins?: AdminPlugin[];
 }
 export declare function createAdminHandler(config: AdminHandlerConfig): ({ event, resolve }: {
     event: any;