sveltekit-admin 0.5.0 → 0.6.0

package/dist/server/introspection/parser.d.ts

@@ -2,46 +2,10 @@
  * Prisma Schema Parser
  * Extracts model information from Prisma schema files
  */
-export interface PrismaField {
-    name: string;
-    type: string;
-    isRequired: boolean;
-    isList: boolean;
-    isUnique: boolean;
-    isId: boolean;
-    isUpdatedAt: boolean;
-    isCreatedAt: boolean;
-    hasDefault: boolean;
-    defaultValue?: string;
-    /** true si `type` correspond à un `enum` déclaré dans le même schéma. */
-    isEnum?: boolean;
-    relation?: {
-        name?: string;
-        model: string;
-        fields?: string[];
-        references?: string[];
-    };
-    documentation?: string;
-}
-export interface PrismaModel {
-    name: string;
-    fields: PrismaField[];
-    documentation?: string;
-    primaryKey?: string;
-    isPivotTable?: boolean;
-}
-export interface PrismaSchema {
-    models: PrismaModel[];
-    enums: Map<string, string[]>;
-    /**
-     * Provider du bloc `datasource` (ex. "postgresql", "sqlite"), tel qu'écrit
-     * littéralement dans le schéma. `undefined` si absent ou si la valeur est
-     * une expression (`env("...")`, un provider non littéral) — dans ce cas
-     * le code appelant doit dégrader vers le comportement le plus prudent
-     * (voir `caseInsensitiveSearch` dans query/listQuery.ts).
-     */
-    provider?: string;
-}
+import type { Field, Model, Schema } from '../types/schema.js';
+export type PrismaField = Field;
+export type PrismaModel = Model;
+export type PrismaSchema = Schema;
 export declare function parsePrismaSchema(schemaPath: string): PrismaSchema;
 export declare function parseSchemaContent(content: string): PrismaSchema;
 /**

package/dist/server/introspection/relations.d.ts

@@ -13,7 +13,7 @@
  * par nom de relation, que Prisma garantit unique pour un couple de modèles.
  */
 import type { PrismaModel, PrismaSchema } from './parser.js';
