@b4moss/crudian 0.5.0 → 0.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 CRUD abstraction for DDD repositories.
 
-Single npm package with adapter subpaths. Shared contracts live at the package root; concrete backends are imported from subpaths.
+One npm package, adapter subpaths. Shared contracts live at the package root; backends are imported from subpaths. Callers inject their own DB/client — crudian never opens connections or reads env secrets for you.
 
 ## Install
 
@@ -10,15 +10,18 @@ Single npm package with adapter subpaths. Shared contracts live at the package r
 npm install @b4moss/crudian
 ```
 
-Adapter peers (install only what you use):
+Install only the peer deps for the adapter you use:
 
-| Subpath | Peer dependencies |
-|---------|-------------------|
-| `@b4moss/crudian/bun-sqlite` | Bun (`bun:sqlite`) |
-| `@b4moss/crudian/drizzle` | `drizzle-orm`, `better-sqlite3` |
-| `@b4moss/crudian/prisma` | `@prisma/client` |
+| Subpath | Runtime | Sync / async | Peer dependencies |
+|---------|---------|--------------|-------------------|
+| `@b4moss/crudian/bun-sqlite` | Bun | sync | Bun (`bun:sqlite`) |
+| `@b4moss/crudian/drizzle` | Node.js 24+ | sync | `drizzle-orm`, `better-sqlite3` |
+| `@b4moss/crudian/prisma` | Node.js 24+ | async | `@prisma/client` |
+| `@b4moss/crudian/libsql` | Node.js 24+ / Bun | async | `@libsql/client` |
 
-## Usage
+Node must not import `@b4moss/crudian/bun-sqlite` (resolves to an explicit error stub).
+
+## Quick start (adapters)
 
 ### Shared contracts
 
@@ -26,7 +29,7 @@ Adapter peers (install only what you use):
 import { where, CrudianError } from "@b4moss/crudian"
 ```
 
-### Bun (`bun:sqlite`)
+### Bun (`bun:sqlite`) — sync
 
 ```ts
 import { Database } from "bun:sqlite"
@@ -34,15 +37,19 @@ import { createCrud } from "@b4moss/crudian/bun-sqlite"
 import { where } from "@b4moss/crudian"
 
 const db = new Database(":memory:")
+db.exec(`
+  CREATE TABLE items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT NOT NULL,
+    score INTEGER,
+    note TEXT
+  )
+`)
 const crud = createCrud(db)
-
-const row = crud.create("items", { name: "alpha", score: 1 })
-const found = crud.read("items", { where: where().eq("id", row.id) })
+// raw DB is also available as crud.db
 ```
 
-Node.js must not import `@b4moss/crudian/bun-sqlite` (resolves to an explicit error stub).
-
-### Drizzle (better-sqlite3)
+### Drizzle (better-sqlite3) — sync
 
 ```ts
 import Database from "better-sqlite3"
@@ -50,11 +57,17 @@ import { drizzle } from "drizzle-orm/better-sqlite3"
 import { createCrud } from "@b4moss/crudian/drizzle"
 
 const sqlite = new Database(":memory:")
+sqlite.exec(`CREATE TABLE items (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  score INTEGER,
+  note TEXT
+)`)
 const db = drizzle(sqlite)
 const crud = createCrud(db)
 ```
 
-### Prisma (SQLite)
+### Prisma (SQLite) — async
 
 ```ts
 import { PrismaClient } from "@prisma/client"
@@ -66,15 +79,312 @@ const crud = createCrud(client)
 await crud.create("items", { name: "alpha", score: 1 })
 ```
 
-Prisma methods are async. Raw SQL goes through the injected client.
+### libSQL (`@libsql/client`) — async
+
+```ts
+import { createClient } from "@libsql/client"
+import { createCrud } from "@b4moss/crudian/libsql"
+
+const client = createClient({
+  url: process.env.LIBSQL_URL ?? "file:local.db",
+  authToken: process.env.LIBSQL_AUTH_TOKEN, // optional; set for remote hosts
+})
+const crud = createCrud(client)
+
+await crud.create("items", { name: "alpha", score: 1 })
+```
+
+URL / auth token belong on the caller-created client (typically from `.env`).
+
+---
+
+## API reference (all methods)
+
+Examples below use the **sync** Bun adapter. For `prisma` / `libsql`, `await` every call (same shapes).
+
+Assume a table:
+
+```sql
+CREATE TABLE items (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  score INTEGER,
+  note TEXT
+);
+```
+
+```ts
+import { Database } from "bun:sqlite"
+import { createCrud } from "@b4moss/crudian/bun-sqlite"
+import { where } from "@b4moss/crudian"
+
+const db = new Database(":memory:")
+db.exec(/* schema above */)
+const crud = createCrud(db)
+
+type Item = { id: number; name: string; score: number | null; note: string | null }
+```
+
+### `create(table, cols)` → row
+
+Inserts one row and returns it (including generated `id`).
+
+```ts
+const row = crud.create<Item>("items", { name: "alpha", score: 10, note: "n" })
+// { id: 1, name: "alpha", score: 10, note: "n" }
+```
+
+### `read(table, query?)` → row | `null`
+
+Reads one row. Misses return `null` (does not throw).
+
+```ts
+const found = crud.read<Item>("items", {
+  columns: ["id", "name"],
+  where: where().eq("id", row.id),
+})
+// { id: 1, name: "alpha" }
+
+const missing = crud.read<Item>("items", { where: where().eq("id", 999) })
+// null
+```
+
+### `update(table, cols, query)` → row | `null`
+
+Updates matching rows; returns the updated row. Zero matches → `null`. `where` is required.
+
+```ts
+const updated = crud.update<Item>(
+  "items",
+  { score: 9 },
+  { where: where().eq("id", row.id) },
+)
+// { id: 1, name: "alpha", score: 9, note: "n" }
+```
+
+### `delete(table, query)` → number
+
+Deletes matching rows; returns affected count. `where` is required.
+
+```ts
+const deleted = crud.delete("items", { where: where().eq("id", row.id) })
+// 1
+```
+
+### `search(table, query?)` → `{ items, nextCursor, hasMore, total }`
+
+Canonical list API. Cursor pagination on `id` ascending. `total` is the full where-match count (ignores `limit` / `cursor`).
+
+`SearchQuery` fields:
+
+| Field | Meaning |
+|-------|---------|
+| `columns?` | Column list for `SELECT` (same idea as `read`). Omit → `*` |
+| `where?` | Condition builder / node |
+| `limit?` | Page size (default `20`) |
+| `cursor?` | Raw `id` cursor (keyset); rows with `id > cursor` |
+
+```ts
+for (let i = 0; i < 5; i++) {
+  crud.create("items", { name: `n${i}`, score: i })
+}
+
+const page1 = crud.search<Item>("items", { limit: 2 })
+// {
+//   items: [ { id: 1, ... }, { id: 2, ... } ],
+//   nextCursor: 2,
+//   hasMore: true,
+//   total: 5,
+// }
+
+const page2 = crud.search<Item>("items", {
+  limit: 2,
+  cursor: page1.nextCursor,
+})
+// items ids [3, 4], total still 5
+
+const filtered = crud.search<Item>("items", {
+  columns: ["id", "name"],
+  where: where().gte("score", 3),
+  limit: 10,
+})
+// each item is { id, name } only
+```
+
+### `list(table, query?)` → same as `search`
+
+Thin alias of `search` (same `SearchQuery`, including `columns`).
+
+```ts
+const a = crud.list<Item>("items", {
+  columns: ["id", "name"],
+  limit: 10,
+})
+const b = crud.search<Item>("items", {
+  columns: ["id", "name"],
+  limit: 10,
+})
+// a and b are deep-equal
+```
+
+### `count(table, query?)` → number
+
+Where-match count only (`CountQuery` is `{ where? }`). No `limit` / `cursor` / `columns`.
+
+```ts
+crud.count("items") // 5
+crud.count("items", { where: where().eq("name", "n0") }) // 1
+```
+
+### `upsert(table, cols)` → row
+
+Conflict target is primary key `id`. Inserts or updates; returns the row. `id` is required in `cols`.
+
+```ts
+const inserted = crud.upsert<Item>("items", { id: 10, name: "new", score: 1 })
+const again = crud.upsert<Item>("items", { id: 10, name: "upd", score: 9 })
+// again.name === "upd"
+```
+
+### `duplicate(table, query)` → row | `null`
+
+Copies the first matching row (new `id`). Optional `overrides`. Zero matches → `null`. `where` is required.
+
+```ts
+const source = crud.create<Item>("items", { name: "a", score: 1, note: "n" })
+const copy = crud.duplicate<Item>("items", {
+  where: where().eq("id", source.id),
+  overrides: { name: "b" },
+})
+// copy.id !== source.id, copy.name === "b"
+
+const none = crud.duplicate<Item>("items", { where: where().eq("id", 999) })
+// null
+```
+
+### `bulkCreate(table, rows)` → number
+
+Inserts many rows; returns inserted count. Empty array → `0`.
+
+```ts
+const n = crud.bulkCreate("items", [
+  { name: "x", score: 1 },
+  { name: "y", score: 2 },
+])
+// 2
+```
+
+### `bulkUpdate(table, cols, query)` → number
+
+Updates many rows; returns affected count. `where` is required.
+
+```ts
+const n = crud.bulkUpdate(
+  "items",
+  { score: 8 },
+  { where: where().eq("name", "x") },
+)
+// 1
+```
+
+### `bulkDelete(table, query)` → number
+
+Deletes many rows; returns affected count. `where` is required.
+
+```ts
+const n = crud.bulkDelete("items", { where: where().eq("name", "y") })
+// 1
+```
+
+### `bulkUpsert(table, rows)` → number
+
+Upserts many rows (each row needs `id`); returns processed count. Empty array → `0`.
+
+```ts
+const n = crud.bulkUpsert("items", [
+  { id: 100, name: "z", score: 1 },
+  { id: 10, name: "z2", score: 2 },
+])
+// 2
+```
+
+### `transaction(fn)` → `fn` return value
+
+Runs `fn` inside a transaction helper. Crudian does **not** auto-wrap each CRUD call; use this when you need atomic multi-step work. Success commits; throw rolls back.
+
+```ts
+const result = crud.transaction(() => {
+  crud.create("items", { name: "a", score: 1 })
+  crud.create("items", { name: "b", score: 2 })
+  return "ok"
+})
+// result === "ok"; both rows visible afterward
+
+try {
+  crud.transaction(() => {
+    crud.create("items", { name: "c", score: 3 })
+    throw new Error("boom")
+  })
+} catch {
+  // partial writes from that callback are rolled back
+}
+```
+
+Async adapters:
+
+```ts
+await crud.transaction(async () => {
+  await crud.create("items", { name: "a", score: 1 })
+  await crud.create("items", { name: "b", score: 2 })
+})
+```
+
+---
+
+## `where()` builder
+
+```ts
+import { where } from "@b4moss/crudian"
+
+where().eq("name", "alpha")
+where().ne("score", 0)
+where().lt("score", 10)
+where().lte("score", 10)
+where().gt("score", 0)
+where().gte("score", 0)
+where().in("name", ["a", "b"])
+where().like("name", "a%")
+where().isNull("note")
+where().isNotNull("note")
+
+where()
+  .eq("name", "alpha")
+  .and(where().gte("score", 5))
+
+where()
+  .eq("name", "alpha")
+  .or(where().eq("name", "beta"))
+```
+
+Nestable `and` / `or`. Empty `in([])` is rejected.
 
-## API surface
+---
 
-`create` / `read` / `update` / `delete` / `search` / `list` / `upsert` / `duplicate` / `bulkCreate` / `bulkUpdate` / `bulkDelete` / `bulkUpsert` / `transaction`
+## Behavior notes
 
-- `search` is canonical; `list` is an alias
-- Cursor pagination uses `id` ascending; response is `{ items, nextCursor, hasMore }`
-- Conditions use the `where()` builder (`eq` / `ne` / `lt` / `gt` / `lte` / `gte` / `in` / `like` / `isNull` / `isNotNull`, nestable `and` / `or`)
+| Topic | Behavior |
+|-------|----------|
+| Entry | `createCrud(db)` — inject a caller-owned client; exposed as `crud.db` |
+| Sync vs async | `bun-sqlite` / `drizzle` sync; `prisma` / `libsql` return `Promise`s |
+| `read` / `update` / `duplicate` miss | `null` |
+| `delete` / bulk miss | `0` |
+| Upsert conflict | primary key `id` |
+| Pagination | cursor on `id` ASC only (no offset) |
+| `columns` | optional on `read` / `search` / `list`; omit → `*` |
+| `search.total` / `count` | full where count; not page length |
+| Errors | minimal `CrudianError`; other errors propagate from the driver |
+| Identifiers | string required; no format validation |
+| Out of scope | relations, migrations, full-text search, ORM models |
 
 ## License
 

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  * - @b4moss/crudian/bun-sqlite
  * - @b4moss/crudian/drizzle
  * - @b4moss/crudian/prisma
