sveltekit-admin 0.5.3 → 0.6.0

package/dist/server/query/listQuery.js

@@ -12,6 +12,7 @@
  * 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;
 /**
@@ -351,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sveltekit-admin",
-  "version": "0.5.3",
+  "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",