-export type RelationKind = 'to-one-owning' | 'to-one-inverse' | 'to-many-inverse' | 'm2m-implicit';
+export type RelationKind = 'to-one-owning' | 'to-one-inverse' | 'to-many-inverse' | 'm2m';
 export type UnsupportedReason = 'composite-fk' | 'ambiguous';
 export interface RelationEdge {
     /** Modèle porteur du champ */

package/dist/server/introspection/relations.js

@@ -74,7 +74,7 @@ export function buildRelationGraph(schema) {
         for (const c of group) {
             let kind;
             if (isImplicitM2M) {
-                kind = 'm2m-implicit';
+                kind = 'm2m';
             }
             else if (c.field.isList) {
                 kind = 'to-many-inverse';

package/dist/server/query/listQuery.d.ts

@@ -12,6 +12,7 @@
  * string) becomes the Prisma operator key.
  */
 import type { PrismaModel } from '../introspection/parser.js';
+import type { Filter } from '../adapters/types.js';
 export type FilterOp = 'equals' | 'contains' | 'startsWith' | 'gte' | 'lte' | 'isnull';
 export interface ActiveFilter {
     field: string;
@@ -32,7 +33,10 @@ export interface ListQuery {
     filters: ActiveFilter[];
     ignored: IgnoredFilter[];
 }
-/** Field-name candidates used both for relation labels and for the default search heuristic (§2.1). */
+/**
+ * Field-name candidates for the default search heuristic (§2.1). Relation-label
+ * resolution (handler.ts) keeps its own separate list — the two are not shared.
+ */
 export declare const DEFAULT_LABEL_FIELDS: string[];
 /**
  * Fields eligible for the free-text search box.
@@ -73,17 +77,10 @@ export declare function resolveDateShortcut(raw: string, now?: () => Date): Date
  * is known to be eligible.
  */
 export declare function parseListQuery(searchParams: URLSearchParams, model: PrismaModel, enums: Map<string, string[]>, searchFields: string[], filterableFields: Set<string>, now?: () => Date): ListQuery;
-/** A Prisma `where` clause built from a `ListQuery`. Opaque to callers — pass straight to Prisma. */
-export type PrismaWhere = Record<string, unknown>;
 /**
- * Compose the final Prisma `where`: `AND: [scope, ...filters, {OR: search}]`.
- * NEVER a spread — a spread of `{...scope, ...filterWhere}` lets a filter
- * on the same field as the developer's scoping silently overwrite it
- * (docs/design §0.c, the exact IDOR the previous `?filter=` had). Two
- * clauses on the same field inside `AND` intersect; they never merge.
- *
- * Returns `undefined` when nothing is active, so the query shape sent to
- * Prisma is byte-for-byte identical to today's unfiltered call — no
- * regression on existing snapshots/assertions.
+ * Compose the final generic `Filter`: `and: [scope, ...filters, {or: search}]`.
+ * NEVER a spread. Flat `{ tenantId: 1 }` scopes become `eq` leaves via
+ * `normalizeScope`; nested Prisma where objects stay opaque for the Prisma
+ * compiler. Drizzle's compiler throws on those opaques.
  */
-export declare function buildWhere(query: ListQuery, scope: Record<string, unknown> | undefined, caseInsensitiveSearch: boolean, model: PrismaModel): PrismaWhere | undefined;
+export declare function buildWhere(query: ListQuery, scope: Record<string, unknown> | undefined, caseInsensitiveSearch: boolean, model: PrismaModel): Filter | Record<string, unknown> | undefined;

package/dist/server/query/listQuery.js

@@ -12,10 +12,25 @@
  * string) becomes the Prisma operator key.
  */
 import { isSensitiveFieldName } from '../introspection/parser.js';
+import { normalizeScope } from '../adapters/filter.js';
 /** Max length accepted for the free-text search term. Longer input is truncated. */
 const MAX_SEARCH_LENGTH = 200;
-/** Field-name candidates used both for relation labels and for the default search heuristic (§2.1). */
-export const DEFAULT_LABEL_FIELDS = ['name', 'title', 'label', 'email', 'username', 'slug'];
+/**
+ * Field-name candidates for the default search heuristic (§2.1). Relation-label
+ * resolution (handler.ts) keeps its own separate list — the two are not shared.
+ */
+export const DEFAULT_LABEL_FIELDS = [
+    'name',
+    'title',
+    'label',
+    'email',
+    'username',
+    'slug',
+    'description',
+    'content',
+    'body',
+    'text'
+];
 /** Types eligible for the free-text search heuristic (String only, see §2.1). */
 function isSearchableByHeuristic(field) {
     return (field.type === 'String' &&
@@ -337,92 +352,69 @@ export function parseListQuery(searchParams, model, enums, searchFields, filtera
 }
 function clauseOf(filter) {
     if (filter.op === 'gte' && filter.value && typeof filter.value === 'object' && 'gte' in filter.value) {
-        // Date shortcut carrying both bounds (see parseOneFilter's DateTime branch).
+        // Date shortcut carrying both bounds (see parseOneFilter's DateTime branch) —
+        // becomes two leaf clauses, re-merged by the Prisma filterCompiler.
         const range = filter.value;
-        return { [filter.field]: { gte: range.gte, lt: range.lt } };
+        return [
+            { op: 'gte', field: filter.field, value: range.gte },
+            { op: 'lt', field: filter.field, value: range.lt }
+        ];
     }
     if (filter.op === 'isnull') {
-        return { [filter.field]: filter.value ? { equals: null } : { not: null } };
+        return [{ op: filter.value ? 'isNull' : 'isNotNull', field: filter.field }];
     }
     if (filter.op === 'equals') {
-        return { [filter.field]: filter.value };
+        return [{ op: 'eq', field: filter.field, value: filter.value }];
     }
-    return { [filter.field]: { [filter.op]: filter.value } };
+    return [{ op: filter.op, field: filter.field, value: filter.value }];
 }
 /**
- * Compose the final Prisma `where`: `AND: [scope, ...filters, {OR: search}]`.
- * NEVER a spread — a spread of `{...scope, ...filterWhere}` lets a filter
- * on the same field as the developer's scoping silently overwrite it
- * (docs/design §0.c, the exact IDOR the previous `?filter=` had). Two
- * clauses on the same field inside `AND` intersect; they never merge.
- *
- * Returns `undefined` when nothing is active, so the query shape sent to
- * Prisma is byte-for-byte identical to today's unfiltered call — no
- * regression on existing snapshots/assertions.
+ * Compose the final generic `Filter`: `and: [scope, ...filters, {or: search}]`.
+ * NEVER a spread. Flat `{ tenantId: 1 }` scopes become `eq` leaves via
+ * `normalizeScope`; nested Prisma where objects stay opaque for the Prisma
+ * compiler. Drizzle's compiler throws on those opaques.
  */
 export function buildWhere(query, scope, caseInsensitiveSearch, model) {
     const and = [];
-    if (scope)
-        and.push(scope);
+    const normalized = normalizeScope(scope);
+    if (normalized)
+        and.push(normalized);
     for (const f of query.filters)
-        and.push(clauseOf(f));
+        and.push(...clauseOf(f));
     if (query.q && query.searchFields.length > 0) {
         const or = [];
         for (const fieldName of query.searchFields) {
             const field = model.fields.find((f) => f.name === fieldName);
-            const clause = searchClauseFor(field, query.q, caseInsensitiveSearch);
+            const clause = searchClauseFor(field, fieldName, query.q);
             if (clause)
-                or.push({ [fieldName]: clause });
+                or.push(clause);
         }
-        // Never emit `{OR: []}` — in Prisma that matches nothing, which would
-        // silently turn "no searchable field" (or "every clause omitted", §2.4)
-        // into "empty result". A no-op search must add nothing to the where.
         if (or.length > 0)
-            and.push({ OR: or });
+            and.push({ op: 'or', clauses: or });
     }
     if (and.length === 0)
         return undefined;
     if (and.length === 1)
         return and[0];
-    return { AND: and };
+    return { op: 'and', clauses: and };
 }
 /**
- * The per-field-type clause for a `searchFields` entry (§2.4):
- * - String @id -> `equals` (a `contains` on a cuid/uuid can't use the
- *   index and never makes semantic sense; §2.1 talks ONLY about the id
- *   here — an earlier version of this function over-generalized to
- *   `@id || @unique`, which silently broke fragment search on the most
- *   common real-world case: `email`/`slug` fields are `@unique` in
- *   nearly every Prisma schema and are exactly what §2.3's "a title, an
- *   email" example means by free-text search. `@unique` alone is NOT a
- *   reason to switch to `equals` — only `@id` is).
- * - other String (including @unique) -> `contains` (+ `mode:
- *   'insensitive'` when the provider supports it).
- * - Int/BigInt/Float/Decimal -> `equals` if `q` coerces to that type,
- *   otherwise the clause is OMITTED — never `contains` on a numeric
- *   column, which Prisma rejects with a hard error (`Unknown argument
- *   contains`), turning any legitimate `?q=` into a 500 (§10's known
- *   trap, discovered via review — the original implementation searched
- *   this exactly wrong).
- * - anything else (enum, Boolean, DateTime, relation, Json/Bytes):
- *   omitted. `resolveSearchFields`'s auto heuristic never proposes these,
- *   but explicit `searchFields` config isn't type-checked against §2.4 at
- *   boot (only against `isFilterableFieldType`), so this is reached in
- *   practice for a misconfigured field — degrading to "omitted" here
- *   keeps the guarantee that a legitimate URL never 500s, without adding
- *   a boot-time validation pass this design doc doesn't ask for.
+ * The per-field-type clause for a `searchFields` entry (§2.4) — same rules as
+ * before (String @id -> eq, other String -> contains, numeric -> eq if
+ * coercible else omitted, anything else omitted). `caseInsensitiveSearch` no
+ * longer lives here: the generic `Filter` doesn't carry a case-sensitivity
+ * flag, `filterCompiler.ts` decides whether to add `mode: 'insensitive'` from
+ * the same boolean at the handler.ts call site instead.
  */
-function searchClauseFor(field, q, caseInsensitiveSearch) {
+function searchClauseFor(field, fieldName, q) {
     if (!field)
         return undefined;
     if (field.type === 'String') {
-        if (field.isId)
-            return { equals: q };
-        return caseInsensitiveSearch ? { contains: q, mode: 'insensitive' } : { contains: q };
+        return field.isId ? { op: 'eq', field: fieldName, value: q } : { op: 'contains', field: fieldName, value: q };
     }
     if (['Int', 'BigInt', 'Float', 'Decimal'].includes(field.type)) {
         const coerced = coerceValue(field, 'equals', q);
-        return coerced === undefined ? undefined : { equals: coerced };
+        return coerced === undefined ? undefined : { op: 'eq', field: fieldName, value: coerced };
     }
     return undefined;
 }

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

@@ -0,0 +1,40 @@
+/**
+ * Generic schema shapes shared by every schema-source adapter (Prisma today,
+ * others later). Deliberately identical in shape to what `introspection/
+ * parser.ts` has always produced — this file is a rename of that shape, not
+ * a redesign of it. `PrismaSchema`/`PrismaModel`/`PrismaField` in parser.ts
+ * become aliases of these.
+ */
+export interface Field {
+    name: string;
+    type: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isUpdatedAt: boolean;
+    isCreatedAt: boolean;
+    hasDefault: boolean;
+    defaultValue?: string;
+    /** true si `type` correspond à un `enum` déclaré dans le même schéma. */
+    isEnum?: boolean;
+    relation?: {
+        name?: string;
+        model: string;
+        fields?: string[];
+        references?: string[];
+    };
+    documentation?: string;
+}
+export interface Model {
+    name: string;
+    fields: Field[];
+    documentation?: string;
+    primaryKey?: string;
+    isPivotTable?: boolean;
+}
+export interface Schema {
+    models: Model[];
+    enums: Map<string, string[]>;
+    provider?: string;
+}

package/dist/server/types/schema.js

@@ -0,0 +1,8 @@
+/**
+ * Generic schema shapes shared by every schema-source adapter (Prisma today,
+ * others later). Deliberately identical in shape to what `introspection/
+ * parser.ts` has always produced — this file is a rename of that shape, not
+ * a redesign of it. `PrismaSchema`/`PrismaModel`/`PrismaField` in parser.ts
+ * become aliases of these.
+ */
+export {};

package/dist/server/views/Form.svelte

@@ -69,7 +69,7 @@
       ? [...model.relationGraph.edges.values()].filter(
           (e) =>
             e.model === model.name &&
-            e.kind === 'm2m-implicit' &&
+            e.kind === 'm2m' &&
             !e.unsupported &&
             !hidden.includes(e.field) &&
             model.relationOptions?.has(`${e.model}.${e.field}`)

package/dist/server/views/RelationCheckboxes.svelte

@@ -17,7 +17,7 @@
 </script>
 
 <!--
-  Fieldset de checkboxes pour une arête m2m-implicite.
+  Fieldset de checkboxes pour une arête m2m.
 
   Nommage `__rel__<field>` pour les valeurs cochées et un hidden sentinelle
   `__rel_present__<field>` toujours émis : en HTML, zéro checkbox cochée

package/dist/server/views/theme.js

@@ -392,61 +392,114 @@ export function styles(primaryColor) {
     .ska-filters {
       margin-bottom: 1.5rem;
       display: flex;
-      flex-wrap: wrap;
-      gap: 1.5rem;
+      flex-direction: column;
+      gap: 0.75rem;
     }
 
     .ska-filters__group {
-      min-width: 140px;
+      display: flex;
+      align-items: center;
+      flex-wrap: wrap;
+      gap: 0.625rem;
+    }
+
+    .ska-filters__group + .ska-filters__group {
+      padding-top: 0.75rem;
+      border-top: 1px solid #f1f5f9;
     }
 
     .ska-filters__title {
-      font-size: 0.75rem;
+      font-size: 0.6875rem;
       font-weight: 600;
       text-transform: uppercase;
       letter-spacing: 0.05em;
-      color: #64748b;
-      margin-bottom: 0.5rem;
+      color: #94a3b8;
+      min-width: 88px;
+      flex-shrink: 0;
     }
 
     .ska-filters__list {
       list-style: none;
       display: flex;
-      flex-direction: column;
-      gap: 0.25rem;
+      flex-wrap: wrap;
+      gap: 0.375rem;
     }
 
     .ska-filters__link {
-      display: block;
-      padding: 0.25rem 0.5rem;
-      border-radius: 0.25rem;
+      display: inline-flex;
+      align-items: center;
+      padding: 0.25rem 0.625rem;
+      border-radius: 999px;
+      border: 1px solid #e2e8f0;
       color: #475569;
       text-decoration: none;
-      font-size: 0.875rem;
+      font-size: 0.8125rem;
+      line-height: 1.25rem;
+      white-space: nowrap;
+      transition: all 0.15s;
     }
 
     .ska-filters__link:hover {
       background: #f1f5f9;
+      border-color: #cbd5e1;
     }
 
     .ska-filters__link--active {
-      background: #eef2ff;
-      color: var(--ska-primary);
+      background: var(--ska-primary);
+      border-color: var(--ska-primary);
+      color: white;
       font-weight: 500;
     }
 
-    .ska-filters__range {
+    .ska-filters__range,
+    .ska-filters__select {
       display: flex;
-      flex-direction: column;
-      gap: 0.375rem;
+      align-items: center;
+      gap: 0.5rem;
     }
 
     .ska-filters__range-input {
-      padding: 0.375rem 0.5rem;
+      padding: 0.25rem 0.5rem;
       border: 1px solid #e2e8f0;
       border-radius: 0.25rem;
       font-size: 0.8125rem;
-      width: 100%;
+      width: 6.5rem;
+    }
+
+    .ska-filters__select-input {
+      padding: 0.25rem 0.625rem;
+      border: 1px solid #e2e8f0;
+      border-radius: 0.25rem;
+      font-size: 0.8125rem;
+      color: #475569;
+      background: white;
+      max-width: 220px;
+    }
+
+    .ska-filters__chip {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.375rem;
+      padding: 0.25rem 0.5rem 0.25rem 0.625rem;
+      border-radius: 999px;
+      background: #eef2ff;
+      color: var(--ska-primary);
+      font-size: 0.8125rem;
+    }
+
+    .ska-filters__chip a {
+      color: inherit;
+      text-decoration: none;
+    }
+
+    .ska-filters__chip-clear {
+      color: #64748b;
+      text-decoration: none;
+      line-height: 1;
+    }
+
+    .ska-filters__chip-clear:hover {
+      color: #dc2626;
     }
 
     /* Back link */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sveltekit-admin",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Django-like admin panel for SvelteKit + Prisma",
   "type": "module",
   "svelte": "./dist/index.js",
@@ -10,6 +10,11 @@
       "types": "./dist/index.d.ts",
       "svelte": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./adapters/drizzle": {
+      "types": "./dist/server/adapters/drizzle/index.d.ts",
+      "svelte": "./dist/server/adapters/drizzle/index.js",
+      "default": "./dist/server/adapters/drizzle/index.js"
     }
   },
   "files": [
@@ -30,22 +35,38 @@
     "test:watch": "svelte-kit sync && npm run test:gen && vitest",
     "test:coverage": "svelte-kit sync && npm run test:gen && vitest run --coverage",
     "lint": "svelte-kit sync && eslint .",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "npm run package && changeset publish"
   },
   "peerDependencies": {
     "@prisma/client": ">=5.0.0",
     "@sveltejs/kit": ">=2.0.0",
+    "drizzle-orm": ">=0.32.0",
     "svelte": ">=5.0.0"
   },
+  "peerDependenciesMeta": {
+    "@prisma/client": {
+      "optional": true
+    },
+    "drizzle-orm": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@changesets/cli": "^3.0.0",
     "@eslint/js": "9",
     "@prisma/client": "^6.19.3",
     "@sveltejs/adapter-auto": "^7.0.1",
     "@sveltejs/kit": "^2.0.0",
     "@sveltejs/package": "^2.5.8",
     "@sveltejs/vite-plugin-svelte": "^4.0.0",
+    "@types/better-sqlite3": "^9.6.0",
     "@types/node": "^22.0.0",
     "@vitest/coverage-v8": "^3.2.7",
+    "better-sqlite3": "12.9.0",
+    "drizzle-orm": "^0.45.2",
     "eslint": "9",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-svelte": "^3.22.0",
@@ -71,7 +92,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/dotNacer/sveltekit-admin.git"
+    "url": "git+https://github.com/dotNacer/sveltekit-admin.git"
   },
   "homepage": "https://github.com/dotNacer/sveltekit-admin#readme",
   "bugs": {