@b4moss/crudian 0.5.0 → 0.8.0

package/README.md

@@ -2,7 +2,9 @@
 
 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.
+
+**Versioning:** this npm package has its own SemVer (`package.json`). It is independent of the Go module (`packages/go/VERSION`). Shipping Go `0.7.0` does not require bumping this package.
 
 ## Install
 
@@ -10,15 +12,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 | 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` |
 
-| Subpath | Peer dependencies |
-|---------|-------------------|
-| `@b4moss/crudian/bun-sqlite` | Bun (`bun:sqlite`) |
-| `@b4moss/crudian/drizzle` | `drizzle-orm`, `better-sqlite3` |
-| `@b4moss/crudian/prisma` | `@prisma/client` |
+Node must not import `@b4moss/crudian/bun-sqlite` (resolves to an explicit error stub).
 
-## Usage
+## Quick start (adapters)
 
 ### Shared contracts
 
@@ -26,7 +31,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 +39,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 +59,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 +81,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/bun-sqlite/crud.d.ts

@@ -1,9 +1,10 @@
 import type { Database } from "bun:sqlite";
+import { type CreateCrudOptions } from "../index.js";
 import { type SyncSqliteCrud } from "../sqlite/sync-crud.js";
 export type BunSqliteCrud = SyncSqliteCrud<Database>;
 /**
  * Create a Crud bound to a Bun SQLite Database.
  * The same Database instance is reused for every operation.
  */
-export declare function createCrud(db: Database): BunSqliteCrud;
+export declare function createCrud(db: Database, options?: CreateCrudOptions): BunSqliteCrud;
 //# sourceMappingURL=crud.d.ts.map

package/dist/bun-sqlite/crud.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/bun-sqlite/crud.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,YAAY,CAAA;AAE5D,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAA;AAM/B,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,QAAQ,GAAG,aAAa,CAyBtD"}
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/bun-sqlite/crud.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAoB,MAAM,YAAY,CAAA;AAC5D,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAClE,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAA;AAM/B,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,EAAE,EAAE,QAAQ,EACZ,OAAO,CAAC,EAAE,iBAAiB,GAC1B,aAAa,CA6Bf"}

package/dist/bun-sqlite/crud.js

@@ -7,7 +7,7 @@ function bindings(args) {
  * Create a Crud bound to a Bun SQLite Database.
  * The same Database instance is reused for every operation.
  */
-export function createCrud(db) {
+export function createCrud(db, options) {
     if (db == null) {
         throw new CrudianError("db is required");
     }
@@ -28,5 +28,5 @@ export function createCrud(db) {
         transaction(fn) {
             return db.transaction(fn)();
         },
-    });
+    }, options);
 }

package/dist/drizzle/crud.d.ts

@@ -1,5 +1,6 @@
 import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
 import type BetterSqlite3 from "better-sqlite3";
+import { type CreateCrudOptions } from "../index.js";
 import { type SyncSqliteCrud } from "../sqlite/sync-crud.js";
 type DrizzleSqliteDb = BetterSQLite3Database<Record<string, unknown>> & {
     $client: BetterSqlite3.Database;
@@ -9,6 +10,6 @@ export type DrizzleCrud = SyncSqliteCrud<DrizzleSqliteDb>;
  * Create a Crud bound to a Drizzle better-sqlite3 database.
  * Raw SQL goes through the underlying better-sqlite3 client (`db.$client`).
  */
-export declare function createCrud(db: DrizzleSqliteDb): DrizzleCrud;
+export declare function createCrud(db: DrizzleSqliteDb, options?: CreateCrudOptions): DrizzleCrud;
 export {};
 //# sourceMappingURL=crud.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/drizzle/crud.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,aAAa,MAAM,gBAAgB,CAAA;AAE/C,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAA;AAE/B,KAAK,eAAe,GAAG,qBAAqB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG;IACtE,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,cAAc,CAAC,eAAe,CAAC,CAAA;AAEzD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,eAAe,GAAG,WAAW,CA2B3D"}
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/drizzle/crud.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,aAAa,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAClE,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAA;AAE/B,KAAK,eAAe,GAAG,qBAAqB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG;IACtE,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,cAAc,CAAC,eAAe,CAAC,CAAA;AAEzD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,EAAE,EAAE,eAAe,EACnB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,WAAW,CA+Bb"}

package/dist/drizzle/crud.js

@@ -4,7 +4,7 @@ import { createSyncSqliteCrud, } from "../sqlite/sync-crud.js";
  * Create a Crud bound to a Drizzle better-sqlite3 database.
  * Raw SQL goes through the underlying better-sqlite3 client (`db.$client`).
  */
-export function createCrud(db) {
+export function createCrud(db, options) {
     if (db == null) {
         throw new CrudianError("db is required");
     }
@@ -29,5 +29,5 @@ export function createCrud(db) {
         transaction(fn) {
             return client.transaction(fn)();
         },
-    });
+    }, options);
 }

package/dist/index.d.ts

@@ -4,8 +4,9 @@
  * - @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";
-export type { Row, SearchResult, WhereInput, ReadQuery, SearchQuery, CountQuery, DeleteQuery, UpdateQuery, DuplicateQuery, } from "./types.js";
+export type { Row, OffsetSearchResult, CursorSearchResult, SearchResult, WhereInput, ReadQuery, SearchQuery, CountQuery, DeleteQuery, UpdateQuery, DuplicateQuery, CreateCrudOptions, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

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,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,EACd,iBAAiB,GAClB,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,32 @@
+import { type CreateCrudOptions } from "../index.js";
+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, options?: CreateCrudOptions): 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":"AAAA,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAClE,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,CACxB,MAAM,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,UAAU,CAiDZ"}

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, options) {
+    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();
+            }
+        },
+    }, options);
+}

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/dist/prisma/crud.d.ts

@@ -1,3 +1,4 @@
+import { type CreateCrudOptions } from "../index.js";
 import { type AsyncSqliteCrud } from "../sqlite/async-crud.js";
 /** Minimal surface of PrismaClient used by the adapter (raw SQL + TX). */
 export type PrismaLikeClient = {
@@ -10,5 +11,5 @@ export type PrismaCrud = AsyncSqliteCrud<PrismaLikeClient>;
  * Create a Crud bound to a PrismaClient (SQLite).
  * Methods are async. The injected client is exposed as `crud.db`.
  */
-export declare function createCrud(client: PrismaLikeClient): PrismaCrud;
+export declare function createCrud(client: PrismaLikeClient, options?: CreateCrudOptions): PrismaCrud;
 //# sourceMappingURL=crud.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/prisma/crud.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAA;AAGhC,0EAA0E;AAC1E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACvE,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAC7E,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CACtE,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAA;AAU1D;;;GAGG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CA0C/D"}
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/prisma/crud.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAClE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAA;AAGhC,0EAA0E;AAC1E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACvE,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IAC7E,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,gBAAgB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CACtE,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,eAAe,CAAC,gBAAgB,CAAC,CAAA;AAU1D;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,UAAU,CA8CZ"}

package/dist/prisma/crud.js

@@ -12,7 +12,7 @@ function normalizeRow(row) {
  * Create a Crud bound to a PrismaClient (SQLite).
  * Methods are async. The injected client is exposed as `crud.db`.
  */
-export function createCrud(client) {
+export function createCrud(client, options) {
     if (client == null) {
         throw new CrudianError("db is required");
     }
@@ -50,7 +50,7 @@ export function createCrud(client) {
                 }
             });
         },
-    });
+    }, options);
 }
 function normalizeQueryResult(result) {
     if (result == null)