+ * - @b4moss/crudian/libsql
  */
 export { CrudianError, assertString } from "./errors.js";
 export { WhereBuilder, where, isWhereBuilder, type Op, type CondNode, type GroupNode, type WhereNode, } from "./where.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EACL,YAAY,EACZ,KAAK,EACL,cAAc,EACd,KAAK,EAAE,EACP,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,GAAG,EACH,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,GACf,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EACL,YAAY,EACZ,KAAK,EACL,cAAc,EACd,KAAK,EAAE,EACP,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,GAAG,EACH,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,GACf,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -4,6 +4,7 @@
  * - @b4moss/crudian/bun-sqlite
  * - @b4moss/crudian/drizzle
  * - @b4moss/crudian/prisma
+ * - @b4moss/crudian/libsql
  */
 export { CrudianError, assertString } from "./errors.js";
 export { WhereBuilder, where, isWhereBuilder, } from "./where.js";

package/dist/libsql/crud.d.ts

@@ -0,0 +1,31 @@
+import { type AsyncSqliteCrud } from "../sqlite/async-crud.js";
+import type { Row } from "../types.js";
+/** Result shape used by the libSQL executor bridge. */
+export type LibsqlResultSet = {
+    rows: Array<Row | unknown>;
+    rowsAffected: number;
+};
+/** Minimal execute surface shared by Client and Transaction. */
+export type LibsqlExecutor = {
+    execute(stmt: {
+        sql: string;
+        args?: unknown[];
+    } | string): Promise<LibsqlResultSet>;
+};
+/** Minimal surface of @libsql/client Client used by the adapter. */
+export type LibsqlLikeClient = LibsqlExecutor & {
+    transaction(mode?: "write" | "read" | "deferred"): Promise<LibsqlLikeTransaction>;
+};
+export type LibsqlLikeTransaction = LibsqlExecutor & {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    close(): void;
+};
+export type LibsqlCrud = AsyncSqliteCrud<LibsqlLikeClient>;
+/**
+ * Create a Crud bound to a libSQL client (`@libsql/client`).
+ * Methods are async. The injected client is exposed as `crud.db`.
+ * Auth / URL are configured on the caller-created client (e.g. from env).
+ */
+export declare function createCrud(client: LibsqlLikeClient): LibsqlCrud;
+//# sourceMappingURL=crud.d.ts.map

package/dist/libsql/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/libsql/crud.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAEtC,uDAAuD;AACvD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,KAAK,CAAC,GAAG,GAAG,OAAO,CAAC,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,gEAAgE;AAChE,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,CACL,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;KAAE,GAAG,MAAM,GAC/C,OAAO,CAAC,eAAe,CAAC,CAAA;CAC5B,CAAA;AAED,oEAAoE;AACpE,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG;IAC9C,WAAW,CACT,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,UAAU,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAAA;CAClC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG;IACnD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACvB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,KAAK,IAAI,IAAI,CAAA;CACd,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAA;AAa1D;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CA6C/D"}

package/dist/libsql/crud.js

@@ -0,0 +1,62 @@
+import { CrudianError } from "../index.js";
+import { createAsyncSqliteCrud, } from "../sqlite/async-crud.js";
+function normalizeRow(row) {
+    if (row == null || typeof row !== "object") {
+        throw new CrudianError("expected row object");
+    }
+    const out = { ...row };
+    for (const [k, v] of Object.entries(out)) {
+        if (typeof v === "bigint")
+            out[k] = Number(v);
+    }
+    return out;
+}
+/**
+ * Create a Crud bound to a libSQL client (`@libsql/client`).
+ * Methods are async. The injected client is exposed as `crud.db`.
+ * Auth / URL are configured on the caller-created client (e.g. from env).
+ */
+export function createCrud(client) {
+    if (client == null) {
+        throw new CrudianError("db is required");
+    }
+    if (typeof client !== "object" ||
+        typeof client.execute !== "function" ||
+        typeof client.transaction !== "function") {
+        throw new CrudianError("db must be a libSQL client");
+    }
+    let active = client;
+    return createAsyncSqliteCrud(client, {
+        async run(sql, args = []) {
+            const result = await active.execute({ sql, args });
+            return { changes: Number(result.rowsAffected ?? 0) };
+        },
+        async get(sql, args = []) {
+            const result = await active.execute({ sql, args });
+            const row = result.rows[0];
+            return row == null ? undefined : normalizeRow(row);
+        },
+        async all(sql, args = []) {
+            const result = await active.execute({ sql, args });
+            return result.rows.map((row) => normalizeRow(row));
+        },
+        async transaction(fn) {
+            const tx = await client.transaction("write");
+            const prev = active;
+            active = tx;
+            try {
+                const value = await fn();
+                await tx.commit();
+                return value;
+            }
+            catch (err) {
+                await tx.rollback();
+                throw err;
+            }
+            finally {
+                active = prev;
+                tx.close();
+            }
+        },
+    });
+}

package/dist/libsql/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * libSQL adapter for @b4moss/crudian.
+ * Import via: `import { createCrud } from "@b4moss/crudian/libsql"`
+ */
+export { createCrud, type LibsqlCrud, type LibsqlLikeClient, type LibsqlLikeTransaction, type LibsqlExecutor, type LibsqlResultSet, } from "./crud.js";
+export type { Row, SearchResult, WhereInput, ReadQuery, SearchQuery, CountQuery, DeleteQuery, UpdateQuery, DuplicateQuery, } from "../types.js";
+export { CrudianError, where, WhereBuilder, type Op, type CondNode, type GroupNode, type WhereNode, } from "../index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/libsql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/libsql/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,UAAU,EACV,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,GAAG,EACH,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,GACf,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,YAAY,EACZ,KAAK,EACL,YAAY,EACZ,KAAK,EAAE,EACP,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,aAAa,CAAA"}

package/dist/libsql/index.js

@@ -0,0 +1,6 @@
+/**
+ * libSQL adapter for @b4moss/crudian.
+ * Import via: `import { createCrud } from "@b4moss/crudian/libsql"`
+ */
+export { createCrud, } from "./crud.js";
+export { CrudianError, where, WhereBuilder, } from "../index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b4moss/crudian",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "CRUD abstraction for DDD repositories",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,11 @@
       "types": "./dist/prisma/index.d.ts",
       "import": "./dist/prisma/index.js",
       "default": "./dist/prisma/index.js"
+    },
+    "./libsql": {
+      "types": "./dist/libsql/index.d.ts",
+      "import": "./dist/libsql/index.js",
+      "default": "./dist/libsql/index.js"
     }
   },
   "files": [
@@ -36,21 +41,26 @@
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
     "prisma:generate": "prisma generate --schema prisma/schema.prisma",
-    "test": "bun run test:bun-sqlite && bun run test:drizzle && bun run test:prisma",
+    "test": "bun run test:bun-sqlite && bun run test:drizzle && bun run test:prisma && bun run test:libsql",
     "test:bun-sqlite": "bun test src/bun-sqlite",
     "test:drizzle": "tsx --test src/drizzle/crud.test.ts",
-    "test:prisma": "bun run prisma:generate && tsx --test src/prisma/crud.test.ts"
+    "test:prisma": "bun run prisma:generate && tsx --test src/prisma/crud.test.ts",
+    "test:libsql": "tsx --test src/libsql/crud.test.ts"
   },
   "engines": {
     "node": ">=24",
     "bun": ">=1.0.0"
   },
   "peerDependencies": {
+    "@libsql/client": "^0.14.0 || ^0.15.0 || ^0.17.0",
     "@prisma/client": "^6.0.0",
     "better-sqlite3": "^11.0.0",
     "drizzle-orm": "^0.39.0 || ^0.40.0 || ^0.41.0 || ^0.44.0"
   },
   "peerDependenciesMeta": {
+    "@libsql/client": {
+      "optional": true
+    },
     "@prisma/client": {
       "optional": true
     },
@@ -62,9 +72,10 @@
     }
   },
   "devDependencies": {
+    "@libsql/client": "^0.17.4",
     "@prisma/client": "^6.14.0",
     "@types/better-sqlite3": "^7.6.13",
-    "better-sqlite3": "^11.10.0",
+    "better-sqlite3": "^13",
     "bun-types": "^1.2.0",
     "drizzle-orm": "^0.44.4",
     "prisma": "^6.14.0",
@@ -78,6 +89,7 @@
     "bun",
     "drizzle",
     "prisma",
+    "libsql",
     "ddd"
   ],
   "repository